miércoles, 30 de marzo de 2016

Hibernate

CRUD simple Uso de Java, Hibernate y MySQL

Usted puede ver y descargar el código fuente completo de este tutorial de mi cuenta de GitHub .
En este tutorial, vamos a crear una sencilla CRUD (Crear Leer Actualizar Borrar) Aplicación del usuario Management Console utilizando Java, Hibernate y MySQL.
Para este tutorial, necesitaremos las siguientes herramientas: (La versión anterior o posterior debe también funciona).
1. Eclipse IDE para Java EE Desarrolladores (Indigo - Ver. 3.7)
2. MySQL Community Server y MySQL Workbench (GUI de la herramienta)
3. MySQL Connector para Java
4. Hibernate ORM
En primer lugar, vamos a crear la base de datos y la tabla de usuario utilizando las siguientes secuencias de comandos SQL. Copiar y ejecutar este script en el MySQL Workbench (GUI de la herramienta) -> Editor de SQL: 
  crear UserDB base de datos;
 utilizar UserDB;
 conceda a todos en UserDB * a 'admin' @ 'localhost' identifica 
mediante "prueba".; 

 CREAR TABLA UserDB.`users` (
   `userid` int (11) NOT NULL AUTO_INCREMENT,
   `firstname` NULL varchar (45) DEFAULT,
   `varchar lastname` (45) DEFAULT NULL,
   `dob` NULL fecha predeterminada,
   `email` NULL varchar (100) DEFAULT,
   PRIMARY KEY ( `userid`)
 ) ENGINE = InnoDB AUTO_INCREMENT = 9 DEFAULT charset = UTF-8
Ir a eclipsar y crear un nuevo proyecto. Seleccione Archivo-> Nuevo-> Proyecto de Java. Enter "SimpleJava hibernación", como el nombre del proyecto. Acepte todo el valor predeterminado. Haga clic en Finalizar.
Consulte en este directorio del proyecto en caso de que se pierda algo en el camino
structure
Después de crear el proyecto, tenemos que añadir conector MySQL archivo .jar a nuestra trayectoria de la estructura del proyecto. Para ello, haga clic derecho en nuestro proyecto recién creado "SimpleJavaHibernate" y seleccione Propiedades para abrir la ventana Propiedades.
Seleccione Java Build Path en la vista de árbol a la izquierda para abrir la derecha vista lateral en detalle. Haga clic en Añadir JAR externos .. botón para abrir diálogo del navegador de archivos y el punto al conector de MySQL .jar archivo que ha descargado anteriormente.
Por otra parte, tenemos que añadir la biblioteca Hibernate a nuestro proyecto. Haga clic derecho de nuevo el proyecto y seleccione Propiedades -> Java Build Path. Esta vez, haga clic en Agregar biblioteca. Seleccionar biblioteca de usuario de la lista de selección. Haga clic en Biblioteca de usuario. A continuación, haga clic en Nuevo. Enter "hibernación", como el nombre de la biblioteca. Ok. Haga clic en nuestra biblioteca de usuario recién creado y haga clic en Agregar archivo JAR. Seleccione todo el archivo .jar, tanto en la carpeta proporcionada y necesaria que se encuentra dentro de esta estructura de directorios [su hibernación descarga carpeta] -> hibernación-search-4.1.0.CR3-dist-> hibernación-search-4.1.0.CR3-> dist-> lib
Verificar su trayectoria de la estructura para que coincida con la configuración en la imagen siguiente:
build path
Esta es toda la configuración que tenemos que hacer y ahora vamos a llegar al código.
Cree cuatro paquetes en la carpeta src.
  • com.daniel: contiene el método principal como punto de entrada para nuestra aplicación de consola
  • com.daniel.dao: contiene la lógica para el funcionamiento de bases de datos
  • com.daniel.model: contiene el POJO (Plain Old Java Object). Cada clase en este paquete representa la tabla de base de datos. Para este tutorial, sin embargo, sólo tenemos una mesa.
  • com.daniel.util: contiene la clase de base de datos para iniciar la conexión
A continuación, crear una nueva clase Java. en la carpeta com.daniel.model. El nombre de "User.java" e insertar estos códigos siguientes. Cada una de las variables en esta clase representa el campo en la tabla de usuarios en nuestra base de datos.


  
  com.daniel.model paquete;

 java.util.Date importación;

 Usuario public class {

     ID de usuario int privado;
     firstName cadena privada;
     lastName cadena privada;
     Fecha dob privada;
     Cadena de correo electrónico privada;
     public int GetUserID () {
         ID de usuario de regreso;
     }
     pública SetUserID void (int id de usuario) {
         este .userid = ID de usuario;
     }
     Cadena getFirstName pública () {
         volver firstName;
     }
     pública setFirstName vacío (String firstName) {
         este .firstName = firstName;
     }
     Cadena getLastName pública () {
         volver lastName;
     }
     pública setLastName vacío (String lastName) {
         este .lastName = lastName;
     }
     Fecha getDob pública () {
         dob regresar;
     }
     pública setDob vacío (Fecha DOB) {
         este .dob = fecha de nacimiento;
     }
     Cadena getEmail pública () {
         correo electrónico de retorno;
     }
     pública setEmail vacío (correo electrónico String) {
         este .email = correo electrónico;
     }
     @Anular
     public String toString () {
         retorno "de usuario [ID de usuario =" + + 
ID de usuario ", firstName =" + firstName
                 + ", LastName =" + Apellido + ", 
fecha de nacimiento =" + + fecha de nacimiento ", email ="
                 + Correo + "]";
     }    
 }
Crear una nueva clase en el paquete com.daniel.util y el nombre HibernateUtil.java. Esta clase leerá la configuración en nuestro fichero hibernate.cfg.xml que se ocupa de la conexión de base de datos a nuestro servidor MySQL. 
  com.daniel.util paquete;

 org.hibernate.SessionFactory importación;
 org.hibernate.cfg.Configuration importación;

 public class {HibernateUtil
     SessionFactory private static final sessionFactory = buildSessionFactory ();

     estática privada SessionFactory buildSessionFactory () {
         try {
             // Crear la SessionFactory de hibernate.cfg.xml
             volver nueva configuración () configurar () buildSessionFactory ()..;
         } Catch (Throwable ex) {
             // Asegúrese de que se conecte la excepción, ya que puede tragarse
             System.err.println ( "Error en la creación SessionFactory inicial." + Ex);
             arrojar nueva ExceptionInInitializerError (ex);
         }
     }

     public static SessionFactory getSessionFactory () {
         volver sessionFactory;
     }
 }
Crear el archivo de configuración hibernate.cfg.xml mencionada directamente en la carpeta SimpleJavaHibernate. Ponga la siguiente información en el interior. 
  <? Xml version = "1.0" encoding = "UTF-8"?>
 <! DOCTYPE PÚBLICO-configuración de hibernación
  "- // Hibernate / Hibernate configuración DTD 3.0 // EN"
  "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
 <Hibernate-configuration>
     <Session-factory>
         <! - Configuración de la conexión de base de datos ->
         <Property name = "connection.driver_class"> com.mysql.jdbc.Driver </ property>
         <Property name = "connection.url"> jdbc: mysql: // localhost / UserDB </ property>
         <Property name = "connection.username"> admin </ property>
         <Property name = "connection.password"> prueba </ property>

         <! - De conexiones JDBC (utilizar el built-in) ->
         <Property name = "connection.pool_size"> 1 </ property>

         <! - Dialecto SQL ->
         <Property name = "dialecto"> org.hibernate.dialect.MySQLDialect </ property>

         <! - Habilitar la administración de contexto de sesión automático de Hibernate ->
         <Property name = "current_session_context_class"> hilo </ property>

         <! - Desactivar la caché de segundo nivel ->
         <Property name = "cache.provider_class"> org.hibernate.cache.NoCacheProvider 
</ property>

         <! - Echo toda SQL ejecutada por la salida estándar ->
         <Property name = "show_sql"> true </ property>

         <! - Drop y vuelva a crear el esquema de base en el inicio ->
         <Property name = "hbm2ddl.auto"> actualización </ property>

         <! - Asignación de archivos ->
         <Mapeo de recursos = "user.hbm.xml" />

     </ Session-factory>
 </ Hibernate-configuración>
Observe que en el interior del archivo, no es un recurso de información sobre la cartografía que apuntan a user.hbm.xml archivo. Por lo tanto, crear un archivo .xml directamente bajo la carpeta SimpleJavaHibernate para mapear nuestra variables con campos en la base de datos de objetos (Plain Old Java POJO). Nombre que user.hbm.xml y escribir el siguiente código dentro de 
  <? xml version = "1.0"?>
 <! DOCTYPE PÚBLICA hibernación de mapeo 
 "- // Hibernate / Hibernate Mapping DTD 3.0 // EN"
 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

 <Hibernate-mapping>
     <Class name = "" com.daniel.model.User tabla = "usuarios">
         <nombre id = "userid" type = columna "int" = "userid">
             <clase generador = "incremento" />
         </ Id>
         <property name = "nombre">
             <nombre de columna = "nombre" />
         </ Property>
         <property name = "Apellido">
             <nombre de columna = "apellido" />
         </ Property>
         <property name = "fecha de nacimiento">
             <column name = "fecha de nacimiento" />
         </ Property>
         <property name = "email">
             <nombre de columna = "email" />
         </ Property>
     </ Class>
 </ Mapeo de Hibernate->
A continuación, crear una nueva clase en el paquete com.daniel.dao, nombrarlo UserDao.java. Dao es sinónimo de acceso a datos de objetos. Contiene la lógica de funcionamiento de bases de datos. 
  com.daniel.dao paquete;

 java.util.ArrayList importación;
 java.util.List importación;

 org.hibernate.Query importación;
 org.hibernate.Session importación;
 org.hibernate.Transaction importación;

 com.daniel.model.User importación;
 com.daniel.util.HibernateUtil importación;

 UserDao public class {

     public void addUser (usuario del usuario) {
         Transacción RRT = null;
         Session session = HibernateUtil.getSessionFactory () openSession (.);
         try {
             RRT = session.beginTransaction ();
             session.save (usuario);
             session.getTransaction () commit ().;
         } Catch (RuntimeException e) {
             si (RRT! = null) {
                 trns.rollback ();
             }
             e.printStackTrace ();
         } Finally {
             session.flush ();
             session.close ();
         }
     }

     pública deleteUser void (int id de usuario) {
         Transacción RRT = null;
         Session session = HibernateUtil.getSessionFactory () openSession (.);
         try {
             RRT = session.beginTransaction ();
             (. De usuario de clase, new Integer (ID de usuario)) 
user = Usuario (User) Session.load;
             Session.delete (usuario);
             session.getTransaction () commit ().;
         } Catch (RuntimeException e) {
             si (RRT! = null) {
                 trns.rollback ();
             }
             e.printStackTrace ();
         } Finally {
             session.flush ();
             session.close ();
         }
     }

     public void updateUser (usuario del usuario) {
         Transacción RRT = null;
         Session session = HibernateUtil.getSessionFactory () openSession (.);
         try {
             RRT = session.beginTransaction ();
             session.update (usuario);
             session.getTransaction () commit ().;
         } Catch (RuntimeException e) {
             si (RRT! = null) {
                 trns.rollback ();
             }
             e.printStackTrace ();
         } Finally {
             session.flush ();
             session.close ();
         }
     }

     Lista pública de usuario> <getAllUsers () {
         Lista <usuario> usuarios = new ArrayList <usuario> ();
         Transacción RRT = null;
         Session session = HibernateUtil.getSessionFactory () openSession (.);
         try {
             RRT = session.beginTransaction ();
             usuarios = session.createQuery ( "de usuario") .list ();
         } Catch (RuntimeException e) {
             e.printStackTrace ();
         } Finally {
             session.flush ();
             session.close ();
         }
         usuarios de retorno;
     }

     getUserById pública (int id de usuario) El usuario {
         User user = null;
         Transacción RRT = null;
         Session session = HibernateUtil.getSessionFactory () openSession (.);
         try {
             RRT = session.beginTransaction ();
             QueryString cadena = "de usuario donde id =: id";
             consulta consulta = session.createQuery (queryString);
             query.setInteger ( "id", ID de usuario);
             user = (Usuario) query.uniqueResult ();
         } Catch (RuntimeException e) {
             e.printStackTrace ();
         } Finally {
             session.flush ();
             session.close ();
         }
         volver usuario;
     }
 }
Por último, crear nuestra clase principal de la aplicación dentro del paquete com.daniel y el nombre App.java 
  com.daniel paquete;

 java.sql.SQLException importación;
 java.text.ParseException importación;
 java.text.SimpleDateFormat importación;
 java.util.Date importación;

 com.daniel.dao.UserDao importación;
 com.daniel.model.User importación;
 com.daniel.util.DbUtil importación;

 public class {App

     principales argumentos (String []) {public static void
         UserDao DAO = new UserDao ();

         // Añadir nuevo usuario
         User = usuario nuevo usuario ();
         user.setFirstName ( "Daniel");
         user.setLastName ( "NikoJdbc");
         try {
             Fecha dob = new SimpleDateFormat 
( "aaaa-MM-dd") .parse ( "02/01/1986");
             user.setDob (DOB);
         } Catch (ParseException e) {
             e.printStackTrace ();
         }
         user.setEmail ( "daniel@example.com");
         dao.addUser (usuario);
 //
 // // Usuario de actualización
         user.setEmail ( "daniel@updatedJdbc.com");
         user.setUserid (1);
         dao.updateUser (usuario);

         // Borrar usuario
         //dao.deleteUser(2);

         // Obtener todos los usuarios
         para (iter del usuario: dao.getAllUsers ()) {
             . Sistema cabo .println (ITER);
         }

         // Obtener usuario por ID
         . Sistema cabo .println (dao.getUserById (8));

         try {
             DbUtil.getConnection () close ().;
         } Catch (SQLException e) {
             e.printStackTrace ();
         }
     }

 }
Eso es. Ejecutar el proyecto de Eclipse y ver la salida de la ventana de la consola
Publicado por en No hay comentarios:

martes, 29 de marzo de 2016

BROMA


  VER VIDEO!!!

Gracioso vídeo para relajarnos un poco…pero estas ancianas me sacaron la ira…jajajaja. Unas bromas muy graciosas de ancianas que le juegan unas bromas dándoles una patatidas al policía,sin embargo culpan al transeúnte que esta al lado.

—————————————————————————————————
El escritorio del futuro ya está aquí: trabajar tumbado es más cómodo, también más saludable

Desde California nos llega el sueño de cualquiera que trabaje pasando muchas horas delante del ordenador. ¿Cómo se puede reinventar la ergonomía y el diseño de un escritorio? Partimos de una base, prácticamente inamovible, la de acomodarnos en una silla frente a un escritorio con una base horizontal sobre la que reposar la pantalla, el teclado, y el ratón. ¿Y si optásemos por tumbar la silla e inclinar el escritorio? Los creadores del Altwork Station aseguran que esta tecnología no solo hará que trabajemos más cómodos, sino que también mejoremos nuestra higiene postural y seamos más productivos. ¿En serio?
escritorio
El diseño del Altwork Station parte de estudios médicos que alertan de los peligros de trabajar sentados. En un momento en el que hasta comer hamburguesas en establecimientos de comida rápida se ha asociado con el cáncer, puede sonar a broma, pero no lo es. Una mala postura puede generar problemas muy serios en espalda y lumbares. Algunos estudios además apuntan que aquellos que pasamos buena parte del día sentados en una silla tenemos un 54% más de probabilidades de sufrir un ataque al corazón.
Esa es la razón por la cual comenzó a imponerse otra moda, la de los Standing Desk, escritorios situados a una altura más elevada de lo habitual para permitirnos trabajar de pie. En esa línea, la Altwork Station quería perfeccionar aún más la postura del que trabaja 8 horas diarias frente al ordenador.
Publicado por en 1 comentario:

JDBC

ver video


Procedimiento y Resultados:
Modelo entidad relación: “tienda”
1.    Acceso a BD desde una aplicación de consola
Aplicacion1.java
package proyecto.dao;
import java.sql.* ;
public class Aplicacion1 {
        
         public static void main(String[] args) {
                   try {
                            Class.forName("com.mysql.jdbc.Driver");
                            Connection con = DriverManager.getConnection("jdbc:mysql://localhost/tienda", "root", "");
                            Statement stmt = con.createStatement();
                            String idUsuario = "esaavedra";
                            ResultSet rs = stmt.executeQuery("select id_usuario,clave,nombres,paterno,materno,correo,direccion,telefono,estado from usuario where id_usuario=' " + idUsuario +  " ' ");
                            if(rs.next()) {
                                      System.out.println("Nombres: " + rs.getString(3));
                                      System.out.println("Paterno: " + rs.getString("paterno"));
                                      System.out.println("Correo: " + rs.getString("correo"));
                            }
                            rs.close();
                            stmt.close();
                            con.close();
                   } catch (ClassNotFoundException e) {
                            e.printStackTrace();
                   } catch (SQLException e) {
                            e.printStackTrace();
                   }
         }

}
2.    Acceso a BD desde una aplicación de consola usando DAO
Usuario.java
package proyecto.modelo;
public class Usuario {
         private String idUsuario;
         private String clave;
         private String nombres;
         private String paterno;
         private String materno;
         private String correo;
         private String direccion;
         private String telefono;
         private String estado;
     /* CREAR LOS MÉTODOS GET Y SET PARA CADA ATRIBUTO */
        
}
UsuarioDAO.java
package proyecto.dao;
import java.sql.*;
public class UsuarioDAO {
         public Usuario obtenerPorIdUsuario(String idUsuario){
                   Usuario vo = new Usuario();
                   try {
                            Class.forName("com.mysql.jdbc.Driver");
                            Connection con = DriverManager.getConnection("jdbc:mysql://localhost/tienda", "root", "");
            Statement stmt = con.createStatement();
            ResultSet rs = stmt.executeQuery("select id_usuario,clave,nombres,paterno,materno,correo,direccion,telefono,estado from usuario where id_usuario='"+
                    idUsuario + "'");
            if(rs.next()) {
                vo.setIdUsuario(rs.getString("id_usuario"));
                vo.setClave(rs.getString("clave"));
                vo.setNombres(rs.getString("nombres"));               
                vo.setPaterno(rs.getString("paterno"));
                vo.setMaterno(rs.getString("materno"));
                vo.setCorreo(rs.getString("correo"));
                vo.setDireccion(rs.getString("direccion"));
                vo.setTelefono(rs.getString("telefono"));
                vo.setEstado(rs.getString("estado"));
            }
            rs.close();
            stmt.close();
            con.close();
           } catch (ClassNotFoundException e) {
                   e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return vo;
      }
}
Aplicacion2.java
package proyecto.dao;
public class Aplicacion2 {
        
         public static void main(String[] args) {
                   UsuarioDAO dao = new UsuarioDAO();
                   Usuario u = dao.obtenerPorIdUsuario("esaavedra");
                   System.out.println(u.getNombres());
                   System.out.println(u.getPaterno());
                   System.out.println(u.getMaterno());
         }
}
Creando una clase conexión y los métodos del DAO:
·         Crear la clase ConexionBD
package proyecto.dao;
import java.sql.*;
public final class ConexionBD {
    
     public static Connection obtenerConexion() throws SQLException {
              Connection con = null;
              try {
                       Class.forName("com.mysql.jdbc.Driver");
              } catch (ClassNotFoundException e) {
                       e.printStackTrace();
              }
              con = DriverManager.getConnection("jdbc:mysql://localhost/tienda", "root", "");
              return con;
     }
}
·         En la clase UsuarioDAO, implementar los siguientes métodos:
public Collection<Usuario> buscarPorNombre(String nombre) {
        String query = "select id_usuario,clave,nombres,paterno,materno,correo,direccion,telefono,estado from usuario where nombres like '%"+nombre +"%'";
        Collection<Usuario> c = new ArrayList<Usuario>();
       
        try {
            Connection con = ConexionBD.obtenerConexion();
            Statement stmt = con.createStatement();
            ResultSet rs = stmt.executeQuery(query);
            while(rs.next()) {
                Usuario vo = new Usuario();
                vo.setIdUsuario(rs.getString("id_usuario"));
                vo.setClave(rs.getString("clave"));
                vo.setNombres(rs.getString("nombres"));              
                vo.setPaterno(rs.getString("paterno"));
                vo.setMaterno(rs.getString("materno"));
                vo.setCorreo(rs.getString("correo"));
                vo.setDireccion(rs.getString("direccion"));
                vo.setTelefono(rs.getString("telefono"));
                vo.setEstado(rs.getString("estado"));
                c.add(vo);
            }
            rs.close();
            stmt.close();
            con.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return c;
    }
     
public Usuario insertar(Usuario vo) {
              String query = "INSERT INTO usuario (id_usuario,clave,nombres,paterno,materno,correo,direccion, telefono,estado) "
                                 + "VALUES (?,?,?,?,?,?,?,?,?)";
              System.err.println(query);
              Connection con = null;
              PreparedStatement stmt = null;
              try {
                       con = ConexionBD.obtenerConexion();
                       stmt = con.prepareStatement(query);
                       stmt.setString(1, vo.getIdUsuario());
                       stmt.setString(2, vo.getClave());
                       stmt.setString(3, vo.getNombres());
                       stmt.setString(4, vo.getPaterno());
                       stmt.setString(5, vo.getMaterno());
                       stmt.setString(6, vo.getCorreo());
                       stmt.setString(7, vo.getDireccion());
                       stmt.setString(8, vo.getTelefono());
                       stmt.setString(9, vo.getEstado());
                       int i = stmt.executeUpdate();
                       if (i != 1) {
                                 throw new SQLException("No se pudo insertar");
                       }
                       stmt.close();
                       con.close();
              } catch (SQLException e) {
                       System.err.println(e.getMessage());
              }
              return vo;
     }
    public Usuario actualizar(Usuario vo) {
       
        String query = "UPDATE usuario SET clave=?, nombres=?, paterno=?, materno=?, correo=?, direccion=?, telefono=?, estado=? WHERE id_usuario=?";
        try {
            Connection con = ConexionBD.obtenerConexion();
            PreparedStatement stmt = con.prepareStatement(query);
            stmt.setString(1, vo.getClave());
            stmt.setString(2, vo.getNombres());
            stmt.setString(3, vo.getPaterno());
            stmt.setString(4, vo.getMaterno());
            stmt.setString(5, vo.getCorreo());
            stmt.setString(6, vo.getDireccion());
            stmt.setString(7, vo.getTelefono());
            stmt.setString(8, vo.getEstado());
            stmt.setString(9, vo.getIdUsuario());
           
            int i = stmt.executeUpdate();
            if(i != 1){
                throw new SQLException("No se pudo actualizar");
            }
           
            stmt.close();
            con.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return vo;
    }
public void eliminar(String idUsuario) {
        String query = "DELETE FROM usuario WHERE id_usuario=?";
        try {
            Connection con = ConexionBD.obtenerConexion();
            PreparedStatement stmt = con.prepareStatement(query);
            stmt.setString(1, idUsuario);
            int i = stmt.executeUpdate();
            if(i != 1){
                throw new SQLException("No se pudo eliminar");
            }
            stmt.close();
            con.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
 
    public Collection<Usuario> listarTodos() {
        Collection<Usuario> c = new ArrayList<Usuario>();
        try {
            Connection con = ConexionBD.obtenerConexion();
            Statement stmt = con.createStatement();
            ResultSet rs = stmt.executeQuery("select id_usuario,clave,nombres,paterno,materno,correo,direccion,telefono,estado from usuario");
            while (rs.next()) {
                Usuario vo = new Usuario();
                vo.setIdUsuario(rs.getString("id_usuario"));
                vo.setClave(rs.getString("clave"));
                vo.setNombres(rs.getString("nombres"));              
                vo.setPaterno(rs.getString("paterno"));
                vo.setMaterno(rs.getString("materno"));
                vo.setCorreo(rs.getString("correo"));
                vo.setDireccion(rs.getString("direccion"));
                vo.setTelefono(rs.getString("telefono"));
                vo.setEstado(rs.getString("estado"));
                c.add(vo);
            }
            rs.close();
            stmt.close();
            con.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return c;
    }
     
 
3. Acceso a BD desde una aplicación Web usando capas
Se rehusarán las clases Usuario y UsuarioDAO del ejercicio 2.
Estructura del proyecto
/src
   |- / proyecto.dao
                  |- UsuarioDAO
                  |- ConexionBD
   |- / proyecto.servlet
                  |- UsuarioBuscarServlet
   |- / proyecto.modelo
                  |- Usuario
    Agregar el método en UsuarioBuscarServlet.java
     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
              UsuarioDAO dao = new UsuarioDAO();
              Collection c = dao.buscarPorNombre(request.getParameter("nombre"));
              request.setAttribute("USUARIOS", c);
              RequestDispatcher rd = request.getRequestDispatcher("/usuario_buscar.jsp");
              rd.forward(request, response);
     }
usuario_buscar.jsp
<%@page import="java.util.*, proyecto.modelo.Usuario" %>
<html>
<head>
<title>Usuario Buscar</title>
</head>
<body>
<form name="f1" action="UsuarioBuscarServlet" method="post">
Nombre: <input type="text" name="nombre"/>
<input type="submit" name="enviar" value="Buscar"/>
</form>
<table border="1">
<tr>
     <th>Id</th><th>Nombre</th><th>Paterno</th><th>Email</th>
</tr>
<%
Collection<Usuario> c = (ArrayList<Usuario>)request.getAttribute("USUARIOS");
if(c != null) {
     for(Usuario vo : c) {
              out.println("<tr><td>"+vo.getIdUsuario()+"</td>");
              out.println("<td>"+vo.getNombres()+"</td>");
              out.println("<td>"+vo.getPaterno()+"</td>");
              out.println("<td>"+vo.getCorreo()+"</td></tr>");
     }
}
%>
</table>
</body>
</html>
Realizar:
  1. Crear una clase padre BaseDAO que mantenga los métodos genéricos para todos los DAO.
  2. Crear una excepción personalizada DAOExcepcion.java que encapsule las excepciones que sucedan en la capa de persistencia.
  3. Las excepciones que sucedan en los DAO no están siendo enviadas a la capa de presentación. Corregir todos los métodos para que lancen excepciones a la capa de presentación (Servlets).
Publicado por en No hay comentarios:
Suscribirse a: Entradas (Atom)