hibernate 之 操作数据库

hibernate 的配置文件：hibernate.cfg.xml(放于src目录下)

<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>

    <session-factory>

        <!-- Database connection settings -->
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="connection.url">jdbc:mysql://localhost/train</property>
        <property name="connection.username">root</property>
        <property name="connection.password"></property>

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

        <!-- SQL dialect -->
        <property name="dialect">org.hibernate.dialect.MySQL5Dialect</property>

        <!-- Enable Hibernate's automatic session context management -->
        <property name="current_session_context_class">thread</property>

        <!-- Disable the second-level cache  -->
        <property name="cache.provider_class">org.hibernate.cache.internal.NoCacheProvider</property>

        <!-- Echo all executed SQL to stdout -->
        <property name="show_sql">true</property>
		<property name="format_sql">true</property>

        <!-- Drop and re-create the database schema on startup -->
        <property name="hbm2ddl.auto">update</property>
		
	<mapping resource="com/hibernate/Student.hbm.xml"/> <!-- 使用xml时-->
	<mapping class="com.hibernate.Teacher"/> <!-- 使用注解时-->
    </session-factory>

</hibernate-configuration>

实体类设置 student.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping>
	<class name="com.bjsxt.hibernate.Student">
		<id name="id">
			<generator class="native"></generator>
		</id>
		
		<property name="name"></property>
    </class>
	
</hibernate-mapping>

 load、get方法，只能通过id查询对象

两者区别：load采用延迟加载，只有使用对象内容的时候才会发出sql语句；而get则会直接从数据库加载；当查询不存在的数据时，load报错，而get会返回null；无论是get还是load都会先去查找缓存（一级缓存），如果缓存中不存在则从数据库中查找，load还会使用二级缓存，而get则不会

User u1=(User) session.get(User.class, 2);//若缓存中没有，此时即发出sql请求
User u2=(User) session.load(User.class, 2);
System.out.println(u2.getId());//若缓存中没有，此时即发出sql请求，而不是上一步

save(user)：在Session清理缓存时候执行在底层生成一个insert sql语句，把对象存入数据库；在你执行Session.save(user)后，在Session清理缓存前，如果你修改user对象属性值，那么最终存入数据库的值将是最后修改的值；此过程中ID不能被修改；

delete(user)：如果user是持久化对象，则执行删除操作，同样底层数据库的执行条件是：在Session清理缓存时候；如果user是游离对象：将user对象和Session关联，使之成为持久化对象；然后按照user 是持久化对象的过程执行；

update(user) ：可以从数据库中获取到其对象后，直接set改变需要设置的属性，然后当session进行commit时，hibernate默认同步数据库，如发现一致，不会发update的sql语句进行更新，当不一致的时候才会发sql的update的语句，当然此时更新也是全部字段进行更新，效率仍然偏低；

saveOrUpdate(Object o);   自动选择save还是update；

clear(); 主要用于清除session的缓存，中间没有与数据库的交互而flush则有；

flush(); 强制让缓存内容与数据库内容做同步，可以设置，默认当session的commit时才同步；

HQL:

public class HqlTest {

	private static SessionFactory sessionFactory;
	private static Session session;

	@BeforeClass
	public static void befor() {
		Configuration cfg = new Configuration();
		cfg.configure();
		ServiceRegistry serviceRegistry = new ServiceRegistryBuilder()
				.applySettings(cfg.getProperties()).buildServiceRegistry();
		sessionFactory = cfg.buildSessionFactory(serviceRegistry);

		session = sessionFactory.getCurrentSession();//如果此处是opensession就不会出现事务异常及未保存异常
	}
	@Test
	public void testHQL3() {
		
		session.beginTransaction();
		Query q=session.createQuery("select distinct c from Category c order by name desc");
		List<Category> categories=q.list();
		for(Category c:categories)
			System.out.println(c.getName());
		session.getTransaction().commit();
	}
	@Test
	public void testHQL4() {
		
		session.beginTransaction();
		Query q=session.createQuery("from Category");
		List<Category> categories=q.list();
		for(Category c:categories)
			System.out.println(c.getName());
		session.getTransaction().commit();
	}
	@Test
	public void testHQL5() {
		
		session.beginTransaction();
		Query q=session.createQuery("from Category c where id>:min and c.id<:max");
//		q.setParameter("min", 2);
//		q.setParameter("max", 5);
		q.setInteger("min", 2);
		q.setInteger("max", 5);
		//Query q1=session.createQuery("from Category c where id>:min and c.id<:max").setInteger("min", 2).setInteger("max", 5);
		List<Category> categories=q.list();
		for(Category c:categories)
			System.out.println(c.getName());
				session.getTransaction().commit();
	}
	
	//分页
	@Test
	public void testHQL6() {
		session.beginTransaction();
		Query q=session.createQuery("from Category").setMaxResults(4).setFirstResult(2);
		List<Category> categories=q.list();
		for(Category c:categories)
			System.out.println(c.getName());
		session.getTransaction().commit();
	}
	
	//只获取单个表中的某些字段
	@Test
	public void testHQL7() {
		session.beginTransaction();
		Query q=session.createQuery("select c.id,c.name from Category c");
		List<Object[]> categories=q.list();
		for(Object[] o:categories)
			System.out.println(o[0]+"---"+o[1]);
		session.getTransaction().commit();
	}
	
	//导航关系
	@Test //ManyToOne处设置为lazy.只有调用category中的内容都会执行查询category表  
	public void testHQL8() {
		session.beginTransaction();
		Query q=session.createQuery("from Topic t where t.category.id=1");
		List<Topic> topic=q.list();
		for(Topic t:topic){
			System.out.println(t.getTitle());
			//System.out.println(t.getCategory().getName());
		}
		session.getTransaction().commit();
	}
	@Test //同上，导航关系
	public void testHQL9() {
		session.beginTransaction();
		Query q=session.createQuery("from Msg m where m.topic.category.id=1");
		List<Msg> msg=q.list();
		for(Msg m:msg){
			System.out.println(m.getContent());
			//System.out.println(t.getCategory().getName());
		}
		session.getTransaction().commit();
	}
	
	@Test
	public void testHQL10() {
		//is empty not empty
		session.beginTransaction();
		Query q=session.createQuery(" from Topic t where t.msg is empty");
		List<Topic> topic=q.list();
		for(Topic t:topic)
			System.out.println(t.getTitle());
		session.getTransaction().commit();
	}
	
	@Test
	public void testHQL11() {
		//native sql
		session.beginTransaction();
		SQLQuery q=session.createSQLQuery("select * from category").addEntity(Category.class);
		List<Category> categories=q.list();
		for(Category c:categories)
			System.out.println(c.getName());
		session.getTransaction().commit();
	}
	@AfterClass
	public static void after() {
		
		if (sessionFactory != null)
			sessionFactory.close();
	}

}
//本地SQL查询还可以支持连接查询，如下面的程序代码：
String sql=”select {c.*},{o.*} from customer c inner join order o where c.id=o.customer_ID”;
Query query=session.createSQLQuery(sql,
new String[]{“c”,”o”},
new Class[]{Customer.class,Order.class});
List list=query.list();
for(int i=0;i<list.size();i++){
 	Object objs=(Object[])list.get(i);
 	Customer customer=(Customer)objs[0];
 	Order order=(Order)objs[1];
}
//值得注意的是以上程序代码中Query的list()方法返回的结果集中存放的是对象数组，在对象数组中成对存放着一对Customer对象和Order对象。

配置文件 （ hibernate .properties或 hibernate .cfg.xml）和映射文件（.hbm.xml）

<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>

    <session-factory>

        <!-- Database connection settings -->
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="connection.url">jdbc:mysql://localhost/train</property>
        <property name="connection.username">root</property>
        <property name="connection.password"></property>

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

        <!-- SQL dialect -->
        <property name="dialect">org.hibernate.dialect.MySQL5Dialect</property>

        <!-- Enable Hibernate's automatic session context management -->
        <property name="current_session_context_class">thread</property>

        <!-- Disable the second-level cache  -->
        <property name="cache.provider_class">org.hibernate.cache.internal.NoCacheProvider</property>

        <!-- Echo all executed SQL to stdout -->
        <property name="show_sql">true</property>
<property name="format_sql">true</property>
        <property name="hbm2ddl.auto">validate</property>
        <mapping class="com.struts2.domain.Message"/>
        <mapping class="com.struts2.domain.User"/>  
    </session-factory>
</hibernate-configuration>