So verwenden Sie allgemeine JPA-Annotationen von SpringBoot

1. Einführung

Jpa ist eine Reihe von ORM-Spezifikationen
hibernate ist nicht nur ein ORM-Framework, sondern bietet auch die Implementierung von JPA

JPA (Java Persistence API) : Java Persistence API

2. Häufig verwendete Anmerkungen

2.1 @Entity

markiert die aktuelle Klasse als Entitätsklasse, die der angegebenen Datenbanktabelle zugeordnet wird

@Entity
public class Users {
		
}

2.2 @Table

wird im Allgemeinen zusammen mit @Entity verwendet Annotation. Wenn der Datenbanktabellenname und die Annotation @Table nicht verwendet werden, wenn die Klassennamen konsistent sind, müssen Sie andernfalls die Annotation
@Table verwenden, um den Tabellennamen anzugeben

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

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

2.3.1 @Id

Wird verwendet, um die Attribute der Entitätsklasse Primärschlüsseln zuzuordnen

2.3.2 @GeneratedValue

Geben Sie die Strategie zur Primärschlüsselgenerierung an

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

Wenn der Name des Entitätsklassenattributs und der Datenbankspaltenname inkonsistent sind, muss diese Annotation verwendet werden.

@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

gibt an, dass das aktuelle Attribut nicht der Datenbank zugeordnet werden muss

2.5 @Temproal

wird hauptsächlich für Datumstypattribute verwendet, und die Genauigkeit der Zeit kann durch diese Annotation angegeben werden

@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

ähnelt der SessionFactory

4 Entitäten

Neuer Zustand: Die neu erstellte Person hat noch keinen dauerhaften Primärschlüssel. Persistenzzustand: Hat bereits einen dauerhaften Primärschlüssel und ist dauerhaft. Eine Kontextbeziehung wurde hergestellt. Freier Zustand: Hat einen dauerhaften Primärschlüssel, tut dies aber keine Kontextbeziehung mit Persistenz haben Gelöschter Zustand: Hat einen persistenten Primärschlüssel und eine Kontextbeziehung mit Persistenz, aber er ist aus der Datenbank gelöscht

4.1 find(Klasse entityClass, Object PrimaryKey)

Ähnlich wie Sitzung get() im Ruhezustand: find gibt null zurück, wenn keine Abfrage gefunden wird Die Attribute im Objekt werden tatsächlich abgerufen. getReference() gibt nur ein Proxy-Objekt zurück. GetReference gibt nicht null zurück, wenn es nicht abgefragt wird, und löst eine EntityNotFoundException aus Methode, das heißt, wir haben die Attributwerte in der Entity-Klasse noch nicht erhalten und der EntityManager wurde daher geschlossen

4.3 persist

Ähnlich wie save() in der Sitzung im Ruhezustand

Hinweis: Das beim Ausführen der Methode übergebene Objekt kann nicht als Primärschlüsselwert festgelegt werden, es wird eine Ausnahme ausgelöst

4.4 entfernen

Ähnlich wie bei der Sitzung im Ruhezustand delete()

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

4.3 persist

类似与 hibernate 中 session 的 save()

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

4.4 remove

类似与 hibernate 中 session 的 delete()

注意：该方法只能删除持久化对象，而不能删除游离状态的对象（hibernate 可以）Hinweis: Diese Methode kann nur persistente Objekte löschen, aber keine freien Objekte (Ruhezustand kann)

	/**
	 * 删除游离态（失败）
	 */
	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(T-Entität)

Ähnlich wie saveOrUpdate() in der Ruhezustandssitzung

	// 新建状态
	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()

ähnelt Flush() in der Ruhezustandssitzung.

Alle nicht gespeicherten Entitäten im Kontext in der Datenbank speichern Ruhezustand, um die Attributwerte aller Entitäten zu aktualisieren. 5.3 Rollback hat mehrere Bestellungen und eine Bestellung gehört nur einem Benutzer

Bei Einfügungen in einer Eins-zu-Viele-Beziehung werden zusätzliche Aktualisierungsanweisungen generiert, unabhängig davon, ob die Viele-Seite oder die Eine-Seite zuerst eingefügt wird, da die Viele-Seite das nicht einfügt Fremdschlüsselspalte beim Einfügen Für das Einfügen einer Viele-zu-Eins-Beziehung ist es am besten, zuerst das Eine-Ende und dann das Viele-Ende zu speichern.

Wenn Sie zuerst die Viele-Seite und dann die Ein-Seite speichern, müssen Sie zur Aufrechterhaltung der Fremdschlüsselbeziehung zusätzliche Aktualisierungsvorgänge auf der Viele-Seite durchführen

/**
 * 订单和用户是多对一的关系
 */
@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 Zwei-Wege-Viele-zu-Eins

Mit der Beziehung zwischen dem Benutzer und der Bestellung Nehmen Sie die Beziehung als Beispiel: Ein Benutzer hat mehrere Bestellungen, und eine Bestellung gehört nur einem Benutzer. Zwei-Wege-Viele-zu-Eins ist eine Kombination der beiden oben genannten, wobei @OneToMany verwendet wird und @ManyToOne gleichzeitig.

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();
	}

Das obige ist der detaillierte Inhalt vonSo verwenden Sie allgemeine JPA-Annotationen von SpringBoot. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!