JPA的基本操作

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence" version="2.0">
<!-- 需要配置一个persistence-unit节点
  持久化单元：
        name 持久化单元名称
        transaction-type 事务管理的方式
          两个属性：
          Jpa  分布式事务管理  （不同的表存在不同的数据库中）
          RESOURCE_LOCAL   本地事务管理   （表都存在一个数据库中）
-->
    <persistence-unit name="myJpa" transaction-type="RESOURCE_LOCAL">
        <!--jpa的实现方式-->
        <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
        <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="123465*"/>
            <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语句  false true
                 自动创建数据库表   create程序运行时创建数据库表如果有表先删除表在创建
                  update  程序运行时创建表 如果有表不会创建表  none 不会创建表 -->
            <property name="hibernate.show_sql" value="true"/>
            <property name="hibernate.hbm2ddl.auto" value="update"/>
        </properties>
    </persistence-unit>
</persistence>

    @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 class JpaUtils {

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

    /**
     * 获取EntityManager对象
     * @return
     */
    public static EntityManager getEntityManager(){
        return factory.createEntityManager();
    }

}

  /**
     * 测试jpa保存
     *    案例 保存一个客户到数据库中
     * jpa的操作步骤：
     *    1.加载配置文件创建工厂 (实体管理器工厂) 对象
     *    2.通过工厂（实体管理器工厂） 获取一个实体管理器
     *    3.获取事务对象，开启事务
     *    4.完成增删改查操作
     *    5.提交或回滚事务
     *    6.释放资源
     */
    @Test
    public void testSave(){
      //  1.加载配置文件创建工厂 (实体管理器工厂) 对象
//        EntityManagerFactory factory = Persistence.createEntityManagerFactory("myJpa");
      // 2.通过工厂（实体管理器工厂） 获取一个实体管理器
//        EntityManager em = factory.createEntityManager();
        EntityManager em = JpaUtils.getEntityManager();
        // 3.获取事务对象，开启事务
        //获取事务对象
        EntityTransaction tx = em.getTransaction();
        //开启事务
        tx.begin();
        // 4.完成增删改查操作  保存一个客户到数据库中
        Customer customer=new Customer();
        customer.setCustName("美团");
        customer.setCustIndustry("外卖");
        //保存
        em.persist(customer);//保存操作
        //5.提交事务
        tx.commit();
        //6.释放资源
        em.close();
        //factory.close();
    }

 /**
     * 使用find方法查询
     *   1.查询的对象就是当前客户对象本身
     *   2.在调用find方法的时候就会发送SQL语句查询数据库
     *  立即加载
     *
     * 根据id查询用户
     */
    @Test
    public void testFind(){
        //1.通过工具类获取一个EntityManager对象
        EntityManager em = JpaUtils.getEntityManager();
        //2.开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        //3.增删改查
        /**
         * 根据id查询数据
         *     class:查询数据的结果需要包装的实体类类型的字节码
         *     id：查询的主键的取值
         *  配置文件需要改成update
         */
        Customer customer = em.find(Customer.class, 1l);
        System.out.println(customer);
        //4.提交事务
        tx.commit();
        //5.释放资源
        em.close();
    }

    /**
     * 使用getReference方法查询
     *     1.获取的对象是一个动态代理对象
     *     2.调用getReference方法不会立即发送SQL查询数据库
     *          当调用查询结果对象的时候才会发送查询的SQL语句
     *           什么时候用什么时候发送SQL语句查询数据库
     *    延迟加载（懒加载）  一般使用延迟加载
     *         得到的是一个动态代理对象
     *         什么时候用什么时候才会查询
     * 根据id查询用户
     */
    @Test
    public void testFind2(){
        //1.通过工具类获取一个EntityManager对象
        EntityManager em = JpaUtils.getEntityManager();
        //2.开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        //3.增删改查
        /**
         * 根据id查询数据
         *     class:查询数据的结果需要包装的实体类类型的字节码
         *     id：查询的主键的取值
         *  配置文件需要改成update
         */
        Customer customer = em.getReference(Customer.class, 1l);
        System.out.println(customer);
        //4.提交事务
        tx.commit();
        //5.释放资源
        em.close();
    }

    /**
     * 客户的更新操作
     * merge(Object)
     */
    @Test
    public void testUpdate(){
        //1.通过工具类获取一个EntityManager对象
        EntityManager em = JpaUtils.getEntityManager();
        //2.开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        //3.增删改查    更新操作
         //先查询客户
        Customer customer = em.getReference(Customer.class, 2l);
        //更新客户
        customer.setCustIndustry("p图");
        em.merge(customer);
        //4.提交事务
        tx.commit();
        //5.释放资源
        em.close();
    }

  /**
     * 删除客户的案例
     *  根据id 删除
     */
    @Test
    public void testRemove(){
        //1.通过工具类获取一个EntityManager对象
        EntityManager em = JpaUtils.getEntityManager();
        //2.开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        //3.增删改查
        //根据id查询客户
        Customer customer = em.getReference(Customer.class, 3l);
        //调用remove方法完成删除操作
        em.remove(customer);
        //4.提交事务
        tx.commit();
        //5.释放资源
        em.close();
    }

 @Test
    /**
     * 查询全部
     *    jpql：from cn.itcast.domain.Customer
     *    sql：select * from cst_customer
     */
    public void testFindAll(){
        //1.获取EntityManager对象
        EntityManager em = JpaUtils.getEntityManager();
        //2.开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        //3.查询所有
        String jpql="from cn.itcast.domain.Customer";
        Query query = em.createQuery(jpql);//创建query查询对象 query对象才是执行jpql的对象。
        //发送查询，并封装结果集
        List list = query.getResultList();
        //遍历结果集
        for (Object object:list){
            System.out.println(object);
        }
        //4.提交事务
        tx.commit();
        //5.释放资源
        em.close();
    }

   @Test
   /**
    * 排序查询 倒序查询全部客户（根据id倒序）
    *  jpql：from Customer order by custId desc
    *  sql：select * from cst_customer order by cust-id desc
    *
    *  进行jpql查询
    *    1.创建query查询对象
    *    2.对参数进行赋值
    *    3.查询并得到返回结果集
    *
    */
    public void testOrder(){
        //1.获取EntityManager对象
        EntityManager em = JpaUtils.getEntityManager();
        //2.开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        //3.查询所有
        String jpql="from Customer order by custId desc";
        Query query = em.createQuery(jpql);//创建query查询对象 query对象才是执行jpql的对象。
        //发送查询，并封装结果集
        List list = query.getResultList();
        //遍历结果集
        for (Object object:list){
            System.out.println(object);
        }
        //4.提交事务
        tx.commit();
        //5.释放资源
        em.close();
    }

  @Test
    /**
     * 使用jpql查询，统计客户的总数
     *    sql: select count(cust_id) from cst_customer
     *    jpql:select count(custId) from Customer
     */
    public void testCount(){
        //1.获取EntityManager对象
        EntityManager em = JpaUtils.getEntityManager();
        //2.开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        //3.查询所有
        // 根据jpql语句创建query查询对象
        String jpql="select count(custId) from Customer";
        Query query = em.createQuery(jpql);//创建query查询对象 query对象才是执行jpql的对象。
        //对参数赋值  没参数可以省略
        //发送查询，并封装结果集
        /**
         * getResultList:直接将查询结果封装为list集合
         *
         * getSingleResult:得到唯一的结果集
         */
        Object o = query.getSingleResult();
        System.out.println(o);
        //4.提交事务
        tx.commit();
        //5.释放资源
        em.close();
    }

 /**
     * 分页查询
     *
     * jpql: from Customer
     */
    @Test
    public void testPaged() {
        //1.获取EntityManager对象
        EntityManager em = JpaUtils.getEntityManager();
        //2.开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        //3.查询所有
        // 根据jpql语句创建query查询对象
        String jpql = " from Customer";
        Query query = em.createQuery(jpql);//创建query查询对象 query对象才是执行jpql的对象。
        //对参数赋值  没参数可以省略---分页参数
        //起始索引  从零开始查 不包含零
        query.setFirstResult(0);
        //每页显示的条数
        query.setMaxResults(3);
        //发送查询，并封装结果集
        /**
         * getResultList:直接将查询结果封装为list集合
         *
         * getSingleResult:得到唯一的结果集
         */
        List list = query.getResultList();
        for (Object obj : list) {
            System.out.println(obj);
        }
        //4.提交事务
        tx.commit();
        //5.释放资源
        em.close();
    }

 /**
     * 条件查询
     * 查询客户名称 以美图开头的客户
     * jpql: from Customer where
     */
    @Test
    public void testCondition() {
        //1.获取EntityManager对象
        EntityManager em = JpaUtils.getEntityManager();
        //2.开启事务
        EntityTransaction tx = em.getTransaction();
        tx.begin();
        //3.查询所有
        // 根据jpql语句创建query查询对象
        String jpql = "from Customer where custName like ?";
        Query query = em.createQuery(jpql);//创建query查询对象 query对象才是执行jpql的对象。
        //对参数赋值  没参数可以省略---占位符参数\
        //第一个参数 占位符的索引位置（从1开始），第二个参数：占位符的取值
        query.setParameter(1, "美图%");
        //发送查询，并封装结果集
        /**
         * getResultList:直接将查询结果封装为list集合
         *
         * getSingleResult:得到唯一的结果集
         */
        List list = query.getResultList();
        for (Object obj : list) {
            System.out.println(obj);
        }
        //4.提交事务
        tx.commit();
        //5.释放资源
        em.close();
    }