一篇文章理清Java持久化脉络（关于JDBC、JPA、Hibernate、Spring Data JPA）

Java持久化

- 一、JDBC、JPA、Spring Data JPA 的定义及关系
- 二、JDBC（古老的东西，只需简单知道是啥）
- - 1.1 JDBC概念
  - 1.2 JDBC示例
- 三、JPA（第二代持久化，代表是Hibernate等框架）
- - 3.1 JPA概念
  - 3.2 JPA示例
- 四、Spring Data JPA（第三代，只需学习这个的使用）
- 五、总结

JDBC、JPA、Hibernate、Spring Data JPA，这个经常听到的词汇，具体是什么，他们是什么关系，以及如何通过他们实现java的持久化，一文带你理清Java持久化的脉络。

一、JDBC、JPA、Spring Data JPA 的定义及关系

JDBC，是一组Java接口，是Java提供的面向关系的持久化规范。各个数据库厂商（Oracle、MySQL等）提供实现，JDBC是面向SQL的，就是在代码力去执行SQL语句。

JPA，也是一组接口，是Java提供的面向对象的持久化规范。各个ORM（也就是Hibernate，MyBatis等）提供实现，JPA是面向对象的，也就是我们熟知的，定义一个实体，然后就可以和关系型数据库进行交互。

Spring Data JPA，ORM的又一层抽象，可以通过方法名约定进一步简化样板代码，底层是通过调用Hibernate等ORM实现的。Spring Data JPA默认是通过调用Hibernate实现的。

二、JDBC（古老的东西，只需简单知道是啥）

1.1 JDBC概念

JDBC是一组java api，只是接口没有实现，各数据库厂商提供实现。开发只需要面向jdbc api即可。

要使用不同的数据库，只需要切换不同的实现类即可。也就是使用不同的驱动包。

jdbc就是建立在sql之上的，sql能干的，它都能干，例如DDL、DML、DQL等，能更好的对数据进行调优，允许使用数据的所有特性，而这是其他框架不鼓励甚至禁止的。

1.2 JDBC示例

不用管具体代码含义，只大概看看，简单一条查询，都干了什么。创建数据库连接–先写SQL语句–关闭连接处理异常等。每一个操作都需要这样执行一遍。

Musician georgeHarrison = new Musician(0, "George Harrison");<br><br>  // 建立数据库连接等

String myDriver = "org.gjt.mm.mysql.Driver";
String myUrl = "jdbc:mysql://localhost/test";
Class.forName(myDriver);
Connection conn = DriverManager.getConnection(myUrl, "root", "");
// 纯SQL语句
String query = " insert into users (id, name) values (?, ?)";
PreparedStatement preparedStmt = conn.prepareStatement(query);
preparedStmt.setInt     (1, 0);
preparedStmt.setString (2, "George Harrison");
preparedStmt.setString (2, "Rubble");
preparedStmt.execute();<br><br>// 必须手动关闭连接
conn.close();
// 还有一些异常处理

每一个查询、操作，即使只查询一条数据，也需要写这一堆代码，极其繁琐。因此催生了JPA的诞生。

三、JPA（第二代持久化，代表是Hibernate等框架）

3.1 JPA概念

JPA是面向对象的持久化规范。不用像JPA一样手动创建连接，编写SQL等，只需要创建与表对应的实体，并给实体打上相应的标记，JPA的实现框架就能自动生成SQL，进行持久化相关操作。

不过它的底层也是通过JDBC实现的。
在这里插入图片描述

JPA与HIbernate的关系？

题外话，现在我们都知道Hibernate是JPA的实现，但是追随历史，这是一个先有鸡还是先有蛋的问题。

Hibernate是2002年发布的，而JPA是2006年发布的，所以JPA的很多规范其实是参考了Hibernate，JPA发布后，Hibernate 3.0又根据JPA规范进行调整，最终被认证为JPA的实现之一。由此可见Hibernate 的江湖地位。

3.2 JPA示例

ORM简单示例

简单演示一下使用Hibernate等这种ORM后，保存数据只需要定义一个Entity，然后保存即可。

// 定义实体，标记上相应的注解
@Entity
public class Musician {
   @Id
   private Long id;
}



Musician georgeHarrison = new Musician(0, "George Harrison");
// 直接一行皆可，不需要处理数据库连接，不需要写一堆SQL
musicianManager.save(georgeHarrison);

Spring继承Hibernate的详细配置

业务操作很简单，下面演示一下spring怎样继承Hibernate。

实现ORM，需要配置三个东西：数据源DataSource、SessionFactory、事务。

通过xml配置：

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 数据源配置 -->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver" />
        <property name="url" value="jdbc:mysql://localhost:3306/yourdb" />
        <property name="username" value="username" />
        <property name="password" value="password" />
    </bean>

    <!-- Hibernate SessionFactory 配置 -->
    <bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <property name="packagesToScan" value="com.yourpackage.model" />
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</prop>
                <prop key="hibernate.show_sql">true</prop>
                <prop key="hibernate.hbm2ddl.auto">update</prop>
            </props>
        </property>
    </bean>

    <!-- 事务管理器 -->
    <bean id="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>

</beans>

通过代码配置：

@Configuration
@EnableTransactionManagement
public class HibernateConfig {

    @Bean
    public DataSource dataSource() {
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/yourdb");
        dataSource.setUsername("username");
        dataSource.setPassword("password");
        return dataSource;
    }

    @Bean
    public LocalSessionFactoryBean sessionFactory() {
        LocalSessionFactoryBean sessionFactory = new LocalSessionFactoryBean();
        sessionFactory.setDataSource(dataSource());
        sessionFactory.setPackagesToScan("com.yourpackage.model");
        sessionFactory.setHibernateProperties(hibernateProperties());
        return sessionFactory;
    }

    private Properties hibernateProperties() {
        Properties properties = new Properties();
        properties.put("hibernate.dialect", "org.hibernate.dialect.MySQL5Dialect");
        properties.put("hibernate.show_sql", "true");
        properties.put("hibernate.hbm2ddl.auto", "update");
        return properties;
    }

    @Bean
    public HibernateTransactionManager transactionManager(SessionFactory sessionFactory) {
        HibernateTransactionManager txManager = new HibernateTransactionManager();
        txManager.setSessionFactory(sessionFactory);
        return txManager;
    }
}

Hibernate 有一个称为上下文会话的功能，其中 Hibernate 本身管理Session每个事务的一个当前会话。一般会通过为每一个实体再创建一个Dao类来调用SessionFactory。

public class ProductDaoImpl implements ProductDao {

 private SessionFactory sessionFactory;

 public void setSessionFactory(SessionFactory sessionFactory) {
  this.sessionFactory = sessionFactory;
 }

 public Collection loadProductsByCategory(String category) {
  return this.sessionFactory.getCurrentSession()
    .createQuery("from test.Product product where product.category=?")
    .setParameter(0, category)
    .list();
 }
}

四、Spring Data JPA（第三代，只需学习这个的使用）

JPA构建在JDBC之上，帮我们省略了数据库连接的管理、sql编写等繁琐的样板代码。而Spring Data JPA是构建在JPA之上的，能够进一步减少样板代码的编写，让我们尽量只关注业务逻辑。

看上面的Hibernate，Dao层其实也有许多样板代码，通过使用SessionFactory 来执行查询和操作等，而这在spring data jpa中进一步做了简化。其中包括：

1、简化配置

一般通过spring boot使用spring data jpa，其中配置项只有这些。

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/yourdb
    username: username
    password: password
    driver-class-name: com.mysql.cj.jdbc.Driver

  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true
    properties:
      hibernate:
        dialect: org.hibernate.dialect.MySQLDialect

可以发现少了事务的配置，这是因为默认使用spring data 的JpaTransactionManager，它可以满足大部分需求，无需再单独配置。

2、Repository 模式极大精简传统Dao层操作

其中包括，直接写接口声明方法，就可以实现数据库访问；自动化CEUD操作，findById(), save(), delete()这些无需手动编写；支持通过方法名称自动生成查询（如 findByLastName(String lastName)）。还包括分页排序、自动创建表等。

Spring Data 进一步简化了这一过程，并可以完全删除 DAO 实现。DAO 的接口现在是我们唯一需要明确定义的工件。

传统的Dao层，可以直接使用以下接口实现。

public interface IFooRepository extends JpaRepository<Foo, Long> {

    Foo findByName(String name);
@Query("SELECT f FROM Foo f WHERE LOWER(f.name) = LOWER(:name)")
  @Query("SELECT f FROM Foo f WHERE LOWER(f.name) = LOWER(:name)")

  Foo retrieveByName(@Param("name")String name);
}

五、总结

java的持久化也是经历了从自行车到汽车的转变，从JDBC直接调用sql，到jpa封装jdbc，使用面向对象的思想处理持久化，再到spring data jpa进一步对jpa进行抽象，目前的学习成本和编码成本已经很低了，只需要学习spring data jpa即可。
了解这些发现，有助于我们理解底层实现，