Apache sorprende con un nuevo producto, Apache TomEE (se pronuncia Tommy y es la union de TomCat y Java EE)
La idea es tener un Web Profile basado en Tomcat que no influya en este proyecto y basado en productos de apache. Veamos los productos que lo conforman:
CDI
Apache OpenWebBeans
EJB
Apache OpenEJB
Javamail
Apache Geronimo JavaMail
JPA
Apache OpenJPA
JSF
Apache MyFaces
JSP
Apache Tomcat
JSTL
Apache Tomcat
JTA
Apache Geronimo Transaction
Servlet
Apache Tomcat
Además viene una versión plus que trae los siguientes servicios:
Estuve leyendo esto y me intereso, la verdad no lo conocía (copio y pego) :
Queremos brindarte la educación, capacitación y el soporte que necesitás para ofrecerle más valor a tus clientes y, como consecuencia, hacer crecer tu negocio. Este programa es ideal para:
Webmasters y desarrolladores web
Cualquier persona o empresa que trabaje para un negocio online
Agencias de publicidad y marketing digital
Al aumentar tus habilidades online y el conocimiento de los productos de Google, tendrás herramientas para atraer potenciales clientes y aportar más y mejores beneficios a tus clientes actuales.
Google nos ofrece un nuevo servicio que es poder ver nuestro blog en forma dinámica. Es fácil, debes ingresar a : http://emanuelpeg.blogspot.com/view y hay un menú con las formas de ver el contenido.
Es muy bueno que el servicio baya mejorando y es una interesante propuesta.
No
voy a hablar del enemigo Harry Poter, si no de la base de datos
utilizada por LinkedIn. Voldemort es una base de datos NoSQL creada
por LinkedIn para solucionar un problema de escalabilidad que tenia
con las base de datos relacionales y luego donado a la comunidad. Voldemort
es
una base de datos NoSQL orientada a guardar datos de forma
clave-valor. Permite configurar diferentes Nodos los cuales contienen
los datos y a la vez los datos se van replicando de forma que si se
cae un nodo la base siga trabajando. Algunas
características de Voldemort:
Los
datos se replican automáticamente a través de
servidores múltiples.
Los
datos son automáticamente particionados por lo tanto cada
servidor contiene sólo un subconjunto de los datos
totales
Las
Fallas en el servidor son manejado de forma transparente
Permite
sereailizar con diferentes frameworks Protocol
Buffers, Thrift, Avro y
Java Serialization; además
permite seriabilizar objetos complejos como listas, arregles, etc.
Los
elementos de datos están versionados para maximizar
la integridad de los datos sin comprometer
la disponibilidad del sistema
Cada
nodo es independiente de otros nodos
Un
buen rendimiento solo nodo: se puede esperar 10-20k de
operaciones por segundo en función de las máquinas, la
red, el sistema de disco, y el factor de replicación
de datos
Utiliza
una estrategia que permite tener nodos en distintos lugares
geograficos.
Voldemort
es libre y fue escrito en java. Tiene una buena documentación y una
comunidad activa.
Hibernate define estos 3 estados, en
los cuales los objetos se encuentran durante la ejecución de nuestra
aplicación:
Transient: Un Objeto es transiente
si fue instanciado con new y no con la session de hibernate. Este
objeto no esta persistido y hibernate no lo conoce.
Persistent: Un objeto persistido
tiene una representación en la base de datos y un identificador.
Este fue guardado o recuperado de la base de datos y se encuentra en
el ámbito de la sesión de hibernate; quiere decir que hibernate
conoce este objeto. Hibernate detecta los cambios en el objeto y
sincroniza con el estado de la base de datos.
Detached: Un objeto es detached
cuando ha sido persistido pero la sesión de hibernate se cerro. La
referencia al objeto es valida y puede ser re-atachada a otra sesión
de hibernate, por ejemplo con el método saveOrUpdate.
En la siguiente imagen podemos ver como
es la transición entre estados de un objeto con hibernate:
Hoy
en día ya paso la furia por NoSQL, podemos decir que esta en un
crecimiento constante. NoSQL es un movimiento que surgió dado
requerimientos no funcionales de aplicaciones que no podian ser
subsanados con bases relacionales. Las bases NoSQL sacrificaron
requerimientos de integridad de datos por requerimientos de
escalabilidad y performance. NoSQL
es una etiqueta en la cual entran todas las bases no relacionales.
Existen gran cantidad de diferentes soluciones etiquetadas como
NoSQL,
Bases
orientadas a grafos (Neo4j) orientada a busquedas en grafos.
Bases
documentales (MongoDb, Apache CouchDB) guardan estructuras complejas de
datos; y pueden guardar diferentes estructuras.
Bases
Clave-Valor (Voldemort): se guardan los datos por clave-valor.
Bases basadas en columnas (Apache Cassandra, BigTable, HBase)
Y
hasta bases orientadas a objeto como db4o son llamadas NoSQL.
Antes
de utilizar un producto NoSQL debe tener en cuenta que cada producto
fue hecho para una realidad diferente y para atacar un problema
particular; es menos generico que las bases relacionales. Por lo
tanto debe ser cuidadoso y analizar bien sus requerimientos no
funcionales para dar justo en la tecla.
No
hay que tener miedo de mezclar bases NoSQL con base de datos
relacionales dado que en una misma aplicación podemos tener
problemas diferentes y por lo tanto soluciones diferentes. Las
Bases NoSQL funcionan y han solucionado muchos problemas, es hora de
probarlas y utilizarlas si se justifica.
Para estas relaciones se puede utilizar una foreing key o algo menos común que las dos tablas tengan similar Id.
Con una relación many-to-one podremos mapear la relación uno a uno utilizando foreing key:
Cuando queremos tener similar primary key debemos utilizar una relación one-to-one:
Para que tome el mismo key no hay que especificar la propiedad “koreing-key”
Mapeo muchos a uno
En este caso puede haber dos situaciones que sea una relación unidireccional o una relación bidireccional.
En el caso de la relación unidireccional se mapea de la siguiente manera:
En el caso de la relación bidireccional se mapea de la siguiente manera:
Mapeos uno a muchos
En este caso también tenemos 2 situaciones unidireccional y bidireccional.
La unidireccional se mapea de la siguiente manera:
La relación bidireccional es similar a la que vimos en many-to-one bidireccional:
Mapeo muchos a muchos
EL mapeo muchos a muchos siempre es bidireccional y se mapea como dos colecciones indicandole el nombre de la tabla relación, la cual va a tener los ids de las diferentes entidades; el mapeo sera como el siguiente:
Hibernate provee 3 estrategias para resolver el mapeo de herencias.
La primera es utilizar una sola tabla lo que es recomendable cuando los objetos “hijos” o subclases no agregan gran cantidad de propiedades.
La segunda es utilizar una tabla para la clase “Padre” y los atributos de las subclases en otras tablas.
La tercera es utilizar una tabla por clase.
Si utilizamos una sola tabla deberíamos utilizar una columna que indique de que tipo es el registro que se esta guardando. Este registro se llama discriminator . Por ejemplo en el mapeo de nuestra clase padre deberíamos agregar la siguiente entrada para indicar el dicriminador:
Y además debemos indicar la subclase:
.....
Con anotaciones podemos hacerlo como muestra el ejemplo:
@Entity
@Inheritance(strategy=InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(
name="planetype",
discriminatorType=DiscriminatorType.STRING
)
@DiscriminatorValue("Plane")
public class Plane { ... }
@Entity
@DiscriminatorValue("A320")
public class A320 extends Plane { ... }
Si utilizamos una tabla con los datos genéricos y otras por subclase se debe mapear de la siguiente manera:
.....
El atributo key indica cual es el nombre de la columna que contiene el id de la clase padre. Veamos un ejemplo:
...
Si utilizamos una tabla por clase se debe declarar de la siguiente manera:
.....
En este caso no es necesario un discriminador ya que cada tabla tiene su clase.
Es
una noticia que se venia venir; oracle anuncio que va a cambiar el
modo en que hace dinero con mysql . Ahora va a tener un “core”
libre y productos comerciales ni libres, ni gratuitos. Imagino que
muchas empresas que optaron por el software libre van a pasarse a
otros proyectos. Me
imagino que esto impulsara el proyecto MariaDB en el que esta
trabajando Monty el creador de MySQL. Creo que también le dará un
empujón a PostgreSQL que viene creciendo de una forma constante. No
estoy en desacuerdo que una empresa haga dinero, es su objetivo pero
creo que por nada del mundo puede cambiar el modelo de negocio de uno
de sus productos. No solo porque pierde credibilidad sino que porque
tambien esta traicionando a sus clientes. Que
opinan de esta noticia?
Bueno ahora viene mi opinión, creo que nuestra profesión es fantástica, si te gusta estudiar todo el tiempo, evolucionar, actualizar constantemente.
El conjunto de incumbencias de nuestra profesión nos posibilitan a dirigir proyectos como a programar y aquí el problema porque el programar nos deja en competencia con el programador de la esquina que sin desmerecer a los programadores de raza (o que aprendieron "de la vida") cobra mucha veces más barato o se olvida de la calidad en pos de un buen precio.
Creo que el mercado es amplio hoy en día todos tenemos oportunidad es necesario saber "venderse" para dejar sentado nuestra calidad. Calidad que se ve reflejada por el precio, los tiempos y el código. Estoy convencido que este es el camino para crecer como profesión.
Hibernate nos permite definir las relaciones de nuestros objetos con las tablas de la base de datos por medio de un archivo xml y por medio de anotaciones en la clase.
Veamos con mayor detalle las partes de este mapeo.
Primero se define la clase y la tabla:
< class name="event" table="events">
...
Cuando usamos anotaciones llamamos a @Entity que indica que la clase es una entidad manejada por hibernate y se va a persistir. Además con @Table indicamos el nombre de la tabla.
Luego se puede definir el id, de la siguiente forma:
name: Indica el nombre de la propiedad.
type: indica el tipo.
column: la columna en la base de datos.
unsaved-value: Valor que toma cuando el objeto no esta guardado.
access: como va aceder hibernate a esta propiedad.
Esto es similar a utilizar la anotación @Id en Jpa.
El generator es el motor que indica como hibernate se va a manegar para obtener los números de las claves nuevas.
Hibernate ofrece varias estrategias:
IDENTITY: soporta id autoincrementales en DB2, MySQL, MS SQL Server, Sybase and
HypersonicSQL .
SEQUENCE : Usa secuencias de la base.
TABLE: Toma el nombre de la tabla y la columna como fuente y genera una un identificador a partir de estas.
AUTO: Toma el más conveniente según el motor de base de datos.
Cuando son claves compuestas las cuales se encuentran en una clase embebida se puede definir de la siguiente manera:
......
Cuando tenemos claves compuestas que no se encuentren en una clase envevida podremos definirla de la siguiente manera:
Version
Cuando queremos que hibernate detecte los conflictos podemos agregar un campo versión, que indica la versión del registro. De esta forma hibernate incrementara este registro cada vez que guarde.
También se puede utilizar un timestamp para mantener la versión de los registros.
Con anotaciones podemos usar el @Version.
Property
Con Property declaramos una propiedad de nuestro objeto:
Componentes o objetos embebidos
Se pueden definir estructuras de objetos contenidos en el archivo contenedor, de esta forma nos ahorramos hacer un archivo de mapeo. Cuando la clase contenida es utilizada en 2 o más clases no es conveniente utilizar componentes.
Es una visión de las empresas de software, habría que hacer un articulo pero desde la visión de los programadores.
En mi opinión creo que unas de las razones del recambio es que las empresas de software no comparten sus ganancias. Todo es dinero y me parece genial que empresas ganen bien; pero esas ganancias se deben reflejar también en el sueldo de sus empleados.
Hacer mvn clean install y mvn eclipse:eclipse. Refrescar el proyecto en eclipse para que tome los cambios.
Generar clase y su mapeo:
Creeamos una clase persona:
package com.ejemplo;
/**
* @author emanuel
*
*/
public class Persona {
private Long id;
private String nombre;
private String apellido;
public Persona(String nombre, String apellido) {
super();
this.nombre = nombre;
this.apellido = apellido;
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
public String getApellido() {
return apellido;
}
public void setApellido(String apellido) {
this.apellido = apellido;
}
//Constructor usado por hibernate
protected Persona() { }
}
Ahora creamos el archivo de mapeo, el cual es un archivo .xml el cual es deseable (no obligatorio) que se llame igual que la clase que mapea y se encuentre en la carpeta resources con la estructura de paquete que tiene la clase, por lo tanto el path sería:
main/resources/com/ejemplo/persona.hbm.xml y el archivo sería como el siguiente:
Configurar hibernate:
Para configurar hibernate es necesario generar un archivo hibernate.cfg.xml y guardarlo en la carpeta resources. Este archivo contendra la siguiente información:
Ahora vamos a crear una clase util, la cual sera encargada de generar las sessiones de Hibernate:
package com.ejemplo.util;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
public class HibernateUtil {
private static final SessionFactory sessionFactory = buildSessionFactory();
private static SessionFactory buildSessionFactory() {
try {
// Create the SessionFactory from hibernate.cfg.xml
return new Configuration().configure().buildSessionFactory();
} catch (Throwable ex) {
// Make sure you log the exception, as it might be swallowed
System.err.println("Initial SessionFactory creation failed." + ex);
throw new ExceptionInInitializerError(ex);
}
}
public static SessionFactory getSessionFactory() {
return sessionFactory;
}
public static void shutdown() {
// Close caches and connection pools
getSessionFactory().close();
}
}
Crear un test:
Vamos a generar un test para probar como todo funciona:
package com.ejemplo;
import static org.junit.Assert.*;
import java.util.List;
import org.hibernate.classic.Session;
import org.junit.Test;
import com.ejemplo.util.HibernateUtil;
public class HibernateTest {
@Test
public void test() {
Persona persona = new Persona("Juan","Rodriguez");
Session session = HibernateUtil.getSessionFactory().openSession();
session.beginTransaction();
session.save(persona);
session.flush();
List personas = session.createQuery("from Persona").list();
assertFalse(personas.isEmpty());
Persona personaGuarda = (Persona) session.get(Persona.class, persona.getId());
assertEquals(persona, personaGuarda);
}
}
Crear esquema en la base de datos:
Es necesario escribir un esquema llamado prueba en la base de datos Mysql.
