JPA学习（二）创建JPAUtil 和简单的增删改查

男娘i 2023-06-07 10:56 19阅读 0赞

前章：[https://blog.csdn.net/qq\_28198181/article/details/102550503][https_blog.csdn.net_qq_28198181_article_details_102550503]

这一节简单的记录一下 创建一个JPAUti类和增删改查的方法

依赖在上一章；

--------------------

**目录**

1.创建JPAUTIL

2.创建增删改查方法

--------------------

# 1.创建JPAUTIL #

创建JPAUtil是用来通过这个方法得到一个单例的entityManagerFactory

public class JPAUtil {
    
        private static EntityManagerFactory entityManagerFactory;
    
        public static EntityManagerFactory getEntityManagerFactoryInstance() {
            if (entityManagerFactory == null) {
                try {
                    entityManagerFactory = Persistence.createEntityManagerFactory("com.zqj.jpa");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            return entityManagerFactory;
        }
    }

这个是一个得到工厂的方法，如果说当前实例的对象为空，会去new一个，如果不是则直接返回。

# 2.创建增删改查方法 #

增加数据的方法：

public void create() {
            //获取管理对象工厂
            EntityManagerFactory entityManagerFactory = JPAUtil.getEntityManagerFactoryInstance();
            //得到管理对象
            EntityManager entityManager = entityManagerFactory.createEntityManager();
            //得到事务
            EntityTransaction transaction = entityManager.getTransaction();
            transaction.begin();
            Employee employee = new Employee();
            employee.setName("GGO");
            employee.setPassword("GGOPWD");
            entityManager.persist(employee);
            //每次得新建一个对象
            employee = new Employee();
            employee.setName("SAO");
            employee.setPassword("SAOPWD");
            entityManager.persist(employee);
            //提交事务
            transaction.commit();
            //关闭管理对象
            entityManager.close();
            entityManagerFactory.close();
        }

**注意：按照我这种方式添加多个数据进入数据库，需要每次new一个对象 否则用同一个对象会直接修改原来的数据**

** **

查询的方法：分为单个查询和多个查询

单个查询：

public void findOne() {
            EntityManagerFactory entityManagerFactory = JPAUtil.getEntityManagerFactoryInstance();
            EntityManager entityManager = entityManagerFactory.createEntityManager();
            //查询可以不用事务  提高效率
            Employee employee1 = entityManager.find(Employee.class, 1L);// private Long id; 主键严格按照类型处理
            System.out.println("SELECT:" + employee1.toString());
            entityManager.close();
            //关闭管理对象工厂实例
            entityManagerFactory.close();
        }

find方法 是要查询的持久类以及主键id。持久类的id类型要一致

多个查询

@Test
        public void findAll() {
            EntityManagerFactory entityManagerFactory = JPAUtil.getEntityManagerFactoryInstance();
            EntityManager entityManager = entityManagerFactory.createEntityManager();
            //如果出现jpql出现的sql关键字 大小写不敏感 
            //最标准的写法
    //        String jpql = "SELECT o " +
    //                     " FROM com.zqj.crud.Employee o";//不能出现表明列名,以及*号 只能是JAVA的类名，属性名，别名
            //推荐写法
            String jpql = "SELECT o " +
                    " FROM Employee o";//不能出现表明列名,以及*号 只能是JAVA的类名，属性名，别名
    
            Query query = entityManager.createQuery(jpql);
            List<Employee> resultList = query.getResultList();
            for (Employee e : resultList) {
                System.out.println(e.toString());
            }
            entityManager.close();
            //关闭管理对象工厂实例
            entityManagerFactory.close();
        }

多个查询要使用create.query方法，将jpql语句放入 jpql语句和传统的sql语句不一致。一定要用类去查询

查询完后得到一个list 遍历list就可以了。

修改语句：

@Test
        public void update() {
            EntityManagerFactory entityManagerFactory = JPAUtil.getEntityManagerFactoryInstance();
            EntityManager entityManager = entityManagerFactory.createEntityManager();
            EntityTransaction transaction = entityManager.getTransaction();
            transaction.begin();
            Employee employee1 = entityManager.find(Employee.class, 1L);// private Long id; 主键严格按照类型处理
            employee1.setPassword("SAOPASSWORD");
            employee1.setName("SAO");
            System.out.println("UPDATE:" + employee1.toString());
            entityManager.merge(employee1);
    
    
            transaction.commit();
            entityManager.close();
            entityManagerFactory.close();
        }

修改的话 先得到对应的对象数据，然后修改完毕通过merge方法修改。

删除语句

public void delete() {
            EntityManagerFactory entityManagerFactory = JPAUtil.getEntityManagerFactoryInstance();
            EntityManager entityManager = entityManagerFactory.createEntityManager();
            EntityTransaction transaction = entityManager.getTransaction();
            transaction.begin();
            Employee employee = entityManager.find(Employee.class, 1L);
            System.out.println("DELETE:" + employee.toString());
            entityManager.remove(employee);
            transaction.commit();
    
            entityManager.close();
            entityManagerFactory.close();
        }

也是先得到数据，再用remove方法删掉即可

将方法放入某一个Test类中：

import com.zqj.util.JPAUtil;
    import org.junit.Before;
    import org.junit.Test;
    
    import javax.persistence.EntityManager;
    import javax.persistence.EntityManagerFactory;
    import javax.persistence.EntityTransaction;
    import javax.persistence.Query;
    import java.util.List;
    
    /**
     * @author : HYXT_ZouQiJun
     * @createTime : 2019/10/14 16:35
     * @descrption :
     */
    public class CrudTest {
    
        @Before
        public void create() {
            //获取管理对象工厂
            EntityManagerFactory entityManagerFactory = JPAUtil.getEntityManagerFactoryInstance();
            //得到管理对象
            EntityManager entityManager = entityManagerFactory.createEntityManager();
            //得到事务
            EntityTransaction transaction = entityManager.getTransaction();
            transaction.begin();
            Employee employee = new Employee();
            employee.setName("GGO");
            employee.setPassword("GGOPWD");
            entityManager.persist(employee);
            //每次得新建一个对象
            employee = new Employee();
            employee.setName("SAO");
            employee.setPassword("SAOPWD");
            entityManager.persist(employee);
            //提交事务
            transaction.commit();
            //关闭管理对象
            entityManager.close();
            //entityManagerFactory.close();
        }
    
        @Test
        public void findOne() {
            EntityManagerFactory entityManagerFactory = JPAUtil.getEntityManagerFactoryInstance();
            EntityManager entityManager = entityManagerFactory.createEntityManager();
            //查询可以不用事务  提高效率
            Employee employee1 = entityManager.find(Employee.class, 1L);// private Long id; 主键严格按照类型处理
            System.out.println("SELECT:" + employee1.toString());
            entityManager.close();
            //关闭管理对象工厂实例
            entityManagerFactory.close();
        }
    
        @Test
        public void findAll() {
            EntityManagerFactory entityManagerFactory = JPAUtil.getEntityManagerFactoryInstance();
            EntityManager entityManager = entityManagerFactory.createEntityManager();
            //如果出现jpql出现的sql关键字 大小写不敏感 
            //最标准的写法
    //        String jpql = "SELECT o " +
    //                     " FROM com.zqj.crud.Employee o";//不能出现表明列名,以及*号 只能是JAVA的类名，属性名，别名
            //推荐写法
            String jpql = "SELECT o " +
                    " FROM com.zqj.crud.Employee o";//不能出现表明列名,以及*号 只能是JAVA的类名，属性名，别名
    
            Query query = entityManager.createQuery(jpql);
            List<Employee> resultList = query.getResultList();
            for (Employee e : resultList) {
                System.out.println(e.toString());
            }
            entityManager.close();
            //关闭管理对象工厂实例
            entityManagerFactory.close();
        }
    
        @Test
        public void update() {
            EntityManagerFactory entityManagerFactory = JPAUtil.getEntityManagerFactoryInstance();
            EntityManager entityManager = entityManagerFactory.createEntityManager();
            EntityTransaction transaction = entityManager.getTransaction();
            transaction.begin();
            Employee employee1 = entityManager.find(Employee.class, 1L);// private Long id; 主键严格按照类型处理
            employee1.setPassword("SAOPASSWORD");
            employee1.setName("SAO");
            System.out.println("UPDATE:" + employee1.toString());
            entityManager.merge(employee1);
    
    
            transaction.commit();
            entityManager.close();
            entityManagerFactory.close();
        }
    
        @Test
        public void delete() {
            EntityManagerFactory entityManagerFactory = JPAUtil.getEntityManagerFactoryInstance();
            EntityManager entityManager = entityManagerFactory.createEntityManager();
            EntityTransaction transaction = entityManager.getTransaction();
            transaction.begin();
            Employee employee = entityManager.find(Employee.class, 1L);
            System.out.println("DELETE:" + employee.toString());
            entityManager.remove(employee);
            transaction.commit();
    
            entityManager.close();
            entityManagerFactory.close();
        }
    }

**注意：因为在最开始的persistence.xml文件中配置的是create方法 所以每次都要新建数据库表，所以通过before注解的方法让其先有数据，然后entityManagerFacotry对象没有关闭，因为后面的方法要使用，使用完毕后才关闭的。**

**否则会报错：**

![20191014173644782.png][]

简单记录如上。

--------------------

2019.10.15更：  
代码方法的一些原理以及伪代码：

package com.zqj.crud;
    
    import com.zqj.util.JPAUtil;
    import org.junit.Before;
    import org.junit.Test;
    
    import javax.persistence.EntityManager;
    import javax.persistence.EntityManagerFactory;
    import javax.persistence.EntityTransaction;
    import javax.persistence.Query;
    import java.util.List;
    
    /**
     * @author : HYXT_ZouQiJun
     * @createTime : 2019/10/14 16:35
     * @descrption :
     */
    public class CrudTest {
    
        @Before
        public void create() {
            //获取管理对象工厂
            EntityManagerFactory entityManagerFactory = JPAUtil.getEntityManagerFactoryInstance();
            //得到管理对象
            EntityManager entityManager = entityManagerFactory.createEntityManager();
            //得到事务
            EntityTransaction transaction = entityManager.getTransaction();
            transaction.begin();
            Employee employee = new Employee();
            employee.setName("GGO");
            employee.setPassword("GGOPWD");
            entityManager.persist(employee);
            //每次得新建一个对象
            employee = new Employee();
            employee.setName("SAO");
            employee.setPassword("SAOPWD");
            entityManager.persist(employee);
            //提交事务
            transaction.commit();
            //关闭管理对象
            entityManager.close();
            entityManagerFactory.close();
    
            /*
             * persist()原理实现
             * 1.所有能找到persist()方法里面传入的对象都必须在持久类上表名@Entity
             * 2.通过类名找到表名 eg:t_employee
             * 3.是否要Id主键加入到Insert语句
             * 关键看注解配置策略（方式）
             * @GeneratedValue(strategy = GenerationType.IDENTITY) //配置主键的生成
             * MysqlDialect方言不用处理主键
             * mysql :insert into t_employee()
             * Oracle的方言是需要加上序列的处理
             * oracle:insert into t_employee(eid)values(seq_emp.nextval,?,?)
             * 4.处理其他非主键属性
             * 主要是看是否有cloumn的注解
             * insert into t_employee(name,pwd)values(?,?)
             * 5.?的值通过反射技术获取employee对象的值然后把sql交给jdbc处理
             * */
        }
    
        @Test
        public void findOne() {
            EntityManagerFactory entityManagerFactory = JPAUtil.getEntityManagerFactoryInstance();
            EntityManager entityManager = entityManagerFactory.createEntityManager();
            //查询可以不用事务  提高效率
            Employee employee1 = entityManager.find(Employee.class, 1L);// private Long id; 主键严格按照类型处理
            //find()底层      Employee employee2 = Employee.class.newInstance(); 这样需要默认构造方法 通过反射机制创建新的对象
    
            System.out.println("SELECT:" + employee1.toString());
            entityManager.close();
            //关闭管理对象工厂实例
            entityManagerFactory.close();
    
            /**
             *find（）签名 <T> T find(Class<T> paramClass,Object ParamObject)
             * 第一个参数 字节码对象
             * 第二个参数 主键对象
             *  Employee employee1 = entityManager.find(Employee.class, 1L)
             *  find方法默认都是查询表的所有的字段,
             *  解析的持久类上面的注解 获取 id property 查看是否有column
             *  就可以解析出sql语句
             *  select eid,name,pwd, from t_employee where id = ?
             *  再交给jdbc 执行
             *  因为是单个 查询 所以可能查询null
             *  ResultSet rs; 比如伪代码如下：
             *  if(rs.next){
             *      Employee e = Employee.class.newInstance() 使用这个newInstance 必须保证注解的持久类是必须要有默认构造器
             *      否则会报错 没有默认无参构造的异常
             *      emp.setId(rs.getLong("Id"));
             *      ......
             *      return emp
             *  }else{
             *      return null;
             *  }
             */
        }
    
        @Test
        public void findAll() {
            EntityManagerFactory entityManagerFactory = JPAUtil.getEntityManagerFactoryInstance();
            EntityManager entityManager = entityManagerFactory.createEntityManager();
            //如果出现jpql出现的sql关键字 大小写不敏感 
            //最标准的写法
    //        String jpql = "SELECT o " +
    //                     " FROM com.zqj.crud.Employee o";//不能出现表明列名,以及*号 只能是JAVA的类名，属性名，别名
            //推荐写法
            String jpql = "SELECT o " +
                    " FROM com.zqj.crud.Employee o";//不能出现表明列名,以及*号 只能是JAVA的类名，属性名，别名
    
            Query query = entityManager.createQuery(jpql);
            List<Employee> resultList = query.getResultList();
            for (Employee e : resultList) {
                System.out.println(e.toString());
            }
            entityManager.close();
            //关闭管理对象工厂实例
            entityManagerFactory.close();
    
            /*
            * 处理 jpql语句 查询
            * 和find 方法差不多 如果没查到不是返回null 而是返回集合为0的list对象
            * 伪代码：
            * List<Employee> list = new ArrayList<Employee>;
            * while(rs.next){
            * Empolyee emp = Employee.class.newInstance();
            * remp.setId(xxxx)
            * ......
            * list.add(employee);
            * }
            * return list;
            * */
        }
    
        @Test
        public void update() {
            EntityManagerFactory entityManagerFactory = JPAUtil.getEntityManagerFactoryInstance();
            EntityManager entityManager = entityManagerFactory.createEntityManager();
            EntityTransaction transaction = entityManager.getTransaction();
            transaction.begin();
            Employee employee1 = entityManager.find(Employee.class, 1L);// private Long id; 主键严格按照类型处理
            employee1.setPassword("SAOPASSWORD");
            employee1.setName("SAO");
            System.out.println("UPDATE:" + employee1.toString());
            entityManager.merge(employee1);
    
    
            transaction.commit();
            entityManager.close();
            entityManagerFactory.close();
        }
    
        @Test
        public void delete() {
            EntityManagerFactory entityManagerFactory = JPAUtil.getEntityManagerFactoryInstance();
            EntityManager entityManager = entityManagerFactory.createEntityManager();
            EntityTransaction transaction = entityManager.getTransaction();
            transaction.begin();
            Employee employee = entityManager.find(Employee.class, 1L);
            System.out.println("DELETE:" + employee.toString());
            entityManager.remove(employee);
            transaction.commit();
    
            entityManager.close();
            entityManagerFactory.close();
        }
    }

[https_blog.csdn.net_qq_28198181_article_details_102550503]: https://blog.csdn.net/qq_28198181/article/details/102550503
[20191014173644782.png]: /images/20230601/8570540823884370bef66dcfbe67e471.png