spring-data-jpa 二、多对一结构、Repository

忘是亡心i 2022-01-06 14:57 197阅读 0赞

## 一、Entity ##

例如一个user实体和一个department实体  多个用户对应一个部门

1、user类

@id：声明了一个属性映射到数据库主键字段，主键生成策略有@GenerateValue来指定

@Column：声明了一个字段（字段名可以通过name来自定义）

@ManyToOne：多对一，many指的是定义此类的实体（User），one指的是此注解所注解的属性

@JoinColumn：与@ManyToOne配合使用，说明外键字段是“department\_id”

package com.nxz.blog;
    
    import javax.persistence.*;
    import java.util.Date;
    
    @Entity
    public class User{
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        private Long id;
        @Column
        private String name;
        @Column(name = "create_date")
        private Date createDate;
        
        @ManyToOne
        @JoinColumn(name = "department_id")
        private Department department;
    }

2、department类

@oneToMany：一对多，One指的是次注解所在的实体（department），many是指此注解的属性（User），

在这种一对多的关系映射上，“One”端采用@OneToMany注解是必须使用mapperBy，以声明Many端的对象（这里只User对象）的department属性提供了对应的映射关系

（User为什么使用Set而不是List，这个是jpa要求的，因为Set结构是存放不同元素的集合）

@Entity
    class Department {
        
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        private Integer id;
        @Column
        private String name;
        
        @OneToMany(mappedBy = "department")
        private Set<User> users = new HashSet<>();
    
    }

3、现在越来越多的jpa应用2简化了Entity的定义，去掉了关系映射的相关配置，去掉了数据库外键的设置（类似其他f非ORM），一个表对应一个简单的对象，这样使JPA变得简单

例：（在下边这个User对象中只会用到基本的注解：@Entity、@Id、@GenerateValue、@Column），这样定义Entity，不用理解复杂的映射关系（便于初学者应用）

@Entity
    public class User {
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        private Long id;
        @Column
        private String name;
        @Column(name = "create_date")
        private Date createDate;
        @Column(name = "department_id")
        private Integer departmentId;
    }

@Entity
    class Department {
    
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        private Integer id;
        @Column
        private String name;
    
    }

## 二、Repository ##

1、Repository是SpringData的核心，抽象了对**数据库和nosql**的操作，提供了几个接口：

CurdRepository：提供了基本的增删改查

PagingAndSortingRepository：集成CrudRepository，并提供了分页功能

JPARepository：专门用于JPA，提供了更丰富的数据库访问接口

源码：

CrudRepository：T表示实体，ID表示主键（ID必须实现序列化接口）

import java.util.Optional;
    
    @NoRepositoryBean
    public interface CrudRepository<T, ID> extends Repository<T, ID> {
        <S extends T> S save(S var1);//save方法保存Entity，如果Entity包含主键，SpringData则认为是更新操作
    
        <S extends T> Iterable<S> saveAll(Iterable<S> var1);
    
        Optional<T> findById(ID var1);/根据主键查询实体，返回Optional对象
    
        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();
    }

PagingAndSortingRepository：

PageAble是用于构造分页查询的接口，其实现类是PageRequest

import org.springframework.data.domain.Page;
    import org.springframework.data.domain.Pageable;
    import org.springframework.data.domain.Sort;
    
    @NoRepositoryBean
    public interface PagingAndSortingRepository<T, ID> extends CrudRepository<T, ID> {
        Iterable<T> findAll(Sort var1);
    
        Page<T> findAll(Pageable var1);
    }

JpaRepository：Example是SpringData提供的用来构造查询条件的对象

import java.util.List;
    import org.springframework.data.domain.Example;
    import org.springframework.data.domain.Sort;
    import org.springframework.data.repository.NoRepositoryBean;
    import org.springframework.data.repository.PagingAndSortingRepository;
    import org.springframework.data.repository.query.QueryByExampleExecutor;
    
    @NoRepositoryBean
    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);
    }

2、例

最简单的Repository就是直接继承一个接口，下边这个即可实现简单的增删改查

import org.springframework.data.jpa.repository.JpaRepository;
    
    public interface U1tsRepository extends JpaRepository<User,Integer> {
        
    }

如果需要自定义查询，可以新增基于方法名字的查询：（方法的参数和方法名需要遵循一定的规则，spirngData才能自动转化为sql），

方法名之间可以用And或Or连接

public interface U1tsRepository extends JpaRepository<U1ts, Integer> {
        U1ts findByName(String name);//方法名是根据查询对象的属性类定义的
    }

3、JPA使用@Query注解，手动写JPQL

@Query("select u from User u where u.name = ?1 and u.department.id = ?2")
        User findUser(String name,Integer departmentId);

4、如果手写sql，也可以在@Query注解中添加nativeQuery参数

@Query(value = "select * from user where name = ?1 and department_id = ?2",nativeQuery = true)
        User findUser1(String name,Integer departmentId);

5、命名参数（sql和jpql都支持）

@Query(value = "select * from user where name = :name and department_id = :departmentId",nativeQuery = true)
        User findUser2(String name,Integer departmentId);

6、如果查询结果不是Entity对象，也可以用Object【】数组代替

7、分页

@Query(value = "select * from user where name = :name and department_id = :departmentId",nativeQuery = true)
        User findUser2(String name, Integer departmentId, Pageable pageable);

8、跟新删除

@Modifying//更新和删除必须加modifying注解
        @Query("update User u set u.name = ?1 where u.id = ?2")
        User updateUser(String name, Integer id);

## 三、EntityManager ##

EntityManger提供了实体操作的所有接口，可以通过@Autowired注入到类中

作用:弥补Repository在复杂查询上的不足

转载于:https://www.cnblogs.com/nxzblogs/p/10744649.html