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.释放资源 i.搭建环境的过程 1.创建maven工程导入坐标 2.需要配置jpa的核心配置文件 *位置：配置到类路径下的一个叫做 META-INF 的文件夹下 *命名：persistence.xml 3.编写客户的实体类 4.配置实体类和表，类中属性和表中字段的映射关系 5.保存客户到数据库中 ii.完成基本CRUD案例 persist ： 保存 merge ： 更新 remove ： 删除 find/getRefrence ： 根据id查询 iii.jpql查询 sql：查询的是表和表中的字段 jpql：查询的是实体类和类中的属性 * jpql和sql语句的语法相似 1.查询全部 2.分页查询 3.统计查询 4.条件查询 5.排序
项目结构：
依赖
<properties> <maven.compiler.source>8</maven.compiler.source> <maven.compiler.target>8</maven.compiler.target> <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> <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <version>1.18.20</version> </dependency> </dependencies>
persistence.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"> <!--事务的实现--> <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider> <!--可选配置：配置jpa实现方式的配置信息--> <properties> <!--数据库信息 用户名：javax.persistence.jdbc.user 密码:javax.persistence.jdbc.password 驱动:javax.persistence.jdbc.diver 数据库地址: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:///jpa"/> <!--配置jpa实现方（hibernate）的配置信息 显示sql：false|true 自动创建数据库表:hibernate.hbm2ddl.auto create：程序运行时创建数据库表（如果有表，先删除表在创建） update:程序运行时穿件表（如果有表，不会删除表） none:不会创建表 --> <property name="hibernate.show_sql" value="true"/> <property name="hibernate.hbm2ddl.auto" value="update"/> </properties> </persistence-unit> </persistence>
实体类
package com.qijian.domain; import lombok.Data; import javax.persistence.*; /** * TODO 客户实体类 * 配置映射关系 * 1，实体类和表的映射关系 * 2，实体类中属性和表中字段的映射关系 * 1, * @Entity:申明实体类 * @Table：配置实体类和表的映射关系 * name:配置数据库表的名称 *2, * * @author qijian. * @date 2021/7/25 11:17 */ @Data @Entity @Table(name = "cst_customer") public class Customer { /** * 客户主键 * @Id:申明是主键的配置 * @GeneratedValue配置主键的生成策略 * strategy = GenerationType.IDENTITY:自增 * public enum GenerationType{ * TABLE, * SEQUENCE, * IDENTITY, * AUTO * } * JPA提供的四种标准用法为TABLE，SEQUENCE，IDENTITY，AUTO。 * a，TABLE：使用一个特定的数据库表格来保存主键。 * b，SEQUENCE：根据底层数据库的序列来生成主键，条件是数据库支持序列。 * c，IDENTITY：主键由数据库自动生成（主要是自动增长型） mysql数据库 * d，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_industry") private String custIndustry; /** * 客户级别 */ @Column(name = "cust_level") private String custLevel; /** * 客户地址 */ @Column(name = "cust_address") private String custAddress; /** * 客户联系方式 */ @Column(name = "cust_phone") private String custPhone; }
工具类
package com.qijian.utils; import javax.persistence.EntityManager; import javax.persistence.EntityManagerFactory; import javax.persistence.Persistence; /** * TODO 解决实体管理器工厂的浪费资源和消耗 * 通过静态代码块的形式，当程序第一次访问工具类时，创建一个公共的实体类管理器工厂对象 * * 第一次访问getEntityManager方法，经过静态代码块创建factory对象，再调用方法创建一个EntityManager对象 * 第二次访问getEntityManager方法，直接通过一个已经创建的factory对象，再创建一个EntityManager对象 * @author qijian. * @date 2021/7/25 19:34 */ public class JpaUtils { private static EntityManagerFactory factory; static { //1，加载配置文件，创建entityMangerFactory factory = Persistence.createEntityManagerFactory("MyJpa"); } /** * 获取EntityManager对象 */ public static EntityManager getEntityMaanger(){ return factory.createEntityManager(); } }
测试
测试jpa的保存
案例：保存一个客户到数据库中
jpa的操作
1，加载配置文件穿件工厂（实体管理工厂）对象
2，通过试题管理工厂获取实体管理器
3，获取食物对象，开启事务
4，完成增删改查的操作
5，提交事务
6，释放资源
@Test public void test2(){ // // * 1，加载配置文件穿件工厂（实体管理工厂）对象 // EntityManagerFactory factory = Persistence.createEntityManagerFactory("MyJpa"); // // * 2，通过试题管理工厂获取实体管理器 // EntityManager em = factory.createEntityManager(); EntityManager em = JpaUtils.getEntityMaanger(); // * 3，获取食物对象，开启事务 EntityTransaction tx = em.getTransaction(); tx.begin();//开启事务 Customer customer = new Customer(); customer.setCustName("qijian"); customer.setCustPhone("12345678"); //保存你 em.persist(customer); tx.commit();//提交事务 //释放资源 em.close(); // factory.close();//使用JpaUtils后factory就是公共的不能关闭，关闭后下次就不能使用了 }
/**
* 根据id查询客户
* 使用find方法查询（立即加载）
* 1，查询的对象就是当前客户对象本身
* 2，在调用find方法的时候，就发送sql语句查询数据库
*/
@Test public void testFind(){ // * 1，加载配置文件穿件工厂（实体管理工厂）对象 EntityManagerFactory factory = Persistence.createEntityManagerFactory("MyJpa"); // * 2，通过试题管理工厂获取实体管理器 EntityManager em = factory.createEntityManager(); // * 3，获取事务·对象，开启事务 EntityTransaction tx = em.getTransaction(); tx.begin(); /** * 增删改查 -- 根据id查询客户 * find:根据id查询数据库 * class：查询数据结构需要包装的实体类型的字节码 * id:插叙主键的值 * */ Customer customer = em.find(Customer.class,1l); System.out.println(customer); tx.commit(); factory.close(); // Hibernate: // select // customer0_.cust_id as cust_id1_0_0_, // customer0_.cust_address as cust_add2_0_0_, // customer0_.cust_industry as cust_ind3_0_0_, // customer0_.cust_level as cust_lev4_0_0_, // customer0_.cust_name as cust_nam5_0_0_, // customer0_.cust_phone as cust_pho6_0_0_, // customer0_.cust_source as cust_sou7_0_0_ // from // cst_customer customer0_ // where // customer0_.cust_id=? // Customer(custId=1, custName=qijian, custSource=null, custIndustry=学生, custLevel=null, custAddress=深圳, custPhone=12345678) }
/**
* 根据id查询客户
* getReference方法
* 1，获取的对象时一个动态代理对象
* 2，调用getReference方法不会立即发送sql查询数据库
* *当调用查询结果对象的时候，才会发送sql语句，也就是说，什么时候用什么时候发送sql语句查询数据库
*/
@Test public void testReference() { // * 1，加载配置文件穿件工厂（实体管理工厂）对象 EntityManagerFactory factory = Persistence.createEntityManagerFactory("MyJpa"); // * 2，通过试题管理工厂获取实体管理器 EntityManager em = factory.createEntityManager(); // * 3，获取事务·对象，开启事务 EntityTransaction tx = em.getTransaction(); tx.begin(); /** * 增删改查 -- 根据id查询客户 * getReference:根据id查询数据库(延迟加载) * class：查询数据结构需要包装的实体类型的字节码 * id:插叙主键的值 * */ Customer customer = em.getReference(Customer.class, 1l); System.out.println(customer); tx.commit(); factory.close(); }
/**
* 删除客户
*/
@Test public void testmove(){ //通过工厂获取EntityManager对象 EntityManagerFactory factory = Persistence.createEntityManagerFactory("MyJpa"); EntityManager em = factory.createEntityManager(); //开启事务 EntityTransaction tx = em.getTransaction(); tx.begin(); //3,删除客户 // 1,查询用户 Customer customer = em.getReference(Customer.class,1l); //2,删除用户 em.remove(customer); //提交事务 tx.commit(); //释放资源 em.close(); factory.close(); }
查询用户
@Test public void testUpdate(){ //通过工厂获取entityManager EntityManagerFactory factory = Persistence.createEntityManagerFactory("MyJpa"); EntityManager em = factory.createEntityManager(); //2，开启事务 EntityTransaction tx = em.getTransaction(); tx.begin(); //3,增删改查 更新操作 //i,查询用户 Customer customer = em.find(Customer.class,1l); //ii,更新客户 customer.setCustIndustry("IT"); em.merge(customer); //4,事务提交 tx.commit(); //释放资源 em.close(); factory.close(); }
测试jpql查询
/**
* 查询全部
* jpql:from cn.qijian.domain.Customer
* sql:select * from cst_customer
*/
@Test public void testFindall(){ //1，获取EntityManger对象 EntityManagerFactory factory = Persistence.createEntityManagerFactory("MyJpa"); EntityManager em = factory.createEntityManager(); //2,开启事务 EntityTransaction et = em.getTransaction(); et.begin(); //3，查询全部 String jqpl = "from com.qijian.domain.Customer"; Query query = em.createQuery(jqpl);//创建查询对象，query对象才是执行jqpl对象 //发送查询，并封装结果集 List list = query.getResultList(); System.out.println(list.size()); for (Object o:list ) { System.out.println(o); } //4，提交事务 et.commit(); //5,释放资源 em.close(); }
/**排序查询 ： 倒叙查询全部用户（根据id）
* sql: SELECT * FROM cst_customer ORDER BY cust_id DESC;
* jpql:from Customer order by custId
*/
@Test public void testOrder(){ //1，获取EntityManger对象 EntityManagerFactory factory = Persistence.createEntityManagerFactory("MyJpa"); EntityManager em = factory.createEntityManager(); //2,开启事务 EntityTransaction et = em.getTransaction(); et.begin(); //3，查询全部 String jqpl = "from com.qijian.domain.Customer order by custId desc "; Query query = em.createQuery(jqpl);//创建查询对象，query对象才是执行jqpl对象 //发送查询，并封装结果集 List list = query.getResultList(); System.out.println(list.size()); for (Object o:list ) { System.out.println(o); } //4，提交事务 et.commit(); //5,释放资源 em.close(); }
/**
* 使用jpql统计客户的总人数
* sql:SELECT COUNT(cust_id) FROM cst_customer ;
* jpql:SELECT COUNT(cust_id) FROM Customer ;
*/
@Test public void testCount(){ //1，获取EntityManger对象 EntityManagerFactory factory = Persistence.createEntityManagerFactory("MyJpa"); EntityManager em = factory.createEntityManager(); //2,开启事务 EntityTransaction et = em.getTransaction(); et.begin(); //3，查询全部 String jqpl = "SELECT COUNT(custId) FROM Customer "; Query query = em.createQuery(jqpl);//创建查询对象，query对象才是执行jqpl对象 //发送查询，并封装结果集 /** * getResultList:直接将查询结果封装为list集合1 * getSingleResult：的到唯一的结果集 */ Object result =query.getSingleResult(); System.out.println(result); //4，提交事务 et.commit(); //5,释放资源 em.close(); }
/**
* 分页查询
* sql SELECT * FROM cst_customer LIMIT ？;
* jqpl: from Customer
*/
@Test public void testPaged(){ //1，获取EntityManger对象 EntityManagerFactory factory = Persistence.createEntityManagerFactory("MyJpa"); EntityManager em = factory.createEntityManager(); //2,开启事务 EntityTransaction et = em.getTransaction(); et.begin(); //3，查询全部 //i,根据jpql语句创建Query查询对象 String jqpl = "FROM Customer "; Query query = em.createQuery(jqpl);//创建查询对象，query对象才是执行jqpl对象 //ii,对参数赋值 - 分页查询 //起始索引 query.setFirstResult(0); //分页查询的条数 query.setMaxResults(2); /** * getResultList:直接将查询结果封装为list集合1 * getSingleResult：的到唯一的结果集 */ List list = query.getResultList(); for (Object obj : list){ System.out.println(obj); } //4，提交事务 et.commit(); //5,释放资源 em.close(); }
/**
* 条件查询
* 案例 ：
* sql：select * from cst_customer where cust_name like ?
* jpql:from Customer where custName like ?
*/
@Test public void testCondition(){ //1，获取EntityManger对象 EntityManagerFactory factory = Persistence.createEntityManagerFactory("MyJpa"); EntityManager em = factory.createEntityManager(); //2,开启事务 EntityTransaction et = em.getTransaction(); et.begin(); //3，查询全部 //i,根据jpql语句创建Query查询对象 String jqpl = "from Customer where custAddress like ?"; Query query = em.createQuery(jqpl);//创建查询对象，query对象才是执行jqpl对象 //ii,对参数赋值 - 占位符参数 //第一个参数：占位符索引的位置（从1开始），第二各参数 ； 取值 query.setParameter(1,"北_"); /** * getResultList:直接将查询结果封装为list集合1 * getSingleResult：的到唯一的结果集 */ List list = query.getResultList(); for (Object obj : list){ System.out.println(obj); } //4，提交事务 et.commit(); //5,释放资源 em.close(); }
