JPA的个人小结

JPA的个人小结

原生Jpa的概念和操作

什么是原生Jpa

JPA的全称是Java Persistence API， 即Java 持久化API，是SUN公司推出的一套基于ORM的规范，内部是由一系列的接口和抽象类构成。

JPA通过JDK 5.0注解描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中。

Jpa 的入门

一,创建Maven 工程导入Pom.xml坐标

<?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>org.example</groupId>
    <artifactId>Jpa-test</artifactId>
    <version>1.0-SNAPSHOT</version>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.hibernate.version>5.0.7.Final</project.hibernate.version>
    </properties>
    <dependencies>
        <!-- junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

        <!-- hibernate对jpa的支持包 -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>${project.hibernate.version}</version>
        </dependency>

        <!-- c3p0 -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-c3p0</artifactId>
            <version>${project.hibernate.version}</version>
        </dependency>

        <!-- log日志 -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>

        <!-- Mysql and MariaDB -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>
    </dependencies>

</project>

二，在META-INF 中创建名为"Persistence.xml"资源配置文件

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://java.sun.com/xml/ns/persistence
    http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd"
             version="2.0">
    <!--配置持久化单元
		name：持久化单元名称
		transaction-type：事务类型
		 	RESOURCE_LOCAL：本地事务管理 我们当前是为本地操作
		 	JTA：分布式事务管理 -->
    <persistence-unit name="myJpa" transaction-type="RESOURCE_LOCAL">
        <!--配置JPA规范 服务提供商-->
        <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
        <properties>
            <!--配置数据库-->
            <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver" />
            <!-- 数据库地址 -->
            <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/customer" />
            <!-- 数据库用户名 -->
            <property name="javax.persistence.jdbc.user" value="root" />
            <!-- 数据库密码 -->
            <property name="javax.persistence.jdbc.password" value="1024" />
			<!-- 因为hibernate 提供了JPA的实现也可以配置Hibernate 中属性-->
            <property name="hibernate.show_sql" value="true" /> <!-- 显示sql -->
            <property name="hibernate.format_sql" value="true" />
            <property name="hibernate.hbm2ddl.auto" value="update" /><!--创建生成策略 -->
        </properties>
    </persistence-unit>
</persistence>

log4j配置文件

# Global logging configuration
log4j.rootLogger=DEBUG, stdout
# MyBatis logging configuration...
log4j.logger.org.mybatis.example.BlogMapper=TRACE
# Console output...
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n

三,配置实体类属性

在实体类中要配置实体类属性和表中对应的属性,这里我以我创建的客户表为例

@Entity

​ 作用：指定当前类是实体类。

​ @Table

​ 作用：指定实体类和表之间的对应关系。

​ 属性：

​ name：指定数据库表的名称

​ @Id

​ 作用：指定当前字段是主键。

​ @GeneratedValue

​ 作用：指定主键的生成方式。。

​ 属性：

​ strategy ：指定主键生成策略。

​ @Column

​ 作用：指定实体类属性和数据库表之间的对应关系

​ 属性：

​ name：指定数据库表的列名称。

​ unique：是否唯一

​ nullable：是否可以为空

​ inserttable：是否可以插入

​ updateable：是否可以更新

​ columnDefinition: 定义建表时创建此列的DDL

​ secondaryTable: 从表名。如果此列不建在主表上（默认建在主表），该属性定义该列所在从表的名字搭建开发环境[重点] *这个不清楚

package com.wym.Entity;

import javax.persistence.*;

@Entity
@Table(name = "customer_table")
public class Customer {
    
    
    @Id//声明当前私有主键
    @GeneratedValue(strategy = GenerationType.IDENTITY)//主键生成策略
    @Column(name = "id")
    private Integer id;
    @Column(name = "name")
    private String name;
    @Column(name = "sex")
    private String sex;
    @Column(name = "tell")
    private Integer tell;
    @Column(name = "addr")
    private String addr;
    public Integer getId() {
    
    
        return id;
    }

    public void setId(Integer id) {
    
    
        this.id = id;
    }

    public String getName() {
    
    
        return name;
    }

    public void setName(String name) {
    
    
        this.name = name;
    }

    public String getSex() {
    
    
        return sex;
    }

    public void setSex(String sex) {
    
    
        this.sex = sex;
    }

    public Integer getTell() {
    
    
        return tell;
    }

    public void setTell(Integer tell) {
    
    
        this.tell = tell;
    }

    public String getAddr() {
    
    
        return addr;
    }

    public void setAddr(String addr) {
    
    
        this.addr = addr;
    }

    @Override
    public String toString() {
    
    
        return "Customer{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                ", tell=" + tell +
                ", addr='" + addr + '\'' +
                '}';
    }
}

四，配置Jpa 的管理器

     //获取配置文件得到Factory
        EntityManagerFactory factory = Persistence.createEntityManagerFactory("myJpa");
        //创建实体类管理对象
        EntityManager em = factory.createEntityManager();
        //获取事务对象
        EntityTransaction transaction = em.getTransaction();
        //开启事务
        transaction.begin();
        Customer customer=new Customer();
        customer.setName("廖伟");
        customer.setAddr("井冈山");
        em.persist(customer);//添加数据
        //提交事务
        transaction.commit();
        //释放资源
        em.close();
        factory.close();

五，优化Jpa 的创建过程 抽取一个工具类

package com.wym.Entity.Utils;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

/**
 * Jpa工具类
 */
public class JpaUtil {
    
    
    // JPA的实体管理器工厂：相当于Hibernate的SessionFactory
    private static EntityManagerFactory factory=null;
    // 使用静态代码块赋值
    static{
    
    
      factory = Persistence.createEntityManagerFactory("myJpa");
    }

    /**
     * 提供一个方法管理对象
     */
    public static EntityManager getFactory(){
    
    
        return  factory.createEntityManager();
    }

}

Jpa的CRUD 操作

    /**
     * EntityManager:提供了crud 的方法
     * getTransaction : 获取事务对象
     * 	persist ： 保存操作
     * 	merge ： 更新操作
     * 	remove ： 删除操作
     * 	find/getReference ： 根据id查询
     */

上面我们创建了JpaUtils下面我们使用这个JpaUtils 工具类

一 ,保存操作persist

 @Test
    public  void  testUtil(){
    
    
        EntityManager me = JpaUtil.getFactory();
        EntityTransaction transaction = me.getTransaction();
        transaction.begin();
        try {
    
    
            Customer customer = new Customer();
            customer.setName("wengyanmin");
            customer.setSex("男");
            customer.setAddr("江西");
            customer.setTell(19312312);

            me.persist(customer);//保存
            transaction.commit();
        } catch (Exception e) {
    
    
            e.printStackTrace();
            transaction.rollback();
        }
        me.close();
    }

二，更新数据merge

 @Test
    public void testMerge(){
    
    
        EntityManager me = JpaUtil.getFactory();
        EntityTransaction transaction = me.getTransaction();
        transaction.begin();
        try {
    
    
            //查询前要先查询出对象
            Customer customer = me.find(Customer.class, 1l);
            customer.setAddr("深圳");
            //修改
            me.merge(customer);
            transaction.commit();
        } catch (Exception e) {
    
    
            e.printStackTrace();
            transaction.rollback();
        }
        me.close();
    }

三，删除数据remove

    @Test
    public void testDelete(){
    
    
        EntityManager me = JpaUtil.getFactory();
        EntityTransaction transaction = me.getTransaction();
        transaction.begin();
        try {
    
    
            //查询前要先查询出对象
            Customer customer = me.find(Customer.class, 1l);
            //删除
            me.remove(customer);
            transaction.commit();
        } catch (Exception e) {
    
    
            e.printStackTrace();
            transaction.rollback();
        }
        me.close();
    }

四，查询find 和 getReference

   /**
     * 查询 根据id
     * find :直接获取对象本体
     * getReference：延迟加载
     */
@Test
    public void testFind(){
    
    
        EntityManager me = JpaUtil.getFactory();
        EntityTransaction transaction = me.getTransaction();
        transaction.begin();
        try {
    
    
            //查询前要先查询出对象
            //Customer customer = me.find(Customer.class, 1l);
            Customer c1 = me.find(Customer.class, 1L);
            Customer c2 = me.find(Customer.class, 1L);
            System.out.println(c1==c2);
            //返回true 有缓存
            //getReference：延迟加载
            Customer reference = me.getReference(Customer.class, 1l);
            //删除
            transaction.commit();
        } catch (Exception e) {
    
    
            e.printStackTrace();
            transaction.rollback();
        }
        me.close();
    }

Jpa的复杂查询

jpa提供了一套复杂查询的 方式，就是使用JPQl,下面使用JPQL 来进行复杂的查询，JPQL 的语法是使用实体类中属性来进行语句的书写

一， 查询所有

@Test
    public  void test1(){
    
    
        EntityManager manager = JpaUtil.getFactory();
        EntityTransaction tx = manager.getTransaction();

        tx.begin();
        String jql="from  Customer ";
        Query query = manager.createQuery(jql);
        List resultList = query.getResultList();
        for (Object cus:resultList
             ) {
    
    
            System.out.println(((Customer)cus));
        }
        tx.commit();

        manager.close();
    }

二，分页查询

 @Test
    public  void testLimit(){
    
    
        EntityManager manager = JpaUtil.getFactory();
        EntityTransaction tx = manager.getTransaction();

        tx.begin();
        String jql="from  Customer ";
        Query query = manager.createQuery(jql);
        //起始索引
        query.setFirstResult(1);
        //每页显示条数
        query.setMaxResults(2);

        List resultList = query.getResultList();
        for (Object cus:resultList
        ) {
    
    
            System.out.println(((Customer)cus));
        }
        tx.commit();
        manager.close();
    }

三，条件查询

模糊查询:
 @Test
    public void testFindCondition(){
    
    
        EntityManager manager = JpaUtil.getFactory();
        EntityTransaction tx = manager.getTransaction();

        tx.begin();
        String jql="from Customer where  name like ?";
        Query query = manager.createQuery(jql);
        //站位符
        query.setParameter(1, "weng%");

        //返回对象
        Object singleResult = query.getSingleResult();
        System.out.println(singleResult);
        tx.commit();
        manager.close();
    }
 /**
     * 下面的不写了：
     * 
     * 排序查询：
     *  jql: from Customer order by id desc
     *  统计查询：
     *  jql
     *  select count(id) from Customer
     */

以上是我在学习jpa 后进行的学习小结，希望能帮助到在学习的朋友们