spring boot 简单使用jpa

spring boot 整合 jpa

依赖

pom.xml

<properties>
        <java.version>11</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <spring-boot.version>2.3.7.RELEASE</spring-boot.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </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>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </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>

关键jar包：

spring-boot-starter-data-jpa：jpa包

mysql-connector-java：mysql驱动

lombok：pojo类美观

配置文件

application.yml

# 应用名称
spring.application.name=jpa_test
# 应用服务 WEB 访问端口
server.port=8080

spring.datasource.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8&useSSL=false
spring.datasource.username=root
spring.datasource.password=admine
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

spring.jpa.database-platform=org.hibernate.dialect.MySQL5InnoDBDialect
#显示执行的sql语句
spring.jpa.show-sql=true
spring.jpa.hibernate.ddl-auto=update

create:
每次应用启动的时候会重新根据实体建立表，之前的表和数据都会被删除。
create-drop:
和上面的功能一样，但是多了一样，就是在应用关闭的时候，也就是sessionFactory一关闭，会把表删除。
update:
最常用的，第一次启动根据实体建立表结构，之后启动会根据实体的改变更新表结构，之前的数据都在。
validate:
会验证创建数据库表结构，只会和数据库中的表进行比较，不会创建新表，但是会插入新值，运行程序会校验实体字段与数据库已有的表的字段类型是否相同，不同会报错

实体类

User.java

import lombok.Data;

import javax.persistence.*;
import java.io.Serializable;

@Data
@Entity
@Table
public class User implements Serializable {

    private static final long serialVersionUID = 1L;

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

    @Column
    private String name;

    @Column
    private Integer age;

}

@Entity 是一个必选的注解，声明这个类对应了一个数据库表。

@Table(name = “AUTH_USER”) 是一个可选的注解。声明了数据库实体对应的表信息。包括表名称、索引信息等。这里声明这个实体类对应的表名是 AUTH_USER。如果没有指定，则表名和实体的名称保持一致。

@Id 注解声明了实体唯一标识对应的属性。

@Column(length = 32) 用来声明实体属性的表字段的定义。默认的实体每个属性都对应了表的一个字段。字段的名称默认和属性名称保持一致（并不一定相等）。字段的类型根据实体属性类型自动推断。这里主要是声明了字符字段的长度。如果不这么声明，则系统会采用 255 作为该字段的长度

作者：阿土伯已经不是我
链接：https://www.jianshu.com/p/c14640b63653
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

注意这些注解是：javax.persistence.*下的。

repository类

StudentRepository.java

import com.lwf.jpa_test.pojo.Student;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;

import java.util.List;

public interface StudentRepository extends JpaRepository<Student, Void>, JpaSpecificationExecutor<Student> {
   List<Student> findAllBySSEXEquals(String sex);
}

相当于mybatis的mapper，也可以在类上加注解：@Repository

该层扩展了两个接口

JpaRepository:

public interface JpaRepository<T, ID> extends PagingAndSortingRepository<T, ID>, QueryByExampleExecutor<T> {
    List<T> findAll();

    List<T> findAll(Sort var1);

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

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

    void flush();

    <S extends T> S saveAndFlush(S var1);

    void deleteInBatch(Iterable<T> var1);

    void deleteAllInBatch();

    T getOne(ID var1);

    <S extends T> List<S> findAll(Example<S> var1);

    <S extends T> List<S> findAll(Example<S> var1, Sort var2);
}

JpaSpecificationExecutor

public interface JpaSpecificationExecutor<T> {
    Optional<T> findOne(@Nullable Specification<T> var1);

    List<T> findAll(@Nullable Specification<T> var1);

    Page<T> findAll(@Nullable Specification<T> var1, Pageable var2);

    List<T> findAll(@Nullable Specification<T> var1, Sort var2);

    long count(@Nullable Specification<T> var1);
}

查询所有

studentRepository.findAll().forEach(e->{
            System.out.println(e);
        });

查询所有数据加字段排序

可变长Order，Order可指定对应字段ASC还是DESC

studentRepository.findAll(Sort.by("sno").descending()).forEach(System.out::println);

可变长字符串参数，对应Entity属性名，默认升序

studentRepository.findAll(Sort.by("sno")).forEach(System.out::println);

group by，order by等查询

 studentRepository.findAll(new Specification<Student>() {
            @Override
            public Predicate toPredicate(Root<Student> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
                //where sno>=2
                Path<Integer> sno = root.get("sno");
                Predicate gt = criteriaBuilder.greaterThanOrEqualTo(sno,2);
                
                //order by sno desc
                CriteriaQuery<?> orderBy = criteriaQuery.orderBy(new Order() {
                    @Override
                    public Order reverse() {
                        return null;
                    }

                    @Override
                    public boolean isAscending() {
                        return false;
                    }

                    @Override
                    public Expression<?> getExpression() {
                        return sno;
                    }
                });
                //连起来：select * from student where sno>=2  order by desc
                Predicate g = orderBy.where(gt).getGroupRestriction();
                return g;
            }
        }).forEach(System.out::println);

分页

 studentRepository.findAll(new Specification<Student>() {
            @Override
            public Predicate toPredicate(Root<Student> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
                //where sno>=2
                Path<Integer> sno = root.get("sno");
                Predicate gt = criteriaBuilder.greaterThanOrEqualTo(sno,2);
                //order by sno desc
                CriteriaQuery<?> orderBy = criteriaQuery.orderBy(new Order() {
                    @Override
                    public Order reverse() {
                        return null;
                    }

                    @Override
                    public boolean isAscending() {
                        return false;
                    }

                    @Override
                    public Expression<?> getExpression() {
                        return sno;
                    }
                });
                //连起来：select * from student where sno>=2 group by sno order by desc
                Predicate g = orderBy.where(gt).groupBy(sno).getGroupRestriction();
                return g;
            }
        }, PageRequest.of(0,2)).forEach(System.out::println);

分页使用该方法：Page<T> findAll(@Nullable Specification<T> var1, Pageable var2);

Pageable有实现类:PageRequest; PageRequest.of(0,2)等同limit 0,2

在Repository层里自定义方法查询

import com.lwf.jpa_test.pojo.Daxuesheng;
import com.lwf.jpa_test.pojo.Student;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.stereotype.Repository;

import java.util.List;
@Repository
public interface StudentRepository extends JpaRepository<Student, Daxuesheng>, JpaSpecificationExecutor<Student> {

   //select * from student where sex=sex1
   List<Student> findAllBySSEXEquals(String sex1);
   
   //select * from student where sname like %name and sno>= sno1
   List<Student> findStudentsBySNAMEEndsWithAndAndSnoGreaterThanEqual(String name,Integer sno1);
   }