Programación java

Tienen lugar dos maneras de insertar código JavaScript dentro de una página escribiendo código en la misma (en ingles inline) o a través de un archivo externo utilizando la etiqueta script. El orden en el cual se incluye el código es significativo un código que depende de otro debe ser incluido después del que referencia (Ejemplo Si la función B depende de A el orden debe ser AB y no BA).

Para mejorar el rendimiento de la página el código JavaScript debe ser incluido al final del HTML. Además cuando se labora en un ambiente de producción con múltiples ficheros JavaScript éstos deben ser combinados en un solo archivo.

Ejemplo de código JavaScript en línea

script
console.log('hello')
script
Ejemplo de inclusión de un archivo externo JavaScript

script src='/js/jquery.js'script

Una de las funciones de Hibernate puede generar DDL desde sus ficheros de mapeo. El esquema generado incluye restricciones de integridad referencial claves principales y foráneas para las tablas de entidades y colecciones. También se creen tablas y secuencias para los generadores de identificadores mapeados.

Tiene que especificar un Dialecto SQL por recurso de la propiedad hibernate.dialect al usar esta dispositivo ya que el DDL es altamente específico de acuerdo con el vendedor.

Primero debe personazar sus ficheros de mapeo para mejorar el esquema generado. La próximo sección aborda la personalización del esquema.

21.1.1. Personalización del esquema

Muchos fundamentos de mapeo de Hibernate determinan atributos opcionales denominados length exactitud y scale. Con estos atributos puede establecer el dimensión la precisión y la escala de una columna.


property name=zip length=5

property name=balance precision=12 scale=2
Determinadas etiquetas también aceptan un atributo not-null para generar una restricción NOT NULL en columnas de tablas y un atributo unique para generar restricciones UNIQUE en columnas de tablas.


many-to-one name=bar column=barId not-null=true

element column=serialNumber type=long not-null=true unique=true
Se puede usar un atributo unique-key para agrupar columnas en una restricción de clave única. Actualmente el valor especificado del atributo unique-keyno se emplea para nombrar la restricción en el DDL generado. Sólamente se emplea para agrupar las columnas en el archivo de mapeo.


many-to-one name=org column=orgId unique-key=OrgEmployeeId
property name=employeeId unique-key=OrgEmployee
Un atributo index especifica el nombre de un índice que se creará utilizando la columa o las columnas mapeadas. Se pueden ser agrupar múltiples columnas debajo el mismo índice simplemente especificando el mismo nombre de índice.


property name=lastName index=CustName
property name=firstName index=CustName
Un atributo foreign-key se puede utilizar para sobreescribir el nombre de cualquier restricción de clave foránea generada.


many-to-one name=bar column=barId foreign-key=FKFooBar
Muchos fundamentos de mapeo también aceptan un fundamento column hijo. Esto es particularmente útil para mapear tipos de multi-columna


property name=name type=my.customtypes.Name
column name=last not-null=true index=bar_idx length=30
column name=first not-null=true index=bar_idx length=20
column name=initial
property

El atributo default le faculta especificar un valor por defecto para una columna. Usted le debe asignar el mismo valor a la propiedad mapeada antes de guardar una nueva instancia de la clase mapeada.


property name=credits type=integer insert=false
column name=credits default=10
property


version name=version type=integer insert=false
column name=version default=0
property

El atributo sql-type faculta al usuario sobrescribir el mapeo por defecto de tipo Hibernate a tipo de datos SQL.


property name=balance type=float
column name=balance sql-type=decimal(133)
property

El atributo check le faculta especificar una comprobación de restricción.


property name=foo type=integer
column name=foo check=foo
10
property


class name=Foo table=foos check=bar 100.0
...
property name=bar type=float
class

La próximo tabla resume estos atributos opcionales.

Los operadores de comparación facultan comprobar si determinados valores son equivalentes o idénticos.

Operadores de Comparación

var foo = 1
var cantina = 0
var baz = '1'
var bim = 2

foo == cantina // devuelve falso (false)
foo != cantina // devuelve verdadero (true)
foo == baz // devuelve verdadero (true) tenga cuidado

foo === baz // devuelve falso (false)
foo !== baz // devuelve verdadero (true)
foo === parseInt(baz) // devuelve verdadero (true)

foo bim // devuelve falso (false)
bim baz // devuelve verdadero (true)
foo = baz // devuelve verdadero (true)

El propósito de la comparación es presentar diferencias entre EJB y Spring. Para llegar a esta objetivo se han seleccionado los próximos criterios

Empleo de transacciones (Transaction Manager) la comparación debe permitir comdetener las distintos clases de implementación de transacciones que están soportadas
Oportunidades de criterios de transacción incluidos (Transaction Opportunities) atributos soportados niveles de isolation3) soporte de transacciones anidadas.
Empleo de entidades de persistencia (Entity Persistente) que permitan valorar funcionalidad para persistencia de objetos Object-Relational Mappings (ORM)
AOP (Interceptors) muestran como se provee funcionalidad para programación enfocada a aspectos
Configuración de aplicaciones (Application Configuration) la probabilidad de instalar la configuración de la aplicación y servicios declarativos
Seguridad (Security) la comparación presenta como se proporcionan distintos niveles de seguridad.
Flexibilidad de servicios (Service Flexibility) valorar la probabilidad de reemplazar servicios por otros
Servicios de integración (Service Integration) detecta las facilidades de integración en especial con los servidores de aplicaciones.
Funcionalidad adicional (Additional Functionality) detalla funcionalidad adicional provista por el framework
Criterios para testing (Testability Criterion) en este criterio se explora la facilidad para hacer test en manera conjunta y de todos los componentes por separado.
Madurez de la tecnología y soporte (Technology Maturity and support). Este criterio explora la madurez del artículo y si la compañía proporciona soporte para el mismo.
Precio (Price) probable precio y costos afiliados del artículo.
Documentación (Documentation) investiga si se provee de documentación ejemplos y de soporte para los mismos.

A veces se quiere ejecutar un bloque de código debajo ciertas cláusulas. Las estructuras de control de flujo — a través de la utilización de las declaraciones if y else facultan realizarlo.

Control del flujo

var foo = true
var cantina = false

if (bar) {
// este código jamás se ejecutará
console.log('hello!')
}

if (bar) {
// este código no se ejecutará
} else {
if (foo) {
// este código se ejecutará
} else {
// este código se ejecutará si foo y cantina son falsos (false)
}
}
Nota

En una línea singular cuando se escribe una declaración if las llaves no son estrictamente necesarias sin embargo es recomendable su utilización ya que hace que el código sea mucho más legible.

Debe tener en cuenta de no definir funciones con el mismo nombre múltiples veces dentro de declaraciones if/else ya que puede conseguir frutos no esperados.

Se aconseja que la org.hibernate.SessionFactory cree y almacene en pool conexiones JDBC por usted Si adopta este enfoque el abrir una org.hibernate.Session es tan simple como

Session session = sessions.openSession() // open a new Session
En el momento en que inicie una tarea que requiera entrada a la fundamento de datos se obtendrá una conexión JDBC del pool.

Para que esto funcione primero requiere pasar determinadas las propiedades de conexión JDBC a Hibernate. Todos los nombres de las propiedades de Hibernate y su semántica están definidas en la clase org.hibernate.cfg.Environment. Ahora describiremos las configuraciones más significativos para la conexión JDBC.

Hibernate obtendrá y tendrá en pool las conexiones utilizando java.sql.DriverManager si configura las próximos propiedades

Propiedades JDBC de Hibernate

Nombre de la propiedad Propósito
hibernate.connection.driver_class JDBC driver class
hibernate.connection.url JDBC URL
hibernate.connection.username database user
hibernate.connection.password database user password
hibernate.connection.pool_size maximum number of pooled connections

Sin embargo el algoritmo de pooling de la conexión particular de Hibernate es algo rudimentario. Está concebido para ayudarle a comenzar y no para utilizarse en un sistema de producción ni siquiera para pruebas de rendimiento. Para conseguir un mejor rendimiento y continuidad debe utilizar un pool de terceros. Sólo remplace la propiedad hibernate.connection.pool_size con configuraciones específicas del pool de conexiones. Esto desactivará el pool interno de Hibernate. Por ejemplo es probable utilizar C3P0.

C3P0 es un pool de conexiones JDBC de código abierto distribuido junto con Hibernate en el directorio lib. Hibernate utilizará su org.hibernate.connection.C3P0ConnectionProvider para pooling de conexiones si constituye propiedades hibernate.c3p0.*. Si desea utilizar Proxool refiérase a hibernate.properties incluído en el paquete y al sitio web de Hibernate para conseguir más información.

Aquí hay un archivo hibernate.properties de ejemplo para c3p0

hibernate.connection.driver_class = org.postgresql.Driver
hibernate.connection.url = jdbcpostgresql//localhost/mydatabase
hibernate.connection.username = myuser
hibernate.connection.password = secret
hibernate.c3p0.min_size=5
hibernate.c3p0.max_size=20
hibernate.c3p0.timeout=1800
hibernate.c3p0.max_statements=50
hibernate.dialect = org.hibernate.dialect.PostgreSQLDialect
Para su utilización dentro de un servidor de aplicaciones casi siempre usted debe configurar Hibernate para conseguir conexiones de un javax.sql.Datasource del servidor de aplicaciones registrado en JNDI. Necesitará establecer al menos una de las próximos propiedades

Propiedades de la Fuente de Datos de Hibernate

Nombre de la propiedad Propósito
hibernate.connection.datasource datasource JNDI name
hibernate.jndi.url URL del proveedor JNDI (opcional)
hibernate.jndi.class clase del JNDI InitialContextFactory (opcional)
hibernate.connection.username usuario de la fundamento de datos (opcional)
hibernate.connection.password contraseña del usuario de la fundamento de datos (opcional)

He aquí un archivo hibernate.properties de ejemplo para una fuente de datos JNDI provisto por un servidor de aplicaciones

hibernate.connection.datasource = java/comp/env/jdbc/test
hibernate.transaction.factory_class = \
org.hibernate.transaction.JTATransactionFactory
hibernate.transaction.manager_lookup_class = \
org.hibernate.transaction.JBossTransactionManagerLookup
hibernate.dialect = org.hibernate.dialect.PostgreSQLDialect
Las conexiones JDBC adquiridas de una fuente de datos JNDI participarán automáticamente en las transacciones del servidor de aplicaciones administradas por el contenedor.

Pueden darse propiedades de conexión arbitrarias anteponiendo hibernate.connnection al nombre de propiedad de la conexión. Por ejemplo puede especificar una propiedad de conexión charSet usando hibernate.connection.charSet.

Puede definir su particular táctica plugin para conseguir conexiones JDBC implementando la interfaz org.hibernate.connection.ConnectionProvider y especificando su particular implementación personalizada por recurso de la propiedad hibernate.connection.provider_class.

Vamos a utilizar el plugin de ejecución Maven para arrojar el servidor HSQLDB ejecutando mvn execjava -Dexec.mainClass=org.hsqldb.Server -Dexec.args=-datafundamento.0 filetarget/data/tutorial.Lo verá iniciando y vinculandose a un enchufe TCP/IP allí es donde nuestra aplicación se conectará más adelante. Si desea dar origen con una fundamento de datos fresca mientras este tutorial apague HSQLDB borre todos los ficheros en el directorio target/data e inicie HSQLDB de nuevo.

Hibernate se conectará a la fundamento de datos de fracción de su aplicación así que requiere saber cómo conseguir conexiones. Para este tutorial vamos a utilizar un pool de conexiones autónomo (opuesto a javax.sql.DataSource). Hibernate viene con soporte para dos pools de conexiones JDBC de código abierto de terceros c3p0 y proxool. Sin embargo vamos a utilizar el pool de conexiones incluido de Hibernate para este tutorial.

Atención
El pool de conexiones de Hibernate no está diseñado para utilizarse en producción. Le faltan algúnas funcionalidades que se encuentran en cualquier pool de conexiones decente.
Para la configuración de Hibernate podemos utilizar un archivo hibernate.properties simple un archivo hibernate.cfg.xml un escaso más sofisticado o inclusive una configuración completamente programática. La mayoría de los usuarios eligen el archivo de configuración XML


?xml version='1.0' encoding='utf-8'?
!DOCTYPE hibernate-configuration PUBLIC
-//Hibernate/Hibernate Configuration DTD 3.0//EN
//hibernate.sourceforge.net/hibernate-configuration-3.0.dtd

ibernate-configuration

session-factory

!-- Database connection settings --
property name=connection.driver_class
org.hsqldb.jdbcDriverproperty
property name=connection.url
jdbchsqldbhsql//localhostproperty
property name=connection.username
saproperty
property name=connection.password
property

!-- JDBC connection pool (use the built-in) --
property name=connection.pool_size
1property

!-- SQL dialect --
property name=dialect
org.hibernate.dialect.HSQLDialectproperty

!-- Enable Hibernate's automatic session context management --
property name=current_session_context_class
threadproperty

!-- Disable the second-level cache --
property name=cache.provider_class
org.hibernate.cache.NoCacheProviderproperty

!-- Echo all executed SQL to stdout --
property name=show_sql
trueproperty

!-- Drop and re-create the database schema on startup --
property name=hbm2ddl.auto
updateproperty

mapping resource=org/hibernate/tutorial/domain/Event.hbm.xml

session-factory

hibernate-configuration

Nota
Observe que este archivo de configuración especifica un DTD distinto
Configure la SessionFactory de Hibernate. SessionFactory es una fábrica global responsable de una fundamento de datos en propia. Si usted tiene algúnas fundamentos de datos para un origen más fácil utilice algúnas configuraciones session-factory en varios ficheros de configuración.

Los primeros cuatro fundamentos property contienen la configuración necesaria para la conexión JDBC. El fundamento property dialecto especifica la variante SQL en propia que Hibernate genera.

Guarde este archivo como hibernate.cfg.xml en el directorio src/main/resources.

Puede alcanzar a las métricas de SessionFactory de dos maneras. Su primera opción es llamar a sessionFactory.getStatistics() y leer o presentar por pantalla la Statistics por sí mismo.

Hibernate también puede utilizar JMX para publicar las métricas si habilita el MBean StatisticsService. Puede habilitar un sólo MBean para todas sus SessionFactory o una por fábrica. Véa el próximo código para ver ejemplos de configuración minimalistas

// MBean service registration for a specific SessionFactory
Hashtable tb = new Hashtable()
tb.put(type statistics)
tb.put(sessionFactory myFinancialApp)
ObjectName on = new ObjectName(hibernate tb) // MBean object name

StatisticsService stats = new StatisticsService() // MBean implementation
stats.setSessionFactory(sessionFactory) // Bind the stats to a SessionFactory
server.registerMBean(stats on) // Register the Mbean on the server
// MBean service registration for all SessionFactory's
Hashtable tb = new Hashtable()
tb.put(type statistics)
tb.put(sessionFactory all)
ObjectName on = new ObjectName(hibernate tb) // MBean object name

StatisticsService stats = new StatisticsService() // MBean implementation
server.registerMBean(stats on) // Register the MBean on the server
Puede activar y desactivar el monitoreo de una SessionFactory

en tiempo de configuración establezca hibernate.generate_statistics como false
en tiempo de ejecución sf.getStatistics().setStatisticsEnabled(true) o hibernateStatsBean.setStatisticsEnabled(true)
Las estadísticas pueden ser reajustadas programáticamente utilizando el método clear(). Puede enviarse un resumen a un registro (a nivel de información) utilizando el método logSummary().

Hibernate ofrece un número de métricas desde información muy básica hasta la más especializada sólamente sobresaliente en ciertos escenarios. Todos los contadores disponibles se detallan en la API de la interfaz Statistics en tres categorías

Métricas vinculadas al uso común de Session usage tales como número de sesiones abiertas conexiones JDBC recuperadas etc
Métricas vinculadas con las entidades colecciones consultas y cachés como un todo (también conocidas como métricas globales).
Métricas detalladas vinculadas con una entidad colección consulta o región de caché en propia.
Por ejemplo puede comprobar el entrada pérdida y radio de colecciones de entidades y consultas en el caché y el tiempo promedio que requiere una consulta. Tenga en cuenta que el número de milisegundos está sujeto a una aproximación en Java. Hibernate está asociado a la precisión de la MVJ en determinadas plataformas esto podría tener inclusive una precisión de 10 segundos.

Se usan getters simples para alcanzar a la métrica global (por ejemplo no relacionadas en propia a una entidad colección región de caché etc). Puede alcanzar a las métricas de una entidad colección región de caché en propia a través de su nombre y a través de su representación HQL o SQL para las consultas. Por favor refiérase al Javadoc de la API de Statistics EntityStatistics CollectionStatistics SecondLevelCacheStatistics y QueryStatistics para conseguir más información. El próximo código es un ejemplo fácil

Statistics stats = HibernateUtil.sessionFactory.getStatistics()

double queryCacheHitCount = stats.getQueryCacheHitCount()
double queryCacheMissCount = stats.getQueryCacheMissCount()
double queryCacheHitRatio =
queryCacheHitCount / (queryCacheHitCount + queryCacheMissCount)

log.info(Query Hit ratio + queryCacheHitRatio)

EntityStatistics entityStats =
stats.getEntityStatistics( Cat.class.getName() )
long changes =
entityStats.getInsertCount()
+ entityStats.getUpdateCount()
+ entityStats.getDeleteCount()
log.info(Cat.class.getName() + changed + changes + times )
Para laborar sobre todas las entidades colecciones consultas y regiones de cachés recuperando la lista de nombres de entidades colecciones consultas y regiones de cachés con los próximos métodos getQueries() getEntityNames() getCollectionRoleNames() y getSecondLevelCacheRegionNames().

Una vez adquirida la selección es probable descubrir otros fundamentos utilizando a la misma selección.

En //api.jquery.com/category/traversing/ puede descubrir una completa documentación sobre los métodos de recorrido de DOM (en inglés traversing) que posee jQuery.

Nota

Debe ser cuidadoso en recorrer largas distancias en un documento — recorridos complejos obligan que la articula del documento sea siempre la misma algo que es difícil de garantizar. Uno -o dos- pasos para el recorrido esta bien pero generalmente hay que eludir atravesar desde un contenedor a otro.

Moverse a través del DOM utilizando métodos de recorrido

$('h1').next('p') // seleccionar el inmediato y próximo
// fundamento p con respecto a H1
$('divvisible').parent() // seleccionar el fundamento contenedor
// a un div visible
$('input[name=first_name]').closest('form') // seleccionar el fundamento
// form más cercano a un input
$('#myList').children() // seleccionar todos los fundamentos
// hijos de #myList
$('li.selected').siblings() // seleccionar todos los items
// hermanos del fundamento li
También es probable interactuar con la selección utilizando el método $.fn.each. Dicho método interactúa con todos los fundamentos obtenidos en la selección y ejecuta una función por cada uno. La función recibe como argumento el índice del fundamento actual y al mismo fundamento. De manera predeterminada dentro de la función se puede realizar referencia al fundamento DOM a través de la declaración this.

Interactuar en una selección

$('#myList li').each(function(idx el) {
console.log(
'El fundamento ' + idx +
'contiene el próximo HTML ' +
$(el).html()
)
})

La utilización de una dispositivo de depuración es primordial para laborar con JavaScript. Firefox provee un depurador a través de la extensión Firebug entretanto que Safari y Chrome ya traen uno integrado.

Cada depurador proporciona

Un editor multi-linea para experimentar con JavaScript
Un inspector para revisar el código generado en la página
Un visualizador de red o recursos para examinar las peticiones que se realizan.
Cuando usted este escribiendo código JavaScript podrá utilizar sdeterminados de los próximos métodos para enviar mensajes a la consola del depurador

console.log() para enviar y registrar mensajes globales
console.dir() para registrar un objeto y visualizar sus propiedades
console.warn() para registrar mensajes de alerta
console.yerro() para registrar mensajes de yerro
Tienen lugar otros métodos para utilizar desde la consola pero estos pueden variar según el navegador. La consola además provee la probabilidad de establecer puntos de interrupción y observar expresiones en el código con el fin de facilitar su depuración.

RDBMS Dialecto
DB2 org.hibernate.dialect.DB2Dialect
DB2 AS/400 org.hibernate.dialect.DB2400Dialect
DB2 OS390 org.hibernate.dialect.DB2390Dialect
PostgreSQL org.hibernate.dialect.PostgreSQLDialect
MySQL org.hibernate.dialect.MySQLDialect
MySQL con InnoDB org.hibernate.dialect.MySQLInnoDBDialect
MySQL con MyISAM org.hibernate.dialect.MySQLMyISAMDialect
Oracle (cualquier versión) org.hibernate.dialect.OracleDialect
Oracle 9i org.hibernate.dialect.Oracle9iDialect
Oracle 10g org.hibernate.dialect.Oracle10gDialect
Sybase org.hibernate.dialect.SybaseDialect
Sybase Anywhere org.hibernate.dialect.SybaseAnywhereDialect
Microsoft SQL Server org.hibernate.dialect.SQLServerDialect
SAP DB org.hibernate.dialect.SAPDBDialect
Informix org.hibernate.dialect.InformixDialect
HypersonicSQL org.hibernate.dialect.HSQLDialect
Ingres org.hibernate.dialect.IngresDialect
Progress org.hibernate.dialect.ProgressDialect
Mckoi SQL org.hibernate.dialect.MckoiDialect
Interbase org.hibernate.dialect.InterbaseDialect
Pointbase org.hibernate.dialect.PointbaseDialect
FrontBase org.hibernate.dialect.FrontbaseDialect
Firebird org.hibernate.dialect.FirebirdDialect

La próximo clase demuestra algunos de los tipos de cosas que podemos realizar con estas clases utilizando Hibernate

package eg

import java.util.ArrayList
import java.util.Calendar
import java.util.Iterator
import java.util.List

import org.hibernate.HibernateException
import org.hibernate.Query
import org.hibernate.Session
import org.hibernate.SessionFactory
import org.hibernate.Transaction
import org.hibernate.cfg.Configuration
import org.hibernate.tool.hbm2ddl.SchemaExport

public class BlogMain {

private SessionFactory _sessions

public void configure() throws HibernateException {
_sessions = new Configuration()
.addClass(Blog.class)
.addClass(BlogItem.class)
.buildSessionFactory()
}

public void exportTables() throws HibernateException {
Configuration cfg = new Configuration()
.addClass(Blog.class)
.addClass(BlogItem.class)
new SchemaExport(cfg).create(true true)
}

public Blog createBlog(String name) throws HibernateException {

Blog blog = new Blog()
blog.setName(name)
blog.setItems( new ArrayList() )

Session session = _sessions.openSession()
Transaction tx = null
try {
tx = session.beginTransaction()
session.persist(blog)
tx.commit()
}
catch (HibernateException he) {
if (tx!=null) tx.rollback()
throw he
}
finally {
session.close()
}
return blog
}

public BlogItem createBlogItem(Blog blog String title String text)
throws HibernateException {

BlogItem item = new BlogItem()
item.setTitle(title)
item.setText(text)
item.setBlog(blog)
item.setDatetime( Calendar.getInstance() )
blog.getItems().add(item)

Session session = _sessions.openSession()
Transaction tx = null
try {
tx = session.beginTransaction()
session.update(blog)
tx.commit()
}
catch (HibernateException he) {
if (tx!=null) tx.rollback()
throw he
}
finally {
session.close()
}
return item
}

public BlogItem createBlogItem(Long blogid String title String text)
throws HibernateException {

BlogItem item = new BlogItem()
item.setTitle(title)
item.setText(text)
item.setDatetime( Calendar.getInstance() )

Session session = _sessions.openSession()
Transaction tx = null
try {
tx = session.beginTransaction()
Blog blog = (Blog) session.load(Blog.class blogid)
item.setBlog(blog)
blog.getItems().add(item)
tx.commit()
}
catch (HibernateException he) {
if (tx!=null) tx.rollback()
throw he
}
finally {
session.close()
}
return item
}

public void updateBlogItem(BlogItem item String text)
throws HibernateException {

item.setText(text)

Session session = _sessions.openSession()
Transaction tx = null
try {
tx = session.beginTransaction()
session.update(item)
tx.commit()
}
catch (HibernateException he) {
if (tx!=null) tx.rollback()
throw he
}
finally {
session.close()
}
}

public void updateBlogItem(Long itemid String text)
throws HibernateException {

Session session = _sessions.openSession()
Transaction tx = null
try {
tx = session.beginTransaction()
BlogItem item = (BlogItem) session.load(BlogItem.class itemid)
item.setText(text)
tx.commit()
}
catch (HibernateException he) {
if (tx!=null) tx.rollback()
throw he
}
finally {
session.close()
}
}

public List listAllBlogNamesAndItemCounts(int max)
throws HibernateException {

Session session = _sessions.openSession()
Transaction tx = null
List result = null
try {
tx = session.beginTransaction()
Query q = session.createQuery(
select blog.id blog.name count(blogItem) +
from Blog as blog +
left outer join blog.items as blogItem +
group by blog.name blog.id +
order by max(blogItem.datetime)
)
q.setMaxResults(max)
result = q.list()
tx.commit()
}
catch (HibernateException he) {
if (tx!=null) tx.rollback()
throw he
}
finally {
session.close()
}
return result
}

public Blog getBlogAndAllItems(Long blogid)
throws HibernateException {

Session session = _sessions.openSession()
Transaction tx = null
Blog blog = null
try {
tx = session.beginTransaction()
Query q = session.createQuery(
from Blog as blog +
left outer join fetch blog.items +
where blog.id = blogid
)
q.setParameter(blogid blogid)
blog = (Blog) q.uniqueResult()
tx.commit()
}
catch (HibernateException he) {
if (tx!=null) tx.rollback()
throw he
}
finally {
session.close()
}
return blog
}

public List listBlogsAndRecentItems() throws HibernateException {

Session session = _sessions.openSession()
Transaction tx = null
List result = null
try {
tx = session.beginTransaction()
Query q = session.createQuery(
from Blog as blog +
inner join blog.items as blogItem +
where blogItem.datetime
)

Calendar cal = Calendar.getInstance()
cal.roll(Calendar.MONTH false)
q.setCalendar(minDate cal)

result = q.list()
tx.commit()
}
catch (HibernateException he) {
if (tx!=null) tx.rollback()
throw he
}
finally {
session.close()
}
return result
}
}

La memoria de la Máquina Virtual se divide en algúnas regiones. Una de estas regiones es el PermGen el área de memoria utilizada para entre otras cosas guardar el metadata de las clases como los atributos y sus tipos de datos métodos etc. Esta memoria es de tipo non-heap. Las instancias de las clases se cargan en la memoria de tipo heap a la que se van añadiendo y eliminando las instancias de las clases según se van utilizando y eliminándose por el recolector de basura (Garbage Collector en adelante GC).

No vamos a entrar en el mecanismo de la carga y eliminación de clases en java porque excede este artículo pero sí lo comentaremos brevemente para poder comprender el porqué de la excepción OutOfMemoryException para que una clase pueda ser eliminada por el recolector de basura (GC) es indispensable que no esté referenciada por ninguna otra clase. Para que se pueda descartar la memoria ocupada por una clase en el lugar PermGen es indispensable además que se elimine el classloader que cargó la clase.

El valor por defecto del lugar PermGen es de 64 Mb en la máquina virtual (VM) de Sun. Este valor es suficiente usualmente para las aplicaciones que corren de manera independiente. En el caso de una aplicación que corra en un servidor web tipo Tomcat o un servidor de aplicaciones hay casos en los que este valor no es suficiente.

En primer lugar es probable que la aplicación necesite más lugar por su particular arquitectura. Las librerías Spring e Hibernate son librerías masivos que cargan muchas clases y además hacen uso de proxies y carga dinámica de clases que hacen uso del lugar PermGen por lo que puede que los 64Mb no sean suficientes. Este caso se da cuando la excepción con el yerro se produce nada mas arrancar el servidor web o de aplicaciones o al alcanzar a la aplicación. Para solventar este asunto bastará con crecer el dimensión máximo de la memoria de tipo PermGen según veremos más adelante.

En segundo espacio la motivo más posible de una excepción java.lang.OutOfMemoryError PermGen space failure se produce cuando la aplicación se reinstala en el servidor sin reiniciar el servidor. La manera de reinstalar las aplicaciones es eliminando el classloader que cargó la aplicación por primera vez y manerando un nuevo classloader para la nueva instancia de la aplicación. En teoría esto ofrece una manera limpia de reinstalar aplicaciones pero si el servidor web o de aplicaciones guarda una referencia al classloader antiguo se produce una fuga de memoria (memory leak) y el fruto es que tendremos las clases de la aplicación cargadas dos veces en memoria. Es cuestión del número de recargas y de la memoria gastada por la aplicación el que se produzca la excepción java.lang.OutOfMemoryError PermGen space failure. En este caso no basta con crecer el dimensión máximo de la memoria ya que esto sólo retrasaría el asunto a unas cuantas reinstalaciones más. En este caso la única solución consiste en averiguar la motivo de la fuga de memoria. Esto también excede el contenido de este artículo aunque lo intentarmos tratar con profundidad en otra ocasión. Por el momento sólo ofrecemos un enlace muy interesante aunque en inglés acerca de probables motivos de fugas de memoria en java //opensource.atlassian.com/confluence/spring/pages/viewpage.action?pageId=2669

Por último a continuación incluimos el argumento que es indispensable incluir al arrancar la máquina virtual para especificar el dimensión de esta región PermGen en Mb XXMaxPermSize=128m para el dimensión máximo y XXPermSize=128m para que la máquina virtual ya arranque con este dimensión y no tenga que reservar más lugar en tiempo de ejecución.

Siempre que pase un objeto a save() update() o saveOrUpdate() y siempre que recupere un objeto utilizando load() get() list() iterate() o scroll() ese objeto se agrega al caché interno de la Session.

Cuando despues se llame a flush() el estado de ese objeto será sincronizado con la fundamento de datos. Si no desea que ocurra esta sincronización o si está procesando un número enorme de objetos y requiere gestionar la memoria eficientemente puede utilizar el método evict() para quitar el objeto y sus colecciones del caché de primer nivel.

ScrollableResult cats = sess.createQuery(from Cat as cat).scroll() //a huge result set
while ( cats.next() ) {
Cat cat = (Cat) cats.get(0)
doSomethingWithACat(cat)
sess.evict(cat)
}
La Session también ofrece un método contains() para decidir si una instancia pertenece al caché de la sesión.

Para expulsar todos los objetos del caché de sesión llame a Session.clear().

Para el caché de segundo nivel hay métodos definidos en SessionFactory para explusar el estado en caché de una instancia clase entera instancia de colección o rol entero de colección.

sessionFactory.evict(Cat.class catId) //evict a propia Cat
sessionFactory.evict(Cat.class) //evict all Cats
sessionFactory.evictCollection(Cat.kittens catId) //evict a propia collection of kittens
sessionFactory.evictCollection(Cat.kittens) //evict all kitten collections
El CacheMode controla la forma en que interactúa una sesión en propia con el caché de segundo nivel

CacheMode.NORMAL lee ítems desde y escribe ítems hacia el caché del segundo nivel
CacheMode.GET lee ítems del caché del segundo nivel. No escribe al caché de segundo nivel excepto cuando actualiza datos
CacheMode.PUT escribe ítems al caché de segundo nivel. No lee del caché de segundo nivel
CacheMode.REFRESH escribe ítems al caché de segundo nivel. No lee del caché de segundo nivel saltándose el resultado de hibernate.cache.use_minimal_puts forzando la actualización del caché de segundo nivel para todos los ítems leídos de la fundamento de datos
Para navegar por los contenidos de una región de caché de segundo nivel o de consultas use la API de Statistics

Map cacheEntries = sessionFactory.getStatistics()
.getSecondLevelCacheStatistics(regionName)
.getEntries()
Necesitará habilitar las estadísticas y opcionalmente forzar a Hibernate para que guarde las accesos del caché en un formato más fácil de comprender para humanos

hibernate.generate_statistics true
hibernate.cache.use_structured_entries true

jQuery "sobrecarga" sus métodos en otras palabras el método para establecer un valor posee el mismo nombre que el método para conseguir un valor. Cuando un método es utilizado para establecer un valor es llamado método establecedor (en inglés setter). En cambio cuando un método es utilizado para conseguir (o leer) un valor es llamado obtenedor (en inglés getter).

El método $.fn.html utilizado como establecedor

$('h1').html('hello world')
El método html utilizado como obtenedor

$('h1').html()
Los métodos establecedores devuelven un objeto jQuery permitiendo continuar con la llamada de más métodos en la misma selección entretanto que los métodos obtenedores devuelven el valor por el cual se consultó pero no facultan seguir llamando a más métodos en dicho valor.

Hibernate provee algúnas formas de ejecutar un mismo Query HQL devolviendo los frutos de diferentes formas. La interfaz que se emplea para la ejecución de queries es precisamente org.hibernate.Query que provee 3 metodos para conseguir los frutos de un Query list() iterate() y scroll().

Se analizarán los dos primeros en cuanto a eficiencia y conveniencia de uso.

Contenido [ocultar]
1 Query.list()
2 Query.iterate()
3 Conclusión
4 Ver También
Query.list()
El método Query.list() devuelve en una colección todos los frutos del Query. Es decir en la colección se encuentran instanciadas todas las entidades que corresponden al fruto de la ejecución del HQL por lo tanto el ResultSet subyacente de la conexión JDBC se cierra ya que no se requiere más.

Notar que esta opción realiza una única comunicación con la fundamento de datos en donde se traen todos los frutos y necesita que haya memoria suficiente para Guardar todos los objetos resultantes del query. Si la porción de frutos es extensa el delay del entrada a la fundamento será notorio.

Ejemplo

Query q = session.createQuery(from Auto auto where auto.aniocreacion 1985 )
List autos = q.list()
Query.iterate()
El método Query.iterate() devuelve un iterador java.util.Iterator para iterar los frutos del query. En este caso las entidades se instancian a demanda es decir con cada llamada al método Iterator.next() que devolverá la entidad de la posición actual del iterador.

Para resolver esto Hibernate ejecuta el query obteniendo sólo los ids de las entidades y en cada llamada al método Iterator.next() ejecuta la consulta particular para conseguir la entidad completa. Esto se traduce en una mayor porción de entradas a la fundamento de datos resultando en un mayor tiempo de procesamiento total. La ventaja de este método es que no se necesita que todas las entidades estén cargadas en memoria simultáneamente consumiendo memoria innecesariamente.

Para optimizar la obtención de entidades haciendo que no se realice un entrada a la fundamento por cada llamada al metodo Iterator.next() se puede fijar la porción de frutos a traer en cada entrada o fetch. Esto se configura llamando al método Query.setFetchSize() antes de la ejecución de la consulta.

Ejemplo

Query q = session.createQuery(from Auto auto where auto.aniocreacion 1985 )
q.setFetchSize(10) // se obtendrán 10 frutos en cada entrada a la fundamento.
Iterator iter = q.iterate()
while ( iter.hasNext() ) {
Auto auto = (Auto) iter.next() // fetch the object
...

}
Debe tenerse propia cuidado en que no se cierre la sesión de hibernate entretanto se emplea el iterador de lo opuesto no se podrán conseguir los frutos subsiguientes de la fundamento de datos.

Originalmente Hibernate siempre requería que los usuarios especificaran qué dialecto utilizar. En el caso de aquellos usuarios que buscaban apuntar a múltiples fundamentos de datos de forma simultánea con su construcción eso representaba un asunto. Generalmente esto requería que los usuarios configuraran el dialecto de Hibernate o que definieran su propio método para establecer ese valor.

Empezando con la versión 3.2 Hibernate introdujo la noción de detectar automáticamente el dialecto a utilizar con fundamento en los java.sql.DatafundamentoMetaData que se obtuvieron de una java.sql.Connection a esa fundamento de datos. Esto era mucho mejor pero esta resolución estaba limitada a las fundamentos de datos que Hibernate conoce por adelantado y de ninguna forma era configurable ni se podía sobreescribir.

Starting with version 3.3 Hibernate has a fare more powerful way to automatically determine which dialect to should be used by relying on a series of delegates which implement the org.hibernate.dialect.resolver.DialectResolver which defines only a single method

!-- --span class=java_keywordpublicspan!-- --span class=java_plainspan!-- --span class=java_typeDialectspan!-- --span class=java_plainresolveDialectspan!-- --span class=java_separator(span!-- --span class=java_typeDatabaseMetaDataspan!-- --span class=java_plainmetaDataspan!-- --span class=java_separator)span!-- --span class=java_plainspan!-- --span class=java_keywordthrowsspan!-- --span class=java_plainspan!-- --span class=java_typeJDBCConnectionExceptionspan
. The basic contract here is that if the resolver 'understands' the given database metadata then it returns the corresponding Dialect if not it returns null and the process continues to the next resolver. The signature also identifies org.hibernate.exception.JDBCConnectionException as possibly being thrown. A JDBCConnectionException here is interpreted to imply a non transient (aka non-recoverable) connection problem and is used to indicate an immediate stop to resolution attempts. All other exceptions result in a warning and continuing on to the next resolver.

La fracción divertida de estos resolvedores es que los usuarios también pueden registrar sus propios resolvedores personalizados los cuales se procesarán antes de los incluídos en Hibernate. Esto puede llegar a ser útil en un número de situaciones distintos faculta una fácil integración para la auto-detección de dialectos más allá de los que se envían junto con Hibernate le faculta especificar el uso de un dialecto personalizado cuando se reconoce una fundamento de datos en propia etc. Para registrar uno o más resolvedores simplemente especifiquelos (separados por comas o espacios) usando la configuración 'hibernate.dialect_resolvers' (consulte la constante DIALECT_RESOLVERS en org.hibernate.cfg.Environment).

Inicialización de colecciones y proxies

Hibernate lanzará una LazyInitializationException si se accede a una colección o proxy sin alcanzar afuera del ámbito de la Session por ejemplo cuando la entidad que posee la colección o que tiene la referencia al proxy esté en el estado separado.

A veces es indispensable inicializar un proxy o una colección antes de cerrar la Session. Puede forzar la inicialización llamando a cat.getSex() o cat.getKittens().size() por ejemplo. Sin embargo esto puede ser confuso para los lectores del código y no es conveniente para el código genérico.

Los métodos estáticos Hibernate.initialize() y Hibernate.isInitialized() ofrecen a la aplicación una manera conveniente de laborar con colecciones o proxies inicializados perezosamente. Hibernate.initialize(cat) forzará la inicialización de un proxy cat en tanto su Session esté todavía libre. Hibernate.initialize( cat.getKittens() ) tiene un resultado parecida para la colección de gatitos.

Otra opción es mantener la Session libre hasta que todas las colecciones y proxies necesarios hayan sido cargados. En determinadas arquitecturas de aplicación particularmente en aquellas donde el código que accede a los datos usando Hibernate y el código que los emplea están en capas de aplicación distintos o procesos físicos distintos puede ser un asunto asegurar que la Session esté libre cuando se inicializa una colección. Tienen lugar dos maneras básicas para abordar este asunto

En una aplicación basada en la web se puede utilizar un filtro de servlets para cerrar la Session sólamente al final de una petición del usuario una vez que la entrega de la vista esté completa (el patrón sesión libre en vista (open session in view)). Por supuesto estos sitios necesitan una fuerte demanda de corrección del empleo de excepciones de la infraestructura de su aplicación. Es de una vital relevancia que la Session esté cerrada y la transacción terminada antes de regresar al usuario inclusive cuando ocurra una excepción mientras le entrega de la vista. Refiérase a la Wiki de Hibernate para ver ejemplos de este patrón Open Session in View (sesión libre en vista).
En una aplicación con una capa de negocios separada la lógica empresarial tiene que preparar todas las colecciones que la capa web va a necesitar antes de retornar. Esto implica que la capa empresarial debe cargar todos los datos y devolver a la capa web/presentación todos los datos ya inicializados que se requieran para un caso de uso en propia. Normalmente la aplicación llama a Hibernate.initialize() para cada colección que se necesitará en la capa web (esta llamada debe tener espacio antes de que se cierre la sesión) o recupera la colección tempranamente utilizando una consulta de Hibernate con una cláusula FETCH o una FetchMode.JOIN en Criteria. Normalmente esto es más fácil si adopta el patrón Comando en vez de una Fachada de Sesión.
También puede adjuntar un objeto cargado preliminarmente a una nueva Session con merge() o lock() antes de alcanzar a colecciones no inicializadas u otros proxies. Hibernate no y verdaderamente no debe realizar esto automáticamente ya que introduciría semánticas de transacción improvisadas.
A veces no desea inicializar una colección grande pero todavía requiere cierta información sobre ella como por ejemplo su dimensión o un subconjunto de los datos.

Puede utilizar un filtro de colecciones para conseguir el dimensión de una colección sin inicializarla

( (Integer) s.createFilter( collection select count(*) ).list().get(0) ).intValue()
El método createFilter() también se emplea para recuperar eficientemente subconjuntos de una colección sin necesidad de inicializar toda la colección

s.createFilter( lazyCollection ).setFirstResult(0).setMaxResults(10).list()

Hibernate emplea Simple Logging Facade for Java (SLF4J) con el fin de registrar varios eventos del sistema. SLF4J puede direccionar su salida de registro a varios marcos de esfuerzo de registro (NOP Simple log4j versión 1.2 JDK 1.4 logging JCL o logback) dependiendo de su enlace escogido. Con el fin de configurar el registro necesitará slf4j-api.jar en su ruta de clase junto con el archivo jar para su enlace preferido - slf4j-log4j12.jar en el caso de Log4J. Consulte la documentación SLF4J para conseguir mayores detalles. Para usar Log4j también necesitará colocar un archivo log4j.properties en su ruta de clase. Un archivo de propiedades de ejemplo se distribuye junto con Hibernate en el directorio src/.

Le recomendamos bastante que se familiarice con los mensajes de registro de Hibernate. Se ha trabajado bastante para realizar que los registros de Hibernate sean tan detallados como sea probable sin realizarlos ilegibles. Es un herramienta primordial en la resolución de dificultades. Las categorías de registro más interesantes son las próximos

Categorías de Registro de Hibernate

Categoría Función
org.hibernate.SQL Registra todas las declaraciones DML de SQL a medida que se ejecutan
org.hibernate.type Registra todos los parámetros JDBC
org.hibernate.tool.hbm2ddl Registra todas las declaraciones DDL de SQL a medida que se ejecutan
org.hibernate.pretty Registra el estado de todas las entidades (máximo 20 entidades) asociadas con la sesión en tiempo de limpieza (flush)
org.hibernate.cache Registra toda la actividad del caché de segundo nivel
org.hibernate.transaction Registra la actividad relacionada con la transacción
org.hibernate.jdbc Registra toda adquisición de recursos JDBC
org.hibernate.hql.ast.AST Regista los ASTs de HQL y SQL mientras análisis de consultas.
org.hibernate.secure Registra todas las peticiones de autorización JAAS
org.hibernate Registra todo. Hay mucha información pero es útil para la resolución de dificultades

Al construir aplicaciones con Hibernate casi siempre debe laborar con debug habilitado para la categoría org.hibernate.SQL o alternativamente la propiedad hibernate.show_sql habilitada.

Tienen lugar muchas maneras por las cuales de puede adaptar un fundamento. Entre las tareas más comunes están las de cambiar el HTML interno o algún atributo del mismo. Para este tipo de tareas jQuery proporciona métodos simples funcionales en todos los navegadores modernos. Inclusive es probable conseguir inmaneración sobre los fundamentos utilizando los mismos métodos pero en su manera de método obtenedor.

Nota

Hacer cambios en los fundamentos es un esfuerzo trivial pero hay debe recordar que el cambio afectará a todos los fundamentos en la selección por lo que si quiere adaptar un sólo fundamento tiene que estar seguro de especificarlo en la selección antes de llamar al método establecedor.

Nota

Cuando los métodos actúan como obtenedores por lo común unicamente laboran con el primer fundamento de la selección. Además no devuelven un objeto jQuery por lo cual no es probable encadenar más métodos en el mismo. Una excepción es el método $.fn.text el cual faculta conseguir el texto de los fundamentos de la selección.

$.fn.html
Obtiene o constituye el contenido HTML de un fundamento.

$.fn.text
Obtiene o constituye el contenido en texto del fundamento en caso se pasarle como argumento código HTML este es despojado.

$.fn.attr
Obtiene o constituye el valor de un algun atributo.

$.fn.width
Obtiene o constituye el ancho en pixeles del primer fundamento de la selección como un entero.

$.fn.height
Obtiene o constituye el alto en pixeles del primer fundamento de la selección como un entero.

$.fn.position
Obtiene un objeto con información sobre la posición del primer fundamento de la selección relativo al primer fundamento padre posicionado. Este método es solo obtenedor.

$.fn.val
Obtiene o constituye el valor (value) en fundamentos de formularios.

Cambiar el HTML de un fundamento

$('#myDiv pfirst')
.html('Nuevo primer párrafo')