springDataJPA和spring的整合 之springdata编写sql的5种方式

    Jpa实现数据库的CRUD

需求     使用SpringDataJpa实现数据库的CRUD

开发步骤

​    1    创建MAVEN 工程

​    2    添加依赖

​            mysql

​            c3p0

​            hibernate

​            springDataJpA

​            spring相关jar包

​    3 创建配置文件

​    4 创建实体类

​    5 创建Dao  创建接口 即可  要求接口继承  JpaRspository接口

​    6 编写测试程序

​        1 初始花啊spring  容器

​        2 从容器中获得Dao代理对象

​        3 使用Dao  实现增删改查

​    添加/修改 数据  save

​    删除数据    delete

​         查询    ：findOne.

​    查询全部   findAll()

​            findAll(Pageable pageaable)     返回Page对象      这里面包含：totalElements  总记录数

​                                                                     totalPages     总页数

​                                                                    content   结果列表

​         

## 1 springDataJpa  其它的相关查询方式

​    1 查询全部带排序‘

​    2  count  统计

​    3 exixtx  判断记录是否存在

## 2 在springDataJpa框架使用Jpql 查询

​      使用方法 

​        a:   在dao 接口中定义一个方法  使用方法的参数设置jpql的参数   并且使用方法的返回值接受查询的结果

​        b: 在方法上添加一个注解Qquery

​        c 在注解中编写jpql

​        d 测试

## 3 使用原生的Sql语句

​    使用方法

​          1  dao中  定义一个方法

​           2  在方法中添加@Query注解

​          3 在注解中 添加 原生的sql 语句   添加一个属性  nativeQuery=true

​          4 测试

## 4 方法命名规则查询

​    通过一定的规则 定义一个方法  框架本省就可以根据方法名生成一个SQL语句进行查询

​        规则

​            1 应该使用findBy开头

​            2 查询某个字段  findBy后跟实体类的属性的名称  

​            3 如果有多个条件   就在方法后加And+实体类的属性名

​            4  方法的参数 对应查询的定义

​            5 返回值根据返回的数据类型定义

   如果需要分页查询   在方法中添加一个参数Pageable 即可

## 5 使用Specification方式进行查询

   最强大的查询方式  除了原生的SQL 语句以外   最复杂的查询方式

使用方式

​    1 要在dao 继承JpaSeciFicationExection 接口

​    2 使用JpaSeciFicationExection 接口 中提供的方法进行查询

​        每个方法都需要使用Specification对象作为参数

   CRUD  

​      框架整合

​        （数据源）（工程类对象）（事物）(dao 扫描器)

​    Entity

​    Dao

​       定义接口就行  继承JpaRepository<Customer,Long>

1  crud

​     使用dao 实现CRUD（重点）

​     添加 save

​     修改  save

​      删除  delete

​    查询   findOne    getOne   findAll  可以分页  排序

2 使用jpql 查询

​     查询 @Query    更新   删除   

3 原生 sql 

​    使用@Query注解  添加属性nativeQuery=true

4 方法名命名规则 查询（重点）  findBy

5 使用SpeciFication  方式查询

dao层


public interface CustomerDao extends JpaRepository<Customer,Long>, JpaSpecificationExecutor<Customer> {
    @Query("from Customer")
    List<Customer> getAllCustomer();
    @Query("from Customer")
    List<Customer> getAllCustomerByPape(Pageable pageable);
    // 条件查询‘
    @Query("from Customer where cust_id=?")
    Customer getCustomerById(long id);
    // 模糊查询
    @Query("from Customer where custName like?2 and custAddress like ?1")
    List<Customer> getCustList(String address,String name);
   // 更新
    @Query("update Customer set custSource=? where custId=?")
   @Modifying
//    @Transactional
    void updateSource(String source,long id);
    // 原生语句调价查询操作
    @Query(value = "SELECT  * FROM cst_customer where cust_name LIKE ?",nativeQuery = true)
    List<Customer> getCustomerListByNative(String name);



    //方法命名规则查询
    Customer findByCustId(long id);


    List<Customer> findByCustNameLikeAndCustAddressLike(String name,String address);
    // 分页
    Page<Customer> findByCustAddressLike(String address,Pageable pageable);
}

测试层

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class JpaCRUD1 {
    @Autowired
    private CustomerDao customerDao;
    @Test
    public void addCustomer(){
//        ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
//        CustomerDao customerDao = ac.getBean(CustomerDao.class);
        Customer cc = new Customer();
        cc.setCustName("谢大脚");
        cc.setCustAddress("北京朝阳区");
        cc.setCustLevel("黑金VIP");
        customerDao.save(cc);
    }
    // 删除
    @Test
    public void deleteCustomer(){
        customerDao.delete(2l);
    }
    // 更新数据
    @Test
    public void updateCustomer(){
        Customer customer = customerDao.findOne(1l);
        customer.setCustName("张一山");
        customer.setCustLevel("铂金vip");
        customerDao.save(customer);

    }
    @Test
    public  void findById(){
        Customer one = customerDao.findOne(1l);
        System.out.println(one);
    }
    @Test
    @Transactional// 加上事物注解   在方法执行结束之前   连接不会断
    public  void testGetOne(){
        Customer one = customerDao.getOne(1l);
        System.out.println("-----------------------");
        System.out.println(one);
    }
    @Test
    public void testFindAll(){
        List<Customer> customerDaoAll = customerDao.findAll();
        for(Customer customer:customerDaoAll){
            System.out.println(customer);
        }

    }
    @Test
    public void testFindAllWithPage() {
        PageRequest pageRequest = new PageRequest(0, 2);
        Page<Customer> page = customerDao.findAll(pageRequest);
        long totalElements = page.getTotalElements();
        System.out.println("总记录数"+totalElements);
        int totalPages = page.getTotalPages();
        System.out.println("总页码"+totalPages);
        List<Customer> content = page.getContent();
        for(Customer customer:content){
            System.out.println(customer);
        }
    }
    //  查询所有带排序  8月19日
    @Test
    public void testFindAllWithSort(){
        // 创建一个sort  对象
        //  参数1  排序方式
        // 参数2  排序的字段  应该是实体类的属性名
        Sort sort = new Sort(Sort.Direction.DESC,"custId");
        List<Customer> list = customerDao.findAll(sort);
        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(2l);
        System.out.println(exists);
    }

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class JPQLCrud {
    @Autowired
    private CustomerDao customerDao;
    @Test
    public void testgetAllCustomer(){
        List<Customer> list = customerDao.getAllCustomer();
        for(Customer customer:list){
            System.out.println(customer);
        }
    }
    @Test
    public void testGetAllCustomerByPage(){
        List<Customer> allCustomerByPape = customerDao.getAllCustomerByPape(new PageRequest(0, 3));
      for(Customer customer:allCustomerByPape){
          System.out.println(customer);
      }
    }
    @Test
    public void testGetCustomerById(){
        Customer customerById = customerDao.getCustomerById(1l);
        System.out.println(customerById);
    }
    @Test
    public void testGetCustList(){
        List<Customer> custList = customerDao.getCustList("%北京%", "%大%");
        for(Customer customer:custList){
            System.out.println(customer);
        }
    }
    @Test
    @Transactional
    @Commit
    public void testUpdatSource(){
      customerDao.updateSource("互联网111",1l);
    }
    @Test

    public void testCustomerListByNative(){
        List<Customer> list = customerDao.getCustomerListByNative("%脚%");
        for(Customer customer :list){
            System.out.println(customer);
        }
    }

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class SpringDataJpaVoid {
    @Autowired
    private CustomerDao customerDao;
    @Test
    public void testFindByCustId(){
        Customer customer = customerDao.findByCustId(1l);
        System.out.println(customer);
    }
    @Test
    public void testFindByCustNameLikeAndCustAddressLike(){
        List<Customer> list = customerDao.findByCustNameLikeAndCustAddressLike("%脚%", "%北京%");
        for(Customer customer:list){
            System.out.println(customer);
        }
    }
    @Test
    public void testFindByCustomerAddressByPage(){
        Page<Customer> pa = customerDao.findByCustAddressLike("%北京%", new PageRequest(0, 3));
        System.out.println(pa.getTotalElements());
        System.out.println(pa.getTotalPages());
        List<Customer> list = pa.getContent();
        for(Customer customer:list){
            System.out.println(customer);
        }
        // 测试 使用Specification方式进行查询


    }
    @Test
    public void testFindByIdSpeciFication(){
        Customer customer =customerDao.findOne(new Specification<Customer>() {
            @Override
            public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
               //  参数1  字段名称
                // 参数2    字段的值
                Predicate predicate = criteriaBuilder.equal(root.get("custId"), 1l);
                return predicate;
            }
        });
        System.out.println(customer);
    }
    //  根据地址模糊查询
    @Test
    public void testFindByNmaeAdress(){
        customerDao.findAll(new Specification<Customer>() {
            @Override
            public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
               // 创建 根据模糊查询的条件
                Predicate predicate1 = criteriaBuilder.like(root.get("custName"), "%脚%");

                Predicate like1 = criteriaBuilder.like(root.get("custAddress"), "%北京%");
                // 组合两个条件
                Predicate predicate = criteriaBuilder.and(predicate1, like1);
                return predicate;
            }
        }).forEach(c->System.out.println(c));//forEach(System.out::println);
    }
    @Test
    public void testFindByNmaeAdressWithPage(){
        Page<Customer> page = customerDao.findAll(new Specification<Customer>() {
            @Override
            public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
                // 创建 根据模糊查询的条件
                Predicate predicate1 = criteriaBuilder.like(root.get("custName"), "%脚%");

                Predicate like1 = criteriaBuilder.like(root.get("custAddress"), "%北京%");
                // 组合两个条件
                Predicate predicate = criteriaBuilder.and(predicate1, like1);
                return predicate;
            }
        },new PageRequest(0,3));
        System.out.println(page.getTotalElements());
        System.out.println(page.getTotalPages());
        List<Customer> content = page.getContent();
        for (Customer customer:content){
            System.out.println(customer);
        }
    }
}

https://www.cnblogs.com/dragonyl/p/11364046.html