【Spring】Spring Data JPA

原始JDBC操作数据库

传统JDBC方式实现数据库操作

package com.imooc.util;

import java.io.InputStream;

import java.sql.*;

import java.util.Properties;

/**

 * JDBC工具类：

 * 1） 获取Connection

 * 2） 释放资源

 */

public class JDBCUtil {

    /**

     * 获取Connection

     * @return 所获得到的JDBC的Connection

     */

    public static Connection getConnection() throws Exception {

        /**

         * 不建议大家把配置硬编码到代码中

         *

         * 最佳实践：配置性的建议写到配置文件中

         */

//        String url = "jdbc:mysql:///spring_data";

//        String user = "root";

//        String password = "root";

//        String driverClass = "com.mysql.jdbc.Driver";

        InputStream inputStream = JDBCUtil.class.getClassLoader().getResourceAsStream("db.properties");

        Properties properties = new Properties();

        properties.load(inputStream);

        String url = properties.getProperty("jdbc.url");

        String user = properties.getProperty("jdbc.user");

        String password = properties.getProperty("jdbc.password");

        String driverClass = properties.getProperty("jdbc.driverClass");

        Class.forName(driverClass);

        Connection connection = DriverManager.getConnection(url, user, password);

        return connection;

    }

    /**

     * 释放DB相关的资源

     * @param resultSet

     * @param statement

     * @param connection

     */

    public static void release(ResultSet resultSet,

                               Statement statement, Connection connection){

        if(resultSet != null) {

            try {

                resultSet.close();

            } catch (SQLException e) {

                e.printStackTrace();

            }

        }

        if(statement != null) {

            try {

                statement.close();

            } catch (SQLException e) {

                e.printStackTrace();

            }

        }

        if(connection != null) {

            try {

                connection.close();

            } catch (SQLException e) {

                e.printStackTrace();

            }

        }

    }

}

db.properties

jdbc.url = jdbc:mysql:///spring_data

jdbc.user = root

jdbc.password = root

jdbc.driverClass = com.mysql.jdbc.Driver

接口定义

package com.imooc.dao;

import com.imooc.domain.Student;

import java.util.List;

/**

 * StudentDAO访问接口

 */

public interface StudentDAO {

    /**

     * 查询所有学生

     * @return 所有学生

     */

    public List<Student> query();

    /**

     * 添加一个学生

     * @param student 待添加的学生

     */

    public void save(Student student);

}

package com.imooc.dao;

import com.imooc.domain.Student;

import com.imooc.util.JDBCUtil;

import java.sql.Connection;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.util.ArrayList;

import java.util.List;

/**

 * StudentDAO访问接口实现类：通过最原始的JDBC的方式操作

 */

public class StudentDAOImpl implements  StudentDAO{

    @Override

    public List<Student> query() {

        List<Student> students = new ArrayList<Student>();

        Connection connection = null;

        PreparedStatement preparedStatement = null;

        ResultSet resultSet = null;

        String sql = "select id, name , age from student";

        try {

            connection = JDBCUtil.getConnection();

            preparedStatement = connection.prepareStatement(sql);

            resultSet = preparedStatement.executeQuery();

            Student student = null;

            while (resultSet.next()) {

                int id = resultSet.getInt("id");

                String name = resultSet.getString("name");

                int age = resultSet.getInt("age");

                student = new Student();

                student.setId(id);

                student.setName(name);

                student.setAge(age);

                students.add(student);

            }

        } catch (Exception e) {

            e.printStackTrace();

        } finally {

            JDBCUtil.release(resultSet,preparedStatement,connection);

        }

        return students;

    }

    @Override

    public void save(Student student) {

        Connection connection = null;

        PreparedStatement preparedStatement = null;

        ResultSet resultSet = null;

        String sql = "insert into student(name, age) values(?,?)";

        try {

            connection = JDBCUtil.getConnection();

            preparedStatement = connection.prepareStatement(sql);

            preparedStatement.setString(1, student.getName());

            preparedStatement.setInt(2, student.getAge());

            preparedStatement.executeUpdate();

        } catch (Exception e) {

            e.printStackTrace();

        } finally {

            JDBCUtil.release(resultSet,preparedStatement,connection);

        }

    }

}

JDBC实现操作数据库的测试代码。

package com.imooc.dao;

import com.imooc.domain.Student;

import org.junit.Test;

import java.util.List;

public class StudentDAOImplTest {

    @Test

     public void testQuery() {

        StudentDAO studentDAO = new StudentDAOImpl();

        List<Student> students = studentDAO.query();

        for (Student student : students) {

            System.out.println("id:" + student.getId()

                    + " , name:" + student.getName()

                    + ", age:" + student.getAge());

        }

    }

    @Test

    public void testSave() {

        StudentDAO studentDAO = new StudentDAOImpl();

        Student student = new Student();

        student.setName("test");

        student.setAge(30);

        studentDAO.save(student);

    }

}

使用JdbcTemplate操作数据库

原始JDBC方式操作数据库有很多重复代码，需要自己对数据库连接进行管理。为了简化上述操作可以使用Spring提供的JdbcTemplate操作。

package com.imooc.dao;

import com.imooc.domain.Student;

import org.springframework.jdbc.core.JdbcTemplate;

import org.springframework.jdbc.core.RowCallbackHandler;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.util.ArrayList;

import java.util.List;

/**

 * StudentDAO访问接口实现类：通过Spring jdbc的方式操作

 */

public class StudentDAOSpringJdbcImpl implements  StudentDAO{

    private JdbcTemplate jdbcTemplate;

    @Override

    public List<Student> query() {

        final List<Student> students = new ArrayList<Student>();

        String sql = "select id, name , age from student";

        jdbcTemplate.query(sql, new RowCallbackHandler(){

            @Override

            public void processRow(ResultSet rs) throws SQLException {

                int id = rs.getInt("id");

                String name = rs.getString("name");

                int age = rs.getInt("age");

                Student student = new Student();

                student.setId(id);

                student.setName(name);

                student.setAge(age);

                students.add(student);

            }

        });

        return students;

    }

    @Override

    public void save(Student student) {

        String sql = "insert into student(name, age) values(?,?)";

        jdbcTemplate.update(sql, new Object[]{student.getName(), student.getAge()});

    }

    public JdbcTemplate getJdbcTemplate() {

        return jdbcTemplate;

    }

    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {

        this.jdbcTemplate = jdbcTemplate;

    }

}

需要在Spring配置文件beans.xml中配置类。

<?xml version="1.0" encoding="UTF-8"?>

<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.jdbc.Driver"/>

        <property name="username" value="root"/>

        <property name="password" value="root"/>

        <property name="url" value="jdbc:mysql:///spring_data"/>

    </bean>

    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">

        <property name="dataSource" ref="dataSource"/>

    </bean>

    <bean id="studentDAO" class="com.imooc.dao.StudentDAOSpringJdbcImpl">

        <property name="jdbcTemplate" ref="jdbcTemplate"/>

    </bean>

</beans>

JdbcTemplate操作数据库的测试代码。

package com.imooc.dao;

import com.imooc.domain.Student;

import org.junit.After;

import org.junit.Before;

import org.junit.Test;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.util.List;

public class StudentDAOSpringJdbcImplTest {

    private ApplicationContext ctx = null;

    private StudentDAO studentDAO = null;

    @Before

    public void setup(){

        ctx = new ClassPathXmlApplicationContext("beans.xml");

        studentDAO = (StudentDAO)ctx.getBean("studentDAO");

        System.out.println("setup");

    }

    @After

    public void tearDown(){

        ctx = null;

        System.out.println("tearDown");

    }

    @Test

    public void testQuery() {

        List<Student> students = studentDAO.query();

        for (Student student : students) {

            System.out.println("id:" + student.getId()

                    + " , name:" + student.getName()

                    + ", age:" + student.getAge());

        }

    }

    @Test

    public void testSave() {

        Student student = new Student();

        student.setName("test-spring-jdbc");

        student.setAge(40);

        studentDAO.save(student);

    }

}

虽然Spring JdbcTemplate在一定程度上简化了JDBC操作，但是通过上述代码看到，仍然存在重复代码。

Spring Data

原生JDBC操作与JdbcTemplate操作的弊端

需要书写的代码量还是比较多
有很多的重复代码
如果要开发分页功能或其他功能需要自己进行重新封装

Spring Data JPA

SpringData JPA只是Spring Data中的一个子模块。

JPA是一套标准接口，而Hibernate是JPA的实现。

Spring Data JPA 底层默认实现是使用Hibernate。

Spring DataJPA 的首个接口就是Repository，它是一个标记接口。只要我们的接口实现这个接口，那么我们就相当于在使用SpringDataJPA了。

只要我们实现了这个接口，我们就可以使用"按照方法命名规则"来进行查询。

JPA是用来简化数据库操作的。Spring Data JPA可以支持关系型数据库也支持非关系型数据库。

入门示例

可以使用Spring配置方式或者使用Spring Boot方式。

1、首先介绍Spring Boot的配置方式。

Spring Boot的配置比较简单，直接在Maven的配置文件pom.xml中添加如下依赖。

<dependency

    <groupId>org.springframework.boot</groupId>

    <artifactId>spring-boot-starter-data-jpa</artifactId>

</dependency>

此外需要在Spring Boot的配置文件application.properties中配置相应的配置信息。

spring.datasource.url=jdbc:mysql://localhost:3306/test

spring.datasource.username=root

spring.datasource.password=root

spring.datasource.driver-class-name=com.mysql.jdbc.Driver

spring.jpa.properties.hibernate.hbm2ddl.auto=create-drop

spring.jpa.hibernate.ddl-auto=none

spring.jpa.show-sql=true

spring.jackson.serialization.indent_output=true

spring.jpa.properties.hibernate.hbm2ddl.auto是hibernate的配置属性，其主要作用是：自动创建、更新、验证数据库表结构。该参数的几种配置如下：

create：每次加载hibernate时都会删除上一次的生成的表，然后根据你的model类再重新来生成新表，哪怕两次没有任何改变也要这样执行，这就是导致数据库表数据丢失的一个重要原因。

create-drop：每次加载hibernate时根据model类生成表，但是sessionFactory一关闭,表就自动删除。

update：最常用的属性，第一次加载hibernate时根据model类会自动建立起表的结构（前提是先建立好数据库），以后加载hibernate时根据model类自动更新表结构，即使表结构改变了但表中的行仍然存在不会删除以前的行。要注意的是当部署到服务器后，表结构是不会被马上建立起来的，是要等应用第一次运行起来后才会。

validate：每次加载hibernate时，验证创建数据库表结构，只会和数据库中的表进行比较，不会创建新表，但是会插入新值。

2、传统Spring方式配置

在Maven的配置文件中添加依赖。

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0"

         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <groupId>com.imooc</groupId>

    <artifactId>springdata</artifactId>

    <version>1.0-SNAPSHOT</version>

    <dependencies>

        <!--MySQL Driver-->

        <dependency>

            <groupId>mysql</groupId>

            <artifactId>mysql-connector-java</artifactId>

            <version>5.1.38</version>

        </dependency>

        <!--junit-->

        <dependency>

            <groupId>junit</groupId>

            <artifactId>junit</artifactId>

            <version>4.10</version>

        </dependency>

        <!--spring-->

        <dependency>

            <groupId>org.springframework</groupId>

            <artifactId>spring-jdbc</artifactId>

            <version>4.3.5.RELEASE</version>

        </dependency>

        <dependency>

            <groupId>org.springframework</groupId>

            <artifactId>spring-context</artifactId>

            <version>4.3.5.RELEASE</version>

        </dependency>

        <!--spring data jpa-->

        <dependency>

            <groupId>org.springframework.data</groupId>

            <artifactId>spring-data-jpa</artifactId>

            <version>1.8.0.RELEASE</version>

        </dependency>

        <dependency>

            <groupId>org.hibernate</groupId>

            <artifactId>hibernate-entitymanager</artifactId>

            <version>4.3.6.Final</version>

        </dependency>

    </dependencies>

</project>

Spring的配置文件beans.xml

<?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:context="http://www.springframework.org/schema/context"

       xmlns:tx="http://www.springframework.org/schema/tx"

       xmlns:jpa="http://www.springframework.org/schema/data/jpa"

       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd

		http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd

		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd

		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">

    <!--1 配置数据源-->

    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">

        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>

        <property name="username" value="root"/>

        <property name="password" value="root"/>

        <property name="url" value="jdbc:mysql:///spring_data"/>

    </bean>

    <!--2 配置EntityManagerFactory-->

    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">

        <property name="dataSource" ref="dataSource"/>

        <property name="jpaVendorAdapter">

            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter"/>

        </property>

        <property name="packagesToScan" value="com.imooc"/>

        <property name="jpaProperties">

            <props>

                <prop key="hibernate.ejb.naming_strategy">org.hibernate.cfg.ImprovedNamingStrategy</prop>

                <prop key="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</prop>

                <prop key="hibernate.show_sql">true</prop>

                <prop key="hibernate.format_sql">true</prop>

                <prop key="hibernate.hbm2ddl.auto">update</prop>

            </props>

        </property>

    </bean>

    <!--3 配置事务管理器-->

    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">

        <property name="entityManagerFactory" ref="entityManagerFactory"/>

    </bean>

    <!--4 配置支持注解的事务-->

    <tx:annotation-driven transaction-manager="transactionManager"/>

    <!--5 配置spring data-->

    <jpa:repositories base-package="com.imooc" entity-manager-factory-ref="entityManagerFactory"/>

    <context:component-scan base-package="com.imooc"/>

</beans>

使用JPA

通过上面的两种方式中的任意一种即可使用Spring Data JPA。

1、创建实体

通过ORM框架其会被映射到数据库表中，由于配置了hibernate.hbm2ddl.auto，在应用启动的时候框架会自动去数据库中创建对应的表。

package com.imooc.domain;

import javax.persistence.Column;

import javax.persistence.Entity;

import javax.persistence.GeneratedValue;

import javax.persistence.Id;

/**

 * 雇员:  先开发实体类===>自动生成数据表

 */

@Entity

public class Employee {

    private Integer id;

    private String name;

    private Integer age;

    @GeneratedValue

    @Id

    public Integer getId() {

        return id;

    }

    public void setId(Integer id) {

        this.id = id;

    }

    @Column(length = 20)

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public Integer getAge() {

        return age;

    }

    public void setAge(Integer age) {

        this.age = age;

    }

}

2、定义数据访问接口

比如：定义下面这么一个方法，就可以在外界使用了。

Employee findByName(String name);

创建了实体就能够自动帮我们创建数据库表了，修改了实体字段也能够将数据表一起修改。

当然了，上面根据方法名来使用是有弊端的：

1）方法名会比较长：约定大于配置

2）对于一些复杂的查询，是很难实现

比如：

/ where name like ?% and age <?

    public List<Employee> findByNameStartingWithAndAgeLessThan(String name, Integer age);

    // where name like %? and age <?

    public List<Employee> findByNameEndingWithAndAgeLessThan(String name, Integer age);

    // where name in (?,?....) or age <?

    public List<Employee> findByNameInOrAgeLessThan(List<String> names, Integer age);

    // where name in (?,?....) and age <?

    public List<Employee> findByNameInAndAgeLessThan(List<String> names, Integer age);

Repository中查询方法定义规则和使用如下图

因此，对于这种情况下还是要写SQL语句简单得多。可以使用@Query注解使用原生SQL。

package com.imooc.repository;

import com.imooc.domain.Employee;

import org.springframework.data.jpa.repository.Modifying;

import org.springframework.data.jpa.repository.Query;

import org.springframework.data.repository.Repository;

import org.springframework.data.repository.RepositoryDefinition;

import org.springframework.data.repository.query.Param;

import java.util.List;

//如果不继承Repository接口，可以使用注解RepositoryDefinition

@RepositoryDefinition(domainClass = Employee.class, idClass = Integer.class)

public interface EmployeeRepository { //extends Repository<Employee,Integer>{

    //根据命名规则实现查询

    public Employee findByName(String name);

    // where name like ?% and age <?

    public List<Employee> findByNameStartingWithAndAgeLessThan(String name, Integer age);

    // where name like %? and age <?

    public List<Employee> findByNameEndingWithAndAgeLessThan(String name, Integer age);

    // where name in (?,?....) or age <?

    public List<Employee> findByNameInOrAgeLessThan(List<String> names, Integer age);

    // where name in (?,?....) and age <?

    public List<Employee> findByNameInAndAgeLessThan(List<String> names, Integer age);

    //使用Query注解实现查询

    @Query("select o from Employee o where id=(select max(id) from Employee t1)")

    public Employee getEmployeeByMaxId();

    //索引顺序通过 ?+数字 方式表示

    @Query("select o from Employee o where o.name=?1 and o.age=?2")

    public List<Employee> queryParams1(String name, Integer age);

    //也可以在查询语句中使用 ：+变量名 并在查询方法参数中使用注解 Param 标明查询参数方式实现查询

    @Query("select o from Employee o where o.name=:name and o.age=:age")

    public List<Employee> queryParams2(@Param("name")String name, @Param("age")Integer age);

    @Query("select o from Employee o where o.name like %?1%")

    public List<Employee> queryLike1(String name);

    @Query("select o from Employee o where o.name like %:name%")

    public List<Employee> queryLike2(@Param("name")String name);

    //还可以通过设置nativeQuery为true表示使用原生sql查询

    @Query(nativeQuery = true, value = "select count(1) from employee")

    public long getCount();

    //如果要执行更新、删除操作需要额外使用Modifying注解，同时在Service层调用时添加事务 Transational

    @Modifying

    @Query("update Employee o set o.age = :age where o.id = :id")

    public void update(@Param("id")Integer id, @Param("age")Integer age);

}

对于修改数据，需要增加Modify注解、并且一定要在事务的管理下才能修改数据。一般事务的管理在Service层实现。

package com.imooc.service;

import com.imooc.repository.EmployeeRepository;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

import javax.transaction.Transactional;

@Service

public class EmployeeService {

    @Autowired

    private EmployeeRepository employeeRepository;

    //更新操作需要事务管理，在Service层实现

    @Transactional

    public void update(Integer id, Integer age) {

        employeeRepository.update(id, age);

    }

}

对数据库的增、删、改都需要配置事务进行处理。事务一般在Service层进行处理。

3、方法调用

经过上面两步即实现了对数据库的基本操作，可以在Controller层调用Service层的服务了。下面通过测试用例模拟Service调用。

package com.imooc.service;

import com.imooc.repository.EmployeeRepository;

import org.junit.After;

import org.junit.Before;

import org.junit.Test;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class EmployeeServiceTest {

    private ApplicationContext ctx = null;

    private EmployeeService employeeService = null;

    @Before

    public void setup() {

        ctx = new ClassPathXmlApplicationContext("beans.xml");

        employeeService = ctx.getBean(EmployeeService.class);

        System.out.println("setup");

    }

    @After

    public void tearDown() {

        ctx = null;

        System.out.println("tearDown");

    }

    //更新测试用例

    @Test

    public void testUpdate() {

        employeeService.update(1, 55);

    }

}

Repository的子类

Repository类的定义：

public interface Repository<T, ID extends Serializable> {

}

1）Repository是一个空接口，标记接口

没有包含方法声明的接口

2）如果我们定义的接口EmployeeRepository extends Repository

如果我们自己的接口没有extends Repository，运行时会报错：

org.springframework.beans.factory.NoSuchBeanDefinitionException: No qualifying bean of type 'com.imooc.repository.EmployeeRepository' available

添加注解能到达到不用extends Repository的功能

@RepositoryDefinition(domainClass = Employee.class, idClass = Integer.class)

Repository的子类

JpaRepository继承PagingAndSortingRepository，PagingAndSortingRepository又继承CrudRepository，也就是说我们平时自定义的接口只要继承JpaRepository，就相当于拥有了增删查改，分页，等等功能。

JpaSpecificationExecutor提供了查询时的过滤条件。可以通过该接口构造复杂的查询条件。

基本的增删改查和调用存储过程通过Spring Data JPA Repository来解决。

稍微复杂的查询或是批量操作使用QueryDSL或Spring Data Specification的API来解决。

特别特别复杂的查询操作可以使用Spring Data JPA Repository的注解定义native sql来解决。

参考资料：

SpringBoot Data JPA 实战

 Spring Boot中使用Spring-data-jpa

SpringData JPA就是这么简单

 慕课网轻松愉快之玩转SpringData