SpringData_JPA

Spring Data JAP:
Spring Data JAP是 spring data 项目下的一个模块。提供了一套基于 JPA标准操作数据库的简化方案。底层默认的是依赖 Hibernate JPA 来实现的。

Spring Data JPA 的技术特点
我们只需要定义接口并集成 Spring Data JPA 中所提供的接口就可以了。不需要编写接口实现类

创建 Spring Data JPA 项目

1 导入 jar 包
2 修改配置文件
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
<?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"
xmlns:jpa="http://www.springframework.org/schema/data/jpa"
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/data/jpa
http://www.springframework.org/schema/data/jpa/spring-jpa.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd">
<!-- 配置读取 properties 文件的工具类 -->
<context:property-placeholder
location="classpath:jdbc.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>com.fanke.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="com.fanke"/>
<!-- Spring Data JPA 的配置 -->
<!-- base-package:扫描 dao 接口所在的包 -->
<jpa:repositories base-package="com.fanke.dao"/>
</beans>
3 编写 Dao
1
2
public interface UsersDao extends JpaRepository<Users, Integer> {
}
测试代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class UsersDaoImplTest {
@Autowired
private UsersDao usersDao;
/**
* 添加用户
*/
@Test
@Transactional// 在测试类对于事务提交方式默认的是回滚。
@Rollback(false)//取消自动回滚
public void testInsertUsers(){
Users users = new Users();
users.setUserage(24);
users.setUsername("张三");
this.usersDao.save(users);
}
}

Spring Data JAP的接口继承结构

Repository 接口

Repository 接口是 Spring Data JPA 中为我我们提供的所有接口中的顶层接口
Repository 提供了两种查询方式的支持
1)基于方法名称命名规则查询
2)基于@Query 注解查询

方法名称命名规则查询

findBy(关键字)+属性名称(属性名称的首字母大写)+查询条件(首字母大写)

关键字 方法命名 sql where 字句
And findByNameAndPwd where name= ? and pwd =?
Or findByNameOrSex where name= ? or sex=?
Is,Equal findById,findByIdEquals where id= ?
Between findByIdBetween where id between ?and ?
LessThan findByIdLessThan where id < ?
LessThanEqual findByIdLessThanEquals where id <= ?
GreaterThan findByIdGreaterThan where id > ?
GreaterThanEqual findByIdGreaterThanEquals where id > = ?
After findByIdAfter where id > ?
Before findByIdBefore where id < ?
IsNull findByNameIsNull where name is null
isNotNull,Not findByNameNotNull where name is not
Like findByNameLike where name like ?
NotLike findByNameNotLike where name not like ?
StartingWith findByNameStartingWith where name like ‘?%’
EndingWith findByNameEndingWith where name like ‘%?’
Containing findByNameContaining where name like’%?%’
OrderBy findByIdOrderByXDesc where id=? order byx desc
Not findByNameNot where name <> ?
In findByIdIn(Collection<?> c) where id in (?)
NotIn findByIdNotIn(Collection<?> c) where id not in(?)
True findByAaaTue where aaa = true
False findByAaaFalse where aaa = false
IgnoreCase findByNameIgnoreCase whereUPPER(name)=UPPER(?)
Repository 接口
1
2
3
4
5
public interface UsersDao1 extends Repository<Users, Integer> {
List<Users> findByEmailIs(String string);
List<Users> findByUserNameLike(String string);
// List<Users> findByUsernameAndUserageGreaterThanEqual(String name,Integer age);
}
测试方法
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
/**
* Repository 接口测试
* @author Administrator
*
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class RepositoryTest {
@Autowired
private UsersDao usersDao;
/**
* 需求:使用用户名作为查询条件
*/
@Test
public void test1(){
/**
* 判断相等的条件,有三种表示方式
* 1,什么都不写,默认的就是做相等判断
* 2,Is
* 3,Equal
*/
List<Users> list = this.usersDao.findByUsernameIs("王五");
for (Users users : list) {
System.out.println(users);
}
}
/**
* 需求:根据用户姓名做 Like 处理
* Like:条件关键字
*/
@Test
public void test2(){
List<Users> list = this.usersDao.findByUsernameLike("王%");
for (Users users : list) {
System.out.println(users);
}
}
/**
* 需求:查询名称为王五,并且他的年龄大于等于 22 岁
*/
@Test
public void test3(){
List<Users> list =
this.usersDao.findByUsernameAndUserageGreaterThanEqual("王五", 22);
for (Users users : list) {
System.out.println(users);
}
}
}

基于@Query 注解的查询

通过 JPQL 语句查询

JPQL:通过 Hibernate 的 HQL 演变过来的。他和 HQL 语法及其相似。

创建接口
1
2
3
4
5
6
7
8
9
public interface UsersDao2 extends Repository<Users, Integer> {
//使用@Query 注解查询
@Query(value="from Users where userName = ?")
List<Users> queryUserByNameUseJPQL(String name);
@Query("from Users where userName like ?")
List<Users> queryUserByLikeNameUseJPQL(String name);
@Query("from Users where userName = ? and passWord >= ?")
List<Users> queryUserByNameAndAge(String name,String password);
}


测试方法
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
/**
* 测试@Query 查询 JPQL
*/
@Test
public void test4(){
List<Users> list = this.usersDao2.queryUserByNameUseJPQL("史迪仔");
for (Users users : list) {
System.out.println(users);
}
}
/**
* 测试@Query 查询 JPQL
*/
@Test
public void test5(){
List<Users> list = this.usersDao2.queryUserByLikeNameUseJPQL(" 王%");
for (Users users : list) {
System.out.println(users);
}
}
/**
* 测试@Query 查询 JPQL
*/
@Test
public void test6(){
List<Users> list = this.usersDao2.queryUserByNameAndAge("杜登狗","123456");
for (Users users : list) {
System.out.println(users);
}
}
通过 SQL 语句查询
创建接口
1
2
3
4
5
6
7
8
9
10
public interface UsersDao3 extends Repository<Users, Integer> {
//使用@Query 注解查询 SQL
//nativeQuery:默认的是 false.表示不开启 sql 查询。是否对 value 中的语句做转义。
@Query(value="select * from users where username = ?",nativeQuery=true)
List<Users> queryUserByNameUseSQL(String name);
@Query(value="select * from users where username like ?",nativeQuery=true)
List<Users> queryUserByLikeNameUseSQL(String name);
@Query(value="select * from users where username = ? and password >= ?",nativeQuery=true)
List<Users> queryUserByNameAndAgeUseSQL(String name,String password);
}
测试方法
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
/**
* 测试@Query 查询 SQL
*/
@Test
public void test7(){
List<Users> list = this.usersDao3.queryUserByNameUseSQL("杜登狗");
for (Users users : list) {
System.out.println(users);
}
}
/**
* 测试@Query 查询 SQL
*/
@Test
public void test8(){
List<Users> list = this.usersDao3.queryUserByLikeNameUseSQL(" 悲伤%");
for (Users users : list) {
System.out.println(users);
}
}
/**
* 测试@Query 查询 SQL
*/
@Test
public void test9(){
List<Users> list = this.usersDao3.queryUserByNameAndAgeUseSQL(" 杜登狗", "123456");
for (Users users : list) {
System.out.println(users);
}
}

通过@Query 注解完成数据更新

创建接口
1
2
3
@Query("update Users set userage = ? where userid = ?")
@Modifying //@Modifying 当前语句是一个更新语句
void updateUserAgeById(Integer age,Integer id);
测试类
1
2
3
4
5
6
7
8
9
/**
* 测试@Query update
*/
@Test
@Transactional
@Rollback(false)
public void test10(){
this.usersDao.updateUserAgeById(24, 5);
}

CrudRepository 接口

创建接口
1
2
3
4
5
6
7
/**
* CrudRepository 接口讲解
* @author Administrator
*
*/
public interface UsersDao extends CrudRepository<Users, Integer> {
}
测试方法
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
/**
* CrudRepository 接口测试
* @author Administrator
*
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class RepositoryTest {
@Autowired
private UsersDao usersDao;
/**
* 添加单条数据
*/
@Test
public void test1(){
Users user = new Users();
user.setUserage(21);
user.setUsername("赵小丽");
this.usersDao.save(user);
}
/**
* 批量添加数据
*/
@Test
public void test2(){
Users user = new Users();
user.setUserage(21);
user.setUsername("赵小丽");
Users user1 = new Users();
user1.setUserage(25);
user1.setUsername("王小虎");
List<Users> list= new ArrayList<>();
list.add(user);
list.add(user1);
this.usersDao.save(list);
}
/**
* 根据 ID 查询单条数据
*/
@Test
public void test3(){
Users users = this.usersDao.findOne(13);
System.out.println(users);
}
/**
* 查询全部数据
*/
@Test
public void test4(){
List<Users> list = (List<Users>)this.usersDao.findAll();
for (Users users : list) {
System.out.println(users);
}
}
/**
* 删除数据
*/
@Test
public void test5(){
this.usersDao.delete(13);
}
/**
* 更新数据 方式一
*/
@Test
public void test6(){
Users user = this.usersDao.findOne(12);
user.setUsername("王小红");
this.usersDao.save(user);
}
/**
* 更新数据 方式二
*/
@Test
@Transactional
@Rollback(false)
public void test7(){
Users user = this.usersDao.findOne(12);//持久化状态的
user.setUsername("王小小");
}
}

PagingAndSortingRepository 接口

分页处理

创建接口

1
2
3
4
5
6
7
8
/**
* PagingAndSortingRepository 接口讲解
* @author Administrator
*
*/
public interface UsersDao extends PagingAndSortingRepository<Users,
Integer>{
}

测试方法

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
/**
* CrudRepository 接口测试
* @author Administrator
*
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class RepositoryTest {
@Autowired
private UsersDao usersDao;
/**
* 分页
*/
@Test
public void test1(){
int page = 2; //page:当前页的索引。注意索引都是从 0 开始的。
int size = 3;// size:每页显示 3 条数据
Pageable pageable= new PageRequest(page, size);
Page<Users> p = this.usersDao.findAll(pageable);
System.out.println("数据的总条数:"+p.getTotalElements());
System.out.println("总页数:"+p.getTotalPages());
List<Users> list = p.getContent();
for (Users users : list) {
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
/**
* 对单列做排序处理
*/
@Test
public void test2(){
//Sort:该对象封装了排序规则以及指定的排序字段(对象的属性来表示)
//direction:排序规则
//properties:指定做排序的属性
Sort sort = new Sort(Direction.DESC,"userid");
List<Users> list = (List<Users>)this.usersDao.findAll(sort);
for (Users users : list) {
System.out.println(users);
}
}
/**
* 多列的排序处理
*/
@Test
public void test3(){
//Sort:该对象封装了排序规则以及指定的排序字段(对象的属性来表示)
//direction:排序规则
//properties:指定做排序的属性
Order order1 = new Order(Direction.DESC,"userage");
Order order2 = new Order(Direction.ASC,"username");
Sort sort = new Sort(order1,order2);
List<Users> list = (List<Users>)this.usersDao.findAll(sort);
for (Users users : list) {
System.out.println(users);
}
}

JpaRepository 接口

JpaRepository 接口是我们开发时使用的最多的接口。其特点是可以帮助我们将其他接口
的方法的返回值做适配处理。可以使得我们在开发时更方便的使用这些方法。

创建接口
1
2
3
4
5
6
7
/**
* JpaRepository 接口讲解
* @author Administrator
*
*/
public interface UsersDao extends JpaRepository<Users, Integer>{
}
测试方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
/**
* JpaRepository 接口测试
* @author Administrator
*
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class RepositoryTest {
@Autowired
private UsersDao usersDao;
/**
* 查询全部数据
*/
@Test
public void test1(){
List<Users> list = this.usersDao.findAll();
for (Users users : list) {
System.out.println(users);
}
}
}

JpaSpecificationExecutor 接口

完成多条件查询,并且支持分页与排序

单条件查询
创建接口
1
2
3
4
5
6
7
8
9
/**
* JpaSpecificationExecutor 接口讲解
* @author Administrator
*注意:JpaSpecificationExecutor<Users>:不能单独使用,需要配合着 jpa 中的
其他接口一起使用
*/
public interface UsersDao extends JpaRepository<Users,
Integer>,JpaSpecificationExecutor<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
/**
* JpaRepository 接口测试
* @author Administrator
*
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class RepositoryTest {
@Autowired
private UsersDao usersDao;
/**
* 需求:根据用户姓名查询数据
*/
@Test
public void test1(){
Specification<Users> spec = new Specification<Users>() {
/**
* @return Predicate:定义了查询条件
* @param Root<Users> root:根对象。封装了查询条件的对象
* @param CriteriaQuery<?> query:定义了一个基本的查询.一般不
使用
* @param CriteriaBuilder cb:创建一个查询条件
*/
@Override
public Predicate toPredicate(Root<Users> root,
CriteriaQuery<?> query, CriteriaBuilder cb) {
Predicate pre = cb.equal(root.get("username"), "王五");
return pre;
}
};
List<Users> list = this.usersDao.findAll(spec);
for (Users users : list) {
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
/**
* 多条件查询 方式一
* 需求:使用用户姓名以及年龄查询数据
*/
@Test
public void test2(){
Specification<Users> spec = new Specification<Users>() {
@Override
public Predicate toPredicate(Root<Users> root,
CriteriaQuery<?> query, CriteriaBuilder cb) {
List<Predicate> list = new ArrayList<>();
list.add(cb.equal(root.get("username"),"王五"));
list.add(cb.equal(root.get("userage"),24));
//此时条件之间是没有任何关系的。
Predicate[] arr = new Predicate[list.size()];
return cb.and(list.toArray(arr));
}
};
List<Users> list = this.usersDao.findAll(spec);
for (Users users : list) {
System.out.println(users);
}
给定查询条件方式二
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/**
* 多条件查询 方式二
* 需求:使用用户姓名或者年龄查询数据
*/
@Test
public void test3(){
Specification<Users> spec = new Specification<Users>() {
@Override
public Predicate toPredicate(Root<Users> root,
CriteriaQuery<?> query, CriteriaBuilder cb) {
return cb.or(cb.equal(root.get("username"),"王五
"),cb.equal(root.get("userage"), 25));
}
};
List<Users> list = this.usersDao.findAll(spec);
for (Users users : list) {
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
/**
* 需求:查询王姓用户,并且做分页处理
*/
@Test
public void test4(){
//条件
Specification<Users> spec = new Specification<Users>() {
@Override
public Predicate toPredicate(Root<Users> root,
CriteriaQuery<?> query, CriteriaBuilder cb) {
return cb.like(root.get("username").as(String.class),
"王%");
}
};
//分页
Pageable pageable = new PageRequest(2, 2);
Page<Users> page = this.usersDao.findAll(spec, pageable);
System.out.println("总条数:"+page.getTotalElements());
System.out.println("总页数:"+page.getTotalPages());
List<Users> list = page.getContent();
for (Users users : list) {
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
/**
* 需求:查询数据库中王姓的用户,并且根据用户 id 做倒序排序
*/
@Test
public void test5(){
//条件
Specification<Users> spec = new Specification<Users>() {
@Override
public Predicate toPredicate(Root<Users> root,
CriteriaQuery<?> query, CriteriaBuilder cb) {
return cb.like(root.get("username").as(String.class),
"王%");
}
};
//排序
Sort sort = new Sort(Direction.DESC,"userid");
List<Users> list = this.usersDao.findAll(spec, sort);
for (Users users : list) {
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
/**
* 需求:查询数据库中王姓的用户,做分页处理,并且根据用户 id 做倒序排序
*/
@Test
public void test6(){
//排序等定义
Sort sort = new Sort(Direction.DESC,"userid");
//分页的定义
Pageable pageable = new PageRequest(2,2, sort);
//查询条件
Specification<Users> spec = new Specification<Users>() {
@Override
public Predicate toPredicate(Root<Users> root,
CriteriaQuery<?> query, CriteriaBuilder cb) {
return cb.like(root.get("username").as(String.class),
"王%");
}
};
Page<Users> page = this.usersDao.findAll(spec, pageable);
System.out.println("总条数:"+page.getTotalElements());
System.out.println("总页数:"+page.getTotalPages());
List<Users> list = page.getContent();
for (Users users : list) {
System.out.println(users);
}
}
用户自定义 Repository 接口

还是按照方法名查找

创建接口
1
2
3
public interface UsersRepository {
public Users findUserById(Integer userid);
}
使用接口
1
2
3
4
5
6
7
/**
* 用户自定义 Repository 接口讲解
* @author Administrator
*/
public interface UsersDao extends JpaRepository<Users,
Integer>,JpaSpecificationExecutor<Users>,UsersRepository{
}
创建接口实现类
1
2
3
4
5
6
7
8
9
public class UsersDaoImpl implements UsersRepository {
@PersistenceContext(name="entityManagerFactory")
private EntityManager em;
@Override
public Users findUserById(Integer userid) {
System.out.println("MyRepository......");
return this.em.find(Users.class, userid);
}
}
编写测试代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/**
* JpaRepository 接口测试
* @author Administrator
*
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class RepositoryTest {
@Autowired
private UsersDao usersDao;
/**
* 需求:根据用户 ID 查询数据
*/
@Test
public void test1(){
Users users = this.usersDao.findUserById(5);
System.out.println(users);
}
}