SpringDataJPA概念
Spring Data JPA 是 Spring 基于 ORM 框架、JPA规范的基础上封装的一套JPA应用框架,可使开发者用极简的代码即可实现对数据库的访问和操作
Spring Data JPA 提供了包括增删改查等在内的常用功能,且易于扩展,大大提高了开发效率
SpringDataJPA快速入门
1. 项目配置
1.1 在pom.xml中添加相关依赖
1.2 在applicationContext.xml配置相应的配置
1.3 创建实体类和实体类对应的DAO接口
2. Spring Data JPA DAO流程分析
底层用的动态代理,完成接口的实现类对象,根据方法名查询,更加简单便捷
3. Dao层接口基础方法
继承JpaRepository后的方法列表
继承JpaSpecificationExecutor的方法列表
基础查询
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml" )
public class CustomerDaoTest {
@Autowired
private CustomerDao customerDao;
/**
* 根据id查询
*/
@Test
public void testFindOne (){
Customer c = customerDao.findOne(2l);
System.out.println(c);
}
/**
* 保存与更新 是否传id主键属性
*/
@Test
public void testSave (){
Customer customer = new Customer();
customer.setCustName("洪湖" );
customerDao.save(customer);
}
@Test
public void testUpdate (){
Customer customer = new Customer();
customer.setCustId(4l);
customer.setCustName("大洪湖" );
customerDao.save(customer);
}
/**
* 删除用户
*/
@Test
public void testDelete (){
customerDao.delete(4l);
}
/**
* 查询所有用户
*/
@Test
public void testFindAll (){
List<Customer> list = customerDao.findAll();
for (Customer customer : list) {
System.out.println(customer);
}
}
/**
* 查询客户总数量
*/
@Test
public void testCount (){
long count = customerDao.count();
System.out.println(count);
}
/**
* 判断用户是否存在
*/
@Test
public void testExists (){
boolean exists=customerDao.exists(3l);
System.out.println("是否存在:" +exists);
}
/**
* 根据id从数据库查询
* findOne
* em.find(); 立即加载
* getOne()
* em.getReference(); 延迟加载 什么时候用 什么时候查询
*/
@Test
@Transactional
public void testGetOne (){
Customer customer = customerDao.getOne(3l);
System.out.println(customer);
}
}
4.JPQL
query注解
public interface CustomerDao extends JpaRepository <Customer ,Long >,JpaSpecificationExecutor <Customer > {
@Query (value = "from Customer where custName = ?" )
public Customer findJpql (String custName) ;
@Query (value = "from Customer where custId = ? and custName = ?" )
public Customer findTwoJpql (long custId,String custName) ;
@Query (value = "update Customer set custName = ? where custId = ?" )
@Modifying
public void updateJpql (String custName,long custId) ;
@Query (value = "select * from cst_customer" ,nativeQuery = true )
public List<Object[]> findSql();
@Query (value = "select * from cst_customer WHERE cust_name LIKE ?" ,nativeQuery = true )
public List<Object[]> findSqlFindName(String name);
public Customer findByCustName (String custName) ;
public List<Customer> findByCustNameLike (String custName) ;
public Customer findByCustNameLikeAndCustLevel (String custName,String custLevel) ;
}
@RunWith (SpringJUnit4ClassRunner.class)
@ContextConfiguration (locations = "classpath:applicationContext.xml" )
public class JpqlTest {
@Autowired
private CustomerDao customerDao;
@Test
public void testFindJPQL () {
Customer customer = customerDao.findJpql("深圳计划" );
System.out.println(customer);
}
@Test
public void testFindTwoJPQL () {
Customer c = customerDao.findTwoJpql(2l , "深圳计划" );
System.out.println(c);
}
@Test
@Transactional
@Rollback (value = false )
public void testUpdateJPQL () {
customerDao.updateJpql("大深圳计划" ,2l );
}
@Test
public void testSql () {
List<Object[]> list = customerDao.findSql();
for (Object[] objects : list) {
System.out.println(Arrays.toString(objects));
}
}
@Test
public void testSqlFindName () {
List<Object[]> list = customerDao.findSqlFindName("%计划" );
for (Object[] objects : list) {
System.out.println(Arrays.toString(objects));
}
}
@Test
public void findByCustName () {
Customer c = customerDao.findByCustName("福州计划" );
System.out.println(c);
}
@Test
public void findByCustNameLike () {
List<Customer> list = customerDao.findByCustNameLike("%计划" );
for (Customer customer : list) {
System.out.println(customer);
}
}
@Test
public void findByCustNameLikeAndCustLevel () {
Customer c = customerDao.findByCustNameLikeAndCustLevel("%计划" , "1" );
System.out.println(c);
}
}
Specifications动态查询
@RunWith (SpringJUnit4ClassRunner.class)
@ContextConfiguration (locations = "classpath:applicationContext.xml" )
public class SpecTest {
@Autowired
private CustomerDao customerDao;
@Test
public void testSpec () {
Specification<Customer> spec=new Specification<Customer>() {
public Predicate toPredicate (Root<Customer> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
Path<Object> custName = root.get("custName" );
Predicate p = cb.equal(custName, "福州计划" );
return p;
}
};
Customer customer = customerDao.findOne(spec);
System.out.println(customer);
}
@Test
public void testSpec1 () {
Specification<Customer> spec=new Specification<Customer>() {
public Predicate toPredicate (Root<Customer> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
Path<Object> custName = root.get("custName" );
Path<Object> custLevel = root.get("custLevel" );
Predicate p1 = criteriaBuilder.equal(custName, "大深圳计划" );
Predicate p2 = criteriaBuilder.equal(custLevel, "1" );
Predicate p = criteriaBuilder.and(p1, p2);
return p;
}
};
Customer c = customerDao.findOne(spec);
System.out.println(c);
}
@Test
public void testSpec2 () {
Specification<Customer> spec=new Specification<Customer>() {
public Predicate toPredicate (Root<Customer> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
Path<Object> custName = root.get("custName" );
Predicate p = criteriaBuilder.like(custName.as(String.class), "%计划" );
return p;
}
};
Sort sort = new Sort(Sort.Direction.DESC,"custId" );
List<Customer> list = customerDao.findAll(spec, sort);
for (Customer c : list) {
System.out.println(c);
}
}
@Test
public void testSpec3 () {
Specification spec=null ;
Pageable pageable =new PageRequest(0 ,2 );
Page<Customer> p = customerDao.findAll(spec, pageable);
System.out.println(p.getContent());
System.out.println(p.getTotalElements());
System.out.println(p.getTotalPages());
}
}
5.多表关系
一对多映射
@ManyToOne (targetEntity = Customer.class)
@JoinColumn (name = "lkm_cust_id" ,referencedColumnName = "cust_id" )
private Customer customer;
@OneToMany (mappedBy = "customer" ,cascade = CascadeType.ALL)
private Set<LinkMan> linkMens=new HashSet<LinkMan>();
@Autowired
private CustomerDao customerDao;
@Autowired
private LinkManDao linkManDao;
@Test
@Transactional
@Rollback (value = false )
public void testCascadeAdd () {
Customer customer=new Customer();
customer.setCustName("阿里" );
LinkMan man=new LinkMan();
man.setLkmName("淼哥" );
man.setCustomer(customer);
customer.getLinkMens().add(man);
customerDao.save(customer);
}
@Test
@Transactional
@Rollback (value = false )
public void testCascadeDelete () {
Customer c = customerDao.findOne(1l );
customerDao.delete(c);
}
@Test
@Transactional
public void testQuery1 () {
Customer customer = customerDao.getOne(1l );
Set<LinkMan> set = customer.getLinkMens();
for (LinkMan man : set) {
System.out.println(man);
}
}
@Test
@Transactional
public void testQuery2 () {
LinkMan linkMan = linkManDao.findOne(2l );
Customer customer = linkMan.getCustomer();
System.out.println(customer);
}
多对多映射
@ManyToMany (targetEntity = Role.class,cascade = CascadeType.ALL)
@JoinTable (name = "sys_user_role" ,
joinColumns = {@JoinColumn (name = "sys_user_id" ,referencedColumnName = "user_id" )},
inverseJoinColumns = {@JoinColumn (name = "sys_role_id" ,referencedColumnName = "role_id" )}
)
private Set<Role> roles=new HashSet<Role>();
@ManyToMany (mappedBy = "roles" )
private Set<User> users=new HashSet<User>();
@Test
@Transactional
@Rollback (false )
public void testCasCadeAdd () {
User user = new User();
user.setUserName("淼哥" );
Role role = new Role();
role.setRoleName("java软件工程师" );
user.getRoles().add(role);
userDao.save(user);
}
@Test
@Transactional
@Rollback (false )
public void testCasCadeDelete () {
User user = userDao.findOne(1l );
userDao.delete(user);
}