orm思想和hibernate与JPA规范

orm思想

• 主要目的: 操作实体类就相当于操作数据库表

• 建立连个映射关系:

  1. 实体类和表的映射关系
  2. 实体类中属性和表中字段的映射关系

• 不再重点关注: sql语句

• 实现了ORM思想的框架: mybatis, hibernate

---

hibernate框架介绍

1. Hibernate是一个开放源代码的对象关系映射框架，
2. 它对JDBC进行了非常轻量级的对象封装，
3. 它将POJO与数据库表建立映射关系，是一个全自动的orm框架

---

JPA规范

• jpa规范,实现jpa规范,内部是由接口和抽象类组成

jpa的基本操作

• 基本的增删改查
• 数据库表
  
• 建表语句

/*创建客户表*/
CREATE TABLE cst_customer (
  cust_id BIGINT(32) NOT NULL AUTO_INCREMENT COMMENT '客户编号(主键)',
  cust_name VARCHAR(32) NOT NULL COMMENT '客户名称(公司名称)',
  cust_source VARCHAR(32) DEFAULT NULL COMMENT '客户信息来源',
  cust_industry VARCHAR(32) DEFAULT NULL COMMENT '客户所属行业',
  cust_level VARCHAR(32) DEFAULT NULL COMMENT '客户级别',
  cust_address VARCHAR(128) DEFAULT NULL COMMENT '客户联系地址',
  cust_phone VARCHAR(64) DEFAULT NULL COMMENT '客户联系电话',
  PRIMARY KEY (`cust_id`)
) ENGINE=INNODB AUTO_INCREMENT=94 DEFAULT CHARSET=utf8;

• 建立实体类

@Entity
@Table(name = "cst_customer")
public class Customer {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "cust_id")
    private Long custId;        //客户的主键

    @Column(name = "cust_name")
    private String custName;    //客户名称

    @Column(name = "cust_source")
    private String custSource;  //客户来源

    @Column(name = "cust_level")
    private String custLevel;   //客户级别

    @Column(name = "cust_industry")
    private String custIndustry; //客户所属行业

    @Column(name = "cust_phone")
    private String custPhone;   //客户的联系方式

    @Column(name = "cust_address")
    private String custAddress; //客户地址

 	//get和set省略
    //toString省略
    
    }
}

• 注解解释

	@Entity: 声明实体类
	@Table: 配置实体类和表的映射关系
		name: 配置数据库表的名称
			注: 我这里的数据库表名是cst_customer
		
		
	@Id: 声明主键的配置
	@GeneratedValue: 配置主键的生成策略
		strategy
			GenerationType.IDENTITY : 自增	 注: 一般用于mysql数据库
			* 底层数据库必须支持自动增长(底层数据库支持的自动增长方式,对id自增)
			
			GenerationType.SEQUENCE : 序列,  注: 一般用于oracle数据库
			* 注: 一般主要就是用这两种了,另外两种很少用到


	@Column: 配置属性和字段的隐射关系
		name: 代表数据库表中字段的名称
			注: 我这里每个基本都和数据库相对应

---

配置 配置文件persistence.xml
一般在resource文件夹 然后创建一个META-INF文件夹然后创建xml

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence" version="2.0">
    <!--
        需要配置persistence-unit节点
        持久化单元:
            name: 持久化单元名称
            transaction-type: 事务管理的方式
                JTA: 分布式事务管理(可选)
                RESOURCE_LOCAL: 本地事务管理(可选)
    -->
    <persistence-unit name="myJpa" transaction-type="RESOURCE_LOCAL">
        <!-- jpa的实现方式 -->
        <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>


        <!-- 可选配置, 为了配置jpa实现方的配置信息  -->
        <properties>
            <!--
                数据库信息
                用户名,javax.persistence.jdbc.user
                密码, javax.persistence.jdbc.password
                驱动, javax.persistence.jdbc.driver
                数据库地址 javax.persistence.jdbc.url
              -->
            <property name="javax.persistence.jdbc.user" value="root"/>
            <property name="javax.persistence.jdbc.password" value="root"/>
            <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>
            <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/jpa"/>

            <!--
                配置jpa实现方(hibernate)的配置信息
                显示sql:           hibernate.show_sql
                    false | true
                自动创建数据库表:   hibernate.hbm2ddl.auto
                    create      : 程序运行时,创建数据库表(如果有表,先删除表再创建)
                    update      : 程序运行时创建表(如果有表,不会创建表)
                    none        : 不会创建表
                    
                * 注: 一般用于比较多的是update 
            -->
            <property name="hibernate.show_sql" value="true"/>
            <property name="hibernate.hbm2ddl.auto" value="update"/>
        </properties>
    </persistence-unit>
</persistence>

---

maven的jar包配置坐标

	<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>

---

搭建环境的具体步骤

1. 创建maven工程导入坐标
2. 需要配置jpa的核心配置文件
   * 位置: 配置到类路径下的一个叫做 META-INF的文件夹下
   * 命名: persostence.xml
3. 编写客户的实体类
4. 配置实体类和表, 类中属性和表中字段的映射关系
5. 进行增删改查

使用jpa完成基本的CRUD案例

1. persist: 保存
2. merge: 更新
3. remove: 删除
4. find/getRegrence: 根据id进行查询

	注: 
		find是立即加载
		getRegrence是延迟加载 (就是等用到的时候,才会执行sql语句)

---

小案例

	@Test
   public void testSave() {
      //1. 加载配置文件创建工厂(实体管理器工厂)对象
      EntityManagerFactory factory = Persistence.createEntityManagerFactory("myJpa");

       //2. 通过实体管理类工厂获取实体管理器
       EntityManager em = factory.createEntityManager();

       //3. 获取事务对象, 开启事务
       EntityTransaction tx = em.getTransaction(); //获取事务对象
       tx.begin(); //开启事务

       //4. 完成增删改查操作: 保存一个客户到数据库中
       Customer customer = new Customer();
       customer.setCustName("测试");
       customer.setCustIndustry("JPA测试");

       //保存
       em.persist(customer);   //保存操作

       //5. 提交事务
       tx.commit();

       //6. 释放资源
       em.close();
       factory.close();
   }

注:

• createEntityManagerFactory("myJpa")这里的myJpa需要与persistence.xml里面的配置进行相对应

---

抽取

• 因为加载配置文件创建工厂和通过实体管理类工厂获取实体管理器我们每次都必须做,所以可以进行抽取成为一个工具类.

public class JpaUtils {

    private static EntityManagerFactory factory;

    static {
        //加载配置文件,根创建entityManagerFactory
        factory = Persistence.createEntityManagerFactory("myJpa");
    }

    /**
     * 获取EntityManage实体类对象
     */

    public static EntityManager getEntityManager(){
        return factory.createEntityManager();
    }
}

• 因为是线程安全的,所以不需要担心.

小案例使用工具类进行编码

    @Test
    public void testSave() {

        EntityManager em = JpaUtils.getEntityManager();

        //3. 获取事务对象, 开启事务
        EntityTransaction tx = em.getTransaction(); //获取事务对象
        tx.begin(); //开启事务

        //4. 完成增删改查操作: 保存一个客户到数据库中
        Customer customer = new Customer();
        customer.setCustName("测试");
       customer.setCustIndustry("JPA测试");


        //保存
        em.persist(customer);   //保存操作

        //5. 提交事务(回滚事务)
        tx.commit();

        //6. 释放资源
        em.close();
//        factory.close();
    }