【SpringBoot框架篇】11.Spring Data Jpa实战

深碍√TFBOYSˉ_ 2023-02-11 13:30 40阅读 0赞

### 文章目录 ###

*  简介
 *   *  JPA
     *  Spring Data Jpa
     *  Hibernate
     *  Jpa、Spring Data Jpa、Hibernate三者之间的关系
 *  引入依赖
 *  配置文件
 *  实体类常用注解
 *   *  @Entity和@Table
     *  @Index
     *  @Id和@GeneratedValue
     *  @Column
     *  @Transient
     *  @Where
     *  @OrderBy
 *  继承超类的通用字段属性
 *   *  @MappedSuperclass
     *  @Inheritance
 *  审计功能
 *   *  启用审计功能
     *  审计功能注解
     *  添加审计人
     *  复合主键
 *  Spring Data Jpa 接口使用详解
 *   *  JpaRepository默认提供的方法
     *  查询创建Query Creation
     *  自定义查询@Query
     *   *  位置参数绑定
         *  命名参数绑定
         *  原生查询Native Queries
         *  删除修改操作
     *  分页查询
     *  使用Specification进行动态参数查询
     *  复杂的原生sql查询
 *  级联加载信息
 *   *  一对一
     *  一对多
     *  多对一
     *  多对多
     *  不生成外键
 *  开启jpa SaveAll批量新增或修改操作
 *   *  配置文件
     *  测试代码
     *  开启批处理前
     *  开启批处理后
 *  项目配套代码

# 简介 #

首先了解一下 JPA,Spring Data Jpa，之间的关系

## JPA ##

JPA是Java Persistence API的简称，中文名Java持久层API，是JDK 5.0注解或XML描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中。Sun引入新的JPA ORM规范出于两个原因：其一，简化现有Java EE和Java SE应用开发工作；其二，Sun希望整合ORM技术，实现天下归一。  
JPA包括以下3方面的技术：

*  ORM映射元数据： 支持XML和注解两种元数据的形式，元数据描述对象和表之间的映射关系
 *  API： 操作实体对象来执行CRUD操作
 *  查询语言： 通过面向对象而非面向数据库的查询语言（JPQL）查询数据，避免程序的SQL语句紧密耦合

## Spring Data Jpa ##

下面引入官网的介绍  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmcxOTk1MTIyNA_size_16_color_FFFFFF_t_70]

## Hibernate ##

Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，它将POJO与数据库表建立映射关系，是一个全自动的orm框架，hibernate可以自动生成SQL语句，自动执行，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也可以在Servlet/JSP的Web应用中使用，最具革命意义的是，Hibernate可以在应用EJB的JaveEE架构中取代CMP，完成数据持久化的重任

## Jpa、Spring Data Jpa、Hibernate三者之间的关系 ##

Hibernate是Spring Data Jpa的默认实现方式  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmcxOTk1MTIyNA_size_16_color_FFFFFF_t_70 1]

# 引入依赖 #

<dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-jpa</artifactId>
            </dependency>
                
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>8.0.11</version>
            </dependency>

# 配置文件 #

server:
      port: 8011
    
    spring:
      datasource:
        driver-class-name: com.mysql.cj.jdbc.Driver
        url: jdbc:mysql://localhost:3306/jpa_db?createDatabaseIfNotExist=true&useSSL=false&serverTimezone=GMT%2b8&characterEncoding=utf8&connectTimeout=10000&socketTimeout=3000&autoReconnect=true&rewriteBatchedStatements=true
        username: root
        password: 123456
      jpa:
        database: mysql
        show-sql: true
        hibernate:
          #自动创建或修改表结构
          ddl-auto: update
          naming:
            physical-strategy: org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl
        properties:
          hibernate:
            #设置hibernate方言使用mysql的InnoDBD引擎,InnoDBD支持事务
            dialect: org.hibernate.dialect.MySQL5InnoDBDialect
            #启用懒加载
            enable_lazy_load_no_trans: true

# 实体类常用注解 #

## @Entity和@Table ##

@Entity
    @Table(name = "sys_user")
    public class User{ }

*  @Entity 表明该类 (User) 为一个实体类，它默认对应数据库中的表名是user。这里也可以写成  
    @Entity(name = “sys\_user”)  
    或者  
    @Entity  
    @Table(name = “user”)
 *  @Table 当实体类与其映射的数据库表名不同名时需要使用 @Table注解说明，该标注与 @Entity 注解并列使用

## @Index ##

@Index注解用来添加表的索引，可以指定单个字段和多个字段,多个字段之间用 ’ **,** ’ 隔开

@Entity
    @Table(name = "sys_user",indexes = { 
            @Index(name = "username",  columnList = "username"),
            @Index(name = "address_age",  columnList = "address,age")
    }
    public class User{ 
    	  private String username;
    	  private String address;
    	  private Integer age;
    }

## @Id和@GeneratedValue ##

*  @Id 标识此字段是主键
 *  @GeneratedValue 设置主键的自增策略,默认是**AUTO**
    
     *  TABLE 使用一个特定的数据库表格来保存主键。
     *  SEQUENCE 根据底层数据库的序列来生成主键，条件是数据库支持序列。
     *  IDENTITY 主键由数据库自动生成（主要是自动增长型）
     *  AUTO 主键由程序控制。

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

## @Column ##

@Column 注释定义了将成员属性映射到关系表中的哪一列和该列的结构信息，属性如下：

<table> 
 <thead> 
  <tr> 
   <th>属性名</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>name</td> 
   <td>映射的列名。如：映射tbl_user表的name列，可以在name属性的上面或getName方法上面加入；</td> 
  </tr> 
  <tr> 
   <td>unique</td> 
   <td>是否唯一；</td> 
  </tr> 
  <tr> 
   <td>nullable</td> 
   <td>是否允许为空；</td> 
  </tr> 
  <tr> 
   <td>length</td> 
   <td>对于字符型列，length属性指定列的最大字符长度；</td> 
  </tr> 
  <tr> 
   <td>insertable</td> 
   <td>是否允许插入；</td> 
  </tr> 
  <tr> 
   <td>updatable</td> 
   <td>是否允许更新；</td> 
  </tr> 
 </tbody> 
</table>

@Column(name = "username", unique = true, nullable = false,updatable = false,length = 36)
        private String username;

## @Transient ##

@Transien就是在给某个javabean上需要添加个属性，但是这个属性你又不希望给存到数据库中去，仅仅是做个临时变量，用一下。不修改已经存在数据库的数据的数据结构。

@Transient
        private String ignoreColumn;

## @Where ##

@Where可以在级联加载数据的时候根据条件筛选数据

public class OcrFileInfo{ 
        private Integer page;
    }
    @OneToMany(fetch = FetchType.LAZY)
    @JoinColumn(name="fileId",insertable = false, updatable = false)
    //只查询page字段1~5页的数据
    @Where(clause="page between 1 and 5")
    List<OcrFileInfo> ocrFileInfos;

## @OrderBy ##

根据字段排序

public class OcrFileInfo{ 
        private Integer filed1;
        private Integer filed2;
    }
    //根据filed1字段升序排序,然后根据filed2字段降序排序
    @OrderBy("filed1,filed2 desc")
    List<OcrFileInfo> ocrFileInfos;

# 继承超类的通用字段属性 #

@Inheritance(strategy= InheritanceType.TABLE_PER_CLASS)//选择继承策略
    @MappedSuperclass
    public class BaseModel implements Serializable { 
    	
    	@Id
        @GeneratedValue(strategy=GenerationType.IDENTITY)
        private Integer id;
    	private Date createdDate;
    }
    @Entity
    @Table(name = "sys_user")
    public class User extends  BaseModel{ 
    	//这里就不用再写通用的字段了。
    }

## @MappedSuperclass ##

*  标注为@MappedSuperclass的类将不是一个完整的实体类，他将不会映射到数据库表，但是他的属性都将映射到其子类的数据库字段中。
 *  .标注为@MappedSuperclass的类不能再标注@Entity或@Table注解，也无需实现序列化接口。  
    我们可以把一些通用的表字段放到超类中定义

## @Inheritance ##

Hibernate继承映射在 Annotation 中使用 @Inheritance 注解，并且需要使用 strategy 属性指定继承策略，继承策略有 SINGLE\_TABLE、TABLE\_PER\_CLASS 和 JOINED 三种。

*  SINGLE\_TABLE 是将父类和其所有的子类集合在一块，存在一张表中，并创建一个新的字段来判断对象的类型。
 *  TABLE\_PER\_CLASS 是为每一个类创建一个表，这些表是相互独立的。
 *  JOINED 是将父类、子类分别存放在不同的表中，并且建立相应的外键，以确定相互之间的关系

# 审计功能 #

我们一般对记录的创建和修改需要手动set操作时间  
user.setCreateDate(new Date());  
但是通过使用Jpa的审计功能,就可以交给Jpa去实现了.

## 启用审计功能 ##

**在启动类里添加注解**

@EnableJpaAuditing
    public class SpringDatajpaApplication { }

**在需要使用的类上面添加审计监听器**  
在需要使用审计功能的类上面加@EntityListeners注解指定监听类为AuditingEntityListener  
一般我们会这些审计的通用字段放到超类里面

@EntityListeners(AuditingEntityListener.class)
    public class BaseModel { }

## 审计功能注解 ##

*  @CreatedDate 在记录创建的时候自动插入创建时间
 *  @CreatedBy 在记录创建的时候自动插入创建者名称
 *  @LastModifiedDate 在记录修改的时候自动修改操作 时间
 *  @LastModifiedBy 在记录修改的时候自动修改修改者名称

## 添加审计人 ##

我这里写死了是admin，实际使用场景应该获取当前登录人的用户名

@Component
    public class AuditorAwareImpl implements AuditorAware<String> { 
        @Override
        public Optional<String> getCurrentAuditor() { 
            return Optional.of("admin");
        }
    }

@Inheritance(strategy= InheritanceType.TABLE_PER_CLASS)//选择继承策略
    @MappedSuperclass
    @EntityListeners(AuditingEntityListener.class)
    public class BaseModel implements Serializable { 
        @CreatedDate
        @Column(name = "created_date", updatable = false)
        private Date createdDate;
    
        @CreatedBy
        @Column(name = "created_by", updatable = false, length = 64)
        private String createdBy;
    
        @LastModifiedDate
        @Column(name = "updated_date")
        private Date updatedDate;
    
        @LastModifiedBy
        @Column(name = "updated_by", length = 64)
        private String updatedBy;
    }
    @Entity
    @Table(name = "sys_user")
    @Data
    public class User  extends  BaseMode｛
    ｝

下面我插入一条数据,能看到审计字段也都自动插入了.  
![在这里插入图片描述][2020052402130193.png]  
![在这里插入图片描述][20200524021244570.png]

## 复合主键 ##

在我们的日常开发中，有时候会用到数据库进行设计的时候，采用了复合主键来来保证唯一性，  
hibernate的 **@EmbeddedId** 嵌入式主键应用于实体类或映射超类的持久字段或属性，以表示可嵌入类的组合主键。 可嵌入的类必须标注为 **@Embeddable** 下面介绍一下采用  
下面以用户角色关联表介绍.

@Entity
    @Table(name = "user_role")
    @Data
    public class UserRole { 
    
        public UserRole(){  }
    
        public UserRole(Integer userId, Integer roleId){ 
        this.id=new PK(userId,roleId);
        }
        
        @EmbeddedId
        private PK id;
        
        /** * 联合主键 */
        @Embeddable
        @Data
        public static class PK implements Serializable { 
    
            public PK() {  }
    
            public PK(int userId, Integer roleId) { 
                this.userId = userId;
                this.roleId = roleId;
            }
            /** * 用户id */
            private Integer userId;
    
            /** * 角色id */
            private Integer roleId;
      }
    }

# Spring Data Jpa 接口使用详解 #

创建一个接口,然后继承JpaRepository<T,ID>,T是表对应的实体类,ID是主键的类型

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

## JpaRepository默认提供的方法 ##

我这边列出了一些常用的方法  
@Autowired  
UserRepository userRepository;  
userRepository.findAll();  
下面的方法可以直接通过**userRepository**直接调用

//查询所有信息
     	List<T> findAll();
     	//保存并且刷新
        <S extends T> S saveAndFlush(S var1);
      	//根据主键删除
        void deleteById(ID var1);
        //根据实体对象删除
        void delete(T var1);
        //根据主键获取对象信息
        T getOne(ID var1);
        //添加或则修改
    	<S extends T> S save(S var1);

## 查询创建Query Creation ##

Spring Data Jpa通过解析方法名创建查询，框架在进行方法名解析时，会先把方法名多余的前缀find…By, read…By, query…By, count…By以及get…By截取掉，然后对剩下部分进行解析，第一个By会被用作分隔符来指示实际查询条件的开始。 我们可以在实体属性上定义条件，并将它们与And和Or连接起来，从而创建大量查询：

<table> 
 <thead> 
  <tr> 
   <th>关键字</th> 
   <th>示例</th> 
   <th>JPQL</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>And</td> 
   <td>findByLastnameAndFirstname</td> 
   <td>… where x.lastname = ?1 and x.firstname = ?2</td> 
  </tr> 
  <tr> 
   <td>Or</td> 
   <td>findByLastnameOrFirstname</td> 
   <td>… where x.lastname = ?1 or x.firstname = ?2</td> 
  </tr> 
  <tr> 
   <td>Is,Equals</td> 
   <td>findByFirstnameIs,findByFirstnameEquals</td> 
   <td>… where x.firstname = ?1</td> 
  </tr> 
  <tr> 
   <td>Between</td> 
   <td>findByStartDateBetween</td> 
   <td>… where x.startDate between ?1 and ?2</td> 
  </tr> 
  <tr> 
   <td>LessThan</td> 
   <td>findByAgeLessThan</td> 
   <td>… where x.age &lt; ?1</td> 
  </tr> 
  <tr> 
   <td>LessThanEqual</td> 
   <td>findByAgeLessThanEqual</td> 
   <td>… where x.age ⇐ ?1</td> 
  </tr> 
  <tr> 
   <td>GreaterThan</td> 
   <td>findByAgeGreaterThan</td> 
   <td>… where x.age &gt; ?1</td> 
  </tr> 
  <tr> 
   <td>GreaterThanEqual</td> 
   <td>findByAgeGreaterThanEqual</td> 
   <td>… where x.age &gt;= ?1</td> 
  </tr> 
  <tr> 
   <td>After</td> 
   <td>findByStartDateAfter</td> 
   <td>… where x.startDate &gt; ?1</td> 
  </tr> 
  <tr> 
   <td>Before</td> 
   <td>findByStartDateBefore</td> 
   <td>… where x.startDate &lt; ?1</td> 
  </tr> 
  <tr> 
   <td>IsNull</td> 
   <td>findByAgeIsNull</td> 
   <td>… where x.age is null</td> 
  </tr> 
  <tr> 
   <td>IsNotNull,NotNull</td> 
   <td>findByAge(Is)NotNull</td> 
   <td>… where x.age not null</td> 
  </tr> 
  <tr> 
   <td>Like</td> 
   <td>findByFirstnameLike</td> 
   <td>… where x.firstname like ?1</td> 
  </tr> 
  <tr> 
   <td>NotLike</td> 
   <td>findByFirstnameNotLike</td> 
   <td>… where x.firstname not like ?1</td> 
  </tr> 
  <tr> 
   <td>StartingWith</td> 
   <td>findByFirstnameStartingWith</td> 
   <td>… where x.firstname like ? (parameter bound with appended %)</td> 
  </tr> 
  <tr> 
   <td>EndingWith</td> 
   <td>findByFirstnameEndingWith</td> 
   <td>… where x.firstname like ? (parameter bound with prepended %)</td> 
  </tr> 
  <tr> 
   <td>Containing</td> 
   <td>findByFirstnameContaining</td> 
   <td>… where x.firstname like ?1 (parameter bound wrapped in %)</td> 
  </tr> 
  <tr> 
   <td>OrderBy</td> 
   <td>findByAgeOrderByLastnameDesc</td> 
   <td>… where x.age = ?1 order by x.lastname desc</td> 
  </tr> 
  <tr> 
   <td>Not</td> 
   <td>findByLastnameNot</td> 
   <td>… where x.lastname &lt;&gt; ?1</td> 
  </tr> 
  <tr> 
   <td>In</td> 
   <td>findByAgeIn(Collection ages)</td> 
   <td>… where x.age in ?1</td> 
  </tr> 
  <tr> 
   <td>NotIn</td> 
   <td>findByAgeNotIn(Collection age)</td> 
   <td>… where x.age not in ?1</td> 
  </tr> 
  <tr> 
   <td>TRUE</td> 
   <td>findByActiveTrue()</td> 
   <td>… where x.active = true</td> 
  </tr> 
  <tr> 
   <td>FALSE</td> 
   <td>findByActiveFalse()</td> 
   <td>… where x.active = false</td> 
  </tr> 
  <tr> 
   <td>IgnoreCase</td> 
   <td>findByFirstnameIgnoreCase</td> 
   <td>… where UPPER(x.firstame) = UPPER(?1)</td> 
  </tr> 
 </tbody> 
</table>

## 自定义查询@Query ##

### 位置参数绑定 ###

下标重1开始

@Query("select u from User u where u.username = ?1 and u.password = ?2")
    		User getByUsernameAndPassword(String username, String password);

### 命名参数绑定 ###

@Query("select u from User u where u.username = :username and u.password = :password")
    		User getByUsernameAndPassword(@Param("username")String username,@Param("password") String password);

### 原生查询Native Queries ###

需要在@Query注解中加nativeQuery = true  
注意,from后面对应的是表名称，而不是实体类的名称

@Query(value = "select u.* from sys_user u where u.username = :username and u.password = :password",nativeQuery = true)
    	    User getByUsernameAndPasswordSQl(@Param("username")String username,@Param("password") String password);

### 删除修改操作 ###

单独使用@Query注解只是查询，如涉及到修改、删除则需要再加上@Modifying和@Transactional注解

@Transactional
    	    @Modifying
    	    @Query("delete from User where id=?1")
    	    void deleteByUserId(Integer id);

## 分页查询 ##

Page<User> findAllByUsernameLike(String username, Pageable pageable);

构建Pageable 对象的方法

<table> 
 <thead> 
  <tr> 
   <th>参数</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>page</td> 
   <td>页码,重0开始</td> 
  </tr> 
  <tr> 
   <td>size</td> 
   <td>每页显示的数量</td> 
  </tr> 
  <tr> 
   <td>direction</td> 
   <td>排序类型, Sort.Direction.DESC是降序,Sort.Direction.ASC是升序</td> 
  </tr> 
  <tr> 
   <td>properties</td> 
   <td>排序的字段,可变参数。</td> 
  </tr> 
 </tbody> 
</table>

//2.0版本之前
    		new PageRequest(int page, int size);
    		new PageRequest(int page, int size, Direction direction,String... properties);
    		//2.0版本之后 
    		PageRequest.of(int page, int size);
    		PageRequest.of(int page, int size, Direction direction, String... properties);

完整代码

Pageable pageable = PageRequest.of(0, 10, Sort.Direction.ASC, "id");
            Page<User> userPage = userRepository.findAllByUsernameLike("user%", pageable);
            System.out.println("总记录数"+userPage.getTotalElements()+",总页数"+userPage.getTotalPages());
            for (User user : userPage.getContent()) { 
                System.out.println(user.getUsername());
            }

## 使用Specification进行动态参数查询 ##

对于查询条件不固定的情况下,JPQL实现不了这种情况，这个时候要继承**JpaSpecificationExecutor**  
接口来实现动态参数查询了.  
JpaSpecificationExecutor接口主要的2个方法

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

首先继承JpaSpecificationExecutor接口

public interface UserRepository extends JpaRepository<User,Integer>, JpaSpecificationExecutor { }

然后组装Specification对象

String startDate = "2020-05-22";
            String endDate = "2020-05-25";
            String username = "dominick";
            Specification<User> querySpecifi = new Specification<User>() { 
                @Override
                public Predicate toPredicate(Root<User> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder cb) { 
                    List<Predicate> predicates = new ArrayList<>();
                    if (!StringUtils.isEmpty(startDate)) { 
                        //大于或等于传入时间
                        predicates.add(cb.greaterThanOrEqualTo(root.get("createDate").as(String.class), startDate));
                    }
                    if (!StringUtils.isEmpty(endDate)) { 
                        //小于或等于传入时间
                        predicates.add(cb.lessThanOrEqualTo(root.get("endDate").as(String.class), endDate)));
                    }
                    if (!StringUtils.isEmpty(username)) { 
                        //模糊查询,需要自己手动拼接%%字符
                        predicates.add(cb.like(root.get("username").as(String.class), "%" + username + "%"));
                    }
                    // and到一起的话所有条件就是且关系，or就是或关系
                    return cb.and(predicates.toArray(new Predicate[predicates.size()]));
                }
            };
            List<User> userList = userRepository.findAll(querySpecifi);

## 复杂的原生sql查询 ##

通过**EntityManagerFactory**构建原生sql查询  
下面只是简单的示范了怎么用,然后可以根据需求写对应的sql,能用sql解决的都不是难事。。

public interface UserCustomRepository { 
        List<Object[]> findBynativeQuery(User user);
    }
    
    @Component
    public class UserCustomImplRepsotory implements UserCustomRepository { 
    
        private EntityManagerFactory emf;
    
        @PersistenceUnit
        public void setEntityManagerFactory(EntityManagerFactory emf) { 
            this.emf = emf;
        }
    
        @Override
        public List<Object[]> findBynativeQuery(User user) { 
            EntityManager em = emf.createEntityManager();
            try { 
                Query query = null;
                StringBuilder sql = new StringBuilder("select * from sys_user where 1=1 ");
                List<Object> condition = new ArrayList<>();
                int index = 0;
                if (!StringUtils.isEmpty(user.getUsername())) { 
                    index++;
                    condition.add(user.getUsername());
                    sql.append(" and username=?" + index);
                }
                if (!StringUtils.isEmpty(user.getChannelId())) { 
                    index++;
                    condition.add(user.getChannelId());
                    sql.append(" and channelId=?" + index);
                }
                //创建query对象
                query = em.createNativeQuery(sql.toString());
                //注入参数
                if (index != 0) { 
                    for (int i = 1; i <= index; i++) { 
                        //query的parameter 下标起始位置重1开始的
                        query.setParameter(i, condition.get(i - 1));
                    }
                }
                List<Object[]> success = query.getResultList();
                em.close();
                return success;
            } finally { 
                if (em != null) { 
                    em.close();
                }
            }
        }
    }

调用代码

@Autowired
    	    UserCustomImplRepsotory userCustomImplRepsotory;
       
      		User user=new User();
            user.setUsername("dominick_li");
            user.setChannelId(1);
            List<Object[]>  list=userCustomImplRepsotory.findBynativeQuery(user);
            for(Object[] objs:list){ 
                System.out.println(objs[0]+","+objs[1]);
            }

# 级联加载信息 #

下面级联查询我都用了懒加载  
**fetch = FetchType.LAZY**  
需要在配置文件把懒加载的开关打开

spring.jpa.properties.hibernate.enable_lazy_load_no_trans=true #开启懒加载

## 一对一 ##

使用@OneToOne注解实现一对一的关系映射  
@JoinColumn中的name标识当前实体的外键字段,referencedColumnName标识用户表roleId和Role表的关联字段。  
我这里用 用户表和角色表介绍，省略了其它字段和注解，只描述重点

public class User { 
    	private Integer roleId;
    	@OneToOne(fetch = FetchType.LAZY)
        @JoinColumn(name="roleId",referencedColumnName="id",insertable = false, updatable = false)
        private Role role;
    }
    public class Role(
    	private Integer id;
    	private String roleName;
    )

用户表数据  
![在这里插入图片描述][20200524134752722.png]  
角色表数据  
![在这里插入图片描述][20200524120211902.png]  
测试结果

User user=userRepository.getOne(id);;
           System.out.println("角色名称是:"+user.getRole().getRoleName());

![在这里插入图片描述][2020052412023526.png]

## 一对多 ##

一对多使用 **@OneToMany** 注解实现一对一关系映射  
**@JoinColumn** name属性指的是多的一方外键，也就是用户表的channelId属性,referencedColumnName表示当前类和用户类关联的列,默认是主键  
我这里使用渠道表和用户表介绍

public class User { 
    	private Integer channelId;
    }
    public class Channel { 
    	
        private Integer id;
        private String channelName;
    
        @OneToMany(fetch = FetchType.LAZY)
        @JoinColumn(name="channelId")
        private List<User> users;
    }

渠道表数据  
![在这里插入图片描述][20200524134850543.png]  
用户表数据  
![在这里插入图片描述][20200524134948790.png]  
测试级联查询

Channel channel = channelRepository.getOne(id);
            System.out.println(channel.getChannelName() + "有" + channel.getUsers().size() + "个用户");

![在这里插入图片描述][20200524135103839.png]

## 多对一 ##

多对一使用 **@ManyToOne** 注解进行关系映射  
**@JoinColumn** name属性指的是多的一方外键，也就是user表的channelId属性,referencedColumnName表示渠道表和用户关联的列,默认是主键  
我这里使用用户表和渠道表作介绍

public class User{ 
    	 private Integer id;
    	 private Integer channelId;
    	  @ManyToOne(fetch = FetchType.LAZY)
        @JoinColumn(name="channelId",referencedColumnName="id",insertable = false, updatable = false)
        private Channel channel;
    }
    
    private class Channel{ 
    	private Intger id;
    	private String channelName;
    }

用户表数据  
![在这里插入图片描述][20200524140110832.png]  
渠道表数据  
![在这里插入图片描述][20200524140130723.png]  
测试级联加载结果

User user=userRepository.getOne();
            System.out.println("渠道名称是:"+user.getChannel().getChannelName());

![在这里插入图片描述][2020052414030510.png]

## 多对多 ##

多对多关系用 @ManyToMany 注解进行关系映射  
还需要依赖@JoinTable注解关联 关系表

public  class User{ 
    	private int id;
    	@ManyToMany(fetch = FetchType.LAZY)
        @JoinTable(
                name = "user_role", joinColumns = { @JoinColumn(name = "userId")},
                inverseJoinColumns = { @JoinColumn(name = "roleId")})
        private List<Role> roles;
    }
    public class Role{ 
    	private int id;
    }
    
    public class UserRole{ 
    	private Intger userId;
    	private Intger roleId;
    }

用户表  
![在这里插入图片描述][20200524143734460.png]  
角色表  
![在这里插入图片描述][20200524143808185.png]  
用户角色关系表  
![在这里插入图片描述][20200524143835582.png]  
测试级联加载结果

User user=userRepository.getOne();
           System.out.println("用户拥有:"+user.getRoles().size()+"个角色");

![在这里插入图片描述][20200524144011442.png]

## 不生成外键 ##

可以根据需求决定是否取消外键的生成,在@JoinColumn注解中添加**foreignKey = @ForeignKey(name = “null”, value = ConstraintMode.NO\_CONSTRAINT)**

public class Menu{ 
    private Integer id;
    private Integer parentId;
    @OneToMany(fetch = FetchType.LAZY)
    @JoinColumn(name="parentId",referencedColumnName="id",foreignKey =  @ForeignKey(name = "null", value = ConstraintMode.NO_CONSTRAINT) )
    private List<Menu> children;
    }

# 开启jpa SaveAll批量新增或修改操作 #

jpa默认的saveAll是在里面通关while不停的调用 save方法,假设要添加500条数据,则需要  
执行500条insert语句才能完成操作,sql执行时间会长,jpa提供了批量执行sql的功能,下面  
我来带大家开启批处理功能  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmcxOTk1MTIyNA_size_16_color_FFFFFF_t_70 2]

## 配置文件 ##

spring:
      jpa:
        properties:
          hibernate:
            jdbc:
              batch_size: 50
            #检测批处理开关是否打开
            generate_statistics: true

<table> 
 <thead> 
  <tr> 
   <th>属性</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>batch_size</td> 
   <td>设置批处理一次处理多少条数据,如果大小设置为50,假设执行saveAll的数据300条,则需要执行6次sql才能处理完请求。</td> 
  </tr> 
  <tr> 
   <td>generate_statistics</td> 
   <td>是否检测批处理开关是否打开</td> 
  </tr> 
 </tbody> 
</table>

## 测试代码 ##

> 注意: 如果设置主键为自增类型,则批处理还是会失效。如果想使用批处理,尽量用雪花算法生成ID或者UUID

Model

@Entity
    @Table(name = "orders")
    @Data
    public class Orders  { 
        @Id
        private String id;
        private String orderName;
    }

Dao层

public interface OrdersRepository extends JpaRepository<Orders,String> { 
    }

web层

@RestController
    public class OrdersController { 
        @Autowired
        OrdersRepository ordersRepository;
        @RequestMapping("/saveAll")
        public String saveAll(){ 
            Orders orders=null;
            List<Orders> ordersList=new ArrayList<>(100);
            for(int i=0;i<300;i++){ 
                orders=new Orders();
                //订单表的主键应该使用雪花算法之类生成,雪花算法生成的id是有序的，这样索引查询起来会快很多,uuid是无序的,查询效率极低。。。。
                orders.setId(UUID.randomUUID().toString());
                orders.setOrderName("订单_"+1);
                ordersList.add(orders);
            }
            ordersRepository.saveAll(ordersList);
            return "success";
        }
    
    }

## 开启批处理前 ##

SQL Stat View JSON API 是druid连接池的一个监控工具,我会在下一章博客教大家使用  
可以看到下面执行数是**300**  
![在这里插入图片描述][20200524165115914.png]

## 开启批处理后 ##

可以看到sql执行数是**6**,和我们预期的一致。  
![在这里插入图片描述][20200524165223419.png]  
下面是控制打印的  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmcxOTk1MTIyNA_size_16_color_FFFFFF_t_70 3]

# 项目配套代码 #

[github地址][github]

创作不易,要是觉得我写的对你有点帮助的话,麻烦在github上帮我点下 **Star**

【SpringBoot框架篇】其它文章如下,后续会继续更新。

*  [1.搭建第一个springboot项目][1._springboot]
 *  [2.Thymeleaf模板引擎实战][2.Thymeleaf]
 *  [3.优化代码,让代码更简洁高效][3.]
 *  [4.集成jta-atomikos实现分布式事务][4._jta-atomikos]
 *  [5.分布式锁的实现方式][5.]
 *  [6.docker部署,并挂载配置文件到宿主机上面][6.docker]
 *  [7.项目发布到生产环境][7.]
 *  [8.搭建自己的spring-boot-starter][8._spring-boot-starter]
 *  [9.dubbo入门实战][9.dubbo]
 *  [10.API接口限流实战][10.API]
 *  [11.Spring Data Jpa实战][11.Spring Data Jpa]
 *  [12.使用druid的monitor工具查看sql执行性能][12._druid_monitor_sql]
 *  [13.使用springboot admin对springboot应用进行监控][13._springboot admin_springboot]
 *  [14.mybatis-plus实战][14.mybatis-plus]
 *  [15.使用shiro对web应用进行权限认证][15._shiro_web]
 *  [16.security整合jwt实现对前后端分离的项目进行权限认证][16.security_jwt]
 *  [17.使用swagger2生成RESTful风格的接口文档][17._swagger2_RESTful]
 *  [18.使用Netty加websocket实现在线聊天功能][18._Netty_websocket]
 *  [19.使用spring-session加redis来实现session共享][19._spring-session_redis_session]
 *  [20.自定义@Configuration配置类启用开关][20._Configuration]
 *  [21.对springboot框架编译后的jar文件瘦身][21._springboot_jar]
 *  [22.集成RocketMQ实现消息发布和订阅][22._RocketMQ]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmcxOTk1MTIyNA_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200524000243295.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmcxOTk1MTIyNA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmcxOTk1MTIyNA_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200524000617407.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmcxOTk1MTIyNA==,size_16,color_FFFFFF,t_70
[2020052402130193.png]: https://img-blog.csdnimg.cn/2020052402130193.png
[20200524021244570.png]: https://img-blog.csdnimg.cn/20200524021244570.png
[20200524134752722.png]: https://img-blog.csdnimg.cn/20200524134752722.png
[20200524120211902.png]: https://img-blog.csdnimg.cn/20200524120211902.png
[2020052412023526.png]: https://img-blog.csdnimg.cn/2020052412023526.png
[20200524134850543.png]: https://img-blog.csdnimg.cn/20200524134850543.png
[20200524134948790.png]: https://img-blog.csdnimg.cn/20200524134948790.png
[20200524135103839.png]: https://img-blog.csdnimg.cn/20200524135103839.png
[20200524140110832.png]: https://img-blog.csdnimg.cn/20200524140110832.png
[20200524140130723.png]: https://img-blog.csdnimg.cn/20200524140130723.png
[2020052414030510.png]: https://img-blog.csdnimg.cn/2020052414030510.png
[20200524143734460.png]: https://img-blog.csdnimg.cn/20200524143734460.png
[20200524143808185.png]: https://img-blog.csdnimg.cn/20200524143808185.png
[20200524143835582.png]: https://img-blog.csdnimg.cn/20200524143835582.png
[20200524144011442.png]: https://img-blog.csdnimg.cn/20200524144011442.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmcxOTk1MTIyNA_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200524163651113.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmcxOTk1MTIyNA==,size_16,color_FFFFFF,t_70
[20200524165115914.png]: https://img-blog.csdnimg.cn/20200524165115914.png
[20200524165223419.png]: https://img-blog.csdnimg.cn/20200524165223419.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmcxOTk1MTIyNA_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200524165324341.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmcxOTk1MTIyNA==,size_16,color_FFFFFF,t_70
[github]: https://github.com/Dominick-Li/springboot-master
[1._springboot]: https://blog.csdn.net/ming19951224/article/details/106159309
[2.Thymeleaf]: https://blog.csdn.net/ming19951224/article/details/106160322
[3.]: https://blog.csdn.net/ming19951224/article/details/106173840
[4._jta-atomikos]: https://blog.csdn.net/ming19951224/article/details/105753333
[5.]: https://blog.csdn.net/ming19951224/article/details/106205332
[6.docker]: https://blog.csdn.net/ming19951224/article/details/105923548
[7.]: https://blog.csdn.net/ming19951224/article/details/106212271
[8._spring-boot-starter]: https://blog.csdn.net/ming19951224/article/details/106224172
[9.dubbo]: https://blog.csdn.net/ming19951224/article/details/106225928
[10.API]: https://blog.csdn.net/ming19951224/article/details/106227451
[11.Spring Data Jpa]: https://blog.csdn.net/ming19951224/article/details/106308544
[12._druid_monitor_sql]: https://blog.csdn.net/ming19951224/article/details/106317893
[13._springboot admin_springboot]: https://blog.csdn.net/ming19951224/article/details/107138845
[14.mybatis-plus]: https://blog.csdn.net/ming19951224/article/details/107145780
[15._shiro_web]: https://blog.csdn.net/ming19951224/article/details/107192585
[16.security_jwt]: https://blog.csdn.net/ming19951224/article/details/107733689
[17._swagger2_RESTful]: https://blog.csdn.net/ming19951224/article/details/107741541
[18._Netty_websocket]: https://blog.csdn.net/ming19951224/article/details/108555917
[19._spring-session_redis_session]: https://blog.csdn.net/ming19951224/article/details/112758560
[20._Configuration]: https://blog.csdn.net/ming19951224/article/details/112759717
[21._springboot_jar]: https://dominick-li.blog.csdn.net/article/details/119024251
[22._RocketMQ]: https://dominick-li.blog.csdn.net/article/details/119523197