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

springdata-jpa 八种查询方法的更多相关文章

WordPress慢的八种解决方法（用排查法解决）
WordPress的打开速度慢会影响到用户体验和关键词的稳定排名,WordPress为什么加载慢呢?其实很简单的,就是WordPress水土不服,用WordPress的大家都知道,WordPress是 ...
ZOJ-1610 线段树+两种查询方法（弥补我线段树区间填充的短板）
ZOJ-1610 线段树+两种查询方法(弥补我线段树区间填充的短板) 题意题意:给一个n,代表n次操作,接下来每次操作表示把[l,r]区间的线段涂成k的颜色其中,l,r,k的范围都是0到8000 这 ...
Spring Data Jpa (三)定义查询方法
本章详细讲解如何利用方法名定义查询方法(Defining Query Methods) (1)定义查询方法的配置方法由于Spring JPA Repository的实现原理是采用动态代理的机制,所以 ...
springdata jpa多表查询的方式
方式一:使用@Query注解方式查询主要有JPQL方式,也就是面向对象的方式,这种情况下查表其实查的是对象,字段是实体中的属性,该方式可以直接映射到实体,如下图. 使用jpql的方式模糊查询时候不能使 ...
几种查询方法(lambda Linq Enumerable静态类方式)
1.需要一个数据源类: using System; using System.Collections.Generic; namespace Linq { public class Student { ...
MVC EF两种查询方法
@*@model IQueryable<EFExam.Models.Product>*@@model IQueryable<EFExam.Models.ProductViewMode ...
storm 介绍+八种grouping方法
Storm主要的应用场景就是流式数据处理,例如实时推荐系统,实时监控系统等. storm中的相关概念在storm中,分布式的计算结构指的是一个topology(拓扑),一个topology由流式数据 ...
Form Builder的三种查询方法构建
1.使用DEFAULT_WHERE: DECLARE V_DEFAULT_WHERE VARCHAR2(32767); V_WHERE VARCHAR2(32767); BEGI ...
[moka同学笔记]YII2.0 判断签约状态，sql的两种查询方法
方法一: //判断签约状态 $signed = 0; $sql="SELECT * from usho_community_sign_record WHERE com_id=$r->i ...

随机推荐

数据结构之图论---bfs（邻接表）
数据结构实验之图论二:基于邻接表的广度优先搜索遍历 Time Limit: 1000MS Memory limit: 65536K 题目描述给定一个无向连通图,顶点编号从0到n-1,用广度优先搜索( ...
CodeForces - 55D Beautiful numbers —— 数位DP
题目链接:https://vjudge.net/problem/CodeForces-55D D. Beautiful numbers time limit per test 4 seconds me ...
[Selenium] 使用Firefox Driver 示例
//导入Selenium 库和FirefoxDriver 库 package com.learningselenium.simplewebdriver; import org.openqa.selen ...
学习记录：《高性能javascript》【持续更新】
在看这本书的时候,遇到不懂得地方我一般都会百度一下.这里记录一下我在这本书里捡到的杂碎知识: 1.arrayObject.shift() 2.concat() 3.绑定监听的事件的方法(兼容IE,Fi ...
JavaScript-Tool：jquery.jsprint.js
ylbtech-JavaScript-Tool:jquery.jsprint.js 一个通过单击页面按钮,便实现页面打印的jQuery插件jqprint. 1.返回顶部 1. 插件描述:一个通过单击页 ...
指针 * &
int main() { ; //定义int变量updates int * p_updates; //定义指针p_updates p_updates=&updates;//将updates的地 ...
eclipse整合tomcat
首先确保jdk已经安装好步骤1 获得服务器运行环境配置,Window/Preferences/Server/Runtime Environmen l步骤2 添加服务器步骤3 选择服务器在硬盘的地址 ...
从开发的角度对zigbee安全的杂谈
说起zigbee应该很少人听过,这个B名字怪怪的... 以前开发不懂开发的思想,前前后后花了很久时间,现在回想起来,突然想从安全的角度来理解数据的传输废话:伴随科技的快速演进,物联网(The Int ...
洛谷 - P5000 - Hillwer编码 - 高精度
https://www.luogu.org/problemnew/show/P5000 第一次写一个正经的高精度题. 很明显ASCII码的乘积绝对是溢出的. 那么直接上Java.正好学一手Java的字 ...
POJ1270【拓扑排序+DFS】
题意: 先给你一个字符串,让你给他们排序: 再给你一行,在这一行,每两个就是第一个需要在第二个前面: 思路: //DFS写多了感觉好有啊,就是排序过程中可能会有多种情况. //我们考虑一下怎么排好一个 ...

springdata-jpa 八种查询方法

参考链接

springdata-jpa 八种查询方法的更多相关文章

随机推荐

热门专题