SpringBoot整合JPA

一· 运行效果如下

二项目结构图

三代码

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>
    <groupId>com.example</groupId>
    <artifactId>Chapter03</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>Chapter03</name>
    <description>Chapter03</description>
    <properties>
        <java.version>1.8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <spring-boot.version>2.6.13</spring-boot.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-web</artifactId>
        </dependency>

        <dependency>
            <groupId>com.mysql</groupId>
            <artifactId>mysql-connector-j</artifactId>
            <scope>runtime</scope>
        </dependency>

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

    </dependencies>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>${spring-boot.version}</version>
                <configuration>
                    <mainClass>com.example.chapter03.Chapter03Application</mainClass>
                    <skip>true</skip>
                </configuration>
                <executions>
                    <execution>
                        <id>repackage</id>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>

application.properties


server.port=8080

 spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

spring.datasource.name=defaultDataSource

spring.datasource.url=jdbc:mysql://localhost:3306/data?serverTimezone=UTC&characterEncoding=utf-8&useSSL=false

spring.datasource.username=root
spring.datasource.password=123456

#spring.jpa.open-in-view=false

spring.jpa.show-sql=true
spring.jpa.database=mysql
spring.jpa.hibernate.ddl-auto=update

我所使用的数据库是Mysql

以下是每个属性的含义：

server.port=8080：设置应用程序的端口号为8080。
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver：指定使用的数据库驱动程序类。
spring.datasource.name=defaultDataSource：设置数据源的名称。
spring.datasource.url=jdbc:mysql://localhost:3306/data?serverTimezone=UTC&characterEncoding=utf-8&useSSL=false：指定数据库连接URL，这里使用的是MySQL数据库。
spring.datasource.username=root：指定数据库用户名。
spring.datasource.password=123456：指定数据库密码。
spring.jpa.show-sql=true：设置是否在控制台上显示SQL语句。
spring.jpa.database=mysql：指定使用的数据库类型。
spring.jpa.hibernate.ddl-auto=update：指定Hibernate在启动时对数据库进行DDL操作的策略。

总体而言，这些配置属性用于设置应用程序的端口号、数据库连接、数据库类型和Hibernate的DDL操作策略。您可以根据您的应用程序需要进行适当的配置。

Student类

package com.example.chapter03.Student;

import javax.persistence.*;
import java.time.LocalDate;
@Table(name="Student")
@Entity
public class student {
    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getStu_number() {
        return stu_number;
    }

    public void setStu_number(String stu_number) {
        this.stu_number = stu_number;
    }

    public Integer getAge() {
        return age;
    }

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

    public LocalDate getBirthday() {
        return birthday;
    }

    public void setBirthday(LocalDate birthday) {
        this.birthday = birthday;
    }

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name="id")
    private Integer id;

    @Column(name="name")
    private String name;

    @Column(name="stu_number")
    private String stu_number;

    @Column(name="age")
    private Integer age;

    @Override
    public String toString() {
        return "student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", stu_number='" + stu_number + '\'' +
                ", age=" + age +
                ", birthday=" + birthday +
                '}';
    }

    @Column(name="birthday")
    private LocalDate birthday;

}

@Id注释简析

@Id是Java Persistence API (JPA) 中的一个注解，用于指定实体类中的属性作为数据库表的主键。它可以在实体类的属性上使用，用于标识该属性为主键。

@Id注解可以与@GeneratedValue注解结合使用，用于指定主键的生成策略。常见的主键生成策略包括自增长、UUID、序列等。通过使用@Id和@GeneratedValue注解，可以自动为主键生成唯一的值。

@Id注解的使用要求：

主键属性不能为null。
主键属性应该具有唯一性，不能重复。
主键属性的类型可以是基本数据类型（如int、long），也可以是字符串、日期等。

在持久化操作中，主键的作用非常重要。通过使用@Id注解，可以标识出实体类中的某个属性作为主键，并指定主键的生成策略。这样，JPA框架能够自动处理主键的生成和维护，简化了开发人员的工作。同时，主键的存在也在数据库层面保证了数据的完整性和唯一性。

@GenerateValue注释简析

@GenerateValue注释是一个自定义注解，它用于Java编程语言中的值生成。它用于标记在运行时动态生成值的方法或字段。该注解提供了一种方便和一致的方式来指示一个值不是硬编码的，而是以编程方式生成的。

当@GenerateValue应用于一个方法时，通常意味着该方法返回的是一个动态生成的值，而不是一个固定的值。这在需要基于某些条件或计算生成值的场景中非常有用。

例如，考虑一个名为generateRandomNumber()的方法，它生成一个指定范围内的随机数。通过将@GenerateValue应用于该方法，清楚地表明该方法返回的值不是常量，而是动态生成的。

同样，当@GenerateValue应用于一个字段时，意味着该字段的值不是固定的，而是在运行时生成的。这在需要根据其他变量或外部因素计算字段值的场景中非常有用。

总的来说，@GenerateValue注释通过明确表示一个值是动态生成的而不是硬编码的方式，有助于提高代码的可读性和可维护性。它还有助于理解被注解代码的目的和行为。

@Table注释简析

@Table是Java Persistence API (JPA) 中的一个注解，用于指定实体类与数据库表之间的映射关系。它可以在实体类上使用，用于定义该实体类在数据库中的表的特性。

@Table注解可用于指定数据库表的名称、模式、索引、唯一约束等属性。通过使用@Table注解，可以自定义实体类与数据库表之间的映射关系，从而实现持久化操作。

常用的@Table注解属性包括：

name：指定数据库表的名称，默认为实体类的名称。
schema：指定数据库表的模式，默认为空。
indexes：指定数据库表的索引，默认为空。
uniqueConstraints：指定数据库表的唯一约束，默认为空。

@Table注解在JPA中扮演着重要的角色，它定义了实体类与数据库表之间的映射关系，使得开发人员可以方便地进行对象持久化操作。同时，通过使用@Table注解，可以灵活地定义数据库表的结构，满足不同的业务需求。

@Override注释简析

@Override是Java中的一个注解，用来标识子类中的方法覆盖了父类中的方法。在面向对象的编程中，方法的覆盖是一种多态的实现方式，可以使子类根据自己的需求重新定义父类中的方法。

@column注释简析

@Column是Java Persistence API (JPA) 中的一个注解，用于指定实体类属性与数据库表中的列之间的映射关系。它可以在实体类的属性上使用，用于定义该属性在数据库表中的列的特性。

@Column注解可用于指定数据库表中的列的名称、数据类型、长度、是否允许为空、是否唯一等属性。通过使用@Column注解，可以自定义实体类属性与数据库表列之间的映射关系，从而实现持久化操作。

常用的@Column注解属性包括：

name：指定数据库表中列的名称，默认为属性名。
nullable：指定列是否允许为空，默认为true。
unique：指定列是否唯一，默认为false。
length：指定列数据类型的长度，默认为255。
precision：指定列的精度，用于数值类型，默认为0。
scale：指定列的小数位数，用于数值类型，默认为0。
columnDefinition：指定列的自定义数据库类型，例如可以指定为VARCHAR(100)。
updatable：指定列是否可更新，默认为true。
insertable：指定属性是否插入数据库，默认为true。

@Column注解在JPA中扮演着重要的角色，它定义了实体类属性与数据库表列之间的映射关系，使得开发人员可以方便地进行对象持久化操作。同时，通过使用@Column注解，可以灵活地定义数据库表的结构，满足不同的业务需求。

StudentRepository类

package com.example.chapter03.Student;

//import org.springframework.data.domain.Example;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

//import java.util.List;

@Repository
public interface StudentRepository extends JpaRepository<student,Integer> {
   // List<student>findByName(String name);
}

@Repository注释简析

@Repository注释是Spring框架的注解之一，它用于将一个类标记为数据访问层（DAO）组件。该注释的作用是将数据访问相关的异常自动转换为Spring的数据访问异常类型。

@Repository注释通常被应用于用于数据库操作的类上，比如与数据库交互的DAO类或Repository类。它与Spring的依赖注入和事务管理相关联，可以让Spring自动管理数据库操作的依赖和事务。

通过将@Repository注释应用于一个类，Spring框架会自动检测到该类，并将其注册为一个可被依赖注入的组件。这样，在其他需要使用该类的地方，可以通过依赖注入的方式获得该类的实例。

另外，@Repository注释还提供了一种异常转换机制。当在@Repository注释标记的类中发生数据访问相关的异常时，Spring会将这些异常转换为Spring框架自定义的数据访问异常类型（例如，DataAccessException）。这样，应用程序可以更好地处理和处理这些异常，并且可以与Spring的其他数据访问功能进行无缝集成。

总的来说，@Repository注释是Spring框架中用于标记数据访问层组件的注释，它实现了依赖注入和异常转换的功能，方便地将数据库操作的实现类纳入到Spring容器中，并提供了更好的异常处理和集成能力。

Chapter03ApplicationTests类

package com.example.chapter03;

import com.example.chapter03.Student.StudentRepository;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.domain.*;
import com.example.chapter03.Student.student;
import org.springframework.stereotype.Component;
import org.springframework.test.annotation.Rollback;
//import org.springframework.test.context.junit4.SpringRunner;

//import javax.persistence.criteria.CriteriaBuilder;
import javax.transaction.Transactional;
import java.time.LocalDate;
import java.util.List;
import java.util.Optional;

@Transactional
@Component
@SpringBootTest
class Chapter03ApplicationTests {

    @Autowired
    private StudentRepository studentRepository;

    @Test
    @Rollback(value = false)
    void testInsert() {
        student student = new student();
        student.setId(5);
        student.setAge(100);
        student.setBirthday(LocalDate.now());
        student.setName("Yangan");
        student.setStu_number("12345678");
        studentRepository.save(student);
    }

    @Rollback(value = false)
    @Test

    void testSelect(){
        Optional<student> optional = studentRepository.findById(1);
        if (optional.isPresent()) {
            student student = optional.get();
            System.out.println(student);
        } else {
        System.out.println("记录不存在"); } }

    @Rollback(value = false)
    @Test
    void testUpdate(){
        student student =new student();
        student.setId(2);
        student.setAge(2);
        student.setStu_number("12345678");
        student.setBirthday(LocalDate.now());
        studentRepository.save(student);
    }

    @Rollback(value = false)
    @Test
    void testDelete(){

        //studentRepository.deleteById(1);

        Optional<student> optional = studentRepository.findById(1);
        if (optional.isPresent()) {
            studentRepository.deleteById(1);
        } else {
            System.out.println("记录不存在");
        }
    }

    @Rollback(value = false)
    @Test
    void testPage(){
        PageRequest pageRequest= PageRequest.of(0,1);
        Page<student> studentPage=studentRepository.findAll(pageRequest);
        List<student>studentList=studentPage.getContent();
        System.out.println(studentList);
    }

    @Rollback(false)
    @Test
    void testExample(){
        student student =new student();
        student.setStu_number("12345678");
        Example<student> example=Example.of(student);
        List<student> studentList=studentRepository.findAll(example);
        System.out.println(studentList);

    }
}

@Transactional注释简析

@Transactional注释是Spring框架的注解之一，用于将一个方法或类标记为事务处理的区域。该注释的作用是告诉Spring框架在方法或类中启用事务管理，以保证在执行期间的数据一致性和事务的正确性。

@Transactional注释可以应用于方法级别和类级别。当应用于方法上时，表示该方法需要在事务的上下文中执行。当应用于类上时，表示该类的所有方法都需要在事务的上下文中执行。

使用@Transactional注释时，可以指定一些参数来配置事务的属性，例如事务的隔离级别、传播行为、只读性等。这些参数可以根据具体的业务需求来灵活配置，以实现不同的事务控制方案。

通过@Transactional注释，Spring框架会在运行时为被注释的方法或类创建一个代理对象，并在方法调用前后进行事务的开启、提交或回滚操作。这样，在方法执行过程中，如果发生异常，事务将会回滚，保证数据的一致性。

总的来说，@Transactional注释是Spring框架中用于标记事务处理的注释，它可以应用于方法和类上，通过提供参数配置来控制事务的属性。使用该注释，可以方便地实现对数据库操作的事务管理，确保数据的一致性和事务的正确性。

@Component注释简析

@Component注释是Spring框架的注解之一，用于标记一个类为Spring的组件。被@Component注释的类会被Spring框架扫描并注册为一个Bean，可以通过ApplicationContext或Autowired注释进行依赖注入和使用。

@Component注释可以用于任何类，包括普通的Java类、控制器、服务类和数据访问对象等。通过使用@Component注释，可以将这些类纳入到Spring的上下文管理中，方便进行管理和使用。

@Component注释有一些特殊的派生注释，例如@Repository、@Service和@Controller。这些注释是@Component的扩展，用于更细粒度地标记不同类型的组件，以便在代码中更好地区分它们的角色和功能。

被@Component注释的类在Spring容器中被创建为单例对象，并可以通过@Autowired注释或其他注释进行依赖注入。Spring会在启动时扫描被@Component注释的类，并将它们实例化并管理起来，使得可以在应用程序的不同部分中共享和使用这些组件。

总的来说，@Component注释是Spring框架中用于标记一个类为Spring组件的注释。被@Component注释的类会被Spring扫描并注册为Bean，可以进行依赖注入和使用。通过使用@Component注释，可以将类纳入到Spring的上下文管理中，方便进行管理和使用。

@SpringBootTest注释简析

@SpringBootTest注释是Spring Boot框架的注释之一，用于测试类上，表示这是一个Spring Boot的集成测试类。被@SpringBootTest注释的类可以使用Spring Boot的自动配置和依赖注入等功能，以实现对应用程序的整体测试。

@SpringBootTest注释会启动Spring Boot应用程序的完整上下文，包括所有的配置和Bean。它会自动加载应用程序的主配置类，并根据配置创建一个模拟的应用程序环境。这个环境与实际应用程序的环境类似，但更加适合测试。

@SpringBootTest注释提供了一组方便的工具和功能，用于编写集成测试。例如，可以使用@AutoConfigureMockMvc注释来自动配置并注入一个MockMvc实例，用于模拟HTTP请求并进行测试。还可以使用@MockBean注释来模拟依赖的Bean，并定义它们的行为。

被@SpringBootTest注释的测试类可以使用Spring Boot的自动配置和依赖注入等功能，因此可以方便地进行集成测试。可以通过注入依赖的Bean，调用其方法并断言其返回值，以验证应用程序的行为是否正确。

总的来说，@SpringBootTest注释是Spring Boot框架中用于标记一个集成测试类的注释。被@SpringBootTest注释的测试类可以使用Spring Boot的自动配置和依赖注入等功能，方便进行集成测试。它提供了一组方便的工具和功能，用于编写和执行集成测试。

@Test注释简析

@Test注释是JUnit测试框架中的一个注释，用于标识一个测试方法。当一个方法使用@Test注释进行标记时，JUnit将会将其识别为一个测试用例，并执行该方法。简而言之，@Test注释用于定义一个单元测试方法。

使用@Test注释的方法应满足以下条件：
1. 方法必须是公共的（public）。
2. 方法不能返回任何值，并且不能接受任何参数。
3. 方法必须使用void关键字进行声明。

除了上述条件外，@Test注释还可以使用一些可选的属性来定制测试行为。一些常用的属性包括：
timeout：指定测试方法的超时时间，单位为毫秒。如果方法执行时间超过指定的超时时间，则测试将被认为失败。
expected：指定方法抛出的异常类型。如果方法抛出了指定的异常，则测试将被认为成功，否则将被认为失败。

使用@Test注释可以帮助开发人员编写可靠的单元测试并提供测试结果的可视化反馈。

@Rollback注释简析

@Rollback注释是Spring测试框架中的一个注释，用于控制测试方法在数据库事务中的回滚行为。当一个测试方法被标记为@Rollback(true)时，测试框架将在测试方法结束后回滚数据库操作，即撤销对数据库的更改。相反，当一个测试方法被标记为@Rollback(false)时，测试框架将不会回滚数据库操作，即保留对数据库的更改。

默认情况下，Spring测试框架会自动开启事务并在测试方法结束后回滚数据库操作，以确保每个测试方法都在一个干净的数据库环境中运行。这样做的好处是，每个测试方法都是独立的，不会受其他测试方法的影响。

使用@Rollback注释可以控制是否在测试方法结束后回滚数据库操作，从而实现一些特殊的测试需求。例如，当需要验证一些数据库操作是否正确时，可以标记@Rollback(false)，以便在测试方法结束后查看数据库的实际更改情况。

使用@Rollback注释可以灵活控制测试方法对数据库的影响，同时确保测试方法的独立性。