Spring Data JPA记录

最新推荐文章于 2025-01-22 10:12:18 发布

原创最新推荐文章于 2025-01-22 10:12:18 发布 · 304 阅读

0 ·

CC 4.0 BY-SA版权

从0.5开始学习专栏收录该内容

56 篇文章

订阅专栏

本文详细介绍SpringDataJPA的应用，涵盖环境搭建、实体类映射、DAO层接口编写及常见CRUD操作。深入探讨JPQL查询、动态查询、排序与分页功能，以及自定义查询方法命名规范。

介绍

是spring基于ORM框架、JPA规范的基础上封装的一套JPA应用框架，让程序员用极简单的代码即可实现对数据库的访问和操作。提供了包括增删改查等在内的常用功能，且易于扩展。
使用SpringDataJpa，dao层中只需要写接口，就自动具有了增删改查、分页查询等方法

spring data jpa、jpa规范和hibernate之间的关系

在这里插入图片描述
spring data jpa 封装了jpa规范，最终去操作数据库的，还是hibernate内部封装jdbc操作去对数据库进行操作。

spring整合案例

搭建环境
创建工程导入坐标
配置spring的配置文件
编写实体类，使用jpa注解配置映射关系
编写一个符合spring data jpa 的dao层接口

创建一个基本的java工程，不涉及web页面

在这里插入图片描述
pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<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/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.demo</groupId>
    <artifactId>jpa-demo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <!--定义公共版本号-->
    <properties>
        <spring.version>5.0.7.RELEASE</spring.version>
        <hibernate.version>5.0.7.Final</hibernate.version>
        <slf4j.version>1.6.6</slf4j.version>
        <log4j.version>1.2.12</log4j.version>
        <c3p0.version>0.9.1.2</c3p0.version>
        <mysql.verson>5.1.6</mysql.verson>
    </properties>
    <dependencies>
        <!--junit单元测试-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <!--spring AOP相关坐标-->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.13</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!--spring IOC相关坐标-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!--spring对ORM框架的支持包-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!--hibernate核心包-->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <!--hibernate对jap实现的包-->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <!--hibernate验证包-->
        <dependency>
            <groupId>org.hibernate.validator</groupId>
            <artifactId>hibernate-validator</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <!--c3p0数据库连接池-->
        <dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>${c3p0.version}</version>
        </dependency>
        <!--日志相关包-->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>${log4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <!--mysql驱动包-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.verson}</version>
        </dependency>
        <!--spring 提供对junit单元测试的包-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.1.9.RELEASE</version>
        </dependency>
        <!--spring data jpa 坐标-->
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-jpa</artifactId>
            <version>2.1.6.RELEASE</version>
        </dependency>
        <!--spring data jpa 必须导入的两个坐标,不导入会包el错误-->
        <dependency>
            <groupId>org.glassfish.web</groupId>
            <artifactId>javax.el</artifactId>
            <version>2.2.4</version>
        </dependency>
        <dependency>
            <groupId>javax.el</groupId>
            <artifactId>javax.el-api</artifactId>
            <version>2.2.4</version>
        </dependency>
    </dependencies>
</project>

创建配置文件application.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:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:jdbc="http://www.springframework.org/schema/jdbc" xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:jpa="http://www.springframework.org/schema/data/jpa" xmlns:task="http://www.springframework.org/schema/task"
       xsi:schemaLocation="
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
		http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
		http://www.springframework.org/schema/data/jpa
		http://www.springframework.org/schema/data/jpa/spring-jpa.xsd">

    <!-- 1.dataSource 配置数据库连接池-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver" />
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/knowledge" />
        <property name="user" value="root" />
        <property name="password" value="123456" />
    </bean>

    <!--创建entityManagerFactory对象交给spring容器管理,这个bean的class限定类名是spring data jpa提供的-->
    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <!--依赖注入相关内容-->
        <!--数据库连接池-->
        <property name="dataSource" ref="dataSource"/>
        <!--配置扫描的包，写实体类所在的包-->
        <!--在创建容器的过程中，会根据packagesToScan自动的去扫描这个包下的所有实体类，重点找的是那些配置了entity、table、jpa注解的实体类-->
        <property name="packagesToScan" value="com.demo.domain"/>
        <!--jpa的实现方式,服务的提供者-->
        <property name="persistenceProvider">
            <bean class="org.hibernate.jpa.HibernatePersistenceProvider"/>
        </property>
        <!--jpa的配置-->
        <property name="jpaVendorAdapter">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
                <!--是否自动创建数据库表，false不创建-->
                <property name="generateDdl" value="false" />
                <!--数据库类型-->
                <property name="database" value="MYSQL" />
                <!--数据库方言，借助方言支持特有的语法-->
                <property name="databasePlatform" value="org.hibernate.dialect.MySQLDialect" />
                <!--sql打印到控制台-->
                <property name="showSql" value="true" />
            </bean>
        </property>
        <!--jpa方言，可以使jpa支持提供者的一些高级特性-->
        <property name="jpaDialect">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaDialect"/>
        </property>
    </bean>
    <bean>
        <!-- 整合spring data jpa-->
        <!--base-package是：dao接口所在的包，这里边的所有接口就是真正要操作数据库了
            transaction-manager-ref="transactionManager"开启事务管理器
        -->
        <jpa:repositories base-package="com.demo.dao"
                          transaction-manager-ref="transactionManager"
                          entity-manager-factory-ref="entityManagerFactory"></jpa:repositories>
    </bean>
    <!--配置事务管理器-->
    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory" />
    </bean>
    <!--声明式事务-->


    <!--配置包扫描-->
    <context:component-scan base-package="com.demo"></context:component-scan>
</beans>

创建实体类

package com.demo.domain;
 
import javax.annotation.Generated;
import javax.persistence.*;
 
@Entity
@Table(name = "t_user")//数据库表明
public class User {
    @Id//声明id为主键
    @GeneratedValue(strategy = GenerationType.IDENTITY)//声明自动增长
    @Column(name = "id")//声明数据库对应的字段
    private Integer id;
    @Column(name = "user_name")//声明数据库对应的字段
    private String userName;
    @Column(name = "password")
    private String password;
 
    public Integer getId() {
        return id;
    }
 
    public void setId(Integer id) {
        this.id = id;
    }
 
    public String getUserName() {
        return userName;
    }
 
    public void setUserName(String userName) {
        this.userName = userName;
    }
 
    public String getPassword() {
        return password;
    }
 
    public void setPassword(String password) {
        this.password = password;
    }
 
    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", userName='" + userName + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

编写dao层接口，不需要dao层接口实现类

dao层接口：

要继承两个接口（JpaRepository、JpaSpecificationExecutor）
提供响应的泛型
1. JpaRepository<操作的实体类类型，实体类中主键属性类型>
2. JpaSpecificationExecutor<操作的实体类类型>

其中JpaRepository封装了基本的CRUD操作，JpaSpecificationExecutor封装了复杂查询（分页）

import com.demo.domain.User;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;

public interface UserDao extends JpaRepository<User,Integer>, JpaSpecificationExecutor<User> {

}

测试类

在这里插入图片描述
save()方法会根据主键去判断是保存数据还是更新数据。

jpql

nativeQuery = true 使用本地sql查询

	/**
	 *此时使用的字段是实体类的字段
	 */
    @Query(value = "select u from User u where u.name = ?1")
    public User findJpql(String name);
    
	 /**
	 *此时使用的字段是表的字段
	 *@Query(value = "select * from user where name = ?1",  nativeQuery = true)
	 *  public User findJpql(String name);
	 */

	/**
	 *修改、删除 语句要加注解@Modifying
	 */
    @Query(value = "update User set name = ?1 where id = ?2")
    @Modifying
    public Integer updateById(String name, Integer id);

/**
 *修改删除要加事务，且设置不会自动回滚
 *
 */
    @Transactional
    @Rollback(value = false)
    void test() {
        userDao.updateById("laoli",5);
    }

Specification动态查询

Specification接口中只定义了一个方法

    //构造查询条件
    /**
    *   root            ：Root接口，代表查询的根对象，可以通过root获取实体中的属性
    *   CriteriaQuery   ：代表一个顶层查询对象，用来自定义查询（一般不用）
    *   CriteriaBuilder ：用来构建查询，此对象里有很多条件方法
    **/
    Predicate toPredicate(Root<T> var1, CriteriaQuery<?> var2, CriteriaBuilder var3);

根据id查询

//Specification<User> companySpecification = (Specification<User>) (root, criteriaQuery, criteriaBuilder) -> criteriaBuilder.equal(root.get("id").as(String.class),id);
Specification<User> companySpecification = new Specification<User>(){
    @Override
    public Predicate toPredicate(Root<User> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
    	// root.get("id") id是user类中的属性。10 是具体值
    	// where id = 10
        return criteriaBuilder.equal(root.get("id"),10);
    }
};
userDao.findOne(companySpecification);

多条件查询

//Specification<User> companySpecification = (Specification<User>) (root, criteriaQuery, criteriaBuilder) -> criteriaBuilder.equal(root.get("id").as(String.class),id);
Specification<User> companySpecification = new Specification<User>(){
    @Override
    public Predicate toPredicate(Root<User> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
    	Predicate name = criteriaBuilder.equal(root.get("name"), "laoli");
    	Predicate id = criteriaBuilder.equal(root.get("id"), 10);
    	//使用and：且
    	//使用or：或
        return criteriaBuilder.and(name,id);
    }
};
userDao.findAll(companySpecification);

模糊查询

        Specification<User> companySpecification = new Specification<User>(){
            @Override
            public Predicate toPredicate(Root<User> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
                //查询属性：客户名
                Path<Object> name = root.get("name");
                //查询方式：模糊匹配。要指定字段类型才能进行比较
                Predicate like = criteriaBuilder.like(name.as(String.class), "laoli");
                return like;
            }
        };
        Optional<User> one = userDao.findOne(companySpecification);
        User user = one.get();
        System.out.println(user)

排序

		List<User> list = userDao.findAll(Sort.by(Sort.Direction.DESC, "id","age"));
        for (User customer : list) {
            System.out.println(customer);
        }

分页

 		Pageable pageable =  PageRequest.of(1, 2);
        Page<User> all = userDao.findAll(pageable);

自定义查询方法命名规范

规则：findBy(关键字)+属性名称(属性名称的首字母大写)+查询条件(首字母大写)

关键字	方法命名	sql where 字句
And	findByNameAndPwd	where name= ? and pwd =?
Or	findByNameOrSex	where name= ? or sex=?
Between	findByIdBetween	where id between ? and ?
LessThan	findByIdLessThan	where id < ?
LessThanEqual	findByIdLessThanEquals	where id <= ?
GreaterThan	findByIdGreaterThan	where id > ?
GreaterThanEqual	findByIdGreaterThanEquals	where id > = ?
After	findByIdAfter	where id > ?
Before	indByIdBefore	where id < ?
IsNull	findByNameIsNull	where name is null
isNotNull,Not Null	findByNameNotNull	where name is not
Like	findByNameLike	where name like ?
NotLike	findByNameNotLike	where name not like ?
StartingWith	findByNameStartingWith	where name like ‘?%’
EndingWith	findByNameEndingWith	where name like ‘%?’
Containing	findByNameContaining	where name like ‘%?%’
OrderBy	findByIdOrderByXDesc	where id=? order by x desc
Not	findByNameNot	where name <> ?
In	findByIdIn(Collection<?> c)	where id in (?)
NotIn	findByIdNotIn(Collection<?> c)	where id not in (?)
True	findByAaaTue	where aaa = true
False	findByAaaFalse	where aaa = false
IgnoreCase	findByNameIgnoreCase	where UPPER(name)=UPPER(?)

OneToMany

one

//配置客户和联系人之间的关系（一对多关系）
    /**
     * 使用注解的形式配置多表关系
     *      1.声明关系
     *          @OneToMany : 配置一对多关系
     *              targetEntity ：对方对象的字节码对象
     *      2.配置外键（中间表）
     *              @JoinColumn : 配置外键
     *                  name：外键字段名称
     *                  referencedColumnName：参照的主表的主键字段名称
     *
     *  * 在客户实体类上（一的一方）添加了外键了配置，所以对于客户而言，也具备了维护外键的作用
     *
     */

    @OneToMany(targetEntity = Many.class)
    @JoinColumn(name = "many_one_id",referencedColumnName = "one_id")
    private Set<Many> manys = new HashSet<>();

many

    /**
     * 配置联系人到客户的多对一关系
     *     使用注解的形式配置多对一关系
     *      1.配置表关系
     *          @ManyToOne : 配置多对一关系
     *              targetEntity：对方的实体类字节码
     *      2.配置外键（中间表）
     *
     * * 配置外键的过程，配置到了多的一方，就会在多的一方维护外键
     *
     */
    @ManyToOne(targetEntity = One.class)
    @JoinColumn(name = "many_one_id",referencedColumnName = "one_id")
    private One one;

主表放弃外键维权，并配置级联

    /**
     * 放弃外键维护权
     *      mappedBy：对方配置关系的属性名称,也就是对方的外键
     * cascade : 配置级联（可以配置到设置多表的映射关系的注解上）
     *      CascadeType.all         : 所有
     *                  MERGE       ：更新
     *                  PERSIST     ：保存
     *                  REMOVE      ：删除
     *
     * fetch : 配置关联对象的加载方式
     *          EAGER   ：立即加载
     *          LAZY    ：延迟加载

      */
    @OneToMany(mappedBy = "one",cascade = CascadeType.ALL,fetch = FetchType.LAZY)
    private Set<Many> manys = new HashSet<>();

添加数据

/**
 *由于一的一方可以维护外键：会发送update语句,但是这条语句是多余的。解决方式就是放弃外键维权
 */
    @Transactional //配置事务
    @Rollback(false) //不自动回滚
    public void testAdd2() {
        //创建一个客户，创建一个联系人
        One one = new One();
        One.setName("百度");

        Many many = new Many();
        many.setName("小李");


        many.setOne(one);//由于配置了多的一方到一的一方的关联关系（当保存的时候，就已经对外键赋值）
        one.getManys().add(many);//由于配置了一的一方到多的一方的关联关系（发送一条update语句）

        oneDao.save(one);
        manyDao.save(many);
    }



   /**
     * 级联添加：保存一个客户的同时，保存客户的所有联系人
     *      需要在操作主体的实体类上，配置casacde属性
     */
    @Test
    @Transactional //配置事务
    @Rollback(false) //不自动回滚
    public void testCascadeAdd() {
        One one = new One();
        One.setName("百度");

        Many many = new Many();
        many.setName("小李");
        
        many.setOne(one);
        one.getManys().add(many);

        customerDao.save(customer);
    }


    /**
     * 级联删除：
     *      删除1号客户的同时，删除1号客户的所有联系人
     */
    @Transactional //配置事务
    @Rollback(false) //不自动回滚
    public void testCascadeRemove() {
        //1.查询1号客户
        One one = oneDao.findOne(1l);
        //2.删除1号客户,同时会删除many表数据
        oneDao.delete(one);
    }

ManyToMany

user

    /**
     * 配置用户到角色的多对多关系
     *      配置多对多的映射关系
     *          1.声明表关系的配置
     *              @ManyToMany(targetEntity = Role.class)  //多对多
     *                  targetEntity：代表对方的实体类字节码
     *          2.配置中间表（包含两个外键）
     *                @JoinTable
     *                  name : 中间表的名称
     *                  joinColumns：配置当前对象在中间表的外键
     *                      @JoinColumn的数组
     *                          name：外键名
     *                          referencedColumnName：参照的主表的主键名
     *                  inverseJoinColumns：配置对方对象在中间表的外键
     */
    @ManyToMany(targetEntity = Role.class,cascade = CascadeType.ALL)
    @JoinTable(name = "sys_user_role", //中间表
            //joinColumns,当前对象在中间表中的外键
            joinColumns = {@JoinColumn(name = "sys_user_id",referencedColumnName = "user_id")},
            //inverseJoinColumns，对方对象在中间表的外键
            inverseJoinColumns = {@JoinColumn(name = "sys_role_id",referencedColumnName = "role_id")}
    )
    private Set<Role> roles = new HashSet<>();

Role

//因为插入数据两张表都可以对中间表进行维护，所以中间表会出现主键重复的异常
//被选择方放弃维护权
    @ManyToMany(mappedBy = "roles")  //配置多表关系
    private Set<User> users = new HashSet<>();

操作数据

   //测试级联添加（保存一个用户的同时保存用户的关联角色）
    @Transactional
    @Rollback(false)
    public void  testCasCadeAdd() {
        User user = new User();
        user.setUserName("小李");

        Role role = new Role();
        role.setRoleName("java程序员");

        //配置用户到角色关系，可以对中间表中的数据进行维护    
        user.getRoles().add(role);

        //配置角色到用户的关系，可以对中间表的数据进行维护   
        role.getUsers().add(user);

        userDao.save(user);
    }

    /**
     * 案例：删除id为1的用户，同时删除他的关联对象
     */
    @Transactional
    @Rollback(false)
    public void  testCasCadeRemove() {
        //查询1号用户
        User user = userDao.findOne(1l);
        //删除1号用户
        userDao.delete(user);

    }