SpringData jpa(一)

orm思想和hibernate以及jpa的概述和jpd的基本操作

1.orm思想

主要目的：操作实体类就相当于操作数据库表
    建立两个映射关系：
    		实体类和表的映射关系
    		实体类中属性和表中字段的映射关系
    不在关注的重点： sql语句
实现了ORM思想的框架：mybatis 、 hibernate

2.hibernate框架介绍

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

3.JPA规范

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

4.jpa的基本操作

	案例：客户的相关操作（CRUD）
		客户：就是一家公司
	客户表：

	jpa的操作步骤：
		1.加载配置文件创建实体管理器工厂
			Persisitence：静态方法（根据持久化单元名称创建实体管理器工厂）
				createEntityMnagerFactory（持久化单元名称）
			作用：创建实体管理器工厂
			
		2.根据实体管理器工厂，创建实体管理器
			EntityManagerFactory ：获取EntityManager对象
			方法：createEntityManager
			* 内部维护的很多的内容
				内部维护了数据库信息，
				维护了缓存信息
				维护了所有的实体管理器对象
				再创建EntityManagerFactory的过程中会根据配置创建数据库表
			* EntityManagerFactory的创建过程比较浪费资源
			特点：线程安全的对象
				多个线程访问同一个EntityManagerFactory不会有线程安全问题
			* 如何解决EntityManagerFactory的创建过程浪费资源（耗时）的问题？
			思路：创建一个公共的EntityManagerFactory的对象
			* 静态代码块的形式创建EntityManagerFactory
			
		3.创建事务对象，开启事务
			EntityManager对象：实体类管理器
				beginTransaction : 创建事务对象
				presist ： 保存
				merge  ： 更新
				remove ： 删除
				find/getRefrence ： 根据id查询
				
			Transaction 对象 ： 事务
				begin：开启事务
				commit：提交事务
				rollback：回滚
		4.增删改查操作
		5.提交事务
		6.释放资源
		

find/getRefrence 查询的小细节

	/**
     * 根据id查询客户
     *  使用find方法查询：
     *      1.查询的对象就是当前客户对象本身
     *      2.在调用find方法的时候，就会发送sql语句查询数据库
     *
     *  立即加载
     */

    @Test
    public void testFind(){
        EntityManager em = JpaUtils.getEntityManager();
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        //3.增删改查 -- 根据id查询客户
        /**
         * find : 根据id查询数据
         *      class：查询数据的结果需要包装的实体类类型的字节码
         *      id：查询的主键的取值
         */
        Customer customer = em.find(Customer.class,1l);
        System.out.println(customer);
        tx.commit();
        em.close();
    }

    /**
     * 根据id查询客户
     *      getReference方法
     *          1.获取的对象是一个动态代理对象
     *          2.调用getReference方法不会立即发送sql语句查询数据库
     *              * 当调用查询结果对象的时候，才会发送查询的sql语句：什么时候用，什么时候发送sql语句查询数据库
     *
     * 延迟加载（懒加载）
     *      * 得到的是一个动态代理对象
     *      * 什么时候用，什么使用才会查询
     */
    @Test
    public void testReference(){
        EntityManager em = JpaUtils.getEntityManager();
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        Customer customer = em.getReference(Customer.class, 1L);
        System.out.println(customer);
        tx.commit();
        em.close();
    }






/**
     *客户实体类
     *      配置映射关系
     *   1.实体类和表的映射关系
     *      @Entity ：声明实体类
     *      @Table ：配置实体和表的映射关系
     *          name： 配置数据库表的名称
     *   2.实体类中属性和表中字段的映射关系
     */


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

        /**
         * @Id : 声明主键的配置
         * @GeneratedValue ：配置主键的生成策略
         *      strategy
         *          GenerationType.IDENTITY ：自增，mysql
         *                  * 底层数据库必须支持自动增长（底层数据库支持的自动增长方式，对id自增）
         *          GenerationType.SEQUENCE : 序列 ，oracle
         *                  * 底层数据库必须支持序列
         *          GenerationType.TABLE : jpa提供的一种机制，通过一张数据库表的形式帮助我们完成主键自增
         *          GenerationType.AUTO ： 由程序自动的帮助我们选择主键生成策略
         *@Column : 配置属性和字段的映射关系
         *          name：数据库表中字段的名称
         */

    @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;//客户地址

        public Customer() {
        }

        public Customer(String custName, String custAddress) {
            this.custName = custName;
            this.custAddress = custAddress;
        }

    public Long getCustId() {
        return custId;
    }

    public void setCustId(Long custId) {
        this.custId = custId;
    }

    public String getCustName() {
        return custName;
    }

    public void setCustName(String custName) {
        this.custName = custName;
    }

    public String getCustSource() {
        return custSource;
    }

    public void setCustSource(String custSource) {
        this.custSource = custSource;
    }

    public String getCustLevel() {
        return custLevel;
    }

    public void setCustLevel(String custLevel) {
        this.custLevel = custLevel;
    }

    public String getCustIndustry() {
        return custIndustry;
    }

    public void setCustIndustry(String custIndustry) {
        this.custIndustry = custIndustry;
    }

    public String getCustPhone() {
        return custPhone;
    }

    public void setCustPhone(String custPhone) {
        this.custPhone = custPhone;
    }

    public String getCustAddress() {
        return custAddress;
    }

    public void setCustAddress(String custAddress) {
        this.custAddress = custAddress;
    }

        @Override
        public String toString() {
            return "Customer{" +
                    "custId=" + custId +
                    ", custName='" + custName + '\'' +
                    ", custSource='" + custSource + '\'' +
                    ", custLevel='" + custLevel + '\'' +
                    ", custIndustry='" + custIndustry + '\'' +
                    ", custPhone='" + custPhone + '\'' +
                    ", custAddress='" + custAddress + '\'' +
                    '}';
        }
    }

jpql 查询案例

package top.lhb.test;

import org.junit.Test;
import top.lhb.utils.JpaUtils;

import javax.persistence.EntityManager;
import javax.persistence.EntityTransaction;
import javax.persistence.Query;
import java.util.List;

/**
 * Created by LHB on 2018/12/28
 */
public class JpqlTest {

    /**
     * 查询全部
     *      jqpl：from cn.itcast.domain.Customer
     *      sql：SELECT * FROM cst_customer
     */
    @Test
    public void testFindAll(){
        EntityManager em = JpaUtils.getEntityManager();
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        String jpql="from Customer";
        Query query = em.createQuery(jpql);
        List list = query.getResultList();
        for (Object obj : list) {
            System.out.println(obj);
        }

        tx.commit();
        em.close();
    }


    /**
     * 排序查询： 倒序查询全部客户（根据id倒序）
     *      sql：SELECT * FROM cst_customer ORDER BY cust_id DESC
     *      jpql：from Customer order by custId desc
     *
     * 进行jpql查询
     *      1.创建query查询对象
     *      2.对参数进行赋值
     *      3.查询，并得到返回结果
     */
    @Test
    public void testOrders(){
        EntityManager em = JpaUtils.getEntityManager();
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        String jpql="from Customer order by custId desc";
        Query query = em.createQuery(jpql);
        List list = query.getResultList();
        for (Object obj : list) {
            System.out.println(obj);
        }
        tx.commit();
        em.close();
    }


    /**
     * 使用jpql查询，统计客户的总数
     *      sql：SELECT COUNT(cust_id) FROM cst_customer
     *      jpql：select count(custId) from Customer
     */
    @Test
    public void testCount() {
        EntityManager em = JpaUtils.getEntityManager();
        EntityTransaction tx = em.getTransaction();
        tx.begin();

        String jpql="select count(custId) from Customer";
        Query query = em.createQuery(jpql);
        //ii.对参数赋值
        //iii.发送查询，并封装结果

        /**
         * getResultList ： 直接将查询结果封装为list集合
         * getSingleResult : 得到唯一的结果集
         */
        Object result = query.getSingleResult();
        System.out.println(result);
        tx.commit();
        em.close();
    }


    /**
     * 分页查询
     *      sql：select * from cst_customer limit 0,2
     *      jqpl : from Customer
     */
    @Test
    public void testPaged() {
        EntityManager em = JpaUtils.getEntityManager();
        EntityTransaction tx = em.getTransaction();
        tx.begin();

        String jpql="from Customer";
        Query query = em.createQuery(jpql);
        query.setFirstResult(0);
        query.setMaxResults(2);

        List list = query.getResultList();
        for (Object obj : list) {
            System.out.println(obj);
        }
        tx.commit();
        em.close();
    }


    /**
     * 条件查询
     *     案例：查询客户名称以‘传智播客’开头的客户
     *          sql：SELECT * FROM cst_customer WHERE cust_name LIKE  ?
     *          jpql : from Customer where custName like ?
     */
    @Test
    public void testCondition() {
        EntityManager em = JpaUtils.getEntityManager();
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        String jpql="from Customer where custName like ?";
        Query query = em.createQuery(jpql);
        query.setParameter(1,"疾风%");
        List list = query.getResultList();
        for (Object obj : list) {
            System.out.println(obj);
        }
        tx.commit();
        em.close();
    }

    /**
     * 条件查询：
     *    单独查询两列
     * select c.custName ,c.custAddress from Customer c
     */

    @Test
    public void testSelect(){
        EntityManager em = JpaUtils.getEntityManager();
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        String jpql="select new top.lhb.domain.Customer(c.custName,custAddress)from Customer c ";
        Query query = em.createQuery(jpql);
        List list = query.getResultList();
        for (Object obj : list) {
            System.out.println(obj);
        }
        tx.commit();
        em.close();


    }


}