集成JPA

共计 4561 个字符，预计需要花费 12 分钟才能阅读完成。

上一节我们讲了在 Spring 中集成 Hibernate。Hibernate 是第一个被广泛使用的 ORM 框架，但是很多小伙伴还听说过 JPA：Java Persistence API，这又是啥？

在讨论 JPA 之前，我们要注意到 JavaEE 早在 1999 年就发布了，并且有 Servlet、JMS 等诸多标准。和其他平台不同，Java 世界早期非常热衷于标准先行，各家跟进：大家先坐下来把接口定了，然后，各自回家干活去实现接口，这样，用户就可以在不同的厂家提供的产品进行选择，还可以随意切换，因为用户编写代码的时候只需要引用接口，并不需要引用具体的底层实现（想想 JDBC）。

JPA 就是 JavaEE 的一个 ORM 标准，它的实现其实和 Hibernate 没啥本质区别，但是用户如果使用 JPA，那么引用的就是 jakarta.persistence 这个“标准”包，而不是 org.hibernate 这样的第三方包。因为 JPA 只是接口，所以，还需要选择一个实现产品，跟 JDBC 接口和 MySQL 驱动一个道理。

我们使用 JPA 时也完全可以选择 Hibernate 作为底层实现，但也可以选择其它的 JPA 提供方，比如 EclipseLink。Spring 内置了 JPA 的集成，并支持选择 Hibernate 或 EclipseLink 作为实现。这里我们仍然以主流的 Hibernate 作为 JPA 实现为例子，演示 JPA 的基本用法。

和使用 Hibernate 一样，我们只需要引入如下依赖：

org.springframework:spring-context:6.0.0
org.springframework:spring-orm:6.0.0
jakarta.annotation:jakarta.annotation-api:2.1.1
jakarta.persistence:jakarta.persistence-api:3.1.0
org.hibernate:hibernate-core:6.1.4.Final
com.zaxxer:HikariCP:5.0.1
org.hsqldb:hsqldb:2.7.1

实际上我们这里引入的依赖和上一节集成 Hibernate 引入的依赖完全一样，因为 Hibernate 既提供了它自己的接口，也提供了 JPA 接口，我们用 JPA 接口就相当于通过 JPA 操作 Hibernate。

然后，在 AppConfig 中启用声明式事务管理，创建DataSource：

@Configuration
@ComponentScan
@EnableTransactionManagement
@PropertySource("jdbc.properties")
public class AppConfig {@Bean
    DataSource createDataSource() {...}
}

使用 Hibernate 时，我们需要创建一个LocalSessionFactoryBean，并让它再自动创建一个SessionFactory。使用 JPA 也是类似的，我们也创建一个LocalContainerEntityManagerFactoryBean，并让它再自动创建一个EntityManagerFactory：

@Bean
public LocalContainerEntityManagerFactoryBean createEntityManagerFactory(@Autowired DataSource dataSource) {var emFactory = new LocalContainerEntityManagerFactoryBean();
    // 注入 DataSource:
    emFactory.setDataSource(dataSource);
    // 扫描指定的 package 获取所有 entity class:
    emFactory.setPackagesToScan(AbstractEntity.class.getPackageName());
    // 使用 Hibernate 作为 JPA 实现:
    emFactory.setJpaVendorAdapter(new HibernateJpaVendorAdapter());
    // 其他配置项:
    var props = new Properties();
    props.setProperty("hibernate.hbm2ddl.auto", "update"); // 生产环境不要使用
    props.setProperty("hibernate.dialect", "org.hibernate.dialect.HSQLDialect");
    props.setProperty("hibernate.show_sql", "true");
    emFactory.setJpaProperties(props);
    return emFactory;
}

观察上述代码，除了需要注入 DataSource 和设定自动扫描的 package 外，还需要指定 JPA 的提供商，这里使用 Spring 提供的一个 HibernateJpaVendorAdapter，最后，针对 Hibernate 自己需要的配置，以Properties 的形式注入。

最后，我们还需要实例化一个JpaTransactionManager，以实现声明式事务：

@Bean
PlatformTransactionManager createTxManager(@Autowired EntityManagerFactory entityManagerFactory) {return new JpaTransactionManager(entityManagerFactory);
}

这样，我们就完成了 JPA 的全部初始化工作。有些童鞋可能从网上搜索得知 JPA 需要 persistence.xml 配置文件，以及复杂的 orm.xml 文件。这里我们负责地告诉大家，使用 Spring+Hibernate 作为 JPA 实现，无需任何配置文件。

所有 Entity Bean 的配置和上一节完全相同，全部采用 Annotation 标注。我们现在只需关心具体的业务类如何通过 JPA 接口操作数据库。

还是以 UserService 为例，除了标注 @Component 和@Transactional外，我们需要注入一个EntityManager，但是不要使用Autowired，而是@PersistenceContext：

@Component
@Transactional
public class UserService {@PersistenceContext
    EntityManager em;
}

我们回顾一下 JDBC、Hibernate 和 JPA 提供的接口，实际上，它们的关系如下：

JDBC	Hibernate	JPA
DataSource	SessionFactory	EntityManagerFactory
Connection	Session	EntityManager

SessionFactory和 EntityManagerFactory 相当于 DataSource，Session 和EntityManager相当于 Connection。每次需要访问数据库的时候，需要获取新的Session 和EntityManager，用完后再关闭。

但是，注意到 UserService 注入的不是EntityManagerFactory，而是EntityManager，并且标注了@PersistenceContext。难道使用 JPA 可以允许多线程操作同一个EntityManager？

实际上这里注入的并不是真正的 EntityManager，而是一个EntityManager 的代理类，相当于：

public class EntityManagerProxy implements EntityManager {private EntityManagerFactory emf;
}

Spring 遇到标注了 @PersistenceContext 的EntityManager会自动注入代理，该代理会在必要的时候自动打开 EntityManager。换句话说，多线程引用的EntityManager 虽然是同一个代理类，但该代理类内部针对不同线程会创建不同的 EntityManager 实例。

简单总结一下，标注了 @PersistenceContext 的EntityManager可以被多线程安全地共享。

因此，在 UserService 的每个业务方法里，直接使用 EntityManager 就很方便。以主键查询为例：

public User getUserById(long id) {User user = this.em.find(User.class, id);
    if (user == null) {throw new RuntimeException("User not found by id:" + id);
    }
    return user;
}

与 HQL 查询类似，JPA 使用 JPQL 查询，它的语法和 HQL 基本差不多：

public User fetchUserByEmail(String email) {// JPQL 查询:
    TypedQuery<User> query = em.createQuery("SELECT u FROM User u WHERE u.email = :e", User.class);
    query.setParameter("e", email);
    List<User> list = query.getResultList();
    if (list.isEmpty()) {return null;
    }
    return list.get(0);
}

同样的，JPA 也支持NamedQuery，即先给查询起个名字，再按名字创建查询：

public User login(String email, String password) {TypedQuery<User> query = em.createNamedQuery("login", User.class);
    query.setParameter("e", email);
    query.setParameter("pwd", password);
    List<User> list = query.getResultList();
    return list.isEmpty() ? null : list.get(0);
}

NamedQuery通过注解标注在 User 类上，它的定义和上一节的 User 类一样：

@NamedQueries(
    @NamedQuery(
        name = "login",
        query = "SELECT u FROM User u WHERE u.email=:e AND u.password=:pwd"
    )
)
@Entity
public class User {...}

对数据库进行增删改的操作，可以分别使用 persist()、remove() 和merge()方法，参数均为 Entity Bean 本身，使用非常简单，这里不再多述。

使用 JPA 操作数据库。

下载练习

在 Spring 中集成 JPA 要选择一个实现，可以选择 Hibernate 或 EclipseLink；

使用 JPA 与 Hibernate 类似，但注入的核心资源是带有 @PersistenceContext 注解的 EntityManager 代理类。