CRaZy TeaM » Julian http://www.crazyteam.es Artículos sobre noticias de informática, programación y juegos en red Wed, 30 Nov 2011 18:28:12 +0000 en hourly 1 http://wordpress.org/?v=3.2.1 Persistencia (I): Hibernate básico http://www.crazyteam.es/general/persistencia-i-hibernate-basico/ http://www.crazyteam.es/general/persistencia-i-hibernate-basico/#comments Tue, 18 Nov 2008 16:38:23 +0000 Julian http://www.crazyteam.es/?p=264 Para empezar debemos realizar un pequeño repaso a lo que nos referimos con persistencia, más allá de la mera definición de la RAE este termino surge como la manera de almacenar nuestros objetos en un soporte relacional; es decir como guardar nuestros objetos a base de datos directamente.

El problema es que es como mezclar aceite y agua, aquello no se mezcla ni une, ya que las bases de datos suelen estar orientadas en un modelo relacional y el software orientado en un modelo objetual. Esto hace optemos con frecuencia por soluciones de unir ambos modelos con unas clases dao que muchas veces son meros parseadores de las respuestas a nuestras consultas SQL.

Aquí es donde aparece Hibernate para aportarnos todo eso de una manera más o menos transparente.

Ejemplo para insertar un registro en una tabla habitualmente se utiliza una estructura de este tipo.

Class.forName(“org.oracle.jdbcDriver”);
String url = “jdbc:oracle:@database”;
Connection connection = DriverManager.getConnection(url, “usuario”, “password”);
String ins = “INSERT INTO COCHES VALUES(1, ‘Audi’)”;
Statement stmt = null;
stmt = connection.createStatement();
stmt.executeUpdate(ins);

Con Hibernate, escribiríamos algo similar a esto:

Configuration conf = new Configuration();
conf.addClass(Coches.class);
SessionFactory sessionFactory = conf.buildSessionFactory();
Session session = sessionFactory.openSession();
Coche coche = new Coche();
coche.setModelo(“Audi”);
session.save(coche);
session.flush();
session.close();

Y si nos interesase añadir otro modelo:

session = sessionFactory.openSession();
coche = new Coche();
coche.setModelo(“Ford”);
session.save(coche);
session.flush();
session.close();

Vemos que hay una gran diferencia entre ambos métodos, ya que en el segundo caso pasamos del SQL a simplemente decir que queremos “salvar” un coche.

A la hora de buscar también sabemos cual puede ser el lío con la técnica habitual mientras que con Hibernate se reduce a:

session = sessionFactory.openSession();
String qry = “FROM beans.Coche AS P
WHERE P.Modelo = ‘Audi’
ORDER BY P.Modelo”;
List coches = session.find(qry);
session.close();
for (int i = 0; i < coches.size(); i++) {
Coche c = (Coche)coches.get(i);
…….
}

¿Ya está así de sencillo?
No todo iba a ser así de fácil, para que Hibernate consiga realizar esto debemos realizar un mínimo de configuración:

1. Hibernate.properties: En el que se especifica contra que base de datos y que lenguaje conectaremos y cómo lo haremos.
2. NombreDeClasse.hbm.xml: En el que se describe cómo se relacionan nuestras clases con las tablas.

Hibernate.properties

En este archivo, se pueden especificar muchísimas cosas. Nos limitaremos, por ahora, a proporcionar los datos necesarios para que Hibernate se pueda conectar a nuestra base de datos HSQLDB. Este sería, pues, el mínimo necesario para funcionar:

## HypersonicSQL
hibernate.dialect net.sf.hibernate.dialect.HSQLDialect
hibernate.connection.driver_class org.hsqldb.jdbcDriver
hibernate.connection.username usuario
hibernate.connection.password pasword
hibernate.connection.url jdbc:hsqldb:hsql://localhost

Solo hay que configurar pocos datos. Además dentro de la propia distribución de Hibernate en el fichero vienen ejemplos para todas las bases de datos que soporta Hibernate solo tenemos que descomentar nuestro tipo de bbdd y comenzar.

NombreDeClase.hbm.xml
Este es el archivo que vincula nuestra clase (bean) con la bbdd. Este ejemplo es el que se corresponde con la clase Coche (Coche.hbm.xml).

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">

<hibernate-mapping>
<class name=" beans.Coche" table="coches">
<id name="id" type="integer" column="ID" unsaved-value="-1">
<generator class="identity"/>
</id>

<property name="modelo" column="MODELO"
type="string"
unique=”true”
not-null="true"/>
</class>
</hibernate-mapping>

Para nuestro bean Coche:

Package beans;

public class Coche {
/** Identificador único */
int id;
String modelo;

public String getModelo() {
return modelo;
}

public int getId() {
return id;
}

public void setModelo(String nuevoModelo) {
modelo = nuevoModelo;
}

public void setId(int nuevoId) {
id = nuevoId;
}

public String toString() {
return getId() + " " + getModelo();
}
}

Y con esto si que estaría todo, solo faltaría ubicar correctamente nuestros ficheros de configuración, el Coche.hbm.xml en el mismo directorio de la clase, y el fichero
Hibernate.properties en la raíz de nuestro árbol de paquetes.

Ahora os voy a presentar un pequeño ejemplo de funcionalidad de Hibernate:

public void anadir(String modelo) {
Coche categoria = new Coche();
coche.setModelo(modelo);

//Obtenemos la configuración
Configuration conf = new Configuration();
//Buscamos el mapeo de nuestra clase
conf.addClass(Coche.class);
//Construimos la sesion
SessionFactory sessionFactory = conf.buildSessionFactory();
Session session = sessionFactory.openSession();
//iniciamos la transaccion
Transaction tx = session.beginTransaction();
// Guardamos la nueva Categoria en la base de datos
session.save(coche);
// Confirmamos la transacción
tx.commit();
// Cerramos la sesión
session.close();
}

Configuration conf = new Configuration();
conf.addClass(Categoria.class);
SessionFactory sessionFactory = conf.buildSessionFactory();
Session session = sessionFactory.openSession();
Categoria categ = new Categoria();
categ.setCategoria(“Profesor”);
session.save(categ);
session.flush();
session.close();

Otro ejemplo:

public void borrar(int id) {
[…]
Coche coche = new Coche();
coche.setId(id);
Transaction tx = session.beginTransaction();
session.delete(coche);
tx.commit();
[…]
}

Por supuesto todo esto solo es la punta de Hibernate, os recomiendo que paséis por la página y deis un vistazo, sobre todo a que actualmente soporta mas de 20 diferentes tipos de bases de datos.
Hemos visto que la presencia de los archivos de configuración y demás hace que nuestra aplicación se vuelve un poco compleja, en próximos post analizaremos las anotaciones en java y su aplicación con Hibernate.

Enlace: Hibernate

No hay artículos relacionados. Echa un ojo a estos:

    ]]>     http://www.crazyteam.es/general/persistencia-i-hibernate-basico/feed/ 0     Uso de filtros en Java http://www.crazyteam.es/general/uso-de-filtros-en-java/ http://www.crazyteam.es/general/uso-de-filtros-en-java/#comments Tue, 11 Nov 2008 11:28:44 +0000 Julian http://www.crazyteam.es/?p=177 Vamos a explicar por encima un mecanismo muy potente que se puede utilizar en el diseño modular de portales java, normalmente al desarrollar portales siguiendo un patrón MVC o utilizando algún Framework que lo implemente como Struts o Spring.

    Siempre nos surge la necesidad de desarrollar la seguridad o controlar los “eventos” de navegación, para este caso existen los Filtros, un filtro permite que determinada petición o respuesta sea analizada bajo ciertas condiciones.

    Una de las principales características de un filtro es que puede ser colocado en cualquier punto del flujo de la aplicación, ya sea entre una solicitud de JSP a JSP, Servlet a Servlet, o inclusive Servlet/JSP a HTML, la única condición que debe cumplirse es que debe existir un objeto de entrada (ServletRequest) y otro de salida (ServletResponse).

    Ahora bien, solo queda pensar para que queremos usar nuestro filtro, su uso normal se suele aplicar para “tracear” el flujo de la aplicación con las llamadas que se van realizando, comprobar la sesión del usuario así como implementar la seguridad del portal.

    A continuación vamos a mostrar un ejemplo de un filtro.


    Primero debemos definir el filtro a utilizar, para ello construimos nuestra clase filtro que implementa en interface Filter:

    package es.crazyteam;

    import java.io.*;
    import javax.servlet.*;
    import javax.servlet.http.*;

    public class FiltroUsuario implements Filter
    {

    private FilterConfig config;
    private String urlLogin;

    public void init(FilterConfig config) throws ServletException {
    this.config = config;

    //Tambien se pueden cargar los parametros
    //Configura url desconexión
    this.urlLogin = filterConfig.getInitParameter(“urlLogin”);
    if (urlLogin == null || urlLogin.trim().length() == 0) {
    //Error al cargar la url de login
    throw new ServletException("No se ha configurado URL de login");
    }
    }

    public void destroy() {
    config = null;
    }

    public void doFilter(ServletRequest request, ServletResponse response,FilterChain chain) throws IOException, ServletException {

    chain.doFilter(request, response);

    // Extraer Sesión
    HttpSession session = ((HttpServletRequest)request).getSession();

    if(session.getAttribute("usuario")==null)
    {
    //NO hay una session con ususario
    RequestDispatcher dispatcher =                                                          request.getRequestDispatcher("/"+urlLogin);
    dispatcher.forward(request, response);
    }

    }
    }

    Una vez definido nuestro Filtro solo tenemos que indicar en el web.xml donde aplicarlo:

    <?xml version="1.0" encoding="ISO-8859-1"?>

    <!DOCTYPE web-app
     PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
     "http://java.sun.com/dtd/web-app_2_3.dtd">

    <web-app>
     
        <filter>
          <filter-name>FiltroSesion</filter-name>
          <filter-class>es.crazyteam. FiltroUsuario</filter-class>
          <init-param>
           <param-name>urlLogin</param-name>
           <param-value>Login.jsp</param-value>
          </init-param>
        </filter>

        <filter-mapping>
           <filter-name>FiltroSesion</filter-name>
           <url-pattern>/menu.jsp</url-pattern>
        </filter-mapping>

    </web-app>

    Aquí vemos en nuestro filtro como cuando invoquemos la url menu.jsp ira al filtro a comprobar si tenemos sesión, de no tenerla nos mostrará la página de login.

    Con los filtros también hay que tener especial cuidado en no crear bucles, por ejemplo si en nuestro filtro definimos el patrón *.jsp cuando intentemos entrar a la página de login.jsp al pasar por el filtro verá que no tenemos sesión y nos intentará enviar otra vez a la misma página a lo que se volverá a aplicar el mismo filtro y entraremos en un bucle infinito. Para evitar esto bastará con tener cuidado con la aplicación de los filtros adecuándolos al flujo de la aplicación. O simplemente añadiendo una excepción en el filtro para nuestra página de login.

    No hay artículos relacionados. Echa un ojo a estos:

      ]]>       http://www.crazyteam.es/general/uso-de-filtros-en-java/feed/ 5       Personalizar i18n en Spring Framework http://www.crazyteam.es/general/personalizar-i18n-en-spring-framework/ http://www.crazyteam.es/general/personalizar-i18n-en-spring-framework/#comments Fri, 07 Nov 2008 10:41:17 +0000 Julian http://www.crazyteam.es/?p=68

      Puede que haya circunstancias en las que no queramos utilizar la traducción mediante i18n por defecto y prefiramos usar nuestro propio gestor de idioma.

      En el archivo de configuración de spring myservlet-spring.xml añadimos el bean que usaremos, lo único obligatorio es el nombre del  id del bean que llamarán las tags de spring.

      <bean id="messageSource" class="es.crazyteam.GestorMensajes"/>

      Para buscar un mensaje desde nuestras jsps se utiliza el tag de spring:

      <spring:message code="mensaje-idioma"/>

      ¿ya funciona?, efectivamente nó falta crear la clase del bean, para ello crearemos una clase de ejemplo como la que sigue:

      package es.crazyteam;

      import org.springframework.context.support.AbstractMessageSource;

      public class GestorMensajes extends AbstractMessageSource{
      /** Metodo obligatorio a implementar por heredar AbstractMessageSource este método es al que invoca spring */
      public MessageFormat resolveCode(String a,Locale s){

      //Crear mis locales
      Locale l=new Locale("es","ES");
      return createMessageFormat(getMensaje(a),l);
      }
      private String getMensaje(String mensaje){

      return "Este es el mensaje "+mensaje;
      }

      }

      Ahora ya tenemos todo lo necesario para gestionar nuestros mensajes.

      No hay artículos relacionados. Echa un ojo a estos:

        ]]>         http://www.crazyteam.es/general/personalizar-i18n-en-spring-framework/feed/ 0