• 七、springboot整合Spring-data-jpa


    1.Spring Data JPA是什么

      由Spring提供的一个用于简化JPA开发的框架。可以在几乎不用写实现的情况下,实现对数据的访问和操作。除了CRUD外,还包括如分页、排序等一些常用的功能

      1.Spring Data JPA的核心概念:

    1:Repository:最顶层的接口,是一个空的接口,目的是为了统一所有Repository的类型,且能让组件扫描的时候自动识别。

    2:CrudRepository :是Repository的子接口,提供CRUD的功能

    3:PagingAndSortingRepository:是CrudRepository的子接口,添加分页和排序的功能

    4:JpaRepository:是PagingAndSortingRepository的子接口,增加了一些实用的功能,比如:批量操作等。

    5:JpaSpecificationExecutor:用来做负责查询的接口

    6:Specification:是Spring Data JPA提供的一个查询规范,要做复杂的查询,只需围绕这个规范来设置查询条件即可

       2.JpaRepository的查询

          具体的关键字,使用方法和生产成SQL如下表所示

    KeywordSampleJPQL snippet
    And findByLastnameAndFirstname … where x.lastname = ?1 and x.firstname = ?2
    Or findByLastnameOrFirstname … where x.lastname = ?1 or x.firstname = ?2
    Is,Equals findByFirstnameIs,findByFirstnameEquals … where x.firstname = ?1
    Between findByStartDateBetween … where x.startDate between ?1 and ?2
    LessThan findByAgeLessThan … where x.age < ?1
    LessThanEqual findByAgeLessThanEqual … where x.age ⇐ ?1
    GreaterThan findByAgeGreaterThan … where x.age > ?1
    GreaterThanEqual findByAgeGreaterThanEqual … where x.age >= ?1
    After findByStartDateAfter … where x.startDate > ?1
    Before findByStartDateBefore … where x.startDate < ?1
    IsNull findByAgeIsNull … where x.age is null
    IsNotNull,NotNull findByAge(Is)NotNull … where x.age not null
    Like findByFirstnameLike … where x.firstname like ?1
    NotLike findByFirstnameNotLike … where x.firstname not like ?1
    StartingWith findByFirstnameStartingWith … where x.firstname like ?1 (parameter bound with appended %)
    EndingWith findByFirstnameEndingWith … where x.firstname like ?1 (parameter bound with prepended %)
    Containing findByFirstnameContaining … where x.firstname like ?1 (parameter bound wrapped in %)
    OrderBy findByAgeOrderByLastnameDesc … where x.age = ?1 order by x.lastname desc
    Not findByLastnameNot … where x.lastname <> ?1
    In findByAgeIn(Collection ages) … where x.age in ?1
    NotIn findByAgeNotIn(Collection age) … where x.age not in ?1
    TRUE findByActiveTrue() … where x.active = true
    FALSE findByActiveFalse() … where x.active = false
    IgnoreCase findByFirstnameIgnoreCase … where UPPER(x.firstame) = UPPER(?1)

    And  =>  等价于 SQL 中的 and 关键字 例如:findByUsernameAndPassword(String user, Striang pwd);
    
    Or     =>  等价于 SQL 中的 or 关键字,例如:findByUsernameOrAddress(String user, String addr);
    
    Between   => 等价于 SQL 中的 between 关键字,例如:SalaryBetween(int max, int min);
    
    LessThan  => 等价于 SQL 中的 "<",例如: findBySalaryLessThan(int max);
    
    GreaterThan  => 等价于 SQL 中的">",例如: findBySalaryGreaterThan(int min);
    
    IsNull => 等价于 SQL 中的 "is null",例如: findByUsernameIsNull();
    
    IsNotNull => 等价于 SQL 中的 "is not null",例如: findByUsernameIsNotNull();
    
    NotNull=> 与 IsNotNull 等价;
    
    Like => 等价于 SQL 中的 "like",例如: findByUsernameLike(String user);
    
    NotLike => 等价于 SQL 中的 "not like",例如: findByUsernameNotLike(String user);
    
    OrderBy => 等价于 SQL 中的 "order by",例如: findByUsernameOrderBySalaryAsc(String user);
    
    Not => 等价于 SQL 中的 "! =",例如: findByUsernameNot(String user);
    
    In => 等价于 SQL 中的 "in",例如: findByUsernameIn(Collection<String> userList) ,方法的参数可以是 Collection 类型,也可以是数组或者不定长参数;
    
    NotIn => 等价于 SQL 中的 "not in",例如: findByUsernameNotIn(Collection<String> userList) ,方法的参数可以是 Collection 类型,也可以是数组或者不定长参数;

    Spring Data JPA框架在进行方法名解析时,会先把方法名多余的前缀截取掉,比如 find、findBy、read、readBy、get、getBy,然后对剩下部分进行解析。

    假如创建如下的查询:findByUserDepUuid(),框架在解析该方法时,首先剔除 findBy,然后对剩下的属性进行解析,假设查询实体为Doc

    1:先判断 userDepUuid (根据 POJO 规范,首字母变为小写)是否为查询实体的一个属性,如果是,则表示根据该属性进行查询;如果没有该属性,继续第二步;

    2:从右往左截取第一个大写字母开头的字符串此处为Uuid),然后检查剩下的字符串是否为查询实体的一个属性,如果是,则表示根据该属性进行查询;如果没有该属性,则重复第二步,继续从右往左截取;最后假设user为查询实体的一个属性;

    3:接着处理剩下部分(DepUuid),先判断 user 所对应的类型是否有depUuid属性,如果有,则表示该方法最终是根据 “ Doc.user.depUuid” 的取值进行查询;否则继续按照步骤 2 的规则从右往左截取,最终表示根据 “Doc.user.dep.uuid” 的值进行查询。

    4:可能会存在一种特殊情况,比如 Doc包含一个 user 的属性,也有一个 userDep 属性,此时会存在混淆。可以明确在属性之间加上 "_" 以显式表达意图,比如 "findByUser_DepUuid()" 或者 "findByUserDep_uuid()"

    特殊的参数: 还可以直接在方法的参数上加入分页或排序的参数,比如:

    Page<UserModel> findByName(String name, Pageable pageable);

    List<UserModel> findByName(String name, Sort sort);

    也可以使用JPA的NamedQueries,方法如下:

    1:在实体类上使用@NamedQuery,示例如下:

    @NamedQuery(name = "UserModel.findByAge",query = "select o from UserModel o where o.age >= ?1")

    2:在自己实现的DAO的Repository接口里面定义一个同名的方法,示例如下:

    public List<UserModel> findByAge(int age);

    3:然后就可以使用了,Spring会先找是否有同名的NamedQuery,如果有,那么就不会按照接口定义的方法来解析。

    使用@Query

    可以在自定义的查询方法上使用@Query来指定该方法要执行的查询语句,比如:

    @Query("select o from UserModel o where o.uuid=?1")

    public List<UserModel> findByUuidOrAge(int uuid);

    注意:

    1:方法的参数个数必须和@Query里面需要的参数个数一致

    2:如果是like,后面的参数需要前面或者后面加“%”,比如下面都对:

    @Query("select o from UserModel o where o.name like ?1%")

    public List<UserModel> findByUuidOrAge(String name);

    @Query("select o from UserModel o where o.name like %?1")

    public List<UserModel> findByUuidOrAge(String name);

    @Query("select o from UserModel o where o.name like %?1%")

    public List<UserModel> findByUuidOrAge(String name);

    当然,这样在传递参数值的时候就可以不加‘%’了,当然加了也不会错

    n还可以使用@Query来指定本地查询,只要设置nativeQuery为true,比如:

    @Query(value="select * from tbl_user where name like %?1" ,nativeQuery=true)

    public List<UserModel> findByUuidOrAge(String name);

    注意:当前版本的本地查询不支持翻页和动态的排序

    使用命名化参数,使用@Param即可,比如:

    @Query(value="select o from UserModel o where o.name like %:nn")

    public List<UserModel> findByUuidOrAge(@Param("nn") String name);

    同样支持更新类的Query语句,添加@Modifying即可,比如:

    @Modifying

    @Query(value="update UserModel o set o.name=:newName where o.name like %:nn")

    public int findByUuidOrAge(@Param("nn") String name,@Param("newName") String newName);

    注意:

    1:方法的返回值应该是int,表示更新语句所影响的行数

    2:在调用的地方必须加事务,没有事务不能正常执行

    JpaRepository的查询功能

    创建查询的顺序

    Spring Data JPA 在为接口创建代理对象时,如果发现同时存在多种上述情况可用,它该优先采用哪种策略呢?

    <jpa:repositories> 提供了 query-lookup-strategy 属性,用以指定查找的顺序。它有如下三个取值:

    1:create-if-not-found:如果方法通过@Query指定了查询语句,则使用该语句实现查询;如果没有,则查找是否定义了符合条件的命名查询,如果找到,则使用该命名查询;如果两者都没有找到,则通过解析方法名字来创建查询。这是 query-lookup-strategy 属性的默认值

    2:create:通过解析方法名字来创建查询。即使有符合的命名查询,或者方法通过 @Query指定的查询语句,都将会被忽略

    3:use-declared-query:如果方法通过@Query指定了查询语句,则使用该语句实现查询;如果没有,则查找是否定义了符合条件的命名查询,如果找到,则使用该命名查询;如果两者都没有找到,则抛出异常

      3.Specifications查询

    Spring Data JPA支持JPA2.0的Criteria查询,相应的接口是JpaSpecificationExecutor。
    Criteria 查询:是一种类型安全和更面向对象的查询
     
    这个接口基本是围绕着Specification接口来定义的, Specification接口中只定义了如下一个方法:
    Predicate toPredicate(Root<T> root, CriteriaQuery<?> query, CriteriaBuilder cb);
     
    要理解这个方法,以及正确的使用它,就需要对JPA2.0的Criteria查询有一个足够的熟悉和理解,因为这个方法的参数和返回值都是JPA标准里面定义的对象。
     
    Criteria查询基本概念
    Criteria 查询是以元模型的概念为基础的,元模型是为具体持久化单元的受管实体定义的,这些实体可以是实体类,嵌入类或者映射的父类。
    CriteriaQuery接口:代表一个specific的顶层查询对象,它包含着查询的各个部分,比如:select 、from、where、group by、order by等
    注意:CriteriaQuery对象只对实体类型或嵌入式类型的Criteria查询起作用
    Root接口:代表Criteria查询的根对象,Criteria查询的查询根定义了实体类型,能为将来导航获得想要的结果,它与SQL查询中的FROM子句类似
    1:Root实例是类型化的,且定义了查询的FROM子句中能够出现的类型。
    2:查询根实例能通过传入一个实体类型给 AbstractQuery.from方法获得。
    3:Criteria查询,可以有多个查询根。 
    4:AbstractQuery是CriteriaQuery 接口的父类,它提供得到查询根的方法。
    CriteriaBuilder接口:用来构建CritiaQuery的构建器对象
    Predicate:一个简单或复杂的谓词类型,其实就相当于条件或者是条件组合。
     
    Criteria查询
    基本对象的构建
    1:通过EntityManager的getCriteriaBuilder或EntityManagerFactory的getCriteriaBuilder方法可以得到CriteriaBuilder对象
    2:通过调用CriteriaBuilder的createQuery或createTupleQuery方法可以获得CriteriaQuery的实例
    3:通过调用CriteriaQuery的from方法可以获得Root实例
    过滤条件
    1:过滤条件会被应用到SQL语句的FROM子句中。在criteria 查询中,查询条件通过Predicate或Expression实例应用到CriteriaQuery对象上。
    2:这些条件使用 CriteriaQuery .where 方法应用到CriteriaQuery 对象上
    3:CriteriaBuilder也作为Predicate实例的工厂,通过调用CriteriaBuilder 的条件方法( equal,notEqual, gt, ge,lt, le,between,like等)创建Predicate对象。
    4:复合的Predicate 语句可以使用CriteriaBuilder的and, or andnot 方法构建。
     
    构建简单的Predicate示例:
    Predicate p1=cb.like(root.get(“name”).as(String.class), “%”+uqm.getName()+“%”);
    Predicate p2=cb.equal(root.get("uuid").as(Integer.class), uqm.getUuid());
    Predicate p3=cb.gt(root.get("age").as(Integer.class), uqm.getAge());
    构建组合的Predicate示例:
    Predicate p = cb.and(p3,cb.or(p1,p2));
     

    分组条件查询:http://www.cnblogs.com/shaying/p/7344402.html

    2.与springboot整合

      maven:

    <dependency
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>

      gradle:

    dependencies {
            compile('org.springframework.boot:spring-boot-starter-data-jpa')      
    }

      注:需要配置数据源

      jpa可选配置

    spring.jpa.database=
    spring.jpa.show-sql=
    spring.jpa.properties=
    spring.jpa.generate-ddl=
    spring.jpa.open-in-view=
    spring.jpa.database-platform=
    spring.jpa.hibernate.ddl-auto=
    spring.data.jpa.repositories.enabled=
    spring.jpa.hibernate.naming-strategy=

    3.项目中部分java代码

    @NoRepositoryBean
    public interface DAOInterface<T> extends JpaRepository<T, String>, JpaSpecificationExecutor<T> {
        
    }
    public interface JDCommodityRepository extends DAOInterface<JDCommodityBean> {
        
        /**
         * 分页查询商品
         */
        Page<JDCommodityBean> findAll(Specification<JDCommodityBean> spec, Pageable pageable);
    }
    @Transactional(rollbackFor = Exception.class)
    @Service
    public class JDCommodityServiceImpl extends BaseService<JDCommodityBean> implements JDCommodityService {
    
        @PersistenceContext
        private EntityManager entityManager;
    
        @Autowired
        private JDCommodityRepository jdCommodityRepository;
    
        @Override
        public Page<JDCommodityBean> getJDCommodityListByPage(Integer pageNum, String name, String goodsCategory) {
            Specification<JDCommodityBean> spec = new Specification<JDCommodityBean>() {
    
                /**
                 * 构造断言
                 * 
                 * @param root
                 *            实体对象引用
                 * @param query
                 *            规则查询对象
                 * @param cb
                 *            规则构建对象
                 * @return 断言
                 */
                @Override
                public Predicate toPredicate(Root<JDCommodityBean> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
                    List<Predicate> predicates = new ArrayList<>(); // 所有的断言集合
                    //默认
                    predicates.add(cb.equal(root.get("state").as(Integer.class), 1));// 上下架状态 1为上架,0为下架
                    predicates.add(cb.equal(root.get("saleState").as(Integer.class), 1));// 是否可售,1:是,0:否
                    predicates.add(cb.equal(root.get("isCanVAT").as(Integer.class), 1));// 是否可开增票,1:支持,0:不支持
                    predicates.add(cb.le(root.get("price").as(BigDecimal.class), 500));// 价格小于等于500
                    //自定义
                    // 商品名称
                    if(null != name && !"".equals(name) && !"''".equals(name) && name != "") {
                        predicates.add(cb.like(root.get("name").as(String.class), "%" + name + "%"));
                    }
                    // 商品分类
                    if(goodsCategory != null && !"".equals(goodsCategory) && !"''".equals(goodsCategory)) {
                        predicates.add(cb.equal(root.get("goodsCategory").as(String.class), goodsCategory));
                    }
    
                    return cb.and(predicates.toArray(new Predicate[predicates.size()]));
                }
            };
            Pageable pageable = new PageRequest(pageNum - 1, JDCommonConstant.COMMODITY_PAGE_SIZE);// 页码:前端从1开始,jpa从0开始
            Page<JDCommodityBean> page = jdCommodityRepository.findAll(spec, pageable);
            return page;
        }
    
        @Override
        protected EntityManager getEntityManager() {
            return entityManager;
        }
    
        @Override
        protected DAOInterface<JDCommodityBean> getDAOInterface() {
            return jdCommodityRepository;
        }
    
    }

    分页page属性:

    "总记录数"+page.getTotalElements()  
    "当前第几页"+page.getNumber()
    "总页数"+page.getTotalPages()
    "当前页面的List"+page.getContent()
    "当前页面的记录数"+page.getNumberOfElements()

    参考:

       https://legacy.gitbook.com/book/ityouknow/spring-data-jpa-reference-documentation/details

       http://www.ityouknow.com/springboot/2016/08/20/springboot(%E4%BA%94)-spring-data-jpa%E7%9A%84%E4%BD%BF%E7%94%A8.html

     续:

    1.查询

      规则: 
        find+全局修饰+By+实体的属性名称+限定词+连接词+ …(其它实体属性)+OrderBy+排序属性+排序方向

    1、查询所有数据 findAll()
    
    2、分页查询 findAll(new PageRequest(0, 2))      
    
    3、根据id查询 findOne()      
    
    4、根据实体类属性查询: findByProperty (type Property);   例如:findByAge(int age);
    
    5、排序:  findAll(sort )
    
          Sort sort = new Sort(Sort.Direction.DESC, "age").and (new Sort(Sort.Direction.DESC, "id"));
    
    6、条件查询  and/or/findByAgeLessThan/LessThanEqual 等, 
    
         例如: findByUsernameAndPassword(String username , String password)
    
    7、总数 查询 count()  或者 根据某个属性的值查询总数countByAge(int age);
    
    8、是否存在某个id   exists()

      spring data jpa 利用JpaSpecificationExecutor做复杂查询:https://blog.csdn.net/yingxiake/article/details/51014223

    2.增加

    增加可以使用JpaRepository接口里面的save方法.查看源码可以发现实际上是使用了em.persist(entity)来使对象进入持久化状态,最后提交事务的时候再一起更新到数据库.

    //保存单个
            userRepository.save(user);
            //保存或更新
            userRepository.saveAndFlush(user);
    
            List<User> users = new ArrayList<>();
            users.add(user);
            //保存多个
            userRepository.save(users);

    3.修改

      userRepository.saveAndFlush(user);

      批量更新:

        首先在service层获取持久化管理器:

        @PersistenceContext
        private EntityManager em;

        批量更新方法,同理插入,删除也都可以如此做.

        @Transactional
        public void batchUpateCustom(List<User> users) {
            // TODO Auto-generated method stub
            for(int i = 0; i < users.size(); i++) {  
                em.merge(users.get(i));  
                if(i % 30== 0) {  
                    em.flush();  
                    em.clear();  
                }  
            }
        }

    4.删除

     /**
             * 删除都是根据主键删除
             */
            //删除单条,根据主键值
            userRepository.delete(20);
            //删除全部,先findALL查找出来,再一条一条删除,最后提交事务
            userRepository.deleteAll();
            //删除全部,一条sql
            userRepository.deleteAllInBatch();
    
            List<User> users = new ArrayList<>();
            users.add(user);
            //删除集合,一条一条删除
            userRepository.delete(users);
            //删除集合,一条sql,拼接or语句  如 id=1 or id=2
            userRepository.deleteInBatch(users);

    5.判断

            //根据主键判断是否存在
            userRepository.exists(1);
    
            User user = new User();
            user.setName("小红");
            //根据条件判断是否存在
            userRepository.exists(Example.of(user));

    参考:https://blog.csdn.net/u012706811/article/details/53218083

  • 相关阅读:
    数据库表设计
    solr的schame.xml
    搭建solr服务器
    lucene&solr索引维护之查询
    lucene&solr索引维护之删除和修改
    lucene&solr查询索引实例
    lucene&solr入门实例
    java集合排序整理
    HahMap(jdk=1.8)源码解读
    APIO2020 游记
  • 原文地址:https://www.cnblogs.com/soul-wonder/p/8984785.html
Copyright © 2020-2023  润新知