SpringBoot之Spring Data JPA入门学习

news2024/12/24 20:29:42

JPA（Java Persistence API）Java持久化API，是 Java 持久化的标准规范，Hibernate是持久化规范的技术实现，而Spring Data JPA是在 Hibernate 基础上封装的一款框架。

一、添加依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!--lombok-->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
</dependency>
<!--mysql-->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.31</version>
</dependency>
<!--jpa-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

在pom文件中我们主要添加了Mysql和JPA的依赖。

二、属性配置(application.properties)

# 数据库连接
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/mydb?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf-8&useSSL=false&rewriteBatchedStatements=true

# jpa相关配置
# 显示sql语句
spring.jpa.show-sql=true 
# 指定数据库的初始化模式
spring.jpa.hibernate.ddl-auto=update

spring.jpa.hibernate.ddl-auto属性介绍:

none: 不指定数据库初始化模式

create: 当Spring Boot应用运行时，会删除并重新创建数据库。所以每次启动时，所有的数据都会被清空

create-drop: 当sessionFactory关闭，表会自动删除

validate: 在Spring Boot应用运行时，会检查数据库中的表与java实体类是否匹配。如果不匹配，则运行失败

update: 当在java实体类中新增了一个字段，在应用重新运行时，会将字段添加到数据库表中的新列，但不会移除先前存在的列或约束

在开发阶段中，通常使用update，但需要注意，update不会移除先前已经存在的列和约束，即使是不再需要的。
当产品发布的时候，建议使用none或直接不指定该属性。

三、创建实体

@Entity：定义对象将会成为被JPA管理的实体，将映射到指定的数据库表。

@Table：用于指定数据库表的表名

@Id：定义属性为数据库的主键，一个实体里面必须有一个

@GeneratedValue：主键生成策略。一共有4种生成策略。

TABLE(通过表产生主键，框架由表模拟序列产生主键，使用该策略可以使应用更易于数据库移植),

SEQUENCE(通过序列产生主键，通过@SequenceGenerator注解指定序列名称，MySQL不支持这种方式)

IDENTITY(采用数据库ID自增长，一般用于MYSQL数据库)

AUTO(JPA自动选择合适的策略，是默认选项)

@Column：用来标识实体类中属性与数据表中字段的对应关系 name:数据库中表的列名

import lombok.Data;

import javax.persistence.*;
import java.math.BigDecimal;

/**
 * @author qinxun
 * @date 2023-06-07
 * @Descripion: 用户实体
 */
@Entity
@Table(name = "t_user")
@Data
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    /**
     * 姓名
     */
    @Column(name = "name")
    private String name;

    /**
     * 年龄
     */
    @Column(name = "age")
    private Integer age;

    /**
     * 余额
     */
    @Column(name = "money")
    private BigDecimal money;


}

四、创建数据层

import com.example.quartzdemo.entity.User;
import org.springframework.data.jpa.repository.JpaRepository;

/**
 * @author qinxun
 * @date 2023-06-07
 * @Descripion: 用户数据层
 */
public interface UserRepository extends JpaRepository<User, Long> {
}

继承自 JpaRepository
两个泛型参数，第一个表示这个repository操作的表绑定的POJO，第二个表示自增id类型

五、测试

1.新增数据

import com.example.quartzdemo.entity.User;
import com.example.quartzdemo.repository.UserRepository;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.math.BigDecimal;

/**
 * @author qinxun
 * @date 2023-06-07
 * @Descripion: JPA的使用
 */
@SpringBootTest
public class JpaTest {

    @Autowired
    private UserRepository userRepository;

    /**
     * 新增数据
     */
    @Test
    void test1() {
        User user = new User();
        user.setName("张三");
        user.setMoney(BigDecimal.TEN);
        user.setAge(20);
        userRepository.save(user);
    }

}

控制台显示sql的执行语句

我们查看数据库，看到数据已经新增到了数据库

2.查询数据

    /**
     * 查询所有数据数据
     */
    @Test
    void test2() {
        List<User> userList = userRepository.findAll();
        //Hibernate: select user0_.id as id1_1_, user0_.age as age2_1_, user0_.money as money3_1_, user0_.name as name4_1_ from t_user user0_
        //[User(id=1, name=张三, age=20, money=10.00)]
        System.out.println(userList);
    }

    /**
     * 查询ID对应的数据
     */
    @Test
    void test3() {
        User user = userRepository.findById(1L).get();
        //Hibernate: select user0_.id as id1_1_0_, user0_.age as age2_1_0_, user0_.money as money3_1_0_, user0_.name as name4_1_0_ from t_user user0_ where user0_.id=?
        //User(id=1, name=张三, age=20, money=10.00)
        System.out.println(user);
    }

3.修改数据

 /**
     * 修改数据
     */
    @Test
    void test4() {
        // 修改ID为1的数据
        User user = new User();
        user.setName("张三");
        user.setMoney(BigDecimal.TEN);
        user.setAge(21);
        // 指定要修改的ID
        user.setId(1L);
        userRepository.save(user);
    }

控制台显示sql语句

Hibernate: select user0_.id as id1_1_0_, user0_.age as age2_1_0_, user0_.money as money3_1_0_, user0_.name as name4_1_0_ from t_user user0_ where user0_.id=?
Hibernate: update t_user set age=?, money=?, name=? where id=?

我们查看数据库，这条ID为1的数据已经被修改了 age变成了21

4.删除数据

  /**
     * 删除数据
     */
    @Test
    void test5() {
        // 删除ID为1的数据
        userRepository.deleteById(1L);
    }

控制台显示sql语句

Hibernate: select user0_.id as id1_1_0_, user0_.age as age2_1_0_, user0_.money as money3_1_0_, user0_.name as name4_1_0_ from t_user user0_ where user0_.id=?
Hibernate: delete from t_user where id=?

我们查看数据库，发现这条ID为1的数据已经被删除了