fuente original: http://www.yiidian.com/hibernate/hibernate-get-load.html
1 ilustra el uso básico de los métodos GET y de carga
/**
* 演示基本对象的查询
* @author http://www.yiidian.com
*
*/
public class Demo {
/**
* get()方法: 查询一个对象
*/
@Test
public void test1(){
Session session = HibernateUtil.getSession();
Transaction tx = session.beginTransaction();
Customer cust = session.get(Customer.class,1);
Set<Order> orders = cust.getOrders();
System.out.println(cust.getName()+"的订单：");
for (Order order : orders) {
System.out.println(order.getOrderno());
}
tx.commit();
session.close();
}
/**
* load()方法: 查询一个对象
*/
@Test
public void test2(){
Session session = HibernateUtil.getSession();
Transaction tx = session.beginTransaction();
Customer cust = session.load(Customer.class,1);
Set<Order> orders = cust.getOrders();
System.out.println(cust.getName()+"的订单：");
for (Order order : orders) {
System.out.println(order.getOrderno());
}
tx.commit();
session.close();
}
}
Descargar Fuente: https://pan.baidu.com/s/1c2HD7tm
2 conseguir la diferencia entre los métodos de análisis y de carga
En hibernación, sabemos que si se obtiene un objeto de la base de datos, por lo general hay dos formas, una es a través del método session.get (), y el otro es a través del método Session.load (), y de hecho, estos dos métodos hay una diferencia de la obtención de un objeto sólido en el rendimiento de la consulta de ambos es diferente.
carga 2.1 carga
Cuando para obtener un objeto utilizando el método de carga, a continuación, hibernar mecanismo de carga diferida será utilizada para cargar el objeto, a saber: cuando el método Session.load () se utiliza para cargar un objeto, y esta vez no vamos a emitir la instrucción SQL, el objeto actual resultante es en realidad un objeto proxy, el objeto proxy sólo se almacena el valor de la entidad Identificación objetos sólo cuando queremos utilizar este objeto para obtener otras propiedades, se emitirá la declaración de sql en este momento, a partir de la base de datos para consultar se objetos.
session = HibernateUtil.openSession();
/*
* 通过load的方式加载对象时，会使用延迟加载机制，此时并不会发出sql语句，只有当我们需要使用的时候才会从数据库中去查询
*/
User user = (User)session.load(User.class, 2);
Vemos que si nos cargamos a nuestro objeto Usuario a través de la carga, esta vez de la consola y no vamos a encontrar una consulta de la base de datos del objeto, que no emite declaración de sql, pero si queremos usar el cuando un objeto:
session = HibernateUtil.openSession();
User user = (User)session.load(User.class, 2);
System.out.println(user);
En este punto vemos la consola emitirá una consulta SQL, la consulta será el objeto de la base de datos:
Hibernate: select user0_.id as id0_0_, user0_.username as username0_0_, user0_.password as password0_0_, user0_.born as born0_0_ from user user0_ where user0_.id=?
User [id=2, username=aaa, password=111, born=2013-10-16 00:14:24.0]
Esta vez se podría pensar, ya que cuando se llama al método de carga, y no va a emitir la instrucción SQL para averiguar el objeto a partir de la base de datos, entonces el objeto de usuario en el final es lo que se opone?
De hecho, este es uno de nuestro objeto proxy objeto Usuario, el objeto proxy sólo posee el atributo id:
session = HibernateUtil.openSession();
/*
* 通过load的方式加载对象时，会使用延迟加载机制，此时得到的User对象其实是一个
* 代理对象，该代理对象里面仅仅只有id这个属性
*/
User user = (User)session.load(User.class, 2);
System.out.println(user.getId());
Vemos que si sólo imprimir el valor de ID del objeto de usuario, entonces la consola imprimirá el valor de la identificación, pero la misma no va a la instrucción SQL emitida a partir de la consulta de base de datos. Esto confirma nuestro objetivo es sólo el identificador de usuario guarda un objeto proxy, pero si tengo que imprimir los valores de otros atributos de los objetos de usuario, esta vez no enviará instrucción SQL? La respuesta es sí:
session = HibernateUtil.openSession();
/*
* 通过load的方式加载对象时，会使用延迟加载机制，此时得到的User对象其实是一个
* 代理对象，该代理对象里面仅仅只有id这个属性
*/
User user = (User)session.load(User.class, 2);
System.out.println(user.getId());
// 如果此时要得到user其他属性，则会从数据库中查询
System.out.println(user.getUsername());
En este punto vemos la salida de la consola:
2
Hibernate: select user0_.id as id0_0_, user0_.username as username0_0_, user0_.password as password0_0_, user0_.born as born0_0_ from user user0_ where user0_.id=?
aaa
Creemos que a través de unos ejemplos anteriores, debemos tener una buena comprensión de la forma en que esta carga para cargar el objeto de la misma.
carga 2.2 get
Con respecto a la carga diferida de la carga, llegar más directamente, cuando usamos el método session.get () para obtener un objeto, si no hacemos uso de este objeto, esta vez se emitirá una declaración de SQL para consultar la base de datos:
session = HibernateUtil.openSession();
/*
* 通过get方法来加载对象时，不管使不使用该对象，都会发出sql语句，从数据库中查询
*/
User user = (User)session.get(User.class, 2);
En este punto se llega a conseguir a través de los objetos de usuario, pero no lo usamos, pero encontramos que la voluntad consola de salida de la consulta SQL:
Hibernate: select user0_.id as id0_0_, user0_.username as username0_0_, user0_.password as password0_0_, user0_.born as born0_0_ from user user0_ where user0_.id=?
Así podemos ver que el uso de carga de carga es mejor que el rendimiento de conseguir la carga, ya que cuando se carga la carga, y obtenemos un objeto proxy, ir a la consulta de la base de datos cuando realmente se necesita para utilizar este objeto.
2.3 problemas menores cuando se utiliza get y carga
Cuando mecanismo de carga para comprender la carga y obtener después, esta vez echar un vistazo a algunos de los problemas menores que se producen de dos maneras:
① Si utiliza una manera get para cargar un objeto, cuando tratamos de obtener una ID de objeto no existe en este momento se informó excepción NullPointException
session = HibernateUtil.openSession();
/*
* 当通过get方式试图得到一个id不存在的user对象时，此时会报NullPointException异常
*/
User user = (User)session.get(User.class, 20);
System.out.println(user.getUsername());
En este punto vemos la consola de salida informará excepción de puntero nulo:
Hibernate: select user0_.id as id0_0_, user0_.username as username0_0_, user0_.password as password0_0_, user0_.born as born0_0_ from user user0_ where user0_.id=?
java.lang.NullPointerException .........
Esto se debe a la consulta por la forma en que vamos a salir de este objeto a la base de datos, pero no existe el valor de la identificación, por lo que en este caso el objeto de usuario es nulo, se informó NullPointException la excepción.
② Si un modo de carga para cargar el objeto, cuando tratamos de obtener un objeto que ID no existe en este momento se informará ObjectNotFoundException excepción:
session = HibernateUtil.openSession();
/*
* 当通过get方式试图得到一个id不存在的user对象时，此时会报ObjectNotFoundException异常
*/
User user = (User)session.load(User.class, 20);
System.out.println(user.getId());
System.out.println(user.getUsername());
Nos fijamos en la consola de salida:
20
Hibernate: select user0_.id as id0_0_, user0_.username as username0_0_, user0_.password as password0_0_, user0_.born as born0_0_ from user user0_ where user0_.id=?
org.hibernate.ObjectNotFoundException: No row with the given identifier exists: [com.yiidian.bean.User#20]......
¿Por qué cargar el camino y obtener diferentes maneras de obtener un informe de excepción de un sujeto que no existe todavía? ? La razón para el retraso se debe a que la carga del mecanismo de carga, el uso de la carga, esta vez el objeto de usuario es un objeto proxy que sólo almacena el valor actual del ello, cuando tratamos de obtener la propiedad nombre de usuario del objeto, este atributo no existe realmente , se informó ObjectNotFoundException la excepción.
③org.hibernate.LazyInitializationException 异常
A continuación vamos a ver un ejemplo:
public class UserDAO
{
public User loadUser(int id)
{
Session session = null;
Transaction tx = null;
User user = null;
try
{
session = HibernateUtil.openSession();
tx = session.beginTransaction();
user = (User)session.load(User.class, 1);
tx.commit();
}
catch (Exception e)
{
e.printStackTrace();
tx.rollback();
}
finally
{
HibernateUtil.close(session);
}
return user;
}
}
@Test
public void testLazy06(){
UserDAO userDAO = new UserDAO();
User user = userDAO.loadUser(2);
System.out.println(user);
}
Simula un tal objeto UserDAO, y después de casos de prueba en el que cargar un objeto a través de la carga, esta vez se encontró que la consola informará LazyInitializationException anormal
org.hibernate.LazyInitializationException: could not initialize proxy - no Session .............
Esta excepción es lo que lo causa? ? O debido a una carga mecanismo de retardo en la carga, cuando cargamos un objeto mediante el método load (), esta vez no emitió una instrucción SQL para desproteger el objeto de la base de datos, sólo la corriente Identificación del objeto es solamente un objeto proxy, nos también no utilizar el objeto, pero esta vez nos han cerrado la sesión, por lo que cuando se utiliza el objeto en el caso de prueba se informará LazyInitializationException esta anomalía.
Así que ya que sólo vemos la consola LazyInitializationException informó esta anomalía, ya sabes la manera de utilizar una carga de carga diferida un objeto, y para resolver esto de dos maneras, una es a la carga en forma de llegar a obtener el objeto el otro está en la capa de presentación para abrir nuestra sesión y sesión cerrada.
Bienvenido a mi atención que el público número :: tutorial. Consigue exclusiva organizar los recursos de aprendizaje y productos secos empuje diaria.
Si usted está interesado en mi serie de tutoriales, puede centrarse en mi sitio web: yiidian.com