J2EE

lunes, 27 de febrero de 2012

JSF (Java Server Faces)

Patrón más maduro y recomendable de J2EE, Framework q resuelve el patrón MVC (Módelo-Vista-Controlador) + DI (Inyección de Dependencias)+ORM (Object Relactional Mapping).
Se puede decir que como Swing usa el modelo de eventos(en Swing se usa Listener).
Para resolver el MVC usaremos Servlets. JSF para la vista usa JSP+JSTL(Standard Tag Library) que usa la libreria de etiquetas:<h: html> .
Si en Spring existen los Beans y en JPA los Entitys; en JSF existen los ManagedBeans.
La anotación es @javax.faces.bean.ManagedBean y nos libra de tener que especificar esta información en el archivo XML faces-config.xml.Se puede nombrar o simplemente si se omite por defecto cogerá el nombre que le hallamos dado al archivo.
@ManagedBean(name="cargaCursoBean")

También permite definir el ámbito de las clases manejadas y las hace accesibles desde expresiones EL(Expresion Language).
@RequestScoped :Para el ámbito de petición.
@SessionScoped :Para el ámbito de sesión.
@ApplicationScoped:Para el ambito de aplicación.
@ViewScoped:Mantiene valores en la misma vista (dura mas que el Request y menos que el
Session)
@FlashScoped:Se usa para los mensajes a usuarios por ejemplo los mensajes de error.

También existe otra anotación que permite inyectar en una referencia una instancia de una clase que este siendo manejada en algún ámbito.
@ManagedProperty(value="{bean}")

Para que un objeto sea serializable basta con que implemente la interfaz Serializable. Esto se hace para poder convertir un objeto en bytes y poder ser luego recuperado.
public class SuperBeanDeCurso implements Serializable{
}

El managedBean se realiza creando una clase .java.
Para realizar la vista, nos creamos un .xhtml dentro de la carpeta war desde donde añadiremos las librerias para poder utilizar las etiquetas que nos harán falta para crear el jsf:

<!DOCTYPE html

PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"

"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en"

xmlns:f="http://java.sun.com/jsf/core"

xmlns:h="http://java.sun.com/jsf/html"

xmlns:ui="http://java.sun.com/jsf/facelets">

<h:head id="head">

</h:head>

<h:body id="body">

<h:messages></h:messages>

<h:form id="miForm">

<h:panelGroup id="panelito"

binding="#{paso1Bean.panel}">

AQUI EL PANEL

</h:panelGroup>

<h1>Edita Curso</h1>

<h:inputText binding="#{paso1Bean.texto}" id="tt"

value="#{wizardBean.curso.nombre}">

<f:ajax event="keyup"

render="botonNext tt panelito miForm"

listener="#{paso1Bean.escuchaInputAjax}"

</h:inputText>

<h:commandButton value="next" id="botonNext"

disabled="#{empty wizardBean.curso.nombre}"

action="#{wizardBean.next}" ></h:commandButton>

<h:commandButton value="back"

action="#{wizardBean.back}" ></h:commandButton>

</h:form>

</h:body>

</html>

Para visualizarlo en la barra de direcciones lo pondremos con la extensión .jsf
Pasos interactivos:
Para usar Ajax se necesita la etiqueta <h:head> es donde se coloca internamente el Javascript.
Ajax lo que hace es que recarga parte de la página ahorrando el refresco de una página entera,para mostrar los resultados de un evento.
Cada evento <f:ajax> se coloca dentro del componente relacionado.

Servlet

Todo Servlet hereda de la clase HttpServlet. Corren dentro del contexto de un servidor de aplicaciones por ejemplo Tomcat, por lo tanto este se encarga de crear el objeto Servlet:
MiServlet miservlet = new MiServlet ( );
Es usado para crear páginas web de forma dinámica a partir de los parámetros de la petición que envíe el navegador web.Puede responder ante peticiones HTTP, mediante los métodos doPost() o doGet().Cuyos parametros son: un objeto de la clase HttpServletRequest y un objeto de la clase HttpServletResponse que tienen la funcionalidad especifica de http en el envio de una respuesta o petición.

doGet() se llama después de una consulta de tipo HTTP GET. Generalmente esto ocurre cuando un usuario pulsa en un enlace o cuando se escribe directamente en la barra del navegador.

doPost() se llama después de una consulta de tipo HTTP POST.Se llama principalmente cuando el envio de datos se hace mediante un formulario HTML, haciendo click en un botón de tipo submit. Se supone que es mas seguro lo cual es ficticio también se supone que es mas rápido.

Los 2 métodos se llaman desde la implementación por defecto del método service() que se encuentra en la clase base HttpServlet.
Normalmente el navegador pide siempre páginas mediante GET y puede enviar datos bajo las dos formas (GET y POST). Las dos diferencias son que:

GET está restringido a nivel de medida de los parámetros enviados al servidor.
Se dice que el envio de datos mediante GET puede cuestionar la seguridad debido a que los parámetros se añaden a la URL, pero la seguridad del post como hemos comentado antes no se puede afirmar tampoco.

public void doGet(HttpServlet peticion, HttpServletResponse respuesta){
}

public void doPost(HttpServlet peticion, HttpServletResponse respuesta){
}

web.xml

Este fichero llamado descriptor de despliegue es usado por los Dinamic Web Projects las rutas URLs se definen aqui para indicar cual servlet es al que hay que acceder.También podemos describir los servlets utilizando anotaciones en la clase del servlet. Para poder utilizar las anotaciones debemos de utilizar un contenedor servlet que implemente la especificación 3.0, sino es así debemos de utilizar el descriptor de despliegue.

Para poder utilizar las anotaciones debemos de importar el paquete annotations y utilizar la anotación @WebServlet(“URL-Pattern”). Vamos a ver nuestros tres ejemplos utilizando las anotaciones:

package paquete;

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

@WebServlet("/ejemplo1")
public class HolaMundoServlet extends HttpServlet {
  public void doGet(HttpServletRequest peticion,
                    HttpServletResponse respuesta)
      throws ServletException, IOException {
    PrintWriter salida = respuesta.getWriter();
    salida.println("Hola Mundo!");
  }  
}

El primer elemento <web-app> indica el inicio de la aplicación, es dentro de este elemento donde se definen todos los elementos restantes.

El elemento <servlet> define las características de un servlet y a su vez está compuesto por los elementos <servlet-name> y <servlet-class> que indican un nombre corto para el servlet así como el nombre de la clase Java que contiene el servlet, respectivamente. La clase Java se indica con la ruta completa de packages.

Posteriormente se define el elemento <servlet-mapping> para establecer la ubicación en términos de URL. Está compuesto por los elementos <servlet-name> y <url-pattern> que especifican el nombre del servlet que será accedido a través del un patrón URL .

Vamos a ver como definir el descriptor de despliegue para describir los servlets que hemos utilizado en nuestra aplicación de ejemplos. Creamos un archivo nuevo en WEB-INF llamado web.xml con el siguiente contenido:

<web-app version="3.0"
         xmlns="http://java.sun.com/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
              http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">

  <servlet>
    <servlet-name>ServletEjemplo1</servlet-name>
    <servlet-class>paquete.HolaMundoServlet</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>ServletEjemplo1</servlet-name>
    <url-pattern>/ejemplo1</url-pattern>
  </servlet-mapping>

  <servlet>
    <servlet-name>ServletEjemplo2</servlet-name>
    <servlet-class>paquete.HTMLServlet</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>ServletEjemplo2</servlet-name>
    <url-pattern>/ejemplo2</url-pattern>
  </servlet-mapping>

  <servlet>
    <servlet-name>ServletEjemplo3</servlet-name>
    <servlet-class>paquete.HTMLServletConGenerador</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>ServletEjemplo3</servlet-name>
    <url-pattern>/ejemplo3</url-pattern>
  </servlet-mapping>

A continuación detallamos como sería la implementación en el mapeo de un Listener y un Filter

 <listener>      <listener-class>com.acme.MyConnectionManager</listenerclass>
   </listener>
   <listener>
      <listener-class>com.acme.MyLoggingModule</listener-class>
   </listener>
   <filter> 
    <filter-name>prePost</filter-name>
    <display-name>prePost</display-name>
    <filter-class>com.acme.filter.PrePostFilter</filter-class> 
  </filter> 
  <filter-mapping> 
    <filter-name>prePost</filter-name>
    <url-pattern>/filter3.jsp</url-pattern> 
  </filter-mapping> 
</web-app>

miércoles, 15 de febrero de 2012

JPA (Java Persistence Application)

Basada en el modelo ORM (Object-Relational Mapping), en el que se crean Objetos Persistentes (POO) para la base de datos relacional.

Nosotros hemos usado hasta ahora la API que permite la ejecución de operaciones directamente sobre bases de datos desde el lenguaje de programación Java (JDBC)
Ahora JPA se encarga de crear una capa de persistencia intermedia entre la aplicación y la base de datos.Hibernate Annotation implementa a este standard.
Trabaja con anotaciones.Usando:@Entity, @Column, @Id, @ManyToOne, @OneToOne,... etc.Estas siempre van en sus correspondientes clases persistentes:
-Para crear una de ellas se hace New/Annotation..
-La clase debe implementar Serializable.
-La clase debe de ser un POJO(Plain Old Java Object):constructor vacio o por defecto,solo Getters y Setters.Tal vez Equals and HashCode.Son solo clases contenedoras de datos y no de negocios por lo que no tienen mas que hacer.
Anotaciones minimas:
-@Entity: Se usa para la clase.
-@Id:Para los métodos.
-@GeneratedValue(Strategy=GT.Table):es el autoincrementar para la tabla correspondiente.
Anotaciones para hacer las relaciones de las tablas:
-@ManyToOne: Se situa delante del método "get" del objeto(Many) que posee la relación (ToOne) con la clase.Ejemplo:
@ManyToOne()
public Barrio getBarrio() {
return barrio;}

-@OneToMany:Se situa en el "get" de la lista que posee la clase(One) con la que tiene la relación (ToMany).Ejemplo:
@OneToMany(mappedBy = "barrio")
public List<Casa> getCasas() {
return casas;}

-@ManyToMany:Se situa en el "get" de la lista que posee la clase(Many) con la que tiene la relación (ToMany).Ejemplo:
@ManyToMany @JoinTable(name="CIUDAD_INMOBILIARIA", joinColumns= @JoinColumn(name="ciudad_id", referencedColumnName="id"), inverseJoinColumns= @JoinColumn(name="inmobiliaria_id", referencedColumnName="id")) public List <Inmobiliaria> getInmobiliarias() { return inmobiliarias; }

-@OneToOne:Se situa en el "get" de la lista que posee la clase(One) con la que tiene la relación (ToOne).A ambos lados de la relación deben estar anotados con @oneToOne.

@OneToOne(fetch=FetchType.LAZY,cascade={CascadeType.PERSIST,CascadeType.REMOVE},optional=false)
private Direccion direccion;
public Direccion getDireccion() {
return direccion;}

http://pajarokillo.wordpress.com/2011/11/17/jpa-2-0-mapeando-relaciones-one-to-one/

Creando EntityManagerFactory: Fábrica de conexiones a la base de datos.
// obtener una instancia de EntityManagerFactory usando la clase
// Persistence
// Como consejo debemos guardar la instancia de este factory para
// que no vuelva a ser creado con el objeto Persistence debido a que
// tiene un costo considerable de construcción
EntityManagerFactory factory = Persistence.createEntityManagerFactory("MyPersistenceUnitName");

// obtener una instancia de EntityManager del factory
EntityManager em = factory.createEntityManager();

// Inicio de transacción
em.getTransaction().begin();

//buscar objeto y persistirlo

Employee emp=em.find(Employee.class,id)

// Consulta para obtener todos los empleados que trabajan en una
// división de trabajo especificada y tienen un promedio de 40
// horas trabajadas a la semana
Query query = em.createQuery("SELECT e " +
" FROM Employee e " +
" WHERE e.division.name = 'Research' " +
" AND e.avgHours > 40");

// obtener una lista de resultados
List results = query.getResultList ();

//obtener un solo resultado

String nombre=query.getResult();

// establecer salario a todos los empleados
for (Object res : results) {
Employee emp = (Employee) res;
emp.setSalary(emp.getSalary() * 1.1);}

//Comprometer todos los cambios que han sido //detectados dentro de la transacción en el que se actualizarán todos los //objetospersistentes que hayamos modificado
em.getTransaction().commit();

// liberar los recursos
em.close();

Otros métodos del EntityManager:
//Hace un update
em.merge(emp);
//Hace un borrado
em.remove(emp)
//Es un commit poco a poco
em.flush( );

SPRING (MVC)

Aplicación en Capas, con Interfaces y con Inyección de Dependencias:

Cada Interfaz sirve principalmente para tratar a las clases de diferente forma, según necesidad, es decir las acciones que queremos realizar, métodos que queremos usar.Podemos asi para una misma Clase implementar varias Interfaces.

@Controller: Hace que no haga falta poner al controlador reflejado en el mapeo (.xml).

@Autowired: Indica que inyecte el Objeto del Bean declarado en el controlador.

Patron J2EE: En el controlador frontal del web.xml, todas las peticiones llegan a un solo Servlet:

<servlet>org.springframework.web.servlet.DispatcherServlet</servlet>

Desde éste se le manda al controlador la información necesaria ya que este servlet desde el doGet hace el request:

Spring Servlet{

doGet{

if (request.getParameter(x)=x.....

Controlador c=new Controlador( );

Model m=new Model( );

String v=c.helloWordl(m);

request.setAttribute(m);

request.getRequest.Dispatcher("files/vista...jsp");

}

En el applicationContext.xml se define como será el ámbito del Bean (siempre teniendo en cuenta q se trata de un proyecto web).

scopes="request"

scopes="session"

scopes="singleton"/"prototype"

Ejercicio de ejemplo Registro de Usuario:

Código del Controlador:

@Controller

public class ControladorRegistro {

@Autowired

ServicioReg Sreg;

@RequestMapping(value="registro/mail={mail}&edad={edad}&clave{clave}")//mapeo del servlet del Controlador

public String registro(@PathVariable() int edad,@PathVariable() String mail,@PathVariable() String clave, Model model) {

try {

model.addAttribute("mail","Usuario:"+ Sreg.registra(edad,mail,clave));

return "okRegistro";

} catch (EdadProblemException e) {

return "errorEdad";

} catch (ExisteUsuarioException e) {

return "usuarioExiste";}

}

martes, 14 de febrero de 2012

Coexistencia de los Distintos Frameworks de JAVA

FICHEROS DE CONFIGURACIÓN DE CADA UNO DE LOS FRAMEWORKS

Servlets: web.xml
Struts:struts-config.xml
JSF:faces-config.xml
__________________________
IOC-DI(Dependence Inyection)
Spring:applicationContext.xml
__________________________
Persistencia
JPA:persistence.xml
Hibernate:hibernate.cfg.xml, hbm.xml
__________________________
Logging
Log4j + log4j: log4j.xml, logging.properties.xml
__________________________
Spring-MVC:action-servlet.xml
__________________________
Automatización de tareas
Maven:pom.xml
Ant:build.xml

Funcionamiento de una petición con Servlets

Tomcat internamente crea los Servlets mediante: HttpServlet S1=new S1( );
usaria HttpServletRequest request=new request( );
luego ejecuta el metodo: S1 doGet(request, response) los dos parametros como vemos los crea el Tomcat.

STRUTS Y SERVLET
Struts seria una capa más. Esto da mayor independencia con las capas mas bajas cercanas a la Base de Datos.
Mi App->Struts(MVC)<---->Serclets<--->JDBC<--->BD

INTEGRACIÓN Y FUNCIONAMIENTO CON VARIOS FRAMEWORKS
(Struts, Servlets,Hibernate,Spring).En un Proyecto Web Dinámico.
En Struts como vemos tambien se crean las dependencias de los ActionForms hacia la clase Action.
Usando la URL: /*.do o *.action, como queramos llamarle.

Si activamos JSE damos de alta un Servlet que escucha una peticion hacia una URL : /*.faces

Sistemas en que se basan cada uno de los frameworks:
MVC (Modelo-Vista-Controlador): Servlets,Struts,JSF,Spring (MVC)
DI (Inyección de Dependencias): Spring,JSF,Guice,Weld(Standar de Seam)
ORM (Object-Relational Mapping): JPA,Hibernate

sábado, 11 de febrero de 2012

Struts

Es un framework de apache que tiene 2 proyectos. Nos ayuda a cumplimentar el Modelo-Vista-Controlador.

VISTA :Entorno Gráfico de la Aplicación. (JSP).

MODELO :Tiene toda la lógica del negocio.(CLASES)

CONTROLADOR: Gestiona la información.Relaciona la vista y el controlador.(SERVLET)

El controlador se encarga de que las peticiones se reciban instantaneamente sin necesidad de pasar parametros.Este controlador lo crea Struts y no hace falta codificarlo.La dirección URL usada por el servlet por defecto es "*.do", aunque se puede cambiar por ejemplo :" do.* ..... ", o posibles acciones de palancas.

Archivos que usa Struts:

-struts-config.xml : Estara la configuración de todos los objetos asociados.

-validator-rules.xml: Reglas de validación que tenemos que cumplir en cada campo(por ejemplo:e-mails)

-validation.xml: Asignación de calores a los campos de los usuarios(Rellena el formulario si existe el objeto)

-tile-defs.xml: Etiquetas o plantillas de Struts para las vistas(por ejemplo: Actionform...)

-ApplicationResource.properties: Para mensajes de error(por ejemplo: los campos de password o claves)

Clases del Api de Struts:

-ActionServlet: Donde van todas las etiquetas y donde se ejecuta la aplicación (hereda de httpServlet).

-Action: Es una clase que llama a todas las acciones o métodos del objeto(por cada petición hay un Action distinto) para ello se llama a " execute( )".

-ActionForm: Es un JavaBean, es el encargado de transportar los datos a un formulario y viceversa a traves del Action(Con ello ya no necesitamos los tan usados "getparameter( )").

-ActionMapping: Dentro del Action y se usa para saber de donde viene la petición, "execute(ActionMapping mapping,..)

-ActionForward: Redirecciona es como :"getRequestDispatcher(....).forward()".

*JavaBean:

-Atributos privados y en minúsculas.

-Constructor por defecto, sin parametros.

-Set y Get con nomenclatura de "camello".

Esquema de como seria el funcionamiento con Struts:

Esto sería la 1ª petición, para otras se repetiría el mismo procedimiento pero llamaría a otro "Action" y si existe también a otro "ActionForm".

Librería de acciones de JSP:

HTML, LOGIC, BEAN, NESTED Y TILES.

Los mas usados son los 3 primeros.

viernes, 10 de febrero de 2012

SPRING

Su principal característica es brindar un factory de objetos basado en la Inyeccion De Dependencia.

El fichero de configuración básico de Spring es el contexto de aplicación (application context. xml).
Consiste en un fichero XML donde se añadirán todos los objectos que deberán existir en la aplicación al inicializarse la misma.