Comment utiliser les annotations communes SpringBoot JPA

1. Introduction

Jpa est un ensemble de spécifications ORM
hibernate n'est pas seulement un framework ORM mais fournit également l'implémentation de JPA

JPA (Java Persistence API) : API de persistance Java

2. Annotations couramment utilisées

2.1 @Entity

marque la classe actuelle comme une classe d'entité, qui sera mappée à la table de base de données spécifiée

@Entity
public class Users {
		
}

2.2 @Table

est généralement utilisée avec @Entity annotation. Si le nom de la table de la base de données et Il est normal de ne pas utiliser l'annotation @Table lorsque les noms de classe sont cohérents, sinon vous devez utiliser l'annotation
@Table pour spécifier le nom de la table

@Entity
@Table(name="t_users")
public class Users {
		
}

2.3 @Id, @GeneratedValue, @SequenceGenerator, @Column

2.3.1 @Id

Utilisé pour mapper les attributs de la classe d'entité aux clés primaires

2.3.2 @GeneratedValue

Spécifiez la stratégie de génération de clé primaire

package javax.persistence;
/**
 * 策略类型
 */
public enum GenerationType {
  /**
   * 通过表产生主键，框架借由表模拟序列产生主键，使用该策略可以使应用更易于数据库移植
   */
  TABLE,
  /**
   * 通过序列产生主键，通过 @SequenceGenerator 注解指定序列名
   * MySql 不支持这种方式
   * Oracle 支持
   */
  SEQUENCE,
  /**
   * 采用数据库 ID自增长的方式来自增主键字段
   * Oracle 不支持这种方式；
   */
  IDENTITY,
  /**
   * 缺省值，JPA 根据数据库自动选择
   */
  AUTO;

  private GenerationType() {
  }
}

2.3.3 @SequenceGenerator

2.3.4 @Column

Lorsque le nom de l'attribut de classe d'entité et le nom de la colonne de base de données Cette annotation doit être utilisée en cas d'incohérence

@Entity
@Table(name="t_users")
public class Users {

  @Id
  @Column(name = "user_id")
  @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "user_seq")
  @SequenceGenerator(name = "user_seq", sequenceName = "user_seq")
  private Long userId;
		
}

2.4 @Transient

indique que l'attribut actuel n'a pas besoin d'être mappé à la base de données

2.5 @Temproal

est principalement utilisé pour les attributs de type Date, et la précision de l'heure peut être spécifiée via cette annotation

@Entity
@Table(name="t_users")
public class Users {

  @Temporal(TemporalType.DATE) 
  private Date time1;
  
  @Temporal(TemporalType.TIME)
  private Date time2;
  
  @Temporal(TemporalType.TIMESTAMP)
  private Date time3;
}

3 . EntityManagerFactory

est similaire à SessionFactory

4 d'hibernate. entités

Nouvel état : Le nouveau créé n'a pas encore de clé primaire persistante État de persistance : A déjà une clé primaire persistante et est persistant Établi une relation de contexte État libre : A une clé primaire persistante, mais le fait pas de relation contextuelle avec la persistance État supprimé : A une clé primaire persistante et a une relation contextuelle avec la persistance, mais elle est supprimée de la base de données

4.1 find (ClassentityClass, Object PrimaryKey)

Similaire à la session get() en veille prolongée

find retournera null si aucune requête n'est trouvée

4.2 getReference(ClassentityClass, Object PrimaryKey)

Similaire à hibernate Le chargement()

de la session n'exécutera l'instruction SQL de la requête que lorsque les attributs de l'objet sont réellement obtenus. getReference() renvoie uniquement un objet proxy

getReference ne renverra pas null s'il n'est pas interrogé et lancera EntityNotFoundException

Remarque : des exceptions de chargement paresseux peuvent se produire lors de l'utilisation de ceci. méthode, c'est-à-dire que nous n'avons pas encore obtenu les valeurs d'attribut dans la classe d'entité, et EntityManager a été fermé en conséquence

注意：使用此方法可能出现懒加载异常的情况，也就是我们还没有去获取实体类中的属性值，结果 EntityManager 就已经被关闭了

4.3 persist

类似与 hibernate 中 session 的 save()

注意：执行方法时传入的对象不能为主键设置值会抛出异常

4.4 remove

类似与 hibernate 中 session 的 delete()

注意：该方法只能删除持久化对象，而不能删除游离状态的对象（hibernate 可以）4.3 persist

Similaire à save() en session en veille prolongée

Remarque : L'objet transmis lors de l'exécution de la méthode ne peut pas être défini comme valeur de clé primaire, une exception sera levée

4.4 Remove

Similaire à la session en veille prolongée delete()

Remarque : Cette méthode ne peut supprimer que les objets persistants, mais pas les objets libres (mise en veille prolongée)

	/**
	 * 删除游离态（失败）
	 */
	public void testRemove(){
		Users user = new Users();
		Users.setUserId(1);
		entityManager.remove(customer);
	}
	
	/**
	 * 删除持久化状态（成功）
	 */
	public void testRemove(){
		Users user = entityManager.find(Users.class, 1);
		entityManager.remove(user);
	}

4.5 merge (entité T)

Similaire à saveOrUpdate() en session de mise en veille prolongée

	// 新建状态
	public void testMerge	(){
		Users user= new Users();
		// 省略一系列的set
		// user.set.....
		Users newUser = entityManager.merge(user);
		// user.getUserId() == null  ==> true
		// newUser.getUserId() == null ==> false
	}

4.6 flush()

est similaire à flush() en session de mise en veille prolongée

enregistre toutes les entités non enregistrées dans le contexte dans la base de données

4.6 rafraîchissement()

Similaire à rafraîchir()

dans hiberner pour actualiser les valeurs d'attribut de toutes les entités

5. 3 rollback

6. Cartographie des relations

6.1 Unidirectionnel un-à-plusieurs

Prenons l'exemple de la relation entre les utilisateurs et les commandes Un utilisateur. a plusieurs commandes, et une commande n'appartient qu'à un seul utilisateur

Pour les insertions dans une relation un-à-plusieurs, que le côté plusieurs ou le côté un soit inséré en premier générera des instructions de mise à jour supplémentaires, car le côté plusieurs n'insérera pas le côté colonne de clé étrangère lors de l'insertion

/**
 * 订单和用户是多对一的关系
 */
@Entity
@Table(name="t_order")
public class Order {
	// lazy为懒加载，默认为eager立即查询
	@ManyToOne(fetch=FetchType.Lazy)
	// @JoinColumn标注字段是一个类，userId为该类的主键
	@JoinColumn(name="user_id")
	private Users user;
}

6.2 Unidirectionnel plusieurs-à-un

basé sur la relation entre l'utilisateur et la commande Prenons l'exemple de la relation Un utilisateur a plusieurs commandes, et une seule commande appartient à. un utilisateur. Pour l'insertion d'une relation plusieurs-à-un, il est préférable de sauvegarder d'abord une extrémité, puis de sauvegarder plusieurs extrémités.

Si vous enregistrez d'abord les extrémités multiples, puis l'extrémité unique, afin de maintenir la relation de clé étrangère, vous devez effectuer des opérations de mise à jour supplémentaires sur les extrémités multiples

/**
 * 订单和用户是多对一的关系
 */
@Entity
@Table(name="t_order")
public class Order {
	// lazy为懒加载，默认为eager立即查询
	@ManyToOne(fetch=FetchType.Lazy)
	// @JoinColumn标注字段是一个类，userId为该类的主键
	@JoinColumn(name="user_id")
	private Users user;
}

6.3 Plusieurs-à-un bidirectionnels

Avec la relation entre l'utilisateur et la commande Par exemple, un utilisateur a plusieurs commandes et une commande n'appartient qu'à un seul utilisateur. Le mode bidirectionnel plusieurs-à-un est une combinaison des deux ci-dessus, en utilisant @OneToMany et @ManyToOne à. en même temps

6.4 双向一对一

以学校和校长之间的关系为例，一个学校只有一个校长，一个校长也只属于一个学校
一方使用 @OneToMany + @JoinColumn，另一方使用 @OneToOne(mappedBy=“xx”)
具体由哪一方维护关联关系都可以，这里我们以学校一端维护关联关系为例
保存时先保存不维护关联关系的一方（也就是使用@OneToOne(mappedBy=“xx”)的一方），否则会产生额外的 update 语句

/**
 * 学校
 */
@Entity
@Table(name="t_school")
public class School {
	// 默认为eager立即查询
	@OneToOne
	// 添加唯一约束
	@JoinColumn(name="school_master_id", unique = true)
	private SchoolMaster schoolMaster;
}

/**
 * 校长
 */
@Entity
@Table(name="t_school_master")
public class SchoolMaster {
	// 不维护关联关系要使用 mappedBy
	@OneToOne(mappedBy="schoolMaster")
	private School school;
}

6.5 双向多对多

以学生和课程之间的关系为例，一个学生可以选多门课，一个课程也有多个学生，多对多需要一个中间表，也就是选课表
维护关联关系的一方需要使用 @JoinTable
关联关系也是只有一方维护即可，这里我们由学生表进行维护

/**
 * 学生
 */
@Entity
@Table(name="t_student")
public class Student {
	@GeneratedValue
	@Id
	private Long student_id;
	
	// 要使用 set 集合接收
	// 默认为lazy懒加载
	@ManyToMany
	// name 为中间表的表名
	@JoinTable(name="t_student_choose_course",
			// name 为与中间表与当前表所关联的字段的名称，referencedColumnName 为当前表中与中间表关联的字段的名称
			joinColumns={@JoinColumn(name="student_id", referencedColumnName="student_id")},
			// name 为与中间表与多对多另一方表所关联的字段的名称，referencedColumnName 为多对多另一方与中间表关联的字段的名称
			inverseJoinColumns={@JoinColumn(name="course_id", referencedColumnName="course_id")})
	private Set<Course> courses;
}

/**
 * 课程
 */
@Entity
@Table(name="t_course")
public class Course {
	@GeneratedValue
	@Id
	private Long course_id;
	
	// 要使用 set 集合接收
	// 默认为lazy懒加载
	@ManyToMany(mappedBy="courses")
	private Set<Student> students;
}

7. 二级缓存

开启了二级缓存之后，缓存是可以跨越 EntityManager 的，
默认是一级缓存也就是在一个 EntityManager 中是有缓存的
二级缓存可以实现，关闭了 EntityManager 之后缓存不会被清除
使用 @Cacheable(true) 开启二级缓存

8. JPQL

8.1 查询接口

8.1.1 createQuery

	public void testCreateQuery(){
		// 这里我们使用了一个 new Student，因为我们是查询 Student 中的部分属性，如果不适用 new Student 查询返回的结果就不是 Student 类型而是一个 Object[] 类型的 List
		// 也可以在实体类中创建对应的构造器，然后使用如下这种 new Student 的方式，来把返回结果封装为Student 对象
		String jpql = "SELECT new Student(s.name, s.age) FROM t_student s WHERE s.student_id > ?";
		// setParameter 时下标是从1开始的
		List result = entityManager.createQuery(jpql).setParameter(1, 1).getResultList();
	}

8.1.2 createNamedQuery

需要在类上使用 @NamedQuery 注解，事先声明 sql 语句

@NamedQuery(name="testNamedQuery", query="select * from t_student WHERE student_id = ?")
@Entity
@Table(name="t_student")
public class Student {
	@GeneratedValue
	@Id
	private Long student_id;
	
	@Column
	private String name;
	
	@Column
	private int age;
}

	public void testCreateNamedQuery(){
		Query query = entityManager.createNamedQuery("testNamedQuery").setParameter(1, 3);
		Student student = (Student) query.getSingleResult();
	}

8.1.3 createNativeQuery

	public void testCreateNativeQuery(){
		// 本地sql的意思是只能在数据库中执行的sql语句
		String sql = "SELECT age FROM t_student WHERE student_id = ?";
		Query query = entityManager.createNativeQuery(sql).setParameter(1, 18);
		Object result = query.getSingleResult();
	}

8.2 关联查询

存在一对多关系时，当我们查询一的一端时，默认多的一端是懒加载。此时我们如果想要一次性查询出所有的数据就需要使用关联查询

注意： 下面 sql 中的重点就是要加上 fetch u.orders，表示要查询出用户所关联的所有订单

	public void testLeftOuterJoinFetch(){
		String jpql = "FROM t_users u LEFT OUTER JOIN FETCH u.orders WHERE u.id = ?";
		
		Users user = (Users) entityManager.createQuery(jpql).setParameter(1, 123).getSingleResult();
	}

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!