Mostrar el contenido de un directorio servido por Tomcat

Para mostrar u ocultar el contenido de un directorio servido por Tomcat, se debe modificar la definición del servlet "default" en el archivo $(instalaciónDeTomcat)/conf/web.xml.

Cambiando

        <init-param>
            <param-name>listings</param-name>
            <param-value>false</param-value>
        </init-param>

por: (para que muestre el directorio)

        <init-param>
            <param-name>listings</param-name>
            <param-value>true</param-value>
        </init-param>

Tutorial de Hibernate

Este tutorial se basa en el mapeo de una base de datos en Postgresql, utilizando eclipse y el Hibernate Tools.

Primero crearemos el usuario y la base de datos a utilizar

$ createuser -P -U postgres mundo
Enter password for new role:
Enter it again:
Shall the new role be a superuser? (y/n) n
Shall the new role be allowed to create databases? (y/n) y
Shall the new role be allowed to create more new roles? (y/n) n
CREATE ROLE
$ createdb -U mundo -W mundo
Password:
CREATE DATABASE
$

Ahora con el siguiente script, creamos la estructura de la base de datos

mundo.sql

SET client_encoding = 'UTF8';
SET check_function_bodies = false;
SET client_min_messages = warning;

-- Table: continente

CREATE TABLE continente
(
codcontinente serial NOT NULL,
nombre character varying(50) NOT NULL,
CONSTRAINT pk_continente PRIMARY KEY (codcontinente)
)
WITH (OIDS=FALSE);
ALTER TABLE continente OWNER TO mundo;

-- Table: pais

CREATE TABLE pais
(
codpais serial NOT NULL,
valor character varying(50) NOT NULL,
codcontinente integer NOT NULL,
CONSTRAINT pk_pais PRIMARY KEY (codpais),
CONSTRAINT fk_continente FOREIGN KEY (codcontinente)
REFERENCES continente (codcontinente) MATCH SIMPLE
ON UPDATE NO ACTION ON DELETE NO ACTION
)
WITH (OIDS=FALSE);
ALTER TABLE pais OWNER TO mundo;

-- Index: fki_pais_continente

CREATE INDEX fki_pais_continente
ON pais
USING btree
(codcontinente);

$ psql -U mundo -W -f mundo.sql
Password for user mundo:
SET
SET
SET
CREATE TABLE
ALTER TABLE
CREATE TABLE
ALTER TABLE
CREATE INDEX
$

Ahora crearemos la aplicación que utilizará estas dos tablas.

Primero creamos un "Java Proyect"


Le agregamos las librerías necesarias para Hibernate y el driver jdbc para Postgresql

Una vez creado el proyecto, agregamos el archivo de configuración de Hibernate


Lo dejamos en la raíz del directorio de recursos.


Definimos los parámetros de conexión con la base de datos.

Creamos el "Hibernate Console Configuration", este es el perfil que define todas las características del proyecto con Hibernate.


Una vez creado el "Console Configuration", podemos ir a la vista de Hibernate y ejecutar el generador de código.


Creamos un nuevo perfil.


Le indicamos las caracteristicas de nuestro proyecto.


Le idicamos que genere los archivos de configuración de Hibernate y las clases POJO. Y ejecutamos.


Aquí podemos ver el código generado.


Luego agregamos hibernate.revenge.xml, el archivo de filtro para la ingeniería inversa.

Le indicamos que se guarde en el directorio de recursos del proyecto.

Podemos agregar algún retoque, por ejemplo, que los campos INTEGER de la base de datos, sean mapeados como java.lang.Integer.


Retocamos las claves primarias, para que utilicen la secuencia definida en la base de datos.


Lo mismo con la otra tabla.


Ahora agregagemos un par de clases de servicio, que nos ayudaran con las operaciónes CRUD.

SessionFactory.java : como su nombre lo indica es una fábrica de sesiones.

package test;

import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.cfg.Configuration;

/**
* Configures and provides access to Hibernate sessions, tied to the
* current thread of execution.  Follows the Thread Local Session
* pattern, see {@link http://hibernate.org/42.html }.
*/
public class SessionFactory {

/**
* Location of hibernate.cfg.xml file.
* Location should be on the classpath as Hibernate uses
* #resourceAsStream style lookup for its configuration file.
* The default classpath location of the hibernate config file is
* in the default package. Use #setConfigFile() to update
* the location of the configuration file for the current session.
*/
private static String CONFIG_FILE_LOCATION = "/hibernate.cfg.xml";
private static final ThreadLocal threadLocal = new ThreadLocal();
private  static Configuration configuration = new Configuration();
private static org.hibernate.SessionFactory sessionFactory;
private static String configFile = CONFIG_FILE_LOCATION;

private SessionFactory() {
}

/**
* Returns the ThreadLocal Session instance.  Lazy initialize
* the SessionFactory if needed.
*
*  @return Session
*  @throws HibernateException
*/
public static Session getSession() throws HibernateException {
   Session session = (Session) threadLocal.get();

   if (session == null || !session.isOpen()) {
       System.out.println("<<<<<<<<<>>>>>>>");
       if (sessionFactory == null) {
           rebuildSessionFactory();
       }
       session = (sessionFactory != null) ? sessionFactory.openSession()
               : null;
       threadLocal.set(session);
   }

   return session;
}

/**
*  Rebuild hibernate session factory
*
*/
public static void rebuildSessionFactory() {
   try {
       configuration.configure(configFile);
       sessionFactory = configuration.buildSessionFactory();
   } catch (Exception e) {
       System.err
               .println("%%%% Error Creating SessionFactory %%%%");
       e.printStackTrace();
   }
}

/**
*  Close the single hibernate session instance.
*
*  @throws HibernateException
*/
public static void closeSession() throws HibernateException {
   Session session = (Session) threadLocal.get();
   threadLocal.set(null);

   if (session != null) {
       session.close();
   }
}

/**
*  return session factory
*
*/
public static org.hibernate.SessionFactory getSessionFactory() {
   return sessionFactory;
}

/**
*  return session factory
*
*    session factory will be rebuilded in the next call
*/
public static void setConfigFile(String configFile) {
   SessionFactory.configFile = configFile;
   sessionFactory = null;
}

/**
*  return hibernate configuration
*
*/
public static Configuration getConfiguration() {
   return configuration;
}

}

ControlHibernate.java

package test;

import java.util.ArrayList;
import java.util.List;

import org.apache.log4j.Logger;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.Transaction;

public class ControlHibernate {

 private static Logger log = Logger.getLogger(ControlHibernate.class);

 public static List getObjetos(String hql) throws HibernateException {
  List items = new ArrayList();
  Session session = null;
  Transaction tx = null;
  session = SessionFactory.getSession();
  try {
   tx = session.beginTransaction();
   items = session.createQuery(hql).list();
   tx.commit();
  } catch (HibernateException e) {
   if (tx != null)
    tx.rollback();
   throw e;
  } finally {
   session.close();
  }
  return items;
 }

 public static void guardarObjeto(Object objeto, Integer codigo)
   throws HibernateException {
  Session session = null;
  Transaction tx = null;
  session = SessionFactory.getSession();
  try {
   tx = session.beginTransaction();
   // modifica objeto
   if ((codigo != null) && (codigo.intValue() != 0)) {
    log.info("va a hacer 'merge' de objeto");
    session.saveOrUpdate(objeto);
    session.flush();
   } else { // inserta objeto
    log.info("va a hacer 'save' de objeto");
    session.save(objeto);
   }
   tx.commit();
  } catch (HibernateException e) {
   if (tx != null)
    tx.rollback();
   throw e;
  } finally {
   session.close();
  }
 }
}

Como prueba final de este tutorial, Creamos una clase Prueba.java , que crea un objeto Pais, con un objeto Continente anidado y los almacena en la base de datos.


Aquí podemos observer que los datos se ingresaron correctamente.

También podemos utilizar el editor de sentencias HQL, para realizar pruebas.


Si tienes una crítica o aporte, no dudes en comentarla.

:wq

Creando un proyecto Flex con Java y BlazeDS con RemoteObject en entornos separados

En este tutorial explico paso a paso la creación de un proyecto Flex con Java en entornos separados (front-end - back-end), con BlazeDS y RemoteObject (en Linux).

Se asume tener instalado Jdk y con sus variables de entorno, sino puedes revisar aquí

Configuración del Back-end

Primero debemos bajar BlazeDS, en mi caso bajé el Turnkey, pues ya viene deployado el BlazeDS.
Lo dejé en /home/rene/blazeds_turnkey_3-0-0-544.

Ahora en eclipse creamos un Java Project


Le ponemos un nombre y le indicamos la ruta del Turnkey, como se vé en la imagen. Y siguiente


Establemos la carpeta src como "source folder", ya que por default no lo es. Le idicamos que las clases compiladas deben quedar en el directorio "classes". Y finalizamos

Creamos una clase de prueba.


Le ponemos nombre a la clase y la dejamos bajo un paquete.


Creamos un simple método que retorne un String.


Lo declaramos como "destination" en el archivo "flex/remoting-config.xml"


Agregamos una sección de "login-config" en el web.xml

  <login-config>
      <auth-method>BASIC</auth-method>
  </login-config>

Guardamos todo y levantamos el servidor:

$  cd blazeds_turnkey_3-0-0-544/sampledb/
rene ~/blazeds_turnkey_3-0-0-544/sampledb $  ./startdb.sh
[Server@18a7efd]: [Thread[main,5,main]]: checkRunning(false) entered
[Server@18a7efd]: [Thread[main,5,main]]: checkRunning(false) exited
[Server@18a7efd]: Startup sequence initiated from main() method
[Server@18a7efd]: Loaded properties from [/home/rene/blazeds_turnkey_3-0-0-544/sampledb/server.properties]
[Server@18a7efd]: Initiating startup sequence...
[Server@18a7efd]: Server socket opened successfully in 29 ms.
[Server@18a7efd]: Database [index=0, id=0, db=file:flexdemodb/flexdemodb, alias=flexdemodb] opened sucessfully in 1203 ms.
[Server@18a7efd]: Startup sequence completed in 1233 ms.
[Server@18a7efd]: 2008-04-30 23:14:53.387 HSQLDB server 1.8.0 is online
[Server@18a7efd]: To close normally, connect and execute SHUTDOWN SQL
[Server@18a7efd]: From command line, use [Ctrl]+[C] to abort abruptly

$  cd blazeds_turnkey_3-0-0-544/tomcat/bin/
rene ~/blazeds_turnkey_3-0-0-544/tomcat/bin $  ./startup.sh
Using CATALINA_BASE:   /home/rene/blazeds_turnkey_3-0-0-544/tomcat
Using CATALINA_HOME:   /home/rene/blazeds_turnkey_3-0-0-544/tomcat
Using CATALINA_TMPDIR: /home/rene/blazeds_turnkey_3-0-0-544/tomcat/temp
Using JRE_HOME:       /usr/local/jdk1.6.0_06
$

Comprobamos abriendo el navegador en http://localhost:8400

Configuración del Front-end

Ahora creamos un Flex Project (en el Flex Builder plugin para Linux)


En la configuración del server le indicamos donde están los servicio que vamos a consumir y donde queremos colocar lo archivos generado y compilados.

Creamos una simple aplicación que consuma el RemoteObject definido en el destination. Y ejecutamos la aplicación.


Al pinchar el botón, su label se cargará con lo que retorna el método de la clase java.

:wq