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
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 {
} 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 {
}package javax.persistence;
/**
* 策略类型
*/
public enum GenerationType {
/**
* 通过表产生主键，框架借由表模拟序列产生主键，使用该策略可以使应用更易于数据库移植
*/
TABLE,
/**
* 通过序列产生主键，通过 @SequenceGenerator 注解指定序列名
* MySql 不支持这种方式
* Oracle 支持
*/
SEQUENCE,
/**
* 采用数据库 ID自增长的方式来自增主键字段
* Oracle 不支持这种方式；
*/
IDENTITY,
/**
* 缺省值，JPA 根据数据库自动选择
*/
AUTO;
private GenerationType() {
}
}@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;
}@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;
}est similaire à SessionFactory4 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éefind retournera null si aucune requête n'est trouvée4.2 getReference(ClassentityClass, Object PrimaryKey)
Similaire à hibernate Le chargement()getReference ne renverra pas null s'il n'est pas interrogé et lancera EntityNotFoundExceptionde 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
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 就已经被关闭了
类似与 hibernate 中 session 的 save()
注意：执行方法时传入的对象不能为主键设置值会抛出异常
类似与 hibernate 中 session 的 delete()
注意：该方法只能删除持久化对象，而不能删除游离状态的对象（hibernate 可以）4.3 persist
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ée4.4 Remove
4.5 merge (entité T)
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); }Copier après la connexion
// 新建状态 public void testMerge (){ Users user= new Users(); // 省略一系列的set // user.set..... Users newUser = entityManager.merge(user); // user.getUserId() == null ==> true // newUser.getUserId() == null ==> false }Copier après la connexion
4.6 flush()
est similaire à flush() en session de mise en veille prolongéeenregistre toutes les entités non enregistrées dans le contexte dans la base de données
6. Cartographie des relations
6.1 Unidirectionnel un-à-plusieurs
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./** * 订单和用户是多对一的关系 */ @Entity @Table(name="t_order") public class Order { // lazy为懒加载，默认为eager立即查询 @ManyToOne(fetch=FetchType.Lazy) // @JoinColumn标注字段是一个类，userId为该类的主键 @JoinColumn(name="user_id") private Users user; }Copier après la connexionCopier après la connexion
6.2 Unidirectionnel plusieurs-à-un
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/** * 订单和用户是多对一的关系 */ @Entity @Table(name="t_order") public class Order { // lazy为懒加载，默认为eager立即查询 @ManyToOne(fetch=FetchType.Lazy) // @JoinColumn标注字段是一个类，userId为该类的主键 @JoinColumn(name="user_id") private Users user; }Copier après la connexionCopier après la connexion6.3 Plusieurs-à-un bidirectionnels
以学校和校长之间的关系为例，一个学校只有一个校长，一个校长也只属于一个学校
一方使用 @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;
}以学生和课程之间的关系为例，一个学生可以选多门课，一个课程也有多个学生，多对多需要一个中间表，也就是选课表
维护关联关系的一方需要使用 @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;
}开启了二级缓存之后，缓存是可以跨越 EntityManager 的，
默认是一级缓存也就是在一个 EntityManager 中是有缓存的
二级缓存可以实现，关闭了 EntityManager 之后缓存不会被清除
使用 @Cacheable(true) 开启二级缓存
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();
}需要在类上使用 @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();
} 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();
}存在一对多关系时，当我们查询一的一端时，默认多的一端是懒加载。此时我们如果想要一次性查询出所有的数据就需要使用关联查询
注意： 下面 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!
qu'est-ce que jpa
Étapes de création du projet SpringBoot
Quelle est la différence entre j2ee et springboot
Comment définir un arrêt programmé dans UOS
Patch d'adhésion Thunder
Comment implémenter la technologie de conteneur Docker en Java
Quelles sont les commandes d'arrêt de Linux ?
Comment utiliser l'installation de pip
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
