JPA实践&多种场景应用集锦

拼搏现实的明天。 2022-05-26 11:24 271阅读 0赞

**JPA官方地址：**

![20180501114239263][]

![Image 1][] ![20180501114245771][]

![20180501114301503][]

**JPA语法规则：**

JPA框架在进行方法名解析时，会先把方法名多余的前缀截取掉，比如 find、findBy、read、readBy、get、getBy，然后对剩下部分进行解析。并且如果方法的最后一个参数是 Sort 或者 Pageable 类型，也会提取相关的信息，以便按规则进行排序或者分页查询。

![Image 1][]

And — 等价于 SQL 中的 and 关键字，比如 findByUsernameAndPassword(String user, Striang pwd)；

Or — 等价于 SQL 中的 or 关键字，比如 findByUsernameOrAddress(String user, String addr)；

Between — 等价于 SQL 中的 between 关键字，比如 findBySalaryBetween(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 userList) ，方法的参数可以是 Collection 类型，也可以是数组或者不定长参数；

NotIn — 等价于 SQL 中的 “not in”，比如 findByUsernameNotIn(Collection userList) ，方法的参数可以是 Collection 类型，也可以是数组或者不定长参数；

**[JPA JPQL 查询、排序.....(转)][JPA JPQL _.....]**

Entity - 设定递增列UUID：

@Id
    @GenericGenerator(name = "PKUUID", strategy = "uuid2")
    @GeneratedValue(generator = "PKUUID")
    @Column(length = 36)
    protected String id;

**在Entity添加1:n 或m:n映射：**

[http://blog.csdn.net/linzhiqiang0316/article/details/53022683][http_blog.csdn.net_linzhiqiang0316_article_details_53022683]

示例：

Floor类:

@OneToMany (fetch =  FetchType.LAZY ,mappedBy =  "floor" )

**private**  List<FloorContent>  **floorContents** ;

FloorContent类:

@ManyToOne

@JoinColumn (name =  "floor\_id" ,foreignKey =  @ForeignKey (name =  "fk\_floor\_fc" ))

**private**  Floor  **floor** ;

连接查询 方法：

**public**   **interface**  FloorContentRepos  **extends**  JpaRepository<FloorContent,String>\{

**public**  Page<FloorContent>  **findByFloor\_IdAndIsDeleteOrderByShowIndexAsc** (String floorId, **boolean**  b, Pageable pageable);

**注意：**在findBy后面添加要关联的实体类，然后在 实体类后面写上“\_”，"\_"符号后面是添加关联表的字段而不是本身表的字段。

And+表名字+“\_”+表中要查询的字段。

生成关联表 ：

[http://www.iteye.com/problems/94831][http_www.iteye.com_problems_94831]

不希望生成： @OneToMany( mappedBy = "a" )

**Like写法：**

@Query ( "SELECT u.username FROM User u WHERE u.username LIKE CONCAT('%',:username,'%')" )

**使用@Query注解**实现复杂查询：

[http://www.cnblogs.com/dixinyunpan/p/5856884.html][http_www.cnblogs.com_dixinyunpan_p_5856884.html]

方式一：

@Query("select a from AccountInfo a where a.accountId = ?1") public AccountInfo findByAccountId(Long accountId);

方式二：

@Query("from AccountInfo a where a.accountId = :id") public AccountInfo findByAccountId(@Param("id")Long accountId);

//使用 @Modifying 将查询标识为修改  @Modifying @Query("update AccountInfo a set a.salary = ?1 where a.salary < ?2") public int increaseSalary(int after, int before);

示例： [http://blog.csdn.net/cool\_\_wang/article/details/49495165][http_blog.csdn.net_cool_wang_article_details_49495165]

[**在jpa中获取一条记录的前一条记录的办法**][jpa]

**SpringMVC中JPA**（含分页功能）的使用：

@RequestMapping(value = { "list", "" }) 
        public String list(Model model, HttpServletRequest request) { 
            int page = 0; 
            int pageSize = 10; 
            Pageable pager =new PageRequest(page, pageSize); 
            Page<Employee> employeesPage = manager.getPageEmployee(pager); 
            model.addAttribute("employees", employeesPage.getContent()); 
            model.addAttribute("resultTotal", employeesPage.getTotalElements()); 
            return "employee/queryEmployee"; 
        }

Demo参考：

[http://www.jb51.net/article/111588.htm][http_www.jb51.net_article_111588.htm]

（包括注入EntityManagerFactory的方式）

**findAll(pageable) 查询：**

public Page<Task> getUserTask(Long userId, Map<String, Object> searchParams, int pageNumber, int pageSize,
                String sortType) {
            PageRequest pageRequest = buildPageRequest(pageNumber, pageSize, sortType);
            Specification<Task> spec = buildSpecification(userId, searchParams);
      
            return taskDao.findAll(spec, pageRequest);
        }
      
        /**
         * 创建分页请求.
         */
        private PageRequest buildPageRequest(int pageNumber, int pagzSize, String sortType) {
            Sort sort = null;
            if ("auto".equals(sortType)) {
                sort = new Sort(Direction.DESC, "id");
            } else if ("title".equals(sortType)) {
                sort = new Sort(Direction.ASC, "title");
            }
      
            return new PageRequest(pageNumber - 1, pagzSize, sort);
        }
      
        /**
         * 创建动态查询条件组合:https://github.com/springside/springside4
         */
        private Specification<Task> buildSpecification(Long userId, Map<String, Object> searchParams) {
            Map<String, SearchFilter> filters = SearchFilter.parse(searchParams);
            filters.put("user.id", new SearchFilter("user.id", Operator.EQ, userId));
            Specification<Task> spec = DynamicSpecifications.bySearchFilter(filters.values(), Task.class);
            return spec;
        }

使用传统的EnitityManager来查询单条记录：

@Autowired
    private EnitityManager em;
    
    em.createQuery(query).setFirstResult(start).setMaxResults(max).getResultList();

**添加查询条件：**

使用 **Specification**<T>或 **Criteria<T>**：

Criteria<UserInfo> criteria = new Criteria<>();criteria.add(Restrictions.eq("id",10)).add(Restrictions.like("name","abc"));
     criteria.add(Restrictions.hasMembers("address.name", "北京"));
    criteria.add(Restrictions.hasMembers("provinces", "110000", "120000"));List<UserInfo> users = userInfoService.findAll(criteria);
    Page page = userRepository.findAll(criteria, new PageRequest(0, 10));

**处理一对多的查询:**

[https://blog.csdn.net/tianyaleixiaowu/article/details/78594889][https_blog.csdn.net_tianyaleixiaowu_article_details_78594889]

@Override
        @SuppressWarnings({"rawtypes", "unchecked"})
        public Predicate toPredicate(Root<?> root, CriteriaQuery<?> query,
                                     CriteriaBuilder builder) {
            Path expression;
    
            //此处是表关联数据，注意仅限一层关联，如user.address，
            //查询user的address集合中，address的name为某个值
            if (fieldName.contains(".")) {
                String[] names = StringUtils.split(fieldName, ".");
                //获取该属性的类型，Set？List？Map？
                expression = root.get(names[0]);
                Class clazz = expression.getJavaType();
                if (clazz.equals(Set.class)) {
                    SetJoin setJoin = root.joinSet(names[0]);
                    expression = setJoin.get(names[1]);
                } else if (clazz.equals(List.class)) {
                    ListJoin listJoin = root.joinList(names[0]);
                    expression = listJoin.get(names[1]);
                } else if (clazz.equals(Map.class)) {
                    MapJoin mapJoin = root.joinMap(names[0]);
                    expression = mapJoin.get(names[1]);
                } else {
                    //是many to one时
                    expression = expression.get(names[1]);
                }
    
            } else {
                //单表查询
                expression = root.get(fieldName);
            }

##### FetchType应用： #####

**fetch = FetchType.EAGER 作用**

如果是EAGER，那么表示取出这条数据时，它关联的数据也同时取出放入内存中

如果是LAZY，那么取出这条数据时，它关联的数据并不取出来，在同一个session中，什么时候要用，就什么时候取(再次访问数据库)。

但是，在session外，就不能再取了。用EAGER时，因为在内存里，所以在session外也可以取。

一般只在一边设Eager，JPA接口默认为一对多为Lazy，多对一为Eager，但是Hibernate反向工程生成Entity时，多对一为Lazy， 需要手动改为Eager 。

Spring配置JPA和使用： [http://blog.sina.com.cn/s/blog\_4fb490ff0100xbly.html][http_blog.sina.com.cn_s_blog_4fb490ff0100xbly.html]

[20180501114239263]: /images/20220526/97b75386632149e6bf27f187d84bee15.png
[Image 1]: 
[20180501114245771]: /images/20220526/0cc81f9b148b4667b5c57c049c36ce4a.png
[20180501114301503]: /images/20220526/c9c5f4a524f246f0a6a75afa4b751757.png
[JPA JPQL _.....]: http://macrabbit.iteye.com/blog/855384
[http_blog.csdn.net_linzhiqiang0316_article_details_53022683]: http://blog.csdn.net/linzhiqiang0316/article/details/53022683
[http_www.iteye.com_problems_94831]: http://www.iteye.com/problems/94831
[http_www.cnblogs.com_dixinyunpan_p_5856884.html]: http://www.cnblogs.com/dixinyunpan/p/5856884.html
[http_blog.csdn.net_cool_wang_article_details_49495165]: http://blog.csdn.net/cool__wang/article/details/49495165
[jpa]: http://www.iteye.com/problems/26049
[http_www.jb51.net_article_111588.htm]: http://www.jb51.net/article/111588.htm
[https_blog.csdn.net_tianyaleixiaowu_article_details_78594889]: https://blog.csdn.net/tianyaleixiaowu/article/details/78594889
[http_blog.sina.com.cn_s_blog_4fb490ff0100xbly.html]: http://blog.sina.com.cn/s/blog_4fb490ff0100xbly.html