JPA入门教程

一:关于JPA

优势:

标准化
JPA 是 JCP 组织发布的 Java EE 标准之一,因此任何声称符合 JPA 标准的框架都遵循同样的架构,提供相同的访问API,这保证了基于JPA开发的企业应用能够经过少量的修改就能够在不同的JPA框架下运行。
容器级特性的支持
JPA框架中支持大数据集、事务、并发等容器级事务,这使得 JPA 超越了简单持久化框架的局限,在企业应用发挥更大的作用。
简单方便
JPA的主要目标之一就是提供更加简单的编程模型:在JPA框架下创建实体和创建Java 类一样简单,没有任何的约束和限制,只需要使用 javax.persistence.Entity进行注释,JPA的框架和接口也都非常简单,没有太多特别的规则和设计模式的要求,开发者可以很容易的掌握。JPA基于非侵入式原则设计,因此可以很容易的和其它框架或者容器集成。
查询能力
JPA的查询语言是面向对象而非面向数据库的,它以面向对象的自然语法构造查询语句,可以看成是Hibernate HQL的等价物。JPA定义了独特的JPQL(Java Persistence Query Language),JPQL是EJB QL的一种扩展,它是针对实体的一种查询语言,操作对象是实体,而不是关系数据库的表,而且能够支持批量更新和修改、JOIN、GROUP BY、HAVING 等通常只有 SQL 才能够提供的高级查询特性,甚至还能够支持子查询。
高级特性

JPA 中能够支持面向对象的高级特性,如类之间的继承、多态和类之间的复杂关系,这样的支持能够让开发者最大限度的使用面向对象的模型设计企业应用,而不需要自行处理这些特性在关系数据库的持久化。

(上面的解析,来自百度文库,其实关于这个还是通过实践来更加清晰的进行了解!好了,进入实战部分)

二:构建JPA开发环境(我这里是用的Hibernate来进行演示,当然用其他的支持持久化的框架都可以哦)

步骤:(1)导入依赖

(2)创建META-INF目录和persistence.xml

为什么要创建META-INF呢?这是因为默认是需要扫描该目录的,并且该目录是放在src下面的。另外,对于这个持久化xml文件的名字也必须是pesistence.xml,这个可千万不能打错。


     
     
     
     
  1. “1.0”?>
  2. “http://java.sun.com/xml/ns/persistence”
  3. xmlns:xsi= “http://www.w3.org/2001/XMLSchema-instance”
  4. xsi:schemaLocation= “http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd” version= “1.0”>
  5. “hnuscw” transaction-type= “RESOURCE_LOCAL”>
  6. “hibernate.dialect” value= “org.hibernate.dialect.MySQL5Dialect” />
  7. “hibernate.connection.driver_class” value= “com.mysql.jdbc.Driver” /> //注意这里面,我用的是mysql,如果你用的是oracle那么就相应的进行替换成oracle的连接驱动
  8. “hibernate.connection.username” value= “xxxx” />
  9. “hibernate.connection.password” value= “******” />
  10. “hibernate.connection.url” value= “jdbc:mysql://localhost:3306/hibernatesql” />
  11. “hibernate.max_fetch_depth” value= “3” />
  12. “hibernate.show_sql” value= “true” />
  13. “hibernate.hbm2ddl.auto” value= “update”/>

(3)编写实体


     
     
     
     
  1. package com.hnu.scw.model;
  2. import javax.persistence.Entity;
  3. import javax.persistence.GeneratedValue;
  4. import javax.persistence.Id;
  5. /**
  6. * @author scw
  7. * @create 2018-01-04 17:45
  8. * @desc 对应数据库中的person
  9. **/
  10. @Entity
  11. public class Person {
  12. @Id
  13. @GeneratedValue
  14. private Integer id;
  15. private String name;
  16. private String sex ;
  17. /**
  18. * 空参构造(必须要)
  19. */
  20. public Person(){
  21. }
  22. public Person(String name , String sex){
  23. this.name = name ;
  24. this.sex = sex;
  25. }
  26. public Integer getId() {
  27. return id;
  28. }
  29. public void setId(Integer id) {
  30. this.id = id;
  31. }
  32. public String getName() {
  33. return name;
  34. }
  35. public void setName(String name) {
  36. this.name = name;
  37. }
  38. public String getSex() {
  39. return sex;
  40. }
  41. public void setSex(String sex) {
  42. this.sex = sex;
  43. }
  44. }

(4)编写测试类


     
     
     
     
  1. package com.hnu.scw.test;
  2. import com.hnu.scw.model.Person;
  3. import org.junit.BeforeClass;
  4. import org.junit.Test;
  5. import javax.persistence.EntityManager;
  6. import javax.persistence.EntityManagerFactory;
  7. import javax.persistence.EntityTransaction;
  8. import javax.persistence.Persistence;
  9. /**
  10. * @author scw
  11. * @create 2018-01-04 17:57
  12. * @desc 进行函数测试
  13. **/
  14. public class JpaPersistenceTest {
  15. @BeforeClass
  16. public static void setUpBeforeClass() throws Exception {
  17. System.out.println( "启动了");
  18. }
  19. /**
  20. * 测试是否jpa测试成功
  21. */
  22. @Test
  23. public void personTest(){
  24. //相当于获取Hibernate中的sessionFactory
  25. EntityManagerFactory factory = Persistence.createEntityManagerFactory( "hnuscw");
  26. //相当于获取session
  27. EntityManager entityManager = factory.createEntityManager();
  28. //开启事务
  29. EntityTransaction transaction = entityManager.getTransaction();
  30. transaction.begin();
  31. //进行crud操作
  32. Person person = new Person( "小吴123" , "男");
  33. entityManager.persist(person);
  34. //提交事务
  35. transaction.commit();
  36. entityManager.close();
  37. //关闭sessionFactory
  38. factory.close();
  39. }
  40. }
OK,搭建完成啦。。。。是不是很简单呢?

三:多种不同实体注解的含义和作用

1:@Id————–表示设置该属性为数据库自增主键

2:@GeneratedValue———-表示设置该主键的自增方式,其中主要有四种:AUTO(根据数据库来自动分配),IDENTITY(mysql支持),SEQUENCE(oracle支持),TABLE(这个用得很少),另外,这个注解一般与@Id一起使用

注意:在hibernate中,如果想使用自动创建表,那么就需要指定主键的生成策略,如果不指定,就会出现,操作方法成功,但是却无法达到期望效果,比如,执行save方法,save执行成功,但是数据库却没有数据插入,就是因为主键生成策略出现问题;如果想使用已经创建表的主键策略,那么就用AUTO即可。。。(这是一个非常大的坑)

3:@Entity———-表示该实体类作为一个数据库表

4:@Table———表示设置对应数据库中的表的名字(如果不使用就默认是该实体类名),示例如下:


     
     
     
     
  1. @Table(name = "xxx")
  2. public class Person {
  3. ............
  4. ..........
  5. .......
  6. }

5:@Column——设置属性对应数据库中字段的规范,其中可以设置字段长度,是否可以为空等信息,例如:设置name属性长度最多为10,不能为空


     
     
     
     
  1. @Column(length = 10 ,nullable = false)
  2. private String name;
6:@Enumerated——-设置该属性是一个枚举类,下面的例子中,SexEnum是一个性别的枚举类,这样的话,我们就可以通过下面的形式将枚举类进行设置为属性了。

     
     
     
     
  1. @Enumerated(EnumType.ORDINAL) //这个是将枚举的索引保存到数据库,就是比如0,1,2这样的,如果就是想保存枚举类中的枚举,以字符串进行保存进数据库,那么就可以用EnumType.STRING
  2. private SexEnum gender;
7:@Temporal——–设置日期的格式,比如有属性为Date类型,但是只是想保存为:

(1)比如2018-1-4这种格式:通过@Temporal(TemporalType.DATE)

(2)比如2018-1-4  15:08:55这种格式@Temporal(TemporalType.TIME)

(3)比如15:08:55这种格式@Temporal(TemporalType.TIMESTAMP)
比如:


     
     
     
     
  1. @Temporal(TemporalType.DATE)
  2. private Date birthday;

8:@Lob——设置该属性是大数据类型,比如一个文章存入到数据库,就可以把该属性用这个注解进行标识

9:@Transient——–设置该属性不作为数据库表字段进行生成,我们都知道默认一个实体中所有字段都是会存储为表的字段,但是也有情况是需要该实体某些属性不是作为数据库字段,那么就用该注解。

10:@Lob+@Basic——–设置该属性为懒加载,主要就是对于一些很大的数据量的字段内容来进行的优化,比如有一个字段该存储为5M,那其实加载这个会很花内存的,所以通过这注解就可以实现懒加载机制(一般如果某字段超过1M就应该采用这样的方式),示例如下:


     
     
     
     
  1. @Lob @Basic(fetch = FetchType.LAZY)
  2. private Byte[] file;

四:CRUD的基本操作(这个可以对比一下Hibernate的操作,很类似)


     
     
     
     
  1. package com.hnu.scw.test;
  2. import com.hnu.scw.model.Person;
  3. import org.junit.BeforeClass;
  4. import org.junit.Test;
  5. import javax.persistence.*;
  6. import java.util.List;
  7. /**
  8. * @author scw
  9. * @create 2018-01-04 17:57
  10. * @desc 进行函数测试
  11. **/
  12. public class JpaPersistenceTest {
  13. @BeforeClass
  14. public static void setUpBeforeClass() throws Exception {
  15. System.out.println( "启动了");
  16. }
  17. /**
  18. * 测试是否jpa测试成功
  19. */
  20. @Test
  21. public void personTest(){
  22. //相当于获取Hibernate中的sessionFactory
  23. EntityManagerFactory factory = Persistence.createEntityManagerFactory( "hnuscw");
  24. //相当于获取session
  25. EntityManager entityManager = factory.createEntityManager();
  26. //开启事务
  27. EntityTransaction transaction = entityManager.getTransaction();
  28. transaction.begin();
  29. //进行添加数据操作
  30. /*
  31. Person person = new Person("小吴123" , "男");
  32. entityManager.persist(person);
  33. */
  34. //========================================================
  35. /*
  36. //进行查询操作(不需要事务)
  37. //方法一:下面这个相当于hibernate中的get方法,如果输入的主键是数据库中没有的,会输出null
  38. Person person = entityManager.find(Person.class, 5);
  39. System.out.println(person);*/
  40. /*
  41. //方法二:相当于hibernate中的load方法,如果输入的主键是数据库中没有的,会报异常
  42. // (发生的时机是当进行使用结果的时候,而不是在获取加载的时候)
  43. Person person = entityManager.getReference(Person.class, 5);
  44. System.out.println(person);
  45. */
  46. //========================================================
  47. /*
  48. //进行更新操作(必须要事务)
  49. Person person = entityManager.find(Person.class, 5);
  50. person.setName("我是更新的");
  51. */
  52. //========================================================
  53. /*
  54. //进行删除操作
  55. Person person = entityManager.find(Person.class, 5);
  56. entityManager.remove(person);
  57. */
  58. //========================================================
  59. /*
  60. //进行查询语句JPQL语句
  61. String sql = "select p from Person p where p.id = ?";
  62. Query query = entityManager.createQuery(sql);
  63. query.setParameter(1 , 30);
  64. //单条数据查询
  65. Person personcu = (Person) query.getSingleResult();
  66. System.out.println(personcu);
  67. //查询多条数据
  68. List persons = query.getResultList();
  69. for (Person ps: persons) {
  70. System.out.println(ps);
  71. }*/
  72. //提交事务
  73. transaction.commit();
  74. entityManager.close();
  75. //关闭sessionFactory
  76. factory.close();
  77. }
  78. }

五:一对一的编写和测试


     
     
     
     
  1. package com.hnu.scw.model;
  2. import javax.persistence.*;
  3. /**
  4. * @author scw
  5. * @create 2018-01-08 11:52
  6. * @desc 实体people类
  7. **/
  8. @Entity
  9. public class People {
  10. @Id
  11. @GeneratedValue
  12. private Integer id;
  13. @Column(length = 10)
  14. private String name;
  15. @OneToOne(cascade = CascadeType.ALL ,optional = false)
  16. @JoinColumn(name = "idcard_id")
  17. private IDcard iDcard;
  18. public People(){}
  19. public People(String name){
  20. this.name = name;
  21. }
  22. public Integer getId() {
  23. return id;
  24. }
  25. public void setId(Integer id) {
  26. this.id = id;
  27. }
  28. public String getName() {
  29. return name;
  30. }
  31. public void setName(String name) {
  32. this.name = name;
  33. }
  34. public IDcard getiDcard() {
  35. return iDcard;
  36. }
  37. public void setiDcard(IDcard iDcard) {
  38. this.iDcard = iDcard;
  39. }
  40. }

     
     
     
     
  1. package com.hnu.scw.model;
  2. import javax.persistence.*;
  3. /**
  4. * @author scw
  5. * @create 2018-01-08 11:53
  6. * @desc 身份证实体
  7. **/
  8. @Entity
  9. public class IDcard {
  10. @Id
  11. @GeneratedValue
  12. private Integer id;
  13. @Column(length = 18)
  14. private String numuber;
  15. @OneToOne(cascade = CascadeType.ALL ,mappedBy = "iDcard")
  16. private People people;
  17. public IDcard(){}
  18. public IDcard(String numuber){
  19. this.numuber = numuber;
  20. }
  21. public Integer getId() {
  22. return id;
  23. }
  24. public void setId(Integer id) {
  25. this.id = id;
  26. }
  27. public String getNumuber() {
  28. return numuber;
  29. }
  30. public void setNumuber(String numuber) {
  31. this.numuber = numuber;
  32. }
  33. public People getPeople() {
  34. return people;
  35. }
  36. public void setPeople(People people) {
  37. this.people = people;
  38. }
  39. }
测试类:

     
     
     
     
  1. /**
  2. * 测试1对1的关联关系
  3. */
  4. @Test
  5. public void one2oneTest(){
  6. //相当于获取Hibernate中的sessionFactory
  7. EntityManagerFactory factory = Persistence.createEntityManagerFactory( "hnuscw");
  8. //相当于获取session
  9. EntityManager entityManager = factory.createEntityManager();
  10. //开启事务
  11. EntityTransaction transaction = entityManager.getTransaction();
  12. transaction.begin();
  13. People people = new People( "佘超伟");
  14. IDcard iDcard = new IDcard( "2222222222");
  15. people.setiDcard(iDcard);
  16. entityManager.persist(people);
  17. transaction.commit();
  18. entityManager.close();
  19. factory.close();
  20. }

六:一对多的编写和测试


     
     
     
     
  1. package com.hnu.scw.model;
  2. import javax.persistence.*;
  3. import java.util.Set;
  4. /**
  5. * @author scw
  6. * @create 2018-01-08 15:45
  7. * @desc 订单实体
  8. **/
  9. @Entity
  10. public class MyOrder {
  11. @Id
  12. @GeneratedValue
  13. private Integer id;
  14. @Column(length = 10)
  15. private String name;
  16. @OneToMany(cascade = CascadeType.ALL , mappedBy = "myOrder")
  17. private Set itemOrders;
  18. public Integer getId() {
  19. return id;
  20. }
  21. public void setId(Integer id) {
  22. this.id = id;
  23. }
  24. public String getName() {
  25. return name;
  26. }
  27. public void setName(String name) {
  28. this.name = name;
  29. }
  30. public Set getItemOrders() {
  31. return itemOrders;
  32. }
  33. public void setItemOrders(Set itemOrders) {
  34. this.itemOrders = itemOrders;
  35. }
  36. }

     
     
     
     
  1. package com.hnu.scw.model;
  2. import javax.persistence.*;
  3. /**
  4. * @author scw
  5. * @create 2018-01-08 15:46
  6. * @desc 订单列表
  7. **/
  8. @Entity
  9. public class ItemOrder {
  10. @Id
  11. @GeneratedValue
  12. private Integer id;
  13. @Column(length = 10)
  14. private String itemName ;
  15. /**
  16. * 设置不包含remove删除的级联操作,因为订单列表删除了,但是订单不需要全部删除
  17. */
  18. @ManyToOne(cascade = {CascadeType.PERSIST ,CascadeType.MERGE ,CascadeType.REFRESH} )
  19. @JoinColumn(name = "myorder_id")
  20. private MyOrder myOrder;
  21. public Integer getId() {
  22. return id;
  23. }
  24. public void setId(Integer id) {
  25. this.id = id;
  26. }
  27. public String getItemName() {
  28. return itemName;
  29. }
  30. public void setItemName(String itemName) {
  31. this.itemName = itemName;
  32. }
  33. public MyOrder getMyOrder() {
  34. return myOrder;
  35. }
  36. public void setMyOrder(MyOrder myOrder) {
  37. this.myOrder = myOrder;
  38. }
  39. }
测试类:

     
     
     
     
  1. /**
  2. * 测试1对多的关联关系
  3. */
  4. @Test
  5. public void one2manyTest(){
  6. //相当于获取Hibernate中的sessionFactory
  7. EntityManagerFactory factory = Persistence.createEntityManagerFactory( "hnuscw");
  8. //相当于获取session
  9. EntityManager entityManager = factory.createEntityManager();
  10. //开启事务
  11. EntityTransaction transaction = entityManager.getTransaction();
  12. transaction.begin();
  13. MyOrder myOrder = new MyOrder();
  14. myOrder.setName( "我是总订单");
  15. ItemOrder itemOrder1 = new ItemOrder();
  16. itemOrder1.setItemName( "订单列表1");
  17. itemOrder1.setMyOrder(myOrder);
  18. ItemOrder itemOrder2 = new ItemOrder();
  19. itemOrder2.setItemName( "订单列表2");
  20. itemOrder2.setMyOrder(myOrder);
  21. ItemOrder itemOrder3 = new ItemOrder();
  22. itemOrder3.setItemName( "订单列表3");
  23. itemOrder3.setMyOrder(myOrder);
  24. Set itemOrders = new HashSet();
  25. itemOrders.add(itemOrder1);
  26. itemOrders.add(itemOrder2);
  27. itemOrders.add(itemOrder3);
  28. //设置订单列表
  29. myOrder.setItemOrders(itemOrders);
  30. //执行保存
  31. entityManager.persist(myOrder);
  32. transaction.commit();
  33. entityManager.close();
  34. factory.close();
  35. }

七:多对多的编写和测试


     
     
     
     
  1. package com.hnu.scw.model;
  2. import javax.persistence.*;
  3. import java.util.Set;
  4. /**
  5. * @author scw
  6. * @create 2018-01-08 16:11
  7. * @desc 学生实体
  8. * 备注:设置该实体为对多对端的维护端
  9. **/
  10. @Entity
  11. public class Student {
  12. @Id
  13. @GeneratedValue
  14. private Integer id;
  15. @Column(length = 10)
  16. private String name;
  17. @ManyToMany(cascade = {CascadeType.PERSIST , CascadeType.REFRESH ,CascadeType.MERGE})
  18. //关键注意下面的这些代码(多对多的关系通过第三张表来实现)
  19. @JoinTable(name = "student_course" , joinColumns = @JoinColumn(name = "student_id") ,
  20. inverseJoinColumns = @JoinColumn(name = "course_id"))
  21. private Set courses;
  22. public Integer getId() {
  23. return id;
  24. }
  25. public void setId(Integer id) {
  26. this.id = id;
  27. }
  28. public String getName() {
  29. return name;
  30. }
  31. public void setName(String name) {
  32. this.name = name;
  33. }
  34. public Set getCourses() {
  35. return courses;
  36. }
  37. public void setCourses(Set courses) {
  38. this.courses = courses;
  39. }
  40. }

     
     
     
     
  1. package com.hnu.scw.model;
  2. import javax.persistence.*;
  3. import java.io.Serializable;
  4. import java.util.Set;
  5. /**
  6. * @author scw
  7. * @create 2018-01-08 16:13
  8. * @desc 课程实体
  9. **/
  10. @Entity
  11. public class course implements Serializable{
  12. @Id
  13. @GeneratedValue
  14. private Integer id;
  15. @Column(length = 10)
  16. private String name;
  17. @ManyToMany(cascade = {CascadeType.PERSIST , CascadeType.REFRESH ,CascadeType.MERGE},
  18. mappedBy = "courses")
  19. private Set students;
  20. public Integer getId() {
  21. return id;
  22. }
  23. public void setId(Integer id) {
  24. this.id = id;
  25. }
  26. public String getName() {
  27. return name;
  28. }
  29. public void setName(String name) {
  30. this.name = name;
  31. }
  32. public Set getStudents() {
  33. return students;
  34. }
  35. public void setStudents(Set students) {
  36. this.students = students;
  37. }
  38. }
测试类:

     
     
     
     
  1. /**
  2. * 多对多的测试------------建立关系
  3. */
  4. @Test
  5. public void many2manyTest(){
  6. //相当于获取Hibernate中的sessionFactory
  7. EntityManagerFactory factory = Persistence.createEntityManagerFactory( "hnuscw");
  8. //相当于获取session
  9. EntityManager entityManager = factory.createEntityManager();
  10. //开启事务
  11. EntityTransaction transaction = entityManager.getTransaction();
  12. transaction.begin();
  13. Student student1 = new Student();
  14. student1.setName( "小王4");
  15. Student student2 = new Student();
  16. student2.setName( "小黑");
  17. course course1 = new course();
  18. course1.setName( "java");
  19. course course2 = new course();
  20. course2.setName( "C++");
  21. Set courses1 = new HashSet<>();
  22. Set courses2 = new HashSet<>();
  23. courses1.add(course1);
  24. courses1.add(course2);
  25. courses2.add(course2);
  26. student1.setCourses(courses1);
  27. student2.setCourses(courses2);
  28. entityManager.persist(student1);
  29. entityManager.persist(student2);
  30. transaction.commit();
  31. entityManager.close();
  32. factory.close();
  33. }
  34. /**
  35. * 多对多的关联之间的关系解除
  36. */
  37. @Test
  38. public void many2manyDeleteTest(){
  39. //相当于获取Hibernate中的sessionFactory
  40. EntityManagerFactory factory = Persistence.createEntityManagerFactory( "hnuscw");
  41. //相当于获取session
  42. EntityManager entityManager = factory.createEntityManager();
  43. //开启事务
  44. EntityTransaction transaction = entityManager.getTransaction();
  45. transaction.begin();
  46. Student student = entityManager.find(Student.class, 1);
  47. entityManager.remove(student);
  48. transaction.commit();
  49. entityManager.close();
  50. factory.close();
  51. }
好了,最基本的关于JPA规范的使用通过上面这些内容,我想应该能够实现基本的使用了。当学习完这个之后,然后再去看我写的Hibernate的文章,我想应该很容易明白了。看看hibernate整合     并且,Hibernate的封装,及其hibernate精华。。欢迎大家的关注哦~!


            

你可能感兴趣的:(JPA入门教程)