zoukankan      html  css  js  c++  java
  • 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=true4 测试
    
    ## 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

  • 相关阅读:
    Encryption (hard) CodeForces
    cf 1163D Mysterious Code (字符串, dp)
    AC日记——大整数的因子 openjudge 1.6 13
    AC日记——计算2的N次方 openjudge 1.6 12
    Ac日记——大整数减法 openjudge 1.6 11
    AC日记——大整数加法 openjudge 1.6 10
    AC日记——组合数问题 落谷 P2822 noip2016day2T1
    AC日记——向量点积计算 openjudge 1.6 09
    AC日记——石头剪刀布 openjudge 1.6 08
    AC日记——有趣的跳跃 openjudge 1.6 07
  • 原文地址:https://www.cnblogs.com/dragonyl/p/11378844.html
Copyright © 2011-2022 走看看