`

SpringBoot中使用Spring Data Jpa 实现简单的动态查询的两种方法

SpringBootJpa动态查询 
阅读更多

 

创建实体类：

复制代码
package com.entity;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;

/**
 *create by yyc 2017年6月11日上午9:59:59
 */
@Entity
@Table(name="test_user")
public class TestUser {

    @Id
    @GeneratedValue
    private int userId;
    private Integer userAge;
    private String  userName;
    private Integer high;//高
    //省略getter、setter
    
}
复制代码

为了测试，先创建一个简单的实体类。

写元数据模型：

Criteria API

这套API可用于构建对数据库的查询。

类型安全。通过定义元数据模型，在程序编译阶段就可以对类型进行检查，不像SQL需要与Mysql进行交互后才能发现类型问题。

如下即为元数据模型。创建一个元模型类，类名最后一个字符为下划线，内部的成员变量与UserInfo.class这个实体类的属性值相对应。

复制代码
package com.entity;

import javax.persistence.metamodel.SingularAttribute;
import javax.persistence.metamodel.StaticMetamodel;
import com.TestUser;
@StaticMetamodel(TestUser.class)
public class TestUser_ {

     public static volatile SingularAttribute<TestUser, Integer> userId;// 用户ID，自增量
     public static volatile SingularAttribute<TestUser, Integer> userAge;
     public static volatile SingularAttribute<TestUser, String> userName;
     public static volatile SingularAttribute<TestUser, Integer> high;

    }
复制代码

可移植。API并不依赖具体的数据库，可以根据数据库类型的不同生成对应数据库类型的SQL，所以其为可移植的。
面向对象。Criteria API是使用的是各种类和对象如CriteriaQuery、Predicate等构建查询，是面向对象的。而如果直接书写SQL则相对于面向的是字符串。

现在开始SpringBoot中使用Spring Data Jpa 实现简单的动态查询的两种方式方法

第一种方式：通过JPA的Criteria API实现

  1. EntityManager获取CriteriaBuilder
  2. CriteriaBuilder创建CriteriaQuery
  3. CriteriaQuery指定要查询的表，得到Root<UserInfo>，Root代表要查询的表
  4. CriteriaBuilder创建条件Predicate，Predicate相对于SQL的where条件，多个Predicate可以进行与、或操作。
  5. 通过EntityManager创建TypedQuery
  6. TypedQuery执行查询，返回结果
复制代码
package com.repository;

import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import com.entity.TestUser;
import com.entity.TestUser_;

/**
 *create by yyc 2017年6月11日下午9:08:39
 */
@Repository
public class TestUserExtendDao {

//    @Autowired
    @PersistenceContext//@Autowired和@PersistenceContext注解任取一
    EntityManager em;
    
    @SuppressWarnings("unused")
    public List<TestUser> getTestUserInfo(final Integer age, final String name, final Integer high){
         //1
        CriteriaBuilder cb = em.getCriteriaBuilder();
         //2
        CriteriaQuery<TestUser> query = cb.createQuery(TestUser.class);
        
        //3
        //from 
        Root<TestUser> root = query.from(TestUser.class);
        
         //4
         //where
        Predicate p1 = null;
        if (age != 0) {
            System.out.println("正在操作age！！！");
            Predicate p2 = cb.equal(root.get(TestUser_.userAge), age);
            if (p1 != null) {
                p1=cb.and(p1, p2);
            } else {
                p1 = p2;
            }
        }
        if (false==name.isEmpty()) {
            System.out.println("正在操作name！！！");
            Predicate p2 = cb.equal(root.get(TestUser_.userName), name);
            if (p1 != null) {
                p1=cb.and(p1, p2);
            } else {
                p1 = p2;
            }
        }
        if (high != 0) {
            System.out.println("正在操作high！！！");
            Predicate p2 = cb.equal(root.get(TestUser_.high), high);
            if (p1 != null) {
                p1=cb.and(p1, p2);
            } else {
                p1 = p2;
            }
        }
        //5
        query.where(p1);
        //6
        List<TestUser> testUsers = em.createQuery(query).getResultList();
        return testUsers;
    }
}
复制代码

第二种方式：DAO层接口实现JpaSpecificationExecutor<T>接口

　　JpaSpecificationExecutor如下，方法参数Specification接口有一个方法toPredicate，返回值正好是Criteria API中的Predicate，而Predicate相对于SQL的where条件。与上一个方法相比，这种写法不需要指定查询的表是哪一张，也不需要自己通过Criteria API实现排序和分页，只需要通过新建Pageable、Sort对象并传参给findAll方法即可，简便一些。

这是JpaSpecificationExecutor接口中的方法：

复制代码
public interface JpaSpecificationExecutor<T> {
 　　T findOne(Specification<T> spec);
 　　List<T> findAll(Specification<T> spec);
 　　Page<T> findAll(Specification<T> spec, Pageable pageable);
 　　List<T> findAll(Specification<T> spec, Sort sort);
 　　long count(Specification<T> spec);
}
复制代码

TestRepository继承JpaSpecificationExecutor接口：

复制代码
package com.repository;

import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.repository.PagingAndSortingRepository;
import com.entity.TestUser;

/**
 *create by yyc 2017年6月11日上午9:36:27
 *测试动态sql
 */
public interface TestRepository extends PagingAndSortingRepository<TestUser, Integer>, JpaSpecificationExecutor<TestUser>{

}
复制代码

实现Specification：

复制代码
package com.entity;

import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import org.springframework.data.jpa.domain.Specification;
import com.entity.TestUser;

/**
 * create by yyc 2017年6月11日上午10:17:44
 */
public class TestUserDaoSpec {
    public static Specification<TestUser> getSpec(final Integer age, final String name, final Integer high) {
        return new Specification<TestUser>() {

            @SuppressWarnings("unused")
            @Override
            public Predicate toPredicate(Root<TestUser> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
                Predicate p1 = null;
                if (age != 0) {
                    System.out.println("正在操作age！！！");
                    Predicate p2 = cb.equal(root.get(TestUser_.userAge), age);
                    if (p1 != null) {
                        p1=cb.and(p1, p2);
                    } else {
                        p1 = p2;
                    }
                }
                if (false==name.isEmpty()) {
                    System.out.println("正在操作name！！！");
                    Predicate p2 = cb.equal(root.get(TestUser_.userName), name);
                    if (p1 != null) {
                        p1=cb.and(p1, p2);
                    } else {
                        p1 = p2;
                    }
                }
                if (high != 0) {
                    System.out.println("正在操作high！！！");
                    Predicate p2 = cb.equal(root.get(TestUser_.high), high);
                    if (p1 != null) {
                        p1=cb.and(p1, p2);
                    } else {
                        p1 = p2;
                    }
                }
                return p1;
            }
        };
    }

}
复制代码

Service层的调用测试类：

复制代码
package com.service.impl;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.entity.TestUser;
import com.entity.TestUserDaoSpec;
import com.repository.TestRepository;
import com.repository.TestUserExtendDao;
import com.result.Result;//一个方法返回的封装，这里直接忽略即可


/**
 *create by yyc 2017年6月11日上午9:40:51
 */
@Service("testService")
public class TestService {

    @Autowired
    private TestRepository testRepository;
    
    @Autowired
    private TestUserExtendDao testUserExtendDao;
    
    //测试第一种方式
    public Result getTestUsersByExtendDao(){
        List<TestUser> list = testUserExtendDao.getTestUserInfo(20, "", 170);//通过两个条件，string设为空
        printTestUserInfo(list);
        return new Result("查询成功！", list);
    }
    
    //测试第二种方式
    public Result getTestUsersByThreeParameter(){
        List<TestUser> list = testRepository.findAll(TestUserDaoSpec.getSpec(20, "yyc", 170));//通过三个条件
        printTestUserInfo(list);
        return new Result("查询成功！",list);
    }
    public Result getTestUsersByTwoParameter1(){
        List<TestUser> list = testRepository.findAll(TestUserDaoSpec.getSpec(20, "yyc", 0));//通过两个条件，Integer设为0
        printTestUserInfo(list);
        return new Result("查询成功！",list);
    }

    public Result getTestUsersByOneParameter(){
        List<TestUser> list = testRepository.findAll(TestUserDaoSpec.getSpec(0, "lrs", 0));//通过一个条件查询
        printTestUserInfo(list);
        return new Result("查询成功！",list);
    }

    private void printTestUserInfo(List<TestUser> list) {
        if (list!=null) {
            for (TestUser testUser : list) {
                System.out.println("userId："+testUser.getUserId()+
                        " userName:"+testUser.getUserName()+
                        " userAge:"+testUser.getUserAge()+
                        " userHigh:"+testUser.getHigh());
            }
        }
        
    }
}
复制代码

 

 

http://www.cnblogs.com/hyyq/p/6986797.html

分享到：
| spring boot Websocket
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    基于Thymeleaf+SpringBoot+SpringDataJPA实现的的中小医院信息管理系统

    本系统是基于Thymeleaf+SpringBoot+SpringDataJPA实现的的中小医院信息管理系统。简单实现了挂号收费，门诊管理，划价收费，药房取药，体检管理，药房管理，系统维护等基础功能。就诊卡提供了手动和读卡两种方式录入...

    springboot+spring data jpa+thymeleaf学习web项目整合demo源码

    在 "springboot+spring data jpa+thymeleaf学习web项目整合demo源码" 中，我们可以学习到以下几个关键知识点： 1. **Spring Boot 整合**：Spring Boot 可以与多个框架集成，如 Spring MVC、Spring Data 和 ...

    SpringBoot中使用Spring-data-jpa分页查询

    在Spring Boot应用中，使用Spring Data JPA进行分页查询是一种高效且简洁的方式。Spring Data JPA是Spring框架的一部分，它提供了对Java Persistence API (JPA) 的简化封装，允许开发者通过面向接口的方式进行数据库...

    SpringBoot + SpringData Jpa + Scala + Mysql（java+Scala混编）

    在SpringBoot项目中，MySQL可以通过JDBC驱动和SpringData JPA进行集成，实现数据的存储和检索。 【pom.xml】 pom.xml是Maven项目对象模型（Project Object Model）的配置文件，用于定义项目的依赖、插件和其他构建...

    springboot+springdata jpa增删改查

    SpringBoot和SpringData JPA是Java开发中的两个关键框架，它们极大地简化了Web应用程序的构建过程，特别是数据库操作。SpringBoot以其"开箱即用"的特性，减少了配置工作，而SpringData JPA则提供了对Java ...

    使用 SpringBoot + SpringDataJPa 设计通用的权限管理系统.zip

    - **Repository 抽象层**：Spring Data JPA 提供了一种声明式的数据访问接口，通过继承 `JpaRepository` 或自定义接口，可以轻松实现 CURD 操作。 - **Query 方法命名规则**：通过方法名自动构造 SQL 查询，例如 `...

    Springboot中使用Druid+JPA

    在Spring Boot应用中，Druid和JPA是两种常见的数据库操作工具。Druid是一个功能强大的数据库连接池，而JPA（Java Persistence API）是Java平台上的一个标准，用于对象关系映射（ORM）。本篇文章将深入探讨如何在...

    Springboot中使用JPA操作数据库

    Spring Data JPA还支持动态查询，只需要编写接口方法名，就能自动生成对应的SQL语句。 要开始在Spring Boot项目中使用Spring Data JPA，首先需要在`pom.xml`或`build.gradle`文件中添加依赖： ```xml &lt;groupId&gt;...

    SpringBoot集成Spring Data JPA及读写分离

    SpringBoot集成Spring Data JPA及读写分离是现代Java Web应用程序中常见的技术组合，用于高效地管理和处理数据库操作。Spring Boot简化了应用的初始化和配置，而Spring Data JPA则进一步降低了使用Java Persistence ...

    使用springboot + JPA / MyBatis 实现多数据源动态切换

    本教程将详细讲解如何使用Spring Boot结合JPA或MyBatis框架实现多数据源的动态切换。 **一、Spring Boot与JPA** 1. **Spring Boot简介**：Spring Boot是Spring Framework的一个模块，旨在简化Spring应用的初始搭建...

    Spring Data JPA初使用 .doc

    - **JPQL（Java Persistence Query Language）和 Criteria API**：Spring Data JPA支持JPQL（一种面向对象的查询语言）和Criteria API，用于编写更复杂的查询，当自动的方法命名不能满足需求时，可以通过这两个API来...

    Spring集成JPA和MyBatis简单例子-20170622

    在IT行业中，Spring框架...在"Spring集成JPA和MyBatis简单例子-20170622"这个压缩包中，可能包含了示例代码，演示了如何在Spring项目中配置和使用这两种技术，这对于初学者理解和实践Spring的集成能力具有很大的帮助。

    SpringBoot-SpringData-ManyToOne

    标题“SpringBoot-SpringData-ManyToOne”涉及到的是Spring Boot与Spring Data JPA在处理多对一关系时的应用。Spring Boot是Spring框架的一个轻量级版本，它简化了配置和项目初始化，使得开发者能够更快地开始开发...

    springboot热部署以及集成JPA.rar

    在本文中，我们将深入探讨Spring Boot的热部署技术以及如何集成JPA（Java Persistence API），主要涉及Hibernate和Spring Data JPA这两个流行的DAO层框架。热部署允许开发者在代码变动后无需重启应用即可看到更改...

    springboot JPA

    SpringBoot与SpringData JPA是Java开发中常用的两个框架，它们极大地简化了Web应用的构建和数据访问。SpringBoot提供了一种快速启动和配置Spring应用的方式，而SpringData JPA则是Spring Framework的一部分，用于...

    SpringBoot+JPA.zip

    在"SpringBoot+JPA.zip"这个压缩包中，你将找到一个入门级的示例项目，它展示了如何在SpringBoot环境中使用JPA进行基本的数据库操作，包括增（Create）、删（Delete）、改（Update）和查（Query）。这个项目对于初学...

    Spring Boot整合Spring Data Jpa代码实例

    可以使用 `@Repository` 注解创建一个 Repository 接口，然后使用 Spring Data Jpa 提供的方法来操作数据。 以下是一个示例 Repository 接口： ```java package com.offcn.repository; import org.spring...

    Spring Boot中使用Spring-data-jpa实现数据库增删查改

    在实际应用中，你还可以利用Spring Data JPA的其他特性，比如分页查询、排序、自定义查询方法等。Spring Data JPA的`Pageable`接口可以用于分页查询，`Sort`接口用于排序。此外，通过`@Modifying`和`@Transactional`...

    SpringBoot-SpringData-ManyToMany

    在Spring Boot和Spring Data的框架下，`ManyToMany`关系是一种常见的数据库模型，用于表示两个实体之间多对多的关系。这种关系意味着一个实体可以与多个其他实体相关联，反之亦然。例如，用户和角色之间的关系，一个...

    springboot-jpa加上jdbctemple

    标题“springboot-jpa加上jdbctemple”指的是在Spring Boot项目中同时使用JPA（Java Persistence API）和JdbcTemplate的技术整合。这是一个常见的后端开发场景，涉及到Spring Boot的数据库访问层的构建，旨在提供...

Magicbox
Global site tag (gtag.js) - Google Analytics