Spring Data 系列(三) Spring+JPA(spring-data-commons)

本章是Spring Data系列的第三篇。系列文章，重点不是讲解JPA语法，所以跑开了JPA的很多语法等，重点放在环境搭建，通过对比方式，快速体会Spring 对JPA的强大功能。

准备代码过程中，保持了每个例子的独立性，和简单性，准备的源码包，下载即可使用。如果，对JPA语法想深入研究的话，直接下载在此基础上进行测试。

前言

Spring Data 系列(一) 入门：简单介绍了原生态的SQL使用，以及JdbcTemplate的使用，在这里写SQL的活还需要自己准备。

Spring Data 系列(二)  Spring+JPA入门（集成Hibernate) ： 使用JPA API，SQL实现了透明化，可以在不同数据库之间进行切换，以及JPA解决方案间切换。这时候的业务DAO层，是自定义的方法。

Spring Data 系列(三) Spring+JPA(spring-data-commons)： 在Spring Data 系列(二)
的基础上，业务DAO层，也可以省掉。

1.XML配置实现spring-data-commons集成

环境代码和项目结构和Spring Data 系列(二) 基本一致

1.1 项目结构

1.2.pom.xml

  4.0.0
  com.springframework
  springJpaExample2
  1.0-SNAPSHOT
  jar
  springJpaExample2
  http://maven.apache.org

  
    UTF-8
  
  
    
      org.springframework.boot
      spring-boot-starter-data-jpa
    
    
      mysql
      mysql-connector-java
    
    
      org.springframework
      spring-test
    
    
      junit
      junit
      4.12
    
  
  
    
      spring-releases
      Spring Releases
      https://repo.spring.io/libs-release
    
    
      org.jboss.repository.releases
      JBoss Maven Release Repository
      https://repository.jboss.org/nexus/content/repositories/releases
    
  
  
    
      spring-releases
      Spring Releases
      https://repo.spring.io/libs-release
    
  
  
    
      
        io.spring.platform
        platform-bom
        1.1.2.RELEASE
        pom
        import
      
    
  

1.3 persistence.xml

    
        org.hibernate.jpa.HibernatePersistenceProvider
    

1.4 日志文件（这对研究框架操作过程，是个很好的入口）

    
        
            
                %d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n
            
        
    
    
        
    

    
        
    

1.5 核心配置文件spring.xml

    
        
        
        
        
    
    
        
        
        
        
        
        
            
                true
            
        
    

    
        
        
    

    

    
    
    
    
    

    
    

    

    

1.6 业务Entity

package com.journaldev.spring.jpa.model;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.IdClass;

@Entity
public class Employee {
    @Id
    private Integer id;
    private String name;
    private String role;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getRole() {
        return role;
    }

    public void setRole(String role) {
        this.role = role;
    }

    @Override
    public String toString() {
        return "{ID=" + id + ",Name=" + name + ",Role=" + role + "}";
    }
}

1.7 DAO

public interface EmployeeDAO extends CrudRepository {
}

DAO接口定义，这儿有几点2点注意

1. 不需要在这儿重复通过@Reposity,@Component等注解声明Bean，因为通过语法已经声明了

2. CrudRepository是泛型，不能省略。
   

1.8 最后测试

import com.journaldev.spring.jpa.dao.EmployeeDAO;
import com.journaldev.spring.jpa.model.Employee;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.AbstractTransactionalJUnit4SpringContextTests;
import org.springframework.test.context.junit4.SpringJUnit4Cla***unner;
import javax.annotation.Resource;
import java.util.Iterator;
import java.util.Random;

@RunWith(SpringJUnit4Cla***unner.class)
@ContextConfiguration(locations = "classpath:spring.xml")
public class SpringJPATest /*extends AbstractTransactionalJUnit4SpringContextTests */{
    @Autowired
    private EmployeeDAO employeeDAO;

    @Test
    public void testSave(){
        Employee emp = new Employee();
        int rand = new Random().nextInt(1000);
        emp.setId(rand);
        emp.setName("Pankaj");
        emp.setRole("Java Developer");
        employeeDAO.save(emp);
        emp.setName(emp.getName() + "_update");
        employeeDAO.save(emp);

        Iterable employees = employeeDAO.findAll();
        Iterator iterator = employees.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }

    }
}

测试代码，不多测试。还是那句话，该系列文章，重点是演示搭建过程，以及对比方式，理解Spring Data带来的威力。

最后：

通过对比，相信大家不难发现，本文的DAO层连实现都不需要了，定义一个接口就齐活了，逻辑由Spring自动实时自动生成。最后我要说的时，虽然Spring给我们带来的便利，但麻烦也随之而来。把底层实现进行了屏蔽，凡是遇到错误，也很难定位问题了，弄清楚Spring的工作机制，这也是我们以后的课题了。

---

2.Annotation配置实现spring-data-commons集成

和<1.XML配置实现spring-data-commons集成>节基本一样。

稍微有点差别的是

2.1 spring.xml

去除数据库，事务管理器配置，改用java annotation。相信熟悉spring的同学都知道，他们仅仅是声明spring bean的方式有点差别，基本本质是一样，都是注册BeanDefinition元数据，进而根据元数据构建需要的Bean对象。

2.2 添加配置bean

package com.journaldev.spring.jpa;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import javax.persistence.EntityManagerFactory;
import javax.sql.DataSource;
import java.util.Properties;

@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(basePackages = {"com.journaldev.spring.jpa"
})
class PersistenceContext {

   //Configure the required beans here
    @Bean
  public DataSource dataSource() {
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setUrl("jdbc:mysql://localhost:3306/exampledb");
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUsername("root");
        dataSource.setPassword("root");
        return  dataSource;
    }

    @Bean
    public LocalContainerEntityManagerFactoryBean entityManagerFactory(DataSource dataSource) {
        LocalContainerEntityManagerFactoryBean entityManagerFactoryBean = new LocalContainerEntityManagerFactoryBean();
        entityManagerFactoryBean.setDataSource(dataSource);
        entityManagerFactoryBean.setJpaVendorAdapter(new HibernateJpaVendorAdapter());
//        entityManagerFactoryBean.setPackagesToScan("com.journaldev.spring.jpa");

        Properties jpaProperties = new Properties();

        //Configures the used database dialect. This allows Hibernate to create SQL
        //that is optimized for the used database.
        jpaProperties.put("hibernate.dialect", "org.hibernate.dialect.MySQL5Dialect");

        //Specifies the action that is invoked to the database when the Hibernate
        //SessionFactory is created or closed.
        jpaProperties.put("hibernate.hbm2ddl.auto",true);

        //If the value of this property is true, Hibernate writes all SQL
        //statements to the console.
        jpaProperties.put("hibernate.show_sql",true);

        //If the value of this property is true, Hibernate will format the SQL
        //that is written to the console.
        jpaProperties.put("hibernate.format_sql",true);

        entityManagerFactoryBean.setJpaProperties(jpaProperties);

        return entityManagerFactoryBean;
    }
    @Bean
    public JpaTransactionManager transactionManager(EntityManagerFactory entityManagerFactory) {
        JpaTransactionManager transactionManager = new JpaTransactionManager();
        transactionManager.setEntityManagerFactory(entityManagerFactory);
        return transactionManager;
    }
}

使用编码式声明，我能想到唯一的优点：自动程度高一些，方便动态配置相关信息。

总之，变更了2处地方，其他完全一样。可以理解为就是声明底层支持对象（如数据源，事务管理器）两个地方发生了变化），看各自爱好，那种方式都可以。我比较倾向于XML声明方式。

源码包2个