Spring全家桶之SpringData——Spring 整合Hibernate与Hibernate Jpa_spring hibernate

一. Spring 整合Hibernate

正向工程: 通过实体类和查询方法自动创建数据库表 如Hibernate与Hibernate Jpa
逆向工程: 通过数据库表自动创建对应的实体类以及查询方法 逆向工程的使用

Hibernate简单环境搭建

Hibernate介绍

Hibernate是一种ORM框架，ORM全称为 Object_Relative DateBase-Mapping，在Java对象与关系数据库之间建立某种映射，以实现直接存取Java对象！

搭建步骤

1. 相关jar的的导入

IOC : 提供Spring的IOC容器
AOP :提供Spring对事务的处理
ORM :提供Spring整合hirebnate
单元测试
日志jar
hiernate 核心jar
数据库连接池
jdbc的jar

antlr-2.7.7.jar
aopalliance.jar
aspectjrt.jar
aspectjweaver.jar
c3p0-0.9.2.1.jar
commons-logging-1.1.1.jar
dom4j-1.6.1.jar
geronimo-jta_1.1_spec-1.1.1.jar
hibernate-c3p0-5.0.7.Final.jar
hibernate-commons-annotations-5.0.1.Final.jar
hibernate-core-5.0.7.Final.jar
hibernate-jpa-2.1-api-1.0.0.Final.jar
jandex-2.0.0.Final.jar
javassist-3.18.1-GA.jar
jboss-logging-3.3.0.Final.jar
mchange-commons-java-0.2.3.4.jar
mysql-connector-java-5.1.7-bin.jar
spring-aop-4.2.0.RELEASE.jar
spring-aspects-4.2.0.RELEASE.jar
spring-beans-4.2.0.RELEASE.jar
spring-context-4.2.0.RELEASE.jar
spring-core-4.2.0.RELEASE.jar
spring-expression-4.2.0.RELEASE.jar
spring-jdbc-4.2.0.RELEASE.jar
spring-orm-4.2.0.RELEASE.jar
spring-test-4.2.0.RELEASE.jar
spring-tx-4.2.0.RELEASE.jar
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

2 .编写配置文件完成框架的整合(src下)

配置读取properties工具类
配置c3p0数据库连接池
配置Hibernate的sessionFactory
扫描实体类所在的包
配置HibernateTemplate对象
配置Hibernate的事务管理器
配置开启注解的事务管理
配置SpringIOC的注解扫描

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans.xsd
	http://www.springframework.org/schema/context
	http://www.springframework.org/schema/context/spring-context.xsd
	http://www.springframework.org/schema/aop
	http://www.springframework.org/schema/aop/spring-aop.xsd
	http://www.springframework.org/schema/tx 
	http://www.springframework.org/schema/tx/spring-tx.xsd">

	<!-- 配置读取properties工具类 -->
	<context:property-placeholder location="classpath:*.properties" />

	<!-- 配置c3p0数据库连接池 -->
	<bean id="dataSource"
		class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="jdbcUrl" value="${jdbc.url}" />
		<property name="driverClass" value="${jdbc.driver.class}" />
		<property name="user" value="${jdbc.username}" />
		<property name="password" value="${jdbc.password}" />
	</bean>

	<!-- 配置Hibernate的SeesionFactory -->
	<bean id="sessionFactory"
		class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
		<property name="dataSource" ref="dataSource" />
		<!-- hibernateProperties属性：配置与hibernate相关的内容，如显示sql语句，开启正向工程 -->
		<property name="hibernateProperties">
			<props>
				<!-- 显示当前执行的sql语句 -->
				<prop key="hibernate.show_sql">true</prop>
				<!-- 开启正向工程 -->
				<prop key="hibernate.hbm2ddl.auto">update</prop>
			</props>
		</property>
		<!-- 扫描实体所在的包 -->
		<property name="packagesToScan">
			<list>
				<value>ah.szxy.pojo</value>
			</list>
		</property>
	</bean>

	<!-- 配置HiberanteTemplate 对象 -->
	<bean id="hibernateTemplate"
		class="org.springframework.orm.hibernate5.HibernateTemplate">
		<property name="sessionFactory" ref="sessionFactory" />
	</bean>


	<!-- 配置Hibernate的事务管理器 -->
	<bean id="transactionManager"
		class="org.springframework.orm.hibernate5.HibernateTransactionManager">
		<property name="sessionFactory" ref="sessionFactory" />
	</bean>

	<!-- 配置开启注解事务处理 -->
	<tx:annotation-driven
		transaction-manager="transactionManager" />

	<!-- 配置springIOC的注解扫描 -->
	<context:component-scan base-package="ah.szxy" />


</beans>


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

db.properties

#数据库连接参数的配置
jdbc.url=jdbc:mysql://localhost:3306/springdata
jdbc.driver.class=com.mysql.jdbc.Driver
jdbc.username=root
jdbc.password=root
1
2
3
4
5

通过hibernate完成crud操作

项目结构

0. 创建数据库

新建一个数据库 ,无需建表,只需要和db.properties相对应即可

1. 创建实体 ,加注解

@Entity //表示当前类是实体类
@Table(name=“t_users”) //表示将该实体类通过正向工程时创建的表名为 t_users;
//依次为主键 ,自增长 ,列名 ,注意导的是 persistence包
@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
@Column(name=“userid”)

package ah.szxy.pojo;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name="t_users")
public class Users {
	//依次为主键 ,自增长 ,列名
	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	@Column(name="userid")
	private Integer userid;
	
	@Column(name="username")
	private String username;
	
	@Column(name="userage")
	private Integer userage;

	public Integer getUserid() {
		return userid;
	}

	public void setUserid(Integer userid) {
		this.userid = userid;
	}

	public String getUsername() {
		return username;
	}

	public void setUsername(String username) {
		this.username = username;
	}

	public Integer getUserage() {
		return userage;
	}

	public void setUserage(Integer userage) {
		this.userage = userage;
	}

	@Override
	public String toString() {
		return "Users [userid=" + userid + ", username=" + username + ", userage=" + userage + "]";
	}

	public Users(Integer userid, String username, Integer userage) {
		super();
		this.userid = userid;
		this.username = username;
		this.userage = userage;
	}

	public Users() {
		super();
	}
	
	
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

2 .配置HibernateTemplate对象

位于事务管理器上方即可

<!-- 配置HiberanteTemplate 对象 -->
	<bean id="hibernateTemplate"
		class="org.springframework.orm.hibernate5.HibernateTemplate">
		<property name="sessionFactory" ref="sessionFactory" />
	</bean>
1
2
3
4
5

3. 编写user Dao接口与接口实现类(@Repository) ,增删改查(根据Interger userid)

@Repository //表名当前是dao层的实现类
注入 HibernateTemplate的对象 hibernateTemplate(增删改查方法如下)
hibernateTemplate.save(users);
hibernateTemplate.delete(users);
hibernateTemplate.update(users);
hibernateTemplate.get(Users.class, userid);

接口类

package ah.szxy.dao;

import java.util.List;

import ah.szxy.pojo.Users;

public interface UserDao {
	
	void insert(Users users);
	void delete(Users users);
	void update(Users users);
	Users selectByUserid(Integer userid);
	
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

接口实现类

import org.hibernate.Query;
import org.hibernate.Session;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.orm.hibernate5.HibernateTemplate;
import org.springframework.stereotype.Repository;

import ah.szxy.dao.UserDao;
import ah.szxy.pojo.Users;

@Repository
public class UserDaoImpl implements UserDao {

	@Autowired
	private HibernateTemplate hibernateTemplate;

	public void insert(Users users) {

		this.hibernateTemplate.save(users);
	}

	public void delete(Users users) {

		this.hibernateTemplate.delete(users);
	}

	public void update(Users users) {

		this.hibernateTemplate.update(users);
	}

	public Users selectByUserid(Integer userid) {

		return this.hibernateTemplate.get(Users.class, userid);
	}


}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

4. 编写测试代码 .加入相关注解

@RunWith(SpringJUnit4ClassRunner.class) //表示使用的测试工具版本
@ContextConfiguration(“classpath:applicationContext.xml”) //表示读取的配置文件
@Test //表示该方法可以被测试
@Transactional // 在测试类对于事务提交方式默认的是回滚。
@Rollback(false) // 取消自动回滚

package ah.szxy.test;

import java.util.List;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.annotation.Rollback;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;

import ah.szxy.dao.UserDao;
import ah.szxy.pojo.Users;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class TestHibernate {

	@Autowired
	private UserDao userDao;

	/**
	 * 添加用户
	 */
	@Test
	@Transactional // 在测试类对于事务提交方式默认的是回滚。
	@Rollback(false) // 取消自动回滚
	public void testInsertUsers() {
		Users users = new Users();
		users.setUserage(23);
		users.setUsername("宿州学院");
		this.userDao.insert(users);
	}
	
	/**
	 * 修改用户
	 */
	@Test
	@Transactional
	@Rollback(false)
	public void testUpdateUsers() {
		Users users = new Users();
		users.setUserid(1);
		users.setUsername("chy");
		users.setUserage(24);
		this.userDao.update(users);
	}
	
	/**
	 * 查询用户
	 */
	@Test
	public void getUserByuserid() {
		
		Integer userid=2;;
		Users users = this.userDao.selectByUserid(userid);
		System.out.println(users);
		
		
	}
	
	/**
	 * 删除用户
	 */
	@Test
	@Transactional
	@Rollback(false)
	public void deleteUsers() {
		Users users = new Users();
		users.setUserid(1);
		this.userDao.delete(users);
		
	}
	
	/**
	 * 测试HQL查询 ,根据用户名称查询用户信息
	 * 必须加上@Transactional注解
	 */
	@Test
	@Transactional
	public void selectByUsername() {
		
		List<Users> users = this.userDao.selectByUserName("宿州学院");
		System.out.println(users);
	}
	

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

Hibernate的查询(非主键列)-HQL查询

介绍

HQL：Hibernate Query Language
HQL 的语法：就是将原来的sql 语句中的表与字段名称换成对象与属性的名称

接口类

List<Users> selectByUserName(String username);
1

接口实现类

注意
1. sql语句 ,是通过对象查询的表 ,虽然可以出现select 但是却不能出现通配符 *,故可以省略 Select *
2 .区别 getCurrentSession 与openSession 方法的用法
getCurrentSession:当前session 必须要有事务边界， 且只能处理唯一的一个事务。当事务提交或者回滚后session 自动失效
openSession:每次都会打开一个新的session.加入每次使用多次。则获得的是不同session 对象。使用完毕后我们需要手动的调用colse方法关闭session

@Override
	public List<Users> selectByUserName(String username) {
		/**
		 * 1. getCurrentSession:当前session 必须要有事务边界，
		 * 	      且只能处理唯一的一个事务。当事务提交或者回滚后session 自动失效
		 * 2. openSession:每次都会打开一个新的session.加入每次使用多次。则获得的是不同session 对象。
		 * 	      使用完毕后我们需要手动的调用colse方法关闭session
		 */
		Session session = this.hibernateTemplate.getSessionFactory().getCurrentSession();
		// sql:select * from t_users where username =
		Query query = session.createQuery("from Users where username= :username");
		Query queryTemp = query.setString("username", username);

		return queryTemp.list();

	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

测试类

测试该查询时需要加上@Test @Transactional 注解

/**
	 * 测试HQL查询 ,根据用户名称查询用户信息
	 * 必须加上@Transactional注解
	 */
	@Test
	@Transactional
	public void selectByUsername() {
		
		List<Users> users = this.userDao.selectByUserName("宿州学院");
		System.out.println(users);
	}
1
2
3
4
5
6
7
8
9
10
11

Hibernate的查询-SQL查询

介绍

在Hibernate中使用正常的sql 语句,进行查询操作

接口类

List<Users> selectByUsernameUseSQL(String username);
1

接口实现类

注意

sql语句后面的方法 , 绑定值从0开始

@Override
	public List<Users> selectByUsernameUseSQL(String username) {
		Session session = this.hibernateTemplate.getSessionFactory().getCurrentSession();
		Query query = session.createSQLQuery("select * from t_users where username= ?"
				).addEntity(Users.class).setString(0, username);
		
		return query.list();
	}
1
2
3
4
5
6
7
8

测试类

/**
	 * 测试Hibernate的SQL查询
	 */
	@Test
	@Transactional
	public void selecByUserNameUseSql() {
		
		List<Users> users = this.userDao.selectByUsernameUseSQL("宿州学院");
		for(Users user:users) {
			System.out.println(user);
		}
	}
1
2
3
4
5
6
7
8
9
10
11
12

Hibernate的查询-QBC查询

QBC：Query By Criteria

接口实现类

	@Override
	public List<Users> selectUserByNameUseCriteria(String username) {
		Session session = this.hibernateTemplate.getSessionFactory().getCurrentSession();
		// sql:select * from t_users where username = 张三
		Criteria c = session.createCriteria(Users.class);
		c.add(Restrictions.eq("username", username));
		return c.list();
	}
1
2
3
4
5
6
7
8

测试代码

	/**
	 * Criteria 测试
	 */
	@Test
	@Transactional
	public void testSelectUserByNameUseCriteria() {
		List<Users> list = this.usersDao.selectUserByNameUseCriteria("张三");
		for (Users users : list) {
			System.out.println(users);
		}
	}
1
2
3
4
5
6
7
8
9
10
11

查漏补缺:

如果觉得不过瘾 ,请看这篇深入浅出的博文 Hibernate入门这一篇就够了

二 .Spring整合Hibernate JPA

介绍

步骤

1. 创建项目

可以复制以上的项目 ,在其基础上进行修改

2. 在项目中额外导入Hibernate JPA的jar包

hibernate-entitymanager-5.0.7.Final.jar
1

3 .修改配置文件

配置EntityManagerFactory
修改事务管理器
hibernate原生不可以和Hibernate JPA混合使用

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans.xsd
	http://www.springframework.org/schema/context
	http://www.springframework.org/schema/context/spring-context.xsd
	http://www.springframework.org/schema/aop
	http://www.springframework.org/schema/aop/spring-aop.xsd
	http://www.springframework.org/schema/tx 
	http://www.springframework.org/schema/tx/spring-tx.xsd">

	<!-- 配置读取properties工具类 -->
	<context:property-placeholder
		location="classpath:*.properties" />

	<!-- 配置c3p0数据库连接池 -->
	<bean id="dataSource"
		class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="jdbcUrl" value="${jdbc.url}" />
		<property name="driverClass" value="${jdbc.driver.class}" />
		<property name="user" value="${jdbc.username}" />
		<property name="password" value="${jdbc.password}" />
	</bean>



	<!-- Spring 整合JPA 配置EntityManagerFactory -->
	<bean id="entityManagerFactory"
		class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
		<property name="dataSource" ref="dataSource" />
		<property name="jpaVendorAdapter">
			<bean
				class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
				<!-- hibernate 相关的属性的注入 -->
				<!-- 配置数据库类型 -->
				<property name="database" value="MYSQL" />
				<!-- 正向工程自动创建表 -->
				<property name="generateDdl" value="true" />
				<!-- 显示执行的SQL -->
				<property name="showSql" value="true" />
			</bean>
		</property>
		<!-- 扫描实体的包 -->
		<property name="packagesToScan">
			<list>
				<value>ah.szxy.pojo</value>
			</list>
		</property>
	</bean>
	<!-- 配置Hibernate 的事务管理器 -->
	<bean id="transactionManager"
		class="org.springframework.orm.jpa.JpaTransactionManager">
		<property name="entityManagerFactory" ref="entityManagerFactory" />
	</bean>
	


	<!-- 配置开启注解事务处理 -->
	<tx:annotation-driven
		transaction-manager="transactionManager" />
	<!-- 配置springIOC的注解扫描 -->
	<context:component-scan base-package="ah.szxy" />


</beans>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

Hibernate JPA整合实现curd操作

环境搭建.接口实现类 注入EntityManager ,注入的方式改变

@PersistenceContext(name = "entityManagerFactory")
	private EntityManager entityManager;
1
2

删除方式不同 ,要先查询 ,根据id删除

增删改查调用的方法改变 ,通过entityManager对象实现真删改查操作
具体情况请看下面代码

Hibernate JPA中的HQL语句

Hibernate JPA中的SQL语句

Hibernate JPA中的SQL语句的QBC查询

注意 :
为节约时间,特将代码合在一起写 ,可以通过注释区分

实体类

同上 ,代码如下

package ah.szxy.pojo;

import java.io.Serializable;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name="t_users")
public class Users implements Serializable{
	//依次为主键 ,自增长 ,列名
	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	@Column(name="userid")
	private Integer userid;
	
	@Column(name="username")
	private String username;
	
	@Column(name="userage")
	private Integer userage;

	public Integer getUserid() {
		return userid;
	}

	public void setUserid(Integer userid) {
		this.userid = userid;
	}

	public String getUsername() {
		return username;
	}

	public void setUsername(String username) {
		this.username = username;
	}

	public Integer getUserage() {
		return userage;
	}

	public void setUserage(Integer userage) {
		this.userage = userage;
	}

	@Override
	public String toString() {
		return "Users [userid=" + userid + ", username=" + username + ", userage=" + userage + "]";
	}

	public Users(Integer userid, String username, Integer userage) {
		super();
		this.userid = userid;
		this.username = username;
		this.userage = userage;
	}

	public Users() {
		super();
	}
	
	
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

接口类

同上

package ah.szxy.dao;

import java.util.List;

import ah.szxy.pojo.Users;

public interface UserDao {
	
	void insert(Users users);
	void delete(Users users);
	void update(Users users);
	Users selectByUserid(Integer userid);
	
	List<Users> selectByUserName(String username);
	List<Users> selectByUsernameUseSQL(String username);
	List<Users> selectUserByNameUseCriteria(String username);
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

接口实现类

注意实现类中的书写方式
删除方式不同 ,要先查询 ,根据id删除

package ah.szxy.dao.impl;

import java.util.List;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.TypedQuery;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;

import org.springframework.stereotype.Repository;

import ah.szxy.dao.UserDao;
import ah.szxy.pojo.Users;

@Repository
public class UserDaoImpl implements UserDao {

	// 都是持久化操作
	@PersistenceContext(name = "entityManagerFactory")
	private EntityManager entityManager;



	public void insert(Users users) {

		this.entityManager.persist(users);
	}

	public void delete(Users users) {

		Users u = this.selectByUserid(users.getUserid());
		this.entityManager.remove(u);
	}

	public void update(Users users) {

		this.entityManager.merge(users);
	}

	public Users selectByUserid(Integer userid) {

		return this.entityManager.find(Users.class, userid);
	}

	@Override
	public List<Users> selectByUserName(String username) {

		return this.entityManager.createQuery("from Users where username= :suibian").setParameter("suibian", username).getResultList();
	}

	@Override
	public List<Users> selectByUsernameUseSQL(String username) {

		/**
		 * 在Hibernate JPA 中如果通过？方式来绑定参数，那么他的查数下标是从1开始的。而hibernate 中是从0 开始的。
		 */
		return this.entityManager.createNativeQuery("select * from t_users where username = ?", Users.class).setParameter(1, username).getResultList();
	}
	/**
	*采取QBC查询
	*
	*/
	@Override
	public List<Users> selectUserByNameUseCriteria(String username) {
		// CriteriaBuilder 对象：创建一个CriteriaQuery,创建查询条件。
		CriteriaBuilder builber = this.entityManager.getCriteriaBuilder();
		// CriteriaQuery 对象：执行查询的Criteria 对象
		// select * from t_users
		CriteriaQuery<Users> query = builber.createQuery(Users.class);

		// 获取要查询的实体类的对象
		Root<Users> root = query.from(Users.class);
		// 封装查询条件
		Predicate cate = builber.equal(root.get("username"), username);
		// select * from t_users where username = 张三
		query.where(cate);
		// 执行查询
		TypedQuery<Users> typeQuery = this.entityManager.createQuery(query);
		return typeQuery.getResultList();
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

测试类

同上

package ah.szxy.test;

import java.util.List;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.annotation.Rollback;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;

import ah.szxy.dao.UserDao;
import ah.szxy.pojo.Users;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class TestHibernate {

	@Autowired
	private UserDao userDao;

	/**
	 * 添加用户
	 */
	@Test
	@Transactional // 在测试类对于事务提交方式默认的是回滚。
	@Rollback(false) // 取消自动回滚
	public void testInsertUsers() {
		Users users = new Users();
		users.setUserage(23);
		users.setUsername("hello hibernate jpa");
		this.userDao.insert(users);
	}
	
	/**
	 * 修改用户
	 */
	@Test
	@Transactional
	@Rollback(false)
	public void testUpdateUsers() {
		Users users = new Users();
		users.setUserid(5);
		users.setUsername("chy");
		users.setUserage(24);
		this.userDao.update(users);
	}
	
	/**
	 * 查询用户
	 */
	@Test
	public void getUserByuserid() {
		
		Integer userid=2;;
		Users users = this.userDao.selectByUserid(userid);
		System.out.println(users);
		
		
	}
	
	/**
	 * 删除用户
	 * 使用Hibernate    JPA进行删除时,需要在dao层先查询用户id ,然后再删除
	 */
	@Test
	@Transactional
	@Rollback(false)
	public void deleteUsers() {
		Users users = new Users();
		users.setUserid(5);
		this.userDao.delete(users);
		
	}
	
	/**
	 * 测试Hibernate JPA的HQL查询 ,根据用户名称查询用户信息
	 * 必须加上@Transactional注解
	 */
	@Test
	@Transactional
	public void selectByUsername() {
		
		List<Users> users = this.userDao.selectByUserName("宿州学院");
		System.out.println(users);
	}
	
	/**
	 * 测试Hibernate JPA的SQL查询
	 */
	@Test
	@Transactional
	public void selecByUserNameUseSql() {
		
		List<Users> users = this.userDao.selectByUsernameUseSQL("宿州学院");
		for(Users user:users) {
			System.out.println(user);
		}
	}
	/**
	 * 测试Hibernate JPA的Criteria查询
	 */
	@Test
	@Transactional
	public void Criteria() {
		
		List<Users> users = this.userDao.selectByUsernameUseSQL("宿州学院");
		for(Users user:users) {
			System.out.println(user);
		}
	}
	
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

查漏补缺

如果觉得不过瘾 ,请看这篇深入浅出的博文 HibernateJPA入门