SpringDataJpa使用详解

最新推荐文章于 2025-04-17 23:02:40 发布

安迪爸爸

最新推荐文章于 2025-04-17 23:02:40 发布

阅读量6.1k

点赞数 9

分类专栏：服务器文章标签： springdatajpa jpa

本文链接：https://blog.csdn.net/wzmde007/article/details/100031551

版权

服务器专栏收录该内容

25 篇文章

订阅专栏

概述

这里就不引用冠冕堂皇的介绍了。用我概括的话说。他就是一个类似hibernate,mybatis数据访问层的框架。官网有详细的介绍，

戳这里

Jpa是什么？他是一套规范，类似restful风格一样，都是一套规范。使用Jpa必须按照它的规范来操作数据访问。

SpringDataJpa==Jpa规范+Hibernate底层

为什么要用jpa

笔者其实很喜欢用mybatis写sql来操作数据。但mybatis的局限性就是使用比较麻烦。在工作中，其实大多数业务都是简单的增删改查排序分页。使用mybatis时，每个表基本都要写一遍mapping配置。其实这些工作都是重复性的。写多了谁都会烦而且没必要，只是改了表名和实体类。针对这个问题也有解决方案，就是使用生成工具，直接生成。或者封装一个通用基类，但是mybatis封装很麻烦。所以笔者开始用jpa来做这件事。当然mybatis使用配置文件有一点好处，就是修改sql无需重新编译就可以生效。就是说当我们在服务器上部署了一个项目，通过修改配置文件不用重启服务器。

Jpa适合什么样的项目呢？我觉得适合非互联网项目，或者说中小型项目，或者说对sql优化不高的项目，或者说需求变更不是太频繁的项目。我们可以一个项目中mybatis+jpa混合使用，对于不需要sql优化的表，jpa使用更加方便。

综合来说，jpa在开发效率上讲绝对是比mybatis方便的。我们可以根据自己的需求，来界定是否使用jpa。

Jpa用起来有多简单呢？只需要写一个接口，然后继承JpaRepository,就可以使用了。

比如我要操作User表，新增一个接口IUserDao继承JpaRepository。

public interface IUserDao extends JpaRepository<User,Integer>,JpaSpecificationExecutor<User> {}

在调用的地方初始化IUserDao

   @Autowired
    private IUserDao userDao;

最后就是调用的地方写代码即可，增删改查如下，根本不用自己定义一边。

userDao.save(user);增
userDao.delete(1);删
userDao.save(user);改
userDao.findById(1);查

相比mybatis，每个方法都要声明一边，然后写对应的sql，是不是简单了许多？

可能有人会说上边这几个方法使用起来太单一，不能满足我的需求，比如根据用户名查找，根据用户名修改等操作。

别急，我上边只是介绍最基本的操作，你想的这些，Jpa作者都想到了。

比如说根据用户名查找，我们只需要在IUserDao接口中，声明如下方法即可：

public User findByUserName(String userName);

然后在调用的地方,加上如下代码即可。

userDao.findByUserName("zhangsan");

我们也可以这样写：

@Query("from User where userName=?1")
      public User findBySql(String userName);

也可以通过条件修改：

      @Transactional
      @Modifying
      @Query("update User set userName=?1 where id=?2")
      public int updateBySql(String userName,Integer id);

还有很多简便用法，这里就不做展示了。写到这不知道你对Jpa是否有点心动。

使用详解

SpringBoot集成Jpa

使用SpringBoot继承Jpa是最简单的。

操作步骤如下：

打开Idea工具；
选择Spring Initializr,下一步；
定义好工程相关信息，下一步；
选择左侧菜单中的SQL,勾选右边的Spring Data JPA ,MySql Driver,JDBC API。下一步；
finish;

初始化后pom.xml文件如下，也可以新建空的maven工程，倒入下边的依赖。

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.7.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.ming</groupId>
    <artifactId>springbootjpatest</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springbootjpatest</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

工程初始化完毕后，首先新增实体类User。具体注意点，参见代码注释。一定要注意细节，哪个位置没注意，工程就会报错。代码如下：

package com.ming.springbootjpatest.entity;

import javax.annotation.Generated;
import javax.persistence.*;

@Entity
@Table(name = "t_userinfo")//数据库表明
public class User {
    @Id//声明id为主键
    @GeneratedValue(strategy = GenerationType.IDENTITY)//声明自动增长
    @Column(name = "id")//声明数据库对应的字段
    private Integer id;
    @Column(name = "user_name")//声明数据库对应的字段
    //定义字段也是有讲究的，比如首字母小写，后边的驼峰，对应的数据库字段，遇到驼峰用下划线断开
    //比如实体类定义的userName，则数据库字段为user_name，
    //比如实体类定义的username,则数据库字段也为username
    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层接口IUserDao，代码如下：

public interface IUserDao extends JpaRepository<User,Integer>,JpaSpecificationExecutor<User> {}

然后定义配置文件，在resources目录下新增application.yml，将之前的application.properties文件删掉。配置如下：

server:
  port: 8080
  servlet:
    context-path: /
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/jpatest?serverTimezone=UTC
    username: root
    password: 123456
  jpa:
    database: MySQL
    database-platform: org.hibernate.dialect.MySQL5InnoDBDialect #mysql数据库固定配置
    show-sql: true #控制台打印sql
    hibernate:
      ddl-auto: update #update代表数据库没有表的话，会先创建表，有表的话就不创建了。

以上就基本完成了，我们可以在测试类中做各种数据操作了。

有人说数据库表还没有呢啊！这里要告诉大家，程序运行后，Jpa会去数据库查看，如没有表的话，会先创建表，有表的话就不创建了。所以我们不用创建表，jpa帮我们做了。具体配置参见上边ddl-auto字段。

下边就可以在测试类中写一些测试了啦，代码如下：

package com.ming.springbootjpatest;

import com.ming.springbootjpatest.dao.IUserDao;
import com.ming.springbootjpatest.entity.User;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
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.jpa.domain.Specification;
import org.springframework.test.context.junit4.SpringRunner;

import javax.persistence.criteria.*;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Optional;

@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringbootjpatestApplicationTests {
    @Autowired
    private IUserDao userDao;

    /**
     * 增加方法
     */
    @Test
    public void testAdd(){
        User user=new User();
        user.setUserName("zhangsan1");
        user.setPassword("12345");
        userDao.save(user);
    }

    /**
     * 批量增加
     */
    @Test
    public void testAddList(){
        List<User> userList=new ArrayList<>();
        for(int i=0;i<10;i++){
            User user=new User();
            user.setUserName("zhangsan_"+i);
            user.setPassword("12345_"+i);
            userList.add(user);
        }
        userDao.saveAll(userList);
    }
    /**
     * 通过主键查找
     */
    @Test
    public void testFindById(){
        Optional<User> optionalUser = userDao.findById(1);
        User user = optionalUser.get();
        System.out.println(user);
    }

    /**
     * 通用查找方法，基本上按照哪个字段查都可以，写起来稍微麻烦一点点。
     * 下边是按照userName="zhangsan"去查，如果不用=换作like，就将下边的criteriaBuilder.equal
     * 换成criteriaBuilder.like。
     */
    @Test
    public void testCommonFind(){
        Specification<User> specification=new Specification<User>() {
            @Override
            public Predicate toPredicate(Root<User> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
                Path<Object> userName = root.get("userName");
                Predicate predicate = criteriaBuilder.equal(userName, "zhangsan");
                return predicate;
            }
        };
        Optional<User> optionalUser = userDao.findOne(specification);
        User user = optionalUser.get();
        System.out.println(user);
    }

    /**
     * 查询所有，如果想通过条件查询，可以根据上边的方式查询。
     */
    @Test
    public void testFindAll(){
        List<User> userList = userDao.findAll();
        for(User item:userList){
            System.out.println(item);
        }
    }
    @Test
    public void testPage(){
        //排序
        Sort sort=new Sort(Sort.Direction.DESC,"id");
        //分页
        Pageable pageable=PageRequest.of(0,2,sort);
        Page<User> page = userDao.findAll(pageable);
        //当前页结果，（0）页
        List<User> userList = page.getContent();
        //按照每页2条数据，一共有的页数
        int totalPages = page.getTotalPages();
        //总共有多少条数据
        long totalElements = page.getTotalElements();
    }

    /**
     * 通用修改方法，先根据主键查找，然后在修改提交
     * 也可以通过sql直接修改.需要在IUserDao接口中定义，这里不再演示。
     */
    @Test
    public void testUpdate(){
        Optional<User> userOptional = userDao.findById(1);
        User user = userOptional.get();
        user.setUserName("张三");
        //主键存在为修改，不存在为新增
        userDao.save(user);
    }

    /**
     * 通过主键删除
     * 也可以通过sql直接删除.需要在IUserDao接口中定义，这里不再演示
     */
    @Test
    public void testDelete(){
        userDao.deleteById(1);
    }
}

以上基本覆盖了常用的方法。还有很多的复杂方法这里不再介绍。仅当入门演示。

Spring继承Jpa

spring配置起来比SpringBoot麻烦，主要是需要导入很多依赖，版本号控制繁琐，配置也比Springboot麻烦。但难于很多项目都是Spring，在这里增加Jpa在spring中的配置。

可以去maven仓库查询常见依赖版本，maven仓库地址：https://mvnrepository.com/

新建一个空的maven工程，导入pom文件如下：

<?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.ming</groupId>
    <artifactId>spring-jpa-test</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <java.version>1.8</java.version>
        <spring.version>5.1.5.RELEASE</spring.version>
        <hibernate.version>5.4.2.Final</hibernate.version>
        <slf4j.version>1.8.0-beta4</slf4j.version>
        <log4j.version>1.2.17</log4j.version>
        <c3p0.version>0.9.1.2</c3p0.version>
        <mysql.version>5.1.6</mysql.version>
    </properties>

    <dependencies>
        <!-- junit单元测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13-beta-3</version>
            <scope>test</scope>
        </dependency>

        <!-- spring beg -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.4</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <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-orm</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 end -->

        <!-- hibernate beg -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-validator</artifactId>
            <version>6.0.16.Final</version>
        </dependency>
        <!-- hibernate end -->

        <!-- c3p0 beg -->
        <dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>${c3p0.version}</version>
        </dependency>
        <!-- c3p0 end -->

        <!-- log end -->
        <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>
        <!-- log end -->


        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-jpa</artifactId>
            <version>2.1.10.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.1.9.RELEASE</version>
        </dependency>

        <!-- el beg 使用spring data jpa 必须引入 -->
        <dependency>
            <groupId>javax.el</groupId>
            <artifactId>javax.el-api</artifactId>
            <version>3.0.0</version>
        </dependency>

        <dependency>
            <groupId>org.glassfish</groupId>
            <artifactId>javax.el</artifactId>
            <version>3.0.1-b10</version>
        </dependency>
        <!-- el end -->
    </dependencies>
</project>

接下来就是resources中applicationContext.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/jpatest" />
        <property name="user" value="root" />
        <property name="password" value="123456" />
    </bean>

    <!-- 2.配置entityManagerFactory -->
    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <property name="packagesToScan" value="com.ming.springjpatest.entity" />
        <property name="persistenceProvider">
            <bean class="org.hibernate.jpa.HibernatePersistenceProvider" />
        </property>
        <!--JPA的供应商适配器-->
        <property name="jpaVendorAdapter">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
                <property name="generateDdl" value="false" />
                <property name="database" value="MYSQL" />
                <property name="databasePlatform" value="org.hibernate.dialect.MySQLDialect" />
                <property name="showSql" value="true" />
            </bean>
        </property>
        <property name="jpaDialect">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaDialect" />
        </property>
    </bean>


    <!-- 3.事务管理器-->
    <!-- JPA事务管理器  -->
    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory" />
    </bean>

    <!-- 整合spring data jpa-->
    <jpa:repositories base-package="com.ming.springjpatest.dao"
                      transaction-manager-ref="transactionManager"
                      entity-manager-factory-ref="entityManagerFactory"></jpa:repositories>

    <!-- 4.txAdvice-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="save*" propagation="REQUIRED"/>
            <tx:method name="insert*" propagation="REQUIRED"/>
            <tx:method name="update*" propagation="REQUIRED"/>
            <tx:method name="delete*" propagation="REQUIRED"/>
            <tx:method name="get*" read-only="true"/>
            <tx:method name="find*" read-only="true"/>
            <tx:method name="*" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>

    <!-- 5.aop-->
    <aop:config>
        <aop:pointcut id="pointcut" expression="execution(* com.ming.springjpatest.service.*.*(..))" />
        <aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut" />
    </aop:config>

    <context:component-scan base-package="com.ming.springjpatest"></context:component-scan>

    <!--组装其它 配置文件-->

</beans>

主要就是这两个配置文件，具体实现代码同SpringBoot中的代码。

注意pom文件中mysql-connection-java的版本跟你使用的mysql版本有关，如果用5点几的mysql，mysql-connection-java的版本也要用5点几的否则会报错噢，具体版本可以用maven仓库搜索，仓库地址上边有写。

因为配置spring版本等问题，很容易出错，如遇到错误，可先去我的另外一篇文章中查找，戳这里

在多module工程中，如果把model放在单独的工程，记得在jpa工程启动类中，使用@EntityScan注解，扫描实体类噢。

总结

以上就是对SpringDataJpa的介绍，相信通过文章的介绍大家都能入门使用了，有些细节的使用，还需熟悉jpa规范。

我们也可以封装一个公用基类，便于更好的维护管理。

公用基类声明如下：

@NoRepositoryBean
public interface IBaseDao<T,ID extends Serializable> extends JpaRepository<T,ID>, JpaSpecificationExecutor<T> {
}

像IUserDao等接口都直接继承IBaseDao即可。注意上边的注解，否则会报错。

Github

https://github.com/OptimusMX/springdatajpa