JPA入门

1. JPA入门

1.1. 什么是JPA

JPA是Java Persistence API的简称。
Java持久层API，jpa就是做持久层,操作数据库。
JPA作为 Java EE 5.0 平台标准的 对象关系映射(ORM：Object Relational Mapping) 规范

1.2. JPA的用处

优化使用jdbc时在对象和数据库数据之间转换特别麻烦的情况，以面向对象的思维来操作数据

1.3. Hibernate和JPA的关系

JPA是持久化规范，而Hibernate是其实现。

1.4. jdbc和jpa优缺点

jdbc优点：操作数据库最底层,性能最高
缺点：1. 使用复杂(重复代码太多)
2. 移植数据库很麻烦,改动比较多
3. 性能优化得自己处理,没有提供数据的缓存，需要自己实现
4. 面向sql语句操作，不是面向对象的
Jpa优点：1. 程序员操作很简单，代码简单
2. 直接面向持久对象操作
3. 提供世界级数据缓存
4. 数据库移植性很强，很少的修改(通过配置方言搞定)
缺点：1.不能干预sql的生成 ，查询一个数据 find 默认查询所有字段 (select * from )
2.有些优化 jpa做不了，比如特别大数据量的时候，jpa也不适合
3.一个项目里面 对sql要求比较高，就不适合jpa

2. JPA的使用

2.1. 导入jar包

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>cn.itsource</groupId>
<artifactId>jpa-demo</artifactId>
<packaging>pom</packaging>
<version>1.0-SNAPSHOT</version>
<modules>
<module>jpaday01</module>
</modules>

<dependencies>
<!-- hibernate的包 -->
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core</artifactId>
<version>4.3.8.Final</version>
</dependency>
<!-- hibernate对于jpa的支持包 -->
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-entitymanager</artifactId>
<version>4.3.8.Final</version>
</dependency>
<!-- mysql的驱动包 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.6</version>
</dependency>
<!-- junit的测试包 -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
</dependencies>
<build>
<finalName>pss</finalName>
<plugins>
<plugin>
<!-- Maven的编译插件-->
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
</plugins>
</build>
</project>

2.2核心配置文件persistence.xml

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence" version="2.0">
    <!--
        持久化单元名称
         name ：取一个单元的名称
        transaction-type：事务类型 本地数据库的事务
    -->
    <persistence-unit name="cn.itsource.jpa" transaction-type="RESOURCE_LOCAL">
        <properties>
            <!-- 必须配置4个连接数据库属性 -->
            <property name="hibernate.connection.driver_class" value="com.mysql.jdbc.Driver" />
            <property name="hibernate.connection.url" value="jdbc:mysql:///jpa" />
            <property name="hibernate.connection.username" value="root" />
            <property name="hibernate.connection.password" value="123456" />

            <!-- 必须配置1个方言属性 -->
            <!-- 实现跨数据库关键类 :查询MySQLDialect的getLimitString方法 -->
            <property name="hibernate.dialect" value="org.hibernate.dialect.MySQLDialect" />

            <!-- 可选配置 ddl数据定义语言(建库建表建约束)
                          dml数据操作语言 (insert update delete)
                          dql 数据查询语言(select)
                          tcl 事务控制语言 (commit rollback)
                          -->
            <!-- 是否自动生成表 -->
            <property name="hibernate.hbm2ddl.auto" value="create" />
            <!-- 是否显示sql -->
            <property name="hibernate.show_sql" value="true" />
            <!-- 格式化sql -->
            <!--<property name="hibernate.format_sql" value="true" />-->
        </properties>
    </persistence-unit>
</persistence>

2.3核心配置文件中建表策略

<property name="hibernate.hbm2ddl.auto" value="update" /> 

value=“update” ：如果没表就根据最新的映射信息来创建表
如果表里面已经有这个属性,如修改属性的长度,不会更新到表里面，需要更新这个列先删除表或者删除这个属性对应的列名
如果表里面没有属性,映射信息存在,会增加这个列
value=“create” ：如果没有查询的表，则会自动创建一个表。如果存在，则会先删除再创建该表。
value=“create-drop”:先删除表,再创建表,再删除表
作为临时使用表，使用完之后，数据就不应该存在
value=“validate”:用于测试表不存在,会抛出异常

2.4 使用JPA进行CRUD

/创建工具类/

  public static EntityManagerFactory entityManagerFactory;
    static {
        try{
            entityManagerFactory= Persistence.createEntityManagerFactory("cn.whw.jpa");
        }catch (RuntimeException e){
        }
    }

    //创建entityManager对象
    public static EntityManager getEntityManager(){
        EntityManager entityManager = entityManagerFactory.createEntityManager();
        return  entityManager;
    }

/添加对象/

  @Test
    public void add() {
        User user = new User();
        user.setName("小李");
        user.setAge(23);
        user.setIntro("还行");
        //获得entityManager对象
        EntityManager entityManager= JpaUtil.getEntityManager();
        // 开启事务
        EntityTransaction transaction = entityManager.getTransaction();
        transaction.begin();
        // 添加对象
        entityManager.persist(user);
        // 提交事务
        transaction.commit();
        // 关闭资源
        entityManager.close();
    }

/*修改对象*/


  @Test
    public void edit() {
        User user = new User();
        user.setId(4);
        user.setName("雄雄");
        EntityManager entityManager= JpaUtil.getEntityManager();
        entityManager.getTransaction().begin();
        entityManager.merge(user);
        entityManager.getTransaction().commit();
        entityManager.close();
    }

/*查找对象*/
@Test
public void find() {
    //获得entityManager对象
    EntityManager entityManager= JpaUtil.getEntityManager();
    User user =entityManager.find(User.class, 3);
    System.out.println(user);
}

/*查找所有的对象*/


  @Test
    public void findAll() {
        String jpql="select o from User o";
        //获得entityManager对象
        EntityManager entityManager= JpaUtil.getEntityManager();
        Query query = entityManager.createQuery(jpql,User.class);
        List<User> list = query.getResultList();
        for (User user:list){
            System.out.println(user);
        };
        entityManager.close();
    }

/*删除方法：先与对应对象连接，再删除该对象，否则会报错

• */

   @Test
    public void del() throws Exception{
  
        EntityManager entityManager = JpaUtil.getEntityManager();
        //与对象相连接
        User user = entityManager.find(User.class, 1);
  
        entityManager.getTransaction().begin();
        //删除方法
        if(user != null) {
            entityManager.remove(user);
        }
        entityManager.getTransaction().commit();
        entityManager.close();
    }
  

3. 核心API简介

3.1EntityManagerFactory

EntityManagerFactory中应保存了对应的persistence unit中的数据库配置信息和所有实体及关系以及预定义的JPQL语句。同时，EntityManagerFactory还负责维护二级缓存。
EntityManagerFactory对象的创建会有较大的开销，而且EntityManagerFactory对象采取了线程安全的设计方式，因此在实际中EntityManagerFactory对象可以尽量的共享，
在大多数情况下，一个应用中针对一个持久化单元可以共享一个EntityManagerFactory实例。
注意：一个应用程序对应一个EntityManagerFactory：一个数据库

3.2 EntityManager

使用最广泛，类似于Hibernate的Session对象。
它提供和持久化相关的操作。增、删、改、查等。不是线程安全的，
因此，一个EntityManager对象只可以由一个线程使用。
避免多个线程共享。轻量级的，创建和销毁不需要消耗太多资源。
EntityManager中也有类似Hibernate的Session一级缓存。
一级缓存命中测试(同一个EntityManagerFactory，同一个的EntityManager )

public void TestCode1(){
        EntityManager entityManager = JpaUtil.getEntityManager();
        User user = entityManager.find(User.class, 1);
        User user1 = entityManager.find(User.class, 1);
    }

• 一级缓存不命中条件：同一个EntityManagerFactory 同一个OID 同一个EntityManager以上情况有一个未满足

• 比如换一个EntityManager，清空EntityManager再使用

  @Test
  public void TestCode2(){
  EntityManager entityManager = JpaUtil.getEntityManager();
  User user = entityManager.find(User.class, 1);
  // EntityManager entityManager1 = JpaUtil.getEntityManager();
  //清理entityManager数据
  entityManager.clear();
  User user1 = entityManager.find(User.class, 1);
  }

3.3 EntityTransaction

实体的事务对象
JTA事务适用场景(掌握)
比如跨行转账，就需要用到JTA事务
内部实现:事务列表List list
提交的时候,判断list是否全部为true，然后决定是否全部true,是提交事务

3.4单表映射配置

@Entity
@Table(name="t_preson")
public class Person {
    @Id
    @GeneratedValue
    private Long id; //要求：主键，使用数据库的自动生成策略
    @Column(name = "username",length = 20,unique = true,nullable = false)
    private String name;  //要求：varchar(20)，数据库名称为username,不能为空，唯一
    private String password;
    @Column(columnDefinition="int(10)default 25",insertable = false)
    private Integer age = 25; //要求：默认值是25，在插入数据时不允许覆盖(添加数据时不操作该字段)
    private Boolean sex;// 数据库没有布尔类型,bit对象
    @Column(columnDefinition = "decimal(19,2)")
    private BigDecimal salary;// 19,2
    @Temporal(TemporalType.TIMESTAMP)
    @Column(updatable = false)
    private Date createTime;//包含年月日时分秒，不允许修改
    @Temporal(TemporalType.DATE)
    private Date birthday;//包含年月日
    @Temporal(TemporalType.TIME)
    private Date time;//包含时分秒
    @Lob
    private String text;//这是一个大文本
    @Transient
    private String temp;//这一个字段不要同步到数据库