Codigo de sistema

El costo es de 30 $

Puedes realizar el pago por paypal

Gracias por la confianza, cualquier duda, consulta u otra forma de pago escribir a therum06@gmail.com

Características

·                  Lenguaje de Programación: Java Jsf.

·                  Base de Datos: MySql 

·                  Implementación y adaptación: Fácil de implementar y adaptar a nuestra empresa guiándose de los vídeos explicativos paso a paso.

·                  Herramientas: Puedes generar un backup de tu base de datos para respaldar tu información.
·                  Estadísticas: Incluye modulo de clientes, modulo de productos, pedidos, ventas factura y boleta

·                  Fácil Aprendizaje: El sistema es muy intuitivo para el usuario final.

Combos Dependientes en Spring MVC primefaces

En Img anterior se muestra el ejemplo que vamos a trabajar con Spring MVC y Primefaces para los combos dependientes de la tabla UBIGEO

Subir archivo a Cloud Amazon S3 desde java

Servicio de almacenamiento de información basada en la web de  Amazon S3 está experimentando problemas generalizados, llevando al servicio que está parcial o totalmente roto en sitios web, aplicaciones y dispositivos en los que se basa. La oferta de AWS ofrece hosting de imágenes para un montón de sitios y también alberga sitios web y app backends como nido.



import com.amazonaws.AmazonClientException;
import com.amazonaws.AmazonServiceException;
import com.amazonaws.auth.BasicAWSCredentials;
import com.amazonaws.regions.Region;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3Client;
import com.amazonaws.services.s3.model.CannedAccessControlList;
import com.amazonaws.services.s3.model.PutObjectRequest;
import java.io.File;
import java.io.IOException;

public class prueba {
     private static String bucketName = "carpeta";
         private static String keyName = "sub carpeta mas el nombre del archivo";
 

    // ruta del archivo
    private static String uploadFileName = "c:\\hh\\USUARIOS.DB";
 

    private static String s3Url = "";
 
       public static void main(String[] args)  throws IOException{
         
        BasicAWSCredentials awsCredentials = new BasicAWSCredentials("usuario","clave");
        AmazonS3Client s3client = new AmazonS3Client(awsCredentials);
     
        Region usEast1 = Region.getRegion(Regions.US_EAST_1);
        s3client.setRegion(usEast1);
        try {
         
            System.out.println("Uploading a new object to S3 from a file\n");
            File file = new File(uploadFileName);
            s3client.putObject(new PutObjectRequest(
                    bucketName, keyName, file));
            s3client.setObjectAcl(bucketName, keyName, CannedAccessControlList.PublicRead);
            s3Url = s3client.getResourceUrl(bucketName, keyName);
            System.out.println("S3 Url:       " + s3Url);

        } catch (AmazonServiceException ase) {
            System.out.println("Caught an AmazonServiceException, which " +
                    "means your request made it " +
                    "to Amazon S3, but was rejected with an error response" +
                    " for some reason.");
            System.out.println("Error Message:    " + ase.getMessage());
            System.out.println("HTTP Status Code: " + ase.getStatusCode());
            System.out.println("AWS Error Code:   " + ase.getErrorCode());
            System.out.println("Request ID:       " + ase.getRequestId());
            System.out.println("Error Type:       " + ase.getErrorType());
        } catch (AmazonClientException ace) {
            System.out.println("Caught an AmazonClientException, which " +
                    "means the client encountered " +
                    "an internal error while trying to " +
                    "communicate with S3, " +
                    "such as not being able to access the network.");
            System.out.println("Error Message: " + ace.getMessage());
        }
       }
}

Spring MVC + Hibernate + MySQL 5 + integración de Maven 3

En este post van a aprender cómo integrar Spring4 MVC con aplicación de Hibernate con la herramienta de compilación de Maven y realizará las operaciones CRUD usando base de datos MySql.

Estructura del proyecto:

La captura de pantalla siguiente muestra la estructura final del proyecto:

Paso 1: Crear tabla de la base de datos

Para esta demo, he creado una tabla cliente en la base de datos MySQL. Encontrar la secuencia de comandos para crear la tabla cliente.

CREATE TABLE `archivo`.`cliente` (
  `idcliente` INT NOT NULL AUTO_INCREMENT,
  `nombre` VARCHAR(45) NULL,
  `paterno` VARCHAR(45) NULL,
  `materno` VARCHAR(45) NULL,
  `fecha_reg` DATETIME NULL,
  PRIMARY KEY (`idcliente`));
 

Paso 2: Actualizar las dependencias de Maven

Actualización pom.xml para incluir las dependencias necesarias

pom.xml 

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
                             http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.ugurcan.simple</groupId>
    <artifactId>archivo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>war</packaging>
    <name>archivo</name>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>2.3.2</version>
                <configuration>
                    <source>1.7</source>
                    <target>1.7</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
    <dependencies>

        <dependency>
            <groupId>com.sun.faces</groupId>
            <artifactId>jsf-api</artifactId>
            <version>2.1.7</version>
        </dependency>
        <dependency>
            <groupId>com.sun.faces</groupId>
            <artifactId>jsf-impl</artifactId>
            <version>2.1.7</version>
        </dependency>

        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>

        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
        </dependency>

        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.1</version>
        </dependency>

        <dependency>
            <groupId>com.sun.el</groupId>
            <artifactId>el-ri</artifactId>
            <version>1.0</version>
        </dependency>

        <dependency>
            <groupId>org.primefaces.extensions</groupId>
            <artifactId>all-themes</artifactId>
            <version>1.0.7</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>${spring.version}</version>
        </dependency>


        <dependency>
            <groupId>commons-dbcp</groupId>
            <artifactId>commons-dbcp</artifactId>
            <version>1.2.2</version>
        </dependency>

        <dependency>
            <groupId>javax.persistence</groupId>
            <artifactId>persistence-api</artifactId>
            <version>1.0</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>4.1.9.Final</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>
        <!-- http://mvnrepository.com/artifact/org.primefaces/primefaces -->
        <dependency>
            <groupId>org.primefaces</groupId>
            <artifactId>primefaces</artifactId>
            <version>5.3</version>
        </dependency>
        <dependency>
    <groupId>commons-fileupload</groupId>
    <artifactId>commons-fileupload</artifactId>
    <version>1.2.2</version>
</dependency>
<dependency>
    <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
    <version>1.4</version>
</dependency>
    </dependencies>
    <properties>
        <spring.version>3.2.3.RELEASE</spring.version>
        <netbeans.hint.deploy.server>gfv3ee6</netbeans.hint.deploy.server>
    </properties>
    </project>

Paso 3: Descriptor de despliegue (web.xml)

Necesitamos en nuestra aplicación web, que se realiza mediante la configuración de Spring framework DispatcherServlet como controlador frontal plugin framework de spring.

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns="http://java.sun.com/xml/ns/javaee"
         xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
                             http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
                             id="WebApp_ID" version="2.5">

    <display-name>Simple</display-name>

<context-param>
        <param-name>javax.faces.PROJECT_STAGE</param-name>
        <param-value>Projection</param-value>
    </context-param>
    <!-- Spring Context Configuration' s Path definition -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>
            /WEB-INF/applicationContext.xml
        </param-value>
    </context-param>
  
   
    <listener>
        <listener-class>
            org.springframework.web.context.ContextLoaderListener
        </listener-class>
    </listener>
    <listener>
        <listener-class>
            org.springframework.web.context.request.RequestContextListener
        </listener-class>
    </listener>

    <!-- Change to "Production" when you are ready to deploy -->
    <context-param>
        <param-name>javax.faces.PROJECT_STAGE</param-name>
        <param-value>Development</param-value>
    </context-param>

    <!-- Welcome page -->
    <welcome-file-list>
        <welcome-file>login.xhtml</welcome-file>
    </welcome-file-list>

    <!-- JSF mapping -->
    <servlet>
        <servlet-name>Faces Servlet</servlet-name>
        <servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>


    <!-- Map these files with JSF -->
    <servlet-mapping>
        <servlet-name>Faces Servlet</servlet-name>
        <url-pattern>*.jsf</url-pattern>
    </servlet-mapping>
    <servlet-mapping>
        <servlet-name>Faces Servlet</servlet-name>
        <url-pattern>*.faces</url-pattern>
    </servlet-mapping>
    <servlet-mapping>
        <servlet-name>Faces Servlet</servlet-name>
        <url-pattern>*.xhtml</url-pattern>
    </servlet-mapping>
 <context-param> 
        <param-name>primefaces.THEME</param-name> 
        <param-value>blitzer</param-value> 
    </context-param>
     
     <filter>
        <filter-name>PrimeFaces FileUpload Filter</filter-name>
        <filter-class>
            org.primefaces.webapp.filter.FileUploadFilter
        </filter-class>
        <init-param>
            <param-name>javax.faces.UPLOADED_FILE_MAX_SIZE</param-name>
            <param-value>9999999999504857600</param-value>
        </init-param>
    </filter>
   
    <filter-mapping>
        <filter-name>PrimeFaces FileUpload Filter</filter-name>
        <servlet-name>Faces Servlet</servlet-name>
    </filter-mapping>
  </web-app> 

Paso 4: Archivo de configuración de Spring (applicationContext.xml)

MVC-applicationContext.xml

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:jee="http://www.springframework.org/schema/jee"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:task="http://www.springframework.org/schema/task"
       xsi:schemaLocation="http://www.springframework.org/schema/aop
                           http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
                           http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
                           http://www.springframework.org/schema/context
                           http://www.springframework.org/schema/context/spring-context-3.2.xsd
                           http://www.springframework.org/schema/jee
                           http://www.springframework.org/schema/jee/spring-jee-3.2.xsd
                           http://www.springframework.org/schema/tx
                           http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
                           http://www.springframework.org/schema/task
                           http://www.springframework.org/schema/task/spring-task-3.2.xsd">
    <context:component-scan base-package="com.ugurcanlacin.simple.*" />
    <tx:annotation-driven/>
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />
             

        <property name="url" value="jdbc:mysql://localhost:3306/archivo" />
        <property name="username" value="root" />
        <property name="password" value="root" />
          
    </bean>
 
    <bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
        <property name="dataSource" ref="dataSource"></property>
        <property name="packagesToScan" value="com.ugurcanlacin.simple.*"/>
    
        <property name="hibernateProperties">
            <props>
                <prop
                    key="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect
                </prop>
                <!--
                <prop key="hibernate.show_sql">true</prop>
                <prop key="hibernate.format_sql">true</prop>
                -->
            </props>
        </property>
    </bean>
    <bean id="transactionManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager"
            p:sessionFactory-ref="sessionFactory">
    </bean>
</beans>

 Paso 6: Capa de persistencia
 ClienteEntity.java

@Entity
@Table(name = "cliente")
public class ClienteEntity implements Serializable{
    @Id
    @Column(name = "idcliente")
    private Integer id;
    private String nombre;
    private String paterno;
    private String materno;
    @Temporal(javax.persistence.TemporalType.DATE)
    private Date fecha_reg ;
    // get y set
} 

Hibernate DAO implementación

Vamos a crear interfaz GenericDAO para declarar los métodos que usaremos en nuestro proyecto. A continuación, proporcionaremos.

public interface GenericDAO<T> {
    public List<T> getAllDAO();
    public void addDAO(T t);
    public void updateDAO(T t);
    public void deleteDAO(T t);
}
 

Crear una clase de tipo interfaz ClienteDao

public interface ClienteDao extends GenericDAO<ClienteEntity> { 
}

 Crear ClienteDaoImpl java clas

@Repository
public class ClienteDaoImpl implements ClienteDao{
@Autowired
    private SessionFactory sessionFactory;
    private Session getSession() {
        return sessionFactory.getCurrentSession();
    }
    @Override
    public List<ClienteEntity> getAllDAO() {
        Criteria criteriaList = this.getSession().createCriteria(ClienteEntity.class);
        return criteriaList.list();
    }
    @Override
    public void addDAO(ClienteEntity t) {
        this.getSession().save(t);
    }
    @Override
    public void updateDAO(ClienteEntity t) {
        this.getSession().update(t);
    }
    @Override
    public void deleteDAO(ClienteEntity t) {
        this.getSession().delete(t);
    }
}
 Crerar GenericServicede tipo interface
public interface GenericService<T> {
    public List<T> getAllDAO();
    public void addDAO(T t);
    public void updateDAO(T t);
    public void deleteDAO(T t);
}
 
 Crerar ClienteService de tipo interface

 public interface ClienteService extends GenericService<ClienteEntity> {
}


Crear una clase con nombre ClienteServiceImpl

 @Transactional
@Service
public class ClienteServiceImpl implements ClienteService{
@Autowired
   ClienteDao clienteDao;
    @Override
    public List<ClienteEntity> getAllDAO() {
        return  clienteDao.getAllDAO();
    }
    @Override
    public void addDAO(ClienteEntity t) {
        this.clienteDao.addDAO(t);
    }
    @Override
    public void updateDAO(ClienteEntity t) {
        this.clienteDao.updateDAO(t);
    }
    @Override
    public void deleteDAO(ClienteEntity t) {
        this.clienteDao.deleteDAO(t);
    }
}

Crear  ClienteBean de tipo Bean

@Controller
@ManagedBean
@SessionScoped
public class ClienteBean implements Serializable{

     @Autowired
    ClienteService clienteService;
    
   private List<ClienteEntity> list;
   private ClienteEntity entity;
    public ClienteBean() {
        this.entity = new ClienteEntity();
        this.list = new ArrayList<>();
    }

    public List<ClienteEntity> getList() {
        list = clienteService.getAllDAO();
        return list;
    }

    public void setList(List<ClienteEntity> list) {
        this.list = list;
    }

    public ClienteEntity getEntity() {
        return entity;
    }

    public void setEntity(ClienteEntity entity) {
        this.entity = entity;
    }
   
   
      public void registrar(){
               try {
                clienteService.addDAO(entity);
                 FacesContext.getCurrentInstance().addMessage("", new FacesMessage("Se registro correctamente"));
            entity = new ClienteEntity();
           
            } catch (Exception e) {
                System.out.println("Error: " + e.getMessage());
                 FacesMessage message = new FacesMessage(FacesMessage.SEVERITY_ERROR, e.getMessage(), "");
            FacesContext.getCurrentInstance().addMessage("", message);
            }
      }

      public void actualizar(){
          try {
                clienteService.updateDAO(entity);
                 FacesContext.getCurrentInstance().addMessage("", new FacesMessage("Se registro correctamente"));
            entity = new ClienteEntity();
           
            } catch (Exception e) {
                System.out.println("Error: " + e.getMessage());
                 FacesMessage message = new FacesMessage(FacesMessage.SEVERITY_ERROR, e.getMessage(), "");
            FacesContext.getCurrentInstance().addMessage("", message);
            }
      }

      public void eliminar(){
          try {
                clienteService.deleteDAO(entity);
                 FacesContext.getCurrentInstance().addMessage("", new FacesMessage("Se registro correctamente"));
            entity = new ClienteEntity();
           
            } catch (Exception e) {
                System.out.println("Error: " + e.getMessage());
                 FacesMessage message = new FacesMessage(FacesMessage.SEVERITY_ERROR, e.getMessage(), "");
            FacesContext.getCurrentInstance().addMessage("", message);
            }
      }
}
 
cliente de xhtml

 

Resultados

 

http://informaticoesr.com/