Spring-Data-Jpa入门篇

简介

SpringData JPA是spring基于ORM框架、JPA规范的基础上封装的一套JPA应用框架，可以使开发者使用极简的代码实现对数据库的访问和操作。它提供了包括增删改查等在内的基本功能，且易于扩展。

新建SpringBoot工程

选择所需要的依赖，web，Thymeleaf，spring-data-jpa，mysql

1、pom.xml依赖配置

web开发依赖配置

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

thymeleaf模板依赖

 <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-thymeleaf</artifactId>
 </dependency>

添加数据库驱动依赖配置

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <scope>runtime</scope>
</dependency>

最后需要加入spring-boot-starter-data-jpa，他是springboot项目访问数据库的核心依赖配置，加入此配置后，系统会自动导入Spring Data相关的核心数据访问接口包，以及Hibernate框架相关的依赖包，该配置如下

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

之后完整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 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.2.1.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.mcy</groupId>
    <artifactId>spring-data-jpa</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>spring-data-jpa</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-thymeleaf</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</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>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

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

</project>

2、配置基本属性。

在src/main/resources下找到application.properties文件，在该配置文件中配置数据源和jpa相关的属性，需要在数据库中先新建一个jpa数据库。

#数据源信息配置
#数据库地址，jpa数据库名，需要在数据库中先建一个jpa数据库
spring.datasource.url=jdbc:mysql://localhost:3306/jpa?serverTimezone=GMT%2B8
#用户名
spring.datasource.username=root
#密码
spring.datasource.password=root
#链接数据库驱动
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
#指定数据库方言
spring.jpa.database-platform=org.hibernate.dialect.MySQL5InnoDBDialect
#配置在日志中显示SQL语句
spring.jpa.show-sql=true
#指定自动创建|更新|验证数据库表结构等配置，配置成updata
#表示如果数据库中存在持久化类对应的表就不创建，不存在就创建对应的表
spring.jpa.hibernate.ddl-auto=update
spring.jpa.hibernate.use-new-id-generator-mappings=false

3、创建持久化类。

在项目中新建4个包，分别为entity（放置持久化类）、controller（控制器）、repository（定义数据访问接口的包）、service（业务逻辑处理类）。

在entity包中创建一个持久化类User.java

//用于标记持久化类，SpringBoot项目加载后会自动根据持久化类建表
@Entity
//设置表名为tb_user
@Table(name = "tb_user")
public class User {
    /**
     * 使用@id指定主键。使用代码@GeneratedValue(strategy = GenerationType.IDENTITY)
     * 指定主键的生存策略，mysql默认为自动增长
     */
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id; //主键
    private String username;    //姓名，username
    private String loginName;   //登录名
    private char sex;   //性别
    private Integer age;    //年龄

    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 getLoginName() {
        return loginName;
    }

    public void setLoginName(String loginName) {
        this.loginName = loginName;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public User() {
    }

    public User(String username, String loginName, char sex, Integer age) {
        this.username = username;
        this.loginName = loginName;
        this.sex = sex;
        this.age = age;
    }
}

4、定义数据访问层接口

在repository包下新建一个接口，命名为UserRepository，让该接口继承CrudRepository接口，以持久化对象User作为CrudRepository的第一个类型参数，表示当前所操作的持久化对象类型，Integer作为CrudRepository的第二个类型参数，用于指定ID类型，完整代码如下。

import com.mcy.springdatajpa.entity.User;
import org.springframework.data.repository.CrudRepository;

public interface UserRepository extends CrudRepository<User, Integer> {
    
}

CrudRepository提供了最基本的对实体类的增删改查操作，CrudRepository接口的源码如下

package org.springframework.data.repository;

import java.util.Optional;

@NoRepositoryBean
public interface CrudRepository<T, ID> extends Repository<T, ID> {
    <S extends T> S save(S var1);

    <S extends T> Iterable<S> saveAll(Iterable<S> var1);

    Optional<T> findById(ID var1);

    boolean existsById(ID var1);

    Iterable<T> findAll();

    Iterable<T> findAllById(Iterable<ID> var1);

    long count();

    void deleteById(ID var1);

    void delete(T var1);

    void deleteAll(Iterable<? extends T> var1);

    void deleteAll();
}

该接口提供了很多常用的方法。

1. <S extends T> S save(S var1);     保存单个实体对象数据
2. <S extends T> Iterable<S> saveAll(Iterable<S> var1);     保存给定的所有实体对象。
3. Optional<T> findById(ID var1);       根据id查询实体
4. boolean existsById(ID var1);           根据id判断实体是否存在
5. Iterable<T> findAll();                       查询所有实体
6. Iterable<T> findAllById(Iterable<ID> var1);      根据所提供的这些id，将对应的实体全部查询出来。
7. long count();                                    统计实体总数量
8. void deleteById(ID var1);                根据id删除实体
9. void delete(T var1);                         删除一个实体
10. void deleteAll(Iterable<? extends T> var1);         删除一个实体的集合
11. void deleteAll();                               删除所有实体

在SpringBoot项目中，数据层无须提供实现，直接继承数据访问接口即可。

5、定义业务层类。

在service包下新建一个UserService类，代码如下（增删改查方法）。

import com.mcy.springdatajpa.entity.User;
import com.mcy.springdatajpa.repository.UserRepository;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.List;
import java.util.Optional;

@Service
public class UserService {
    //注入UserRepository
    @Resource
    private UserRepository userRepository;

    /**
     * save，update，delete方法需要绑定事务，使用@Transactional进行事务的绑定
     * 保存对象
     * @param user
     * @return 包含自动生成的id的User对象
     */
    @Transactional
    public User save(User user){
        return userRepository.save(user);
    }

    /**
     * 根据id删除对象
     * @param id
     */
    @Transactional
    public void delete(Integer id){
        userRepository.deleteById(id);
    }

    /**
     * 查询所有数据
     * @return
     */
    public Iterable<User> findAll(){
        return userRepository.findAll();
    }

    /**
     * 根据id查询
     * @param id
     * @return
     */
    public User getById(Integer id){
        //根据id查询对应的持久化对象
        Optional<User> op = userRepository.findById(id);
        return op.get();
    }

    /**
     * 修改用户，持久化对象修改后会自动更新到数据库
     * @param user
     */
    @Transactional
    public void update(User user){
        //直接调用持久化对象的set方法修改对象的数据
        user.setUsername("孙悟空");
        user.setLoginName("swk");
    }
}

在业务层中需要注入数据访问层对象，在上述代码中是通过@Resource注解将UserRepository接口对应的实现类注入进来的。从这里可以看出，只要数据访问层接口实现了CrudRepository，springboot项目会自动扫描该类并为该类创建实现类对象。@Transactional注解用于声明方法的事物特性。

6、定义控制器类

在controller包下新建一个UserController类，代码如下（主要增删改查方法）。

import com.mcy.springdatajpa.entity.User;
import com.mcy.springdatajpa.service.UserService;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

@RestController
@RequestMapping("/user")
public class UserController {
    //注入UserServer
    @Resource
    private UserService userService;

    //保存方法
    @RequestMapping("/save")
    public String save(){
        //实例化一个对象，添加值
        User user = new User();
        user.setLoginName("admin");
        user.setUsername("一念之间");
        user.setSex('男');
        user.setAge(19);
        //保存数据
        userService.save(user);
        return "保存数据成功！";
    }

    //修改
    @RequestMapping("/update")
    public String update(){
        //修改的对象必须是持久化对象，所以先从数据库查询id为1的对象开始修改
        User user = userService.getById(1);
        userService.update(user);
        return "修改成功！";
    }
    
    //删除
    @RequestMapping("/delete")
    public String delete(){
        userService.delete(1);
        return "删除成功！";
    }
    
    //查询所有
    @RequestMapping("/getAll")
    public Iterable<User> getAl(){
        //查询所有的用户数据
        return userService.findAll();
    }
}

7、测试应用

启动MySQL数据库，在数据库中创建名为jpa的数据库。

springboot项目启动后，JPA会在数据库中自动创建持久化类对应的tb_user表。需要注意的是，按照JPA规范，实体类User的属性loginName映射到数据库的时候，自动生成的数据库名是login_name。

新建的tb_user表结构。

在浏览器中输入http://localhost:8080/user/save来测试添加数据应用。

请求会提交到UserController类的save方法进行处理，如果该方法保存用户成功即可返回字符串“保存数据成功！”，如下图：

查看数据库的表信息，如下图。

测试修改用户，在浏览器中输入http://localhost:8080/user/update地址。

请求会提交到UserController类的update方法进行处理，如果该方法修改用户成功即可返回字符串“修改成功！”，如下图：

userserver类中update修改方法修改username和loginName字段。修改后数据库表信息。

测试查询所有用户数据，在浏览器中输入http://localhost:8080/user/getAll地址，请求会提交到UserController类的getAll方法进行处理，如果该方法执行查询所有用户成功，即可返回查询到的所有用户信息的json格式的字符串。如下图：

测试删除用户数据，在浏览器中输入http://localhost:8080/user/delete地址，请求会提交到UserController类的delete方法进行处理，如图：

查看数据库的表信息。

案例代码下载链接：https://github.com/machaoyin/spring-data-jpa

上一篇： SpringBoot整合Thymeleaf

下一篇：Spring-Data-Jpa分页数据显示