springdata-jpa 八种查询方法

使用：maven+Spring+jpa+Junit4

查询方式：SQL，JPQL查询，Specification多条件复杂查询

返回类型：list<POJO>,list<Stinrg>,list<Object>,Page<Object>

git源码地址：https://github.com/litblank/SpringFrame/tree/master/DEMO/SpringData_jpa

1. Pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.litblack</groupId>
  <artifactId>SpringData_jpa</artifactId>
  <packaging>war</packaging>
  <version>0.0.1-SNAPSHOT</version>
  <name>SpringData_jpa Maven Webapp</name>
  <url>http://maven.apache.org</url>
  <properties>
        <spring.version>4.3.4.RELEASE</spring.version>
  </properties>
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
    <!-- jpa -->        
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>4.3.8.Final</version>
             <exclusions>
                <exclusion>
                    <groupId>org.javassist</groupId>
                    <artifactId>javassist</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <!-- <dependency>
            <groupId>org.hibernate.javax.persistence</groupId>
            <artifactId>hibernate-jpa-2.0-api</artifactId>
            <version>1.0.1.Final</version>
        </dependency> -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>4.3.11.Final</version>
            <exclusions>
                <exclusion>
                    <groupId>org.javassist</groupId>
                    <artifactId>javassist</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <!-- oracle -->
        <dependency>
            <groupId>ojdbc</groupId>
            <artifactId>ojdbc6</artifactId>
            <version>11.2.0.4</version>
        </dependency>
        <!-- mysql  -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>
        <!-- ali 数据源连接 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.0.31</version>
        </dependency>
        
        <dependency>
            <groupId>javassist</groupId>
            <artifactId>javassist</artifactId>
            <version>3.12.1.GA</version>
        </dependency>
        
        <!-- Test -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring.version}</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-oxm</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>${spring.version}</version>
        </dependency>
        
        <!-- springdata -->
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-jpa</artifactId>
            <version>1.11.1.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-commons-core</artifactId>
            <version>1.4.1.RELEASE</version>
        </dependency>
  </dependencies>
  <build>
    <finalName>SpringData_jpa</finalName>
  </build>
</project>

pom.xml

2. Spring-config.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:p="http://www.springframework.org/schema/p" xmlns:cache="http://www.springframework.org/schema/cache"
    xmlns:jpa="http://www.springframework.org/schema/data/jpa"

    xsi:schemaLocation="http://www.springframework.org/schema/beans   
          http://www.springframework.org/schema/beans/spring-beans-3.1.xsd   
          http://www.springframework.org/schema/context   
          http://www.springframework.org/schema/context/spring-context-3.1.xsd   
          http://www.springframework.org/schema/aop   
          http://www.springframework.org/schema/aop/spring-aop-3.1.xsd   
          http://www.springframework.org/schema/tx    
          http://www.springframework.org/schema/tx/spring-tx-3.1.xsd
          http://www.springframework.org/schema/cache 
          http://www.springframework.org/schema/cache/spring-cache-3.1.xsd
          http://www.springframework.org/schema/data/jpa
          http://www.springframework.org/schema/data/jpa/spring-jpa.xsd
          http://www.springframework.org/schema/data/repository
          http://www.springframework.org/schema/data/repository/spring-repository-1.5.xsd">  
    <context:component-scan base-package="com.litblack.jpa"></context:component-scan>
                                          
    <!-- 配置Spring Data JPA扫描目录, repository 包 -->
    <jpa:repositories base-package="com.litblack.jpa" /> 

    <!-- 定义实体管理器工厂 -->
    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <!-- 扫描pojo -->
        <property name="packagesToScan" value="com.litblack.jpa" />
        <property name="persistenceProvider">
            <bean class="org.hibernate.ejb.HibernatePersistence" />
        </property>
        <property name="jpaVendorAdapter">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
                <property name="generateDdl" value="true" />
                   <property name="database" value="MYSQL" />
                <!-- <property name="database" value="ORACLE" />  -->
                <!-- <property name="databasePlatform" value="org.hibernate.dialect.MySQL5InnoDBDialect" /> -->
                <property name="showSql" value="true" />
            </bean>
        </property>
        <property name="jpaDialect">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaDialect" />
        </property>
        <property name="jpaPropertyMap">
            <map>
                <entry key="hibernate.generate_statistics" value="false" /><!-- 关闭打印的日志 -->
                <entry key="hibernate.query.substitutions" value="true 1, false 0" />
                <entry key="hibernate.default_batch_fetch_size" value="16" />
                <entry key="hibernate.max_fetch_depth" value="2" />
                <entry key="hibernate.bytecode.use_reflection_optimizer" value="true" />
                <entry key="hibernate.cache.use_second_level_cache" value="false" />
                <entry key="hibernate.cache.use_query_cache" value="false" />
            </map>
        </property>
    </bean>
    
    <!-- 数据源 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />
        <property name="url" value="jdbc:mysql://localhost:3306/cyd?useUnicode=true&amp;characterEncoding=UTF-8" />
        <property name="username" value="root" />
        <property name="password" value="root" />
    </bean>
    <!-- 配置事务管理器 -->
    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory" />
    </bean>

    <!-- 启用 annotation事务 -->
    <tx:annotation-driven transaction-manager="transactionManager" />
</beans>

Spring-config.xml

3. UserBean.java

package com.litblack.jpa;

import java.util.Date;

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

import org.hibernate.annotations.GenericGenerator;
import org.springframework.stereotype.Component;

@Table(name = "cyd_sys_user")
@Entity
public class UserBean {

    @Id
    @GeneratedValue(generator = "system_uuid")
    @GenericGenerator(name = "system_uuid", strategy = "uuid")
    private String id;
    @Column(name="user_name")
    private String userName;
    @Column(name="create_time")
    private Date createTime;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public Date getCreateTime() {
        return createTime;
    }

    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }

    @Override
    public String toString() {
        return "UserBean [id=" + id + ", userName=" + userName + ", createTime=" + createTime + "]";
    }
    
}

POJO

4. UserBeanRepository.java

package com.litblack.jpa;

import java.util.List;
import java.util.Map;

import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.jpa.repository.Query;
/**
 * SQL，JPQL查询
 * 返回：list<POJO>,list<Stinrg>,list<Object>,Page<Object>
 * 不能返回MAP
 * @author chenyd
 * 2018年1月10日
 */
public interface UserBeanRepository  extends JpaRepository<UserBean, Long>, JpaSpecificationExecutor<UserBean>{
    
    UserBean findByUserName(String username);
    
    @Query("from UserBean where userName =?1")
    List<UserBean> find_Jpql_list_obj(String username);

    
    @Query("select userName from UserBean where userName =?1")
    List<String> find_Jpql_list_one(String username);
    
    @Query("select userName,createTime from UserBean where userName =?1")
    List<Object> find_Jpql_list_morefield(String username);
    
    @Query("select userName,createTime from UserBean ")
    List<Object> find_Jpql_list_pojo_morefield();
    
    /**
     * 若返回类型为POJO，必须是所有POJO的所有字段，不能只查询某个字段
     */
    @Query(value="select * from cyd_sys_user",nativeQuery=true)
    List<UserBean> find_SQL_pojo();
    
    @Query(value="select user_name,name from cyd_sys_user,t_user",nativeQuery=true)
    List<Object> find_SQL_obj();

　　@Query(value = "select new map(userName,createTime) from UserBean")
    List<Map<String,Object>> find_SQL_obj_map();
    
    /**
     * 分页需要 #pageable 标识
     * NativeJpaQuery
     * @param pageable
     * @return
     */
    @Query(value="select user_name,name from cyd_sys_user,t_user  /*#pageable*/  ",countQuery="select count(*) from cyd_sys_user,t_user",nativeQuery=true)
    Page<Object> find_SQL_obj(Pageable pageable);
}

5. BaseJunit4Test.java

package com.litblack.jpa;

import java.util.Date;
import java.util.List;
import java.util.Map;

import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Expression;
import javax.persistence.criteria.Order;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.data.domain.Sort.Direction;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { "classpath*:/spring-config.xml" })
public class BaseJunit4Test {

    @Autowired
    private UserBeanRepository userRepository;
    
    /**
     * 保存
     */
    public void save_obj() {
        System.out.println(userRepository);
        for (int i = 0; i < 100; i++) {
            UserBean entity = new UserBean();
            entity.setUserName("user_" + i);
            entity.setCreateTime(new Date());
            userRepository.save(entity);
        }

    }
    /**
     * 查询-所有
     */
    public void get_ALL_obj(){
        List<UserBean> list=userRepository.findAll();
        for (int i = 0; i < list.size(); i++) {
            UserBean obj = list.get(i);
            System.out.println(obj.getCreateTime());
        }
    }
    /**
     * 查询-one-obj,自定义接口
     */
    public void get_one_obj(){
        UserBean obj = userRepository.findByUserName("user_1");
        System.out.println(obj.toString());
    }
    /**
     * 根据JQPL查询，获取一个包含所有字段的OBJ
     * 返回: 一个pojo 集合
     */
    public void get_jqpl_obj(){
        List<UserBean> list=userRepository.find_Jpql_list_obj("user_2");
        for (int i = 0; i < list.size(); i++) {
            UserBean obj = list.get(i);
            System.out.println(obj.toString());
        }
    }
    /**
     * 根据JQPL查询,获取一个字段，
     * 返回：一个字段
     */
    public void get_jqpl_onestr(){
        List<String> list=userRepository.find_Jpql_list_one("user_2");
        for (int i = 0; i < list.size(); i++) {
            String obj = list.get(i);
            System.out.println(obj.toString());
        }
    }
    /**
     * 根据JQPL查询,一行数据，获取多个字段
     * 返回：object 不是POJO,不是string[]。是Object[] 
     * 注意：每个数据类型与POJO类型一致
     */
    public void get_jqpl_morestr(){
        List<Object> list=userRepository.find_Jpql_list_morefield("user_2");
        for (int i = 0; i < list.size(); i++) {
            Object[] obj = (Object[]) list.get(i);
            String username=(String) obj[0];
            Date date=(Date) obj[1];
            System.out.println(username+"\t"+date);
        }
    }
    /**
     * JQPL  获取指定字段的多个POJO
     */
    public void get_jqpl_pojo_morestr(){
        List<Object> list=userRepository.find_Jpql_list_pojo_morefield();
        for (int i = 0; i < list.size(); i++) {
            Object[] obj = (Object[]) list.get(i);
            String username=(String) obj[0];
            Date date=(Date) obj[1];
            System.out.println(username+"\t"+date);
        }
    }
    /**
     * SQL  获取POJO的所有字段，必须是所有POJO的所有字段
     */
    public void get_sql_pojo_allstr(){
        List<UserBean> list=userRepository.find_SQL_pojo();
        for (int i = 0; i < list.size(); i++) {
            UserBean obj = list.get(i);
            System.out.println(obj.toString());
        }
    }
    /**
     * SQL  获取多表查询的字段,可用于多表查询，组成临时表
     * 注意：每个数据类型与POJO类型一致
     */
    public void get_sql_obj_morestr(){
        List<Object> list=userRepository.find_SQL_obj();
        for (int i = 0; i < list.size(); i++) {
            Object[] obj = (Object[]) list.get(i);
            String username=(String) obj[0];
            String name=(String) obj[1];
            System.out.println(username+"\t"+name);
        }
    }
/**
     * Hql 能返回list<Map>
     */
    @Test
    public void get_sql_obj_morestr1(){
        List<Map<String,Object>> list=userRepository.find_SQL_obj_map();
        for (int i = 0; i < list.size(); i++) {
            Map<String,Object> obj = list.get(i);
            System.out.println(obj);
        }
    }
    /**
     * 分页查询,先排序后分页
     * select user_name,name from cyd_sys_user,t_user order by user_name desc limit ?, ?
     */
    public void get_sql_obj_morestr_page(){
        Sort sort=new Sort(Direction.DESC,"user_name");
        Pageable page=new PageRequest(2,10,sort);//第二页，每页10条
        Page<Object> p=userRepository.find_SQL_obj(page);
        List<Object> list=p.getContent();
        for (int i = 0; i < list.size(); i++) {
            Object[] obj = (Object[]) list.get(i);
            String username=(String) obj[0];
            String name=(String) obj[1];
            System.out.println(username+"\t"+name);
        }
    }
    /**
     * 多条件查询,分页,排序
     */
    public void get_sql_obj_morestr_(){
        Page<UserBean> p=userRepository.findAll(new Specification<UserBean>() {
            
            public Predicate toPredicate(Root<UserBean> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
                Predicate stuNameLike = cb.like(root.<String> get("userName"), "%user_%");
                Order oderby =cb.desc(root.<String> get("userName"));
                if(null != stuNameLike) query.where(stuNameLike);
                query.orderBy(oderby);
                return stuNameLike;
            }
        },new PageRequest(0, 20));
        List<UserBean> list=p.getContent();
        for (int i = 0; i < list.size(); i++) {
            UserBean obj = list.get(i);
            System.out.println(obj.toString());
        }
    }
    
    /**
     * 通用单个实体查询
     * @param T
     * @return
     */
    public <T> Specification base_Specification(Class T){
        return new Specification<T>(){
            public Predicate toPredicate(Root<T> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
                Predicate predicate=cb.conjunction();
                List<Expression<Boolean>> expression=predicate.getExpressions();
                expression.add(cb.like(root.<String> get(""), ""));
                return predicate;
            }};
    }
    
}

参考链接

 
  Spring Data JPA 简单查询--接口方法  
  https://www.cnblogs.com/rulian/p/6557471.html

 
   Spring data jpa中Query和@Query分别返回map结果集  
   https://www.cnblogs.com/wucongyun/p/6730582.html 
  
    纯干货，Spring-data-jpa详解，全方位介绍。 http://www.cnblogs.com/dreamroute/p/5173896.html 
   
     转载 spring-data-jpa 介绍 复杂查询，包括多表关联，分页，排序等 
    http://blog.csdn.net/mendeliangyang/article/details/52366799

原文地址：https://www.cnblogs.com/litblank/p/8267333.html