Spring Data Jpa的入门以及原理剖析

Spring Data Jpa的入门以及原理剖析

1. 搭建环境

   1. 导入坐标

      <properties>
          <spring.version>4.2.4.RELEASEspring.version>
          <hibernate.version>5.0.7.Finalhibernate.version>
          <slf4j.version>1.6.6slf4j.version>
          <log4j.version>1.2.12log4j.version>
          <c3p0.version>0.9.1.2c3p0.version>
          <mysql.version>5.1.6mysql.version>
      properties>
      
      <dependencies>
          
          <dependency>
              <groupId>junitgroupId>
              <artifactId>junitartifactId>
              <version>4.9version>
              <scope>testscope>
          dependency>
      
          
          <dependency>
              <groupId>org.aspectjgroupId>
              <artifactId>aspectjweaverartifactId>
              <version>1.6.8version>
          dependency>
      
          <dependency>
              <groupId>org.springframeworkgroupId>
              <artifactId>spring-aopartifactId>
              <version>${spring.version}version>
          dependency>
      
          <dependency>
              <groupId>org.springframeworkgroupId>
              <artifactId>spring-contextartifactId>
              <version>${spring.version}version>
          dependency>
      
          <dependency>
              <groupId>org.springframeworkgroupId>
              <artifactId>spring-context-supportartifactId>
              <version>${spring.version}version>
          dependency>
      
          
          <dependency>
              <groupId>org.springframeworkgroupId>
              <artifactId>spring-ormartifactId>
              <version>${spring.version}version>
          dependency>
      
          <dependency>
              <groupId>org.springframeworkgroupId>
              <artifactId>spring-beansartifactId>
              <version>${spring.version}version>
          dependency>
      
          <dependency>
              <groupId>org.springframeworkgroupId>
              <artifactId>spring-coreartifactId>
              <version>${spring.version}version>
          dependency>
      
          
      
          
          <dependency>
              <groupId>org.hibernategroupId>
              <artifactId>hibernate-coreartifactId>
              <version>${hibernate.version}version>
          dependency>
          <dependency>
              <groupId>org.hibernategroupId>
              <artifactId>hibernate-entitymanagerartifactId>
              <version>${hibernate.version}version>
          dependency>
          <dependency>
              <groupId>org.hibernategroupId>
              <artifactId>hibernate-validatorartifactId>
              <version>5.2.1.Finalversion>
          dependency>
          
      
          
          <dependency>
              <groupId>c3p0groupId>
              <artifactId>c3p0artifactId>
              <version>${c3p0.version}version>
          dependency>
          
      
          
          <dependency>
              <groupId>log4jgroupId>
              <artifactId>log4jartifactId>
              <version>${log4j.version}version>
          dependency>
      
          <dependency>
              <groupId>org.slf4jgroupId>
              <artifactId>slf4j-apiartifactId>
              <version>${slf4j.version}version>
          dependency>
      
          <dependency>
              <groupId>org.slf4jgroupId>
              <artifactId>slf4j-log4j12artifactId>
              <version>${slf4j.version}version>
          dependency>
          
      
      
          <dependency>
              <groupId>mysqlgroupId>
              <artifactId>mysql-connector-javaartifactId>
              <version>${mysql.version}version>
          dependency>
      
          
          <dependency>
              <groupId>org.springframework.datagroupId>
              <artifactId>spring-data-jpaartifactId>
              <version>1.9.0.RELEASEversion>
          dependency>
      
          <dependency>
              <groupId>org.springframeworkgroupId>
              <artifactId>spring-testartifactId>
              <version>${spring.version}version>
          dependency>
      
          
          <dependency>
              <groupId>javax.elgroupId>
              <artifactId>javax.el-apiartifactId>
              <version>2.2.4version>
          dependency>
      
          <dependency>
              <groupId>org.glassfish.webgroupId>
              <artifactId>javax.elartifactId>
              <version>2.2.4version>
          dependency>
          
      dependencies>
      

   2. 配置spring的配置文件

      <?xml version="1.0" encoding="UTF-8"?>
      <beans xmlns="http://www.springframework.org/schema/beans"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
              xmlns:context="http://www.springframework.org/schema/context"
                  xmlns:jdbc="http://www.springframework.org/schema/jdbc" xmlns:tx="http://www.springframework.org/schema/tx"
                      xmlns:jpa="http://www.springframework.org/schema/data/jpa" xmlns:task="http://www.springframework.org/schema/task"
                          xsi:schemaLocation="
                              http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
      http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
      http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
      http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc.xsd
      http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
      http://www.springframework.org/schema/data/jpa
      http://www.springframework.org/schema/data/jpa/spring-jpa.xsd">
      
      <!--spring 和spring data jpa 的配置-->
          <!--1.创建entityMangerFactory对象交给spring管理-->
          <bean id="entityMangerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
                  <property name="dataSource" ref="dataSource"></property>
                  <!--配置包扫描，实体类所在的包-->
              <property name="packagesToScan" value="cn.itcast.domain"></property>
                  <!--配置jpa的实现方式-->
              <property name="persistenceProvider">
                      <bean class="org.hibernate.jpa.HibernatePersistenceProvider"></bean>
                  </property>
                  <!--配置jpa的供应商适配器-->
                          <property name="jpaVendorAdapter">
                      <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
                          <!--是否自动创建数据库表-->
                          <property name="generateDdl" value="false" />
                          <!--数据库类型-->
                          <property name="database" value="MYSQL" />
                          <!--数据库方言，支持的特有语法-->
                          <property name="databasePlatform" value="org.hibernate.dialect.MySQLDialect" />
                          <!--是否显示sql语句-->
                          <property name="showSql" value="true" />
                          </bean>
                  </property>
                  <!--jpa的方言，高级特性-->
                          <property name="jpaDialect">
                      <bean class="org.springframework.orm.jpa.vendor.HibernateJpaDialect"></bean>
                  </property>
      
              </bean>
              <!--2.创建数据库连接池-->
                          <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
                  <property name="user" value="root"></property>
                  <property name="password" value="root"></property>
                  <property name="jdbcUrl" value="jdbc:mysql:///eesy"></property>
                  <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
              </bean>
              <!--3.整合springdatajpa-->
                              <jpa:repositories base-package="cn.itcast.dao" transaction-manager-ref="transactionManager" entity-manager-factory-ref="entityMangerFactory"></jpa:repositories>
              <!--配置事务管理器-->
                                  <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
                  <property name="entityManagerFactory" ref="entityMangerFactory"></property>
              </bean>
              <!--5.声明式事务-->
                                      <!--<tx:advice id="txAdvice" transaction-manager="transactionManager">
                  <tx:attributes>
                      <tx:method name="save*" propagation="REQUIRED"/>
                      <tx:method name="insert*" propagation="REQUIRED"/>
                      <tx:method name="update*" propagation="REQUIRED"/>
                      <tx:method name="delete*" propagation="REQUIRED"/>
                      <tx:method name="get*" read-only="true"/>
                      <tx:method name="find*" read-only="true"/>
                      <tx:method name="*" propagation="REQUIRED"/>
                  </tx:attributes>
              </tx:advice>-->
      
                  <!--6.配置包扫描-->
                  <context:component-scan base-package="cn.itcast"></context:component-scan>
      
      </beans>
      

   3. 编写实体类，使用jpa注解配置映射关系

      package cn.itcast.domain;
      
      
      import javax.persistence.*;
      
      @Entity
      @Table(name = "customer")
      public class Customer {
          @Id
          @GeneratedValue(strategy = GenerationType.IDENTITY)
          @Column(name = "id")
          private Integer id;
          @Column(name = "address")
          private String address;
          @Column(name = "industry")
          private String industry;
          @Column(name = "level")
          private String level;
          @Column(name = "name")
          private String name;
          @Column(name = "phone")
          private String phone;
          @Column(name = "source")
          private String source;
      
          @Override
          public String toString() {
              return "Customer{" +
                  "id=" + id +
                  ", address='" + address + '\'' +
                  ", industry='" + industry + '\'' +
                  ", level='" + level + '\'' +
                  ", name='" + name + '\'' +
                  ", phone='" + phone + '\'' +
                  ", source='" + source + '\'' +
                  '}';
          }
      
          public Integer getId() {
              return id;
          }
      
          public void setId(Integer id) {
              this.id = id;
          }
      
          public String getAddress() {
              return address;
          }
      
          public void setAddress(String address) {
              this.address = address;
          }
      
          public String getIndustry() {
              return industry;
          }
      
          public void setIndustry(String industry) {
              this.industry = industry;
          }
      
          public String getLevel() {
              return level;
          }
      
          public void setLevel(String level) {
              this.level = level;
          }
      
          public String getName() {
              return name;
          }
      
          public void setName(String name) {
              this.name = name;
          }
      
          public String getPhone() {
              return phone;
          }
      
          public void setPhone(String phone) {
              this.phone = phone;
          }
      
          public String getSource() {
              return source;
          }
      
          public void setSource(String source) {
              this.source = source;
          }
      }
      

2. 编写一个符合springDatajpa的dao层接口

   只需要编写dao层的接口，不需要编写dao层的实现类

   /**
    * 符合springdatajpa的dao层接口规范
    *      JpaRepository<操作的实体类的类型,实体类中主键属性的类型>,封装了基本CRUD操作
    *      JpaSpecificationExecutor<操作的实体类的类型>，封装了复杂查询的操作
    */
   public interface CustomerDao extends JpaRepository<Customer,Integer>, JpaSpecificationExecutor<Customer> {
   }
   

3. 测试代码：

   import cn.itcast.dao.CustomerDao;
   import cn.itcast.domain.Customer;
   import org.junit.Test;
   import org.junit.runner.RunWith;
   import org.springframework.test.context.ContextConfiguration;
   import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
   
   import javax.annotation.Resource;
   import java.util.List;
   
   @RunWith(SpringJUnit4ClassRunner.class)  //声明spring提供的单元测试环境
   @ContextConfiguration(locations = "classpath:applicationContext.xml")   //指定spring容器的配置信息
   public class CustomerDaoTest {
   
       @Resource
       CustomerDao customerDao;
   
       /*
       * 根据id查询
       * */
       @Test
       public void testFinOne(){
           Customer customer = customerDao.findOne(1);
           System.out.println(customer);
       }
   
       /*
        * save():保存或者更新
        *      根据传递的对象是否存在主键id,如果没有，保存
        *       存在id主键属性，根据id查询数据，更新数据(如果传递了主键id，但是数据库中没有对应的主键，那么传递的主键不会生效，还是保存)
        * */
       @Test
       public void testSave(){
           Customer customer = new Customer();
           customer.setLevel("VIP");
           customer.setName("黑马程序员");
           customerDao.save(customer);
       }
   
       @Test
       public void testUpdate(){
           Customer customer = new Customer();
           customer.setId(4);
           customer.setName("黑马程序员厉!");
           customerDao.save(customer);
       }
   
       /*
        * del():根据id删除
        * */
       @Test
       public void testDelete(){
           customerDao.delete(5);
       }
   
       /*
        * 查询所有的客户
        * */
       @Test
       public void testFindAll(){
           List<Customer> lists = customerDao.findAll();
           System.out.println(lists);
       }
   }
   

4. springDataJpa的运行过程和原理剖析

   1. 通过JDKDynamicAopproxy的invoke方法创建了一个动态代理对象
   2. SimpleJpaRepository当中封装了jpa的操作(借助JPA的api完成数据库的CRUD)
   3. 通过Hibernate完成数据库的操作(封装了jdbc)