JPA + SpringData 操作数据库原来可以这么简单 ---- 深入了解 JPA - 3

╰半橙微兮° 2024-02-19 00:03 34阅读 0赞

前言：

经过了前两篇的详细介绍，终于迎来了 JPA 的终结篇，楼主认为如果仅仅了解了 JPA 的话，大家可能感觉与 Hibernate 几乎差不多，没有什么亮点，但是等大家了解了 SpringData 后，JPA 与 SpringData 相结合，便会发挥出它巨大的优势，极大的简化了我们操作数据库的步骤，使我们的代码具有很强的可维护性，楼主随后的博客也将继续介绍。

#### 六、JPA 的**二级缓存** ####

1. 大家对一级缓存比较熟悉，即若查询一条同样的记录，因为一级缓存的存在只发送一条 SQL 语句。那么 JPA 的二级缓存又体现在哪呢？楼主给大家解释为：查询一条同样的记录，在第一次查询后关闭 EntityManager、提交事务后，再重新获取 EntityManager 并开启事务再查询同样的记录，因为有二级缓存的存在也会只发送一条记录。如下：

//测试 JPA 的二级缓存
        @Test
        public void testSecondLevelCache() {
            Customer customer1 = entityManager.find(Customer.class, 1);
            
            transaction.commit();
            entityManager.close();
            
            entityManager = entityManagerFactory.createEntityManager();
            transaction = entityManager.getTransaction();
            transaction.begin();
            
            Customer customer2 = entityManager.find(Customer.class, 1);
        }

大家可以看到，4 行和 13 行的查询语句一样，6 行，7 行 提交了事务关闭了 EntityManager。若不进行二级缓存的配置，这样的操作会发送两次一模一样的 SQL 语句，结果就不贴上了，大家可以试一试。若配置了二级缓存，同样的操作便只会发送一条 SQL ,这样可以减小服务器的压力，减少访问数据库的次数。那么如何来配置二级缓存呢？

2. 如何配置二级缓存：

1）persistence.xml 文件中配置二级缓存相关

<?xml version="1.0" encoding="UTF-8"?>
    <persistence version="2.0"
        xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">
        <persistence-unit name="jpa-1" transaction-type="RESOURCE_LOCAL">
            
            <provider>org.hibernate.ejb.HibernatePersistence</provider>
    
            
            <class>com.software.jpa.helloworld.Customer</class>
            <class>com.software.jpa.helloworld.Order</class>
    
            <class>com.software.jpa.helloworld.Manager</class>
            <class>com.software.jpa.helloworld.Department</class>
    
            <class>com.software.jpa.helloworld.Category</class>
            <class>com.software.jpa.helloworld.Item</class>
    
            
            <shared-cache-mode>ENABLE_SELECTIVE</shared-cache-mode>
    
            <properties>
                
                
                <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver" />
                <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/jpa" />
                <property name="javax.persistence.jdbc.user" value="root" />
                <property name="javax.persistence.jdbc.password" value="qiqingqing" />
    
                
                <property name="hibernate.format_sql" value="true" />
                <property name="hibernate.show_sql" value="true" />
                <property name="hibernate.hbm2ddl.auto" value="update" />
    
                
                <property name="hibernate.cache.use_second_level_cache"
                    value="true" />
                <property name="hibernate.cache.region.factory_class"
                    value="org.hibernate.cache.ehcache.EhCacheRegionFactory" />
                <property name="hibernate.cache.use_query_cache" value="true" />
            </properties>
        </persistence-unit>
    </persistence>

2）导入 ehcache 的 jar 包和配置文件 ehcache.xml

jar 包：

![1105175-20171023203955676-1924436734.png][]

配置文件：对二级缓存参数的配置

3）给需要缓存的类添加 @Cacheable(true) 注解，有前面的代码可知，楼主获取的是 Customer 对象

![1105175-20171023204152598-1839645945.png][]

二级缓存就给大家介绍到这里。

#### 七、JPQL ####

1.什么是 JPQL:JPQL语言，即 Java Persistence Query Language 的简称。

2.然后来看一个 JPQL 的 Helloworld：

//JPQL 的 HelloWorld
        @Test
        public void testHelloJPQL() {
            String jpql = "FROM Customer c WHERE c.age > ?";
            Query query = entityManager.createQuery(jpql);
            
            //占位符的索引是从 1 开始
            query.setParameter(1, 21);
            
            List<Customer> lists = query.getResultList();
            System.out.println(lists.size());
            
        }

乍一看，大家可能感觉 JPQL 像极了 Hibernate 的 HQL 查询，没错，这两种查询的相似度极高。需要注意的是，使用 Query 的 setParameter() 的方法填占位符是，索引是从 1

开始的。

3. 查询部分属性：

@Test
        public void testPartlyProperties() {
            String jpql = "SELECT new Customer(c.lastName, c.age) FROM Customer c WHERE c.id > ?";
            Query query = entityManager.createQuery(jpql);
            
            query.setParameter(1, 1);
            
            List lists = query.getResultList();
            System.out.println(lists);
        }

默认情况下若只查询部分属性，则将返回 Object\[\] 类型的结果或 Object\[\] 类型的 List，可以在实体类中创建对应的构造器，然后在 jpql 中利用对应的构造器返回实体类对应的对象，这样得到的结果可以很令人满意，也很方便我们来操作。

4.命名查询 NamedQuery：

1）在需要查询的对象类上添加 @NamedQuery 注解：

![1105175-20171024115954660-1782203382.png][]

2）创建测试方法：

![1105175-20171024120007223-1607836470.png][]

5. 本地 SQL 查询使用 EntityManager 的 createNativeQuery() 方法：

//本地 SQL 查询
        @Test
        public void testNativeQuery() {
            String sql = "SELECT age FROM jpa_customer WHERE id = ?";
            Query query = entityManager.createNativeQuery(sql).setParameter(1, 1);
            Object result = query.getSingleResult();
            System.out.println(result);
        }

6. 可以使用 Order By 字句：

// jpql 中的 Order By 子句
        @Test
        public void testOrderBy() {
            String jpql = "FROM Customer c WHERE c.age > ? ORDER BY c.age DESC";
            Query query = entityManager.createQuery(jpql);
            
            //占位符的索引是从 1 开始
            query.setParameter(1, 21);
            
            List<Customer> lists = query.getResultList();
            System.out.println(lists.size());
        }

7.还可以使用 Group By 子句：

//查询 order 数量大于 2 的那些 Customer
        @Test
        public void testGroupBy() {
            String jpql = "SELECT o.customer FROM Order o GROUP BY o.customer HAVING count(o.id) >= 2";
            List<Customer> lists = entityManager.createQuery(jpql).getResultList();
            System.out.println(lists);
        }

8.也可以使用子查询

//子查询
        @Test
        public void testSubQuery() {
            //查询所有 Customer 的 lastName 为 YY 的 Order
            String jpql = "SELECT o FROM Order o"
                    + " WHERE o.customer = (SELECT c FROM Customer c WHERE c.lastName = ?)";
            List<Order> orders = entityManager.createQuery(jpql).setParameter(1, "YY").getResultList();
            System.out.println(orders.size());
        }

#### 八、**Spring** **整合 JPA** ####

JPA 的一些 API 也可以放到 Spring 的 IOC 容器中，交由 Spring 容器管理，那么如何用 Spring 来整合 JPA 呢？

1.新建 JPA 工程，导入所需的 jar包（Hibernate、JPA、c3p0、Spring、MySQL 驱动）

2.类路径下创建 db.properties 数据库配置文件，配置数据库的链接信息(楼主在这只配置了必须属性)

1 jdbc.user=root
    2 jdbc.password=qiqingqing
    3 jdbc.driverClass=com.mysql.jdbc.Driver
    4 jdbc.jdbcUrl=jdbc:mysql://localhost:3306/jpa

3.类路径下创建 Spring 的配置文件 applicationContext.xml，配置自动扫描的包，将 db.propertiest 文件导入，并配置 c3p0 数据源

<context:component-scan base-package="com.software.jpa"></context:component-scan>
    
        
        <context:property-placeholder location="classpath:db.properties"/>
        
        <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
            <property name="user" value="${jdbc.user}"></property>
            <property name="password" value="${jdbc.password}"></property>
            <property name="driverClass" value="${jdbc.driverClass}"></property>
            <property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>
        </bean>

4.在 applicationContext.xml 中配置 JPA 的 EntityManagerFactory

<bean id="entityManagerFactory"
                     class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
            
            <property name="dataSource" ref="dataSource"></property>
            
            <property name="jpaVendorAdapter">
                <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter"></bean>
            </property>
            
            <property name="packagesToScan" value="com.software.jpa.spring.entities"></property>
            
            <property name="jpaProperties">
                <props>
                    <prop key="hibernate.show_sql">true</prop>
                    <prop key="hibernate.format_sql">true</prop>
                    <prop key="hibernate.hbm2ddl.auto">update</prop>
                </props>
            </property>
        </bean>

5.配置 JPA 使用的事务管理器及配置支持基于注解的事务配置

<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
            <property name="entityManagerFactory" ref="entityManagerFactory"></property>
        </bean>
        
        
        <tx:annotation-driven transaction-manager="transactionManager"/>

6.为了测试创建实体类 Person，添加相应的 JPA 注解，生成对应的数据表

package com.software.jpa.spring.entities;
    
    import javax.persistence.Column;
    import javax.persistence.Entity;
    import javax.persistence.GeneratedValue;
    import javax.persistence.Id;
    import javax.persistence.Table;
    
    @Table(name="JPA_PERSONS")
    @Entity
    public class Person {
        
        private Integer id;
        
        private String lastName;
        
        private String email;
        
        private Integer age;
    
        @GeneratedValue
        @Id
        public Integer getId() {
            return id;
        }
    
        public void setId(Integer id) {
            this.id = id;
        }
    
        @Column(name="LAST_NAME")
        public String getLastName() {
            return lastName;
        }
    
        public void setLastName(String lastName) {
            this.lastName = lastName;
        }
    
        public String getEmail() {
            return email;
        }
    
        public void setEmail(String email) {
            this.email = email;
        }
    
        public Integer getAge() {
            return age;
        }
    
        public void setAge(Integer age) {
            this.age = age;
        }
        
    }

7.创建 PersonDao 使用 @PersistenceContext 获取和当前事务关联的 EntityManager 对象

package com.software.jpa.dao;
    
    import javax.persistence.EntityManager;
    import javax.persistence.PersistenceContext;
    
    import org.springframework.stereotype.Repository;
    
    import com.software.jpa.spring.entities.Person;
    
    @Repository
    public class PersonDao {
        
        //使用 @PersistenceContext 获取和当前事务关联的 EntityManager 对象
        @PersistenceContext
        private EntityManager entityManager;
        
        public void save(Person p) {
            entityManager.persist(p);
        }
    
    }

8.创建 PersonService ，模拟事务操作，20 行楼主设计了一个算数异常，若整合成功，因为添加了事务操作，所以 18 行和 22 行的两条记录都没有插入进数据库。

package com.software.jpa.service;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    import org.springframework.transaction.annotation.Transactional;
    
    import com.software.jpa.dao.PersonDao;
    import com.software.jpa.spring.entities.Person;
    
    @Service
    public class PersonService {
        
        @Autowired
        private PersonDao dao;
    
        @Transactional
        public void save(Person p1, Person p2) {
            dao.save(p1);
            
            int i = 10/0;
            
            dao.save(p2);
        }
        
    }

9.创建测试方法，并执行

package com.software.jpa.spring;
    
    import javax.sql.DataSource;
    
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    import com.software.jpa.service.PersonService;
    import com.software.jpa.spring.entities.Person;
    
    public class JPATest {
        
        private ApplicationContext ctx = null;
        
        private PersonService personService = null;
        
        {
            ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
            
            personService = ctx.getBean(PersonService.class);
        }
        
        @Test
        public void testSave() {
            Person p1 = new Person();
            p1.setAge(11);
            p1.setEmail("aa@163.com");
            p1.setLastName("AA");
            
            Person p2 = new Person();
            p2.setAge(12);
            p2.setEmail("bb@163.com");
            p2.setLastName("BB");
            
            System.out.println(personService.getClass().getName());
            personService.save(p1, p2);
        }
    
        @Test
        public void testDataSourct() throws Exception {
            DataSource dataSource = ctx.getBean(DataSource.class);
            System.out.println(dataSource.getConnection());
        }
    
    }

[1105175-20171023203955676-1924436734.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/29/2f845efd71b245e4b7ee3a8148638d2c.png
[1105175-20171023204152598-1839645945.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/29/342da6db53474f0fa59d50502db82970.png
[1105175-20171024115954660-1782203382.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/29/3fb65efcf4c84b498e05a35eab5baea0.png
[1105175-20171024120007223-1607836470.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/29/2bf2b40469764948b6e99c88da302d72.png