Spring Data

最新推荐文章于 2024-10-14 22:42:36 发布

chengman5642

最新推荐文章于 2024-10-14 22:42:36 发布

阅读量91

点赞数

文章标签：数据库 java

原文链接：https://my.oschina.net/u/3592080/blog/1507522

版权

什么是Spring Data

Spring Data项目的目的是为了简化构建基于 Spring 框架应用的数据访问计数，包括非关系数据库、Map-Reduce 框架、云数据服务等等；另外也包含对关系数据库的访问支持。

本文主要简述Spring Data JPA 与传统JDBC 和 Spring JDBC的优势，以及Spring Data JPA的简单使用

传统的JDBC操作数据库

使用JDBC原生操作数据库，会有很多重复性的代码，代码冗余

public class StudentDAOImpl implements StudentDAO{
    @Override
    public void save(Student student) {
        Connection connection = null;
        String sql = "insert into student(name, age) VALUES (?,?)";
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        try {
            connection = JDBCUtil.getConnection();  // 使用工具类获取数据库连接，减少代码冗余
            preparedStatement = connection.prepareStatement(sql);  // 获取操作数据库对象
            preparedStatement.setString(1, student.getName());  // 给sql语句的占位符赋值
            preparedStatement.setInt(2, student.getAge());
            preparedStatement.executeUpdate();  // 执行更新操作
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCUtil.release(resultSet, preparedStatement, connection);  // 关闭资源
        }

    }
    @Override
    public List<Student> query() {
        Connection connection = null;
        String sql = "select id, name, age from student";
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        List<Student> listStudent = new ArrayList<>();
        try {
            connection = JDBCUtil.getConnection();
            preparedStatement = connection.prepareStatement(sql);
            resultSet = preparedStatement.executeQuery();  //执行查询操作
            Student student = null;
        /*对获取的结果集执行对对象赋值（这个在JDBC中简直麻烦）
        */
            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);
                listStudent.add(student);
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCUtil.release(resultSet, preparedStatement, connection);  // 关闭数据库资源
        }
        return listStudent;
    }
}

上述代码中虽然使用了JDBCUtil类减轻了创建连接和释放资源的过程，但获取对象还是麻烦

Spring JDBC操作数据库

在Spring 中操作数据库可以使用Spring Jdbc Template,这使得Spring 可以简化对数据库的操作，在Spring Jdbc中对原生的JDBC操作数据库做了一层简单的封装，把获取数据库连接，释放数据库资源的行为封装起来，只需在spring的配置文件中进行简单的配置，即可直接在代码中使用Spring的JdbcTemplate对数据进行增删改查即可。 JdbcTemplate在Sping配置文件中的配置：

<?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="1234"/>
        <property name="url" value="jdbc:mysql://localhost:3306/spring_data"/>
    </bean>

    <!--配置jdbcTemplate-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
    </bean>
    
    <!--StudentDao的装配-->
    <bean id="studentDAO" class="cc.codingape.dao.StudentDAOSpringJdbcImpl">
        <property name="jdbcTemplate" ref="jdbcTemplate"/>
    </bean>
</beans>

使用了JdbcTemplate的Dao实现类

/**
 * Created by TONY on 2017/8/10.
 * StudentDAO访问接口实现类：通过Spring jdbc 的方式操作
 */
public class StudentDAOSpringJdbcImpl implements StudentDAO {
    private JdbcTemplate jdbcTemplate;
    @Override
    public List<Student> query() {
        List<Student> studentList = new ArrayList<>();
        String sql = "select id, name, age from student";
        jdbcTemplate.query(sql, new RowCallbackHandler() {
            /**
             * 这个方法会循环执行resultSet里面的值，使用了回调接口获得结果集
             * 获取结果集，把结果值里面的内容赋值给具体的对象
             * @param resultSet
             * @throws SQLException
             */
            @Override
            public void processRow(ResultSet resultSet) throws SQLException {
                int id = resultSet.getInt("id");
                String name = resultSet.getString("name");
                int age = resultSet.getInt("age");
                Student student = new Student();
                student.setId(id);
                student.setName(name);
                student.setAge(age);
                studentList.add(student);
            }
        });
        return studentList;
    }
    @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 Jdbc Template简化了部分原生JDBC的操作

Spring Data操作数据库

使用Spring Data可以大大简化了操作数据的过程 Repository接口是Spring Data的核心接口，不提供任何方法，属于标志型接口

public interface Repository<T, ID extends Serializable> {
}

我们自定义的Repository接口需要继承Repository接口或Repository的子接口或在自定义的Repository接口上@RepositoryDefinition注解

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

Repository的子接口

CrudRepository:继承了Repository, 实现了CRUD相关操作的方法
PageingAndSortingRepository:继承了CurdRepository,实现了分页排序相关的方法
JpaRepository:继承PagingAndSortingRepository,实现了JPA规范相关的方法

使用Spring Data 需要在Maven工程中声明相关依赖：

<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>

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: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="1234"/>
        <property name="url" value="jdbc:mysql://localhost:3306/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="cc.codingape"/>
        <!--通过设置jpa属性，可以利用实体生成表-->
        <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="cc.codingape" entity-manager-factory-ref="entityManagerFactory"/>

    <context:component-scan base-package="cc.codingape"/>

</beans>

CrudRepository接口讲解

输入图片说明

PagingAndSortingRespository接口讲解

输入图片说明

public class EmployeePagingAndSortingRespositoryTest {
    private ApplicationContext ctx = null;
    private EmployeePagingAndSortingRepository employeePagingAndSortingRespository = null;

    @Before
    public void init() {
        ctx = new ClassPathXmlApplicationContext("beans-new.xml");
        employeePagingAndSortingRespository = ctx.getBean(EmployeePagingAndSortingRepository.class);
        System.out.println("init");
    }

    @After
    public void destory() {
        ctx = null;
        System.out.println("destory");
    }

    @Test
    public void testPage() {
        //index是从0开始
        Pageable pageable = new PageRequest(0, 10);
        Page<Employee> page = employeePagingAndSortingRespository.findAll(pageable);
        System.out.println("查询的总的记录数" + page.getTotalElements());
        System.out.println("当前第几页" + page.getNumber());
        System.out.println("查询的当前页面的集合" + page.getContent());
    }

    @Test
    public void testPageAndSort() {
        Sort.Order order = new Sort.Order(Sort.Direction.DESC, "id");
        Sort sort = new Sort(order);
        //index是从0开始
        Pageable pageable = new PageRequest(0, 10, sort);
        Page<Employee> page = employeePagingAndSortingRespository.findAll(pageable);
        System.out.println("查询的总的记录数" + page.getTotalElements());
        System.out.println("当前第几页" + page.getNumber());
        System.out.println("查询的当前页面的集合" + page.getContent());
    }

}

JpaRepository接口讲解

输入图片说明

JpaSpecificationExecutor接口讲解

JpaSpecificationExecutor接口封装了JPA Criterial查询条件，在PagingAndSortingRespository接口中虽然可以进行排序等操作，但不能带查询条件。因此引入了JpaSpecificationExecutor接口

public class EmployeeSpecificationRepositoryTest {
    private ApplicationContext ctx = null;
    private EmployeeJpaSpecificationExecutorRepository employeeJpaSpecificationExecutorRepository = null;

    @Before
    public void init() {
        ctx = new ClassPathXmlApplicationContext("beans-new.xml");
        employeeJpaSpecificationExecutorRepository = ctx.getBean(EmployeeJpaSpecificationExecutorRepository.class);
        System.out.println("init");
    }

    @After
    public void destory() {
        ctx = null;
        System.out.println("destory");
    }

    /**
     * 1.分页
     * 2.排序
     * 3.查询条件 age > 50
     */
    @Test
    public void testQuery() {

        Sort.Order order = new Sort.Order(Sort.Direction.DESC, "id");
        Sort sort = new Sort(order);
        //index是从0开始
        Pageable pageable = new PageRequest(0, 10, sort);

        /**
         * root:就是我们要查询的类型
         * query:添加查询条件
         * cb:构建Predicate
         */
        Specification<Employee> specification = new Specification<Employee>() {
            @Override
            public Predicate toPredicate(Root<Employee> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
                // root (employee (age))
                Path path = root.get("age");
                return criteriaBuilder.gt(path, 50);
            }
        };

        //根据排序条件返回的page
        Page<Employee> page = employeeJpaSpecificationExecutorRepository.findAll(specification, pageable);
        System.out.println("查询的总的记录数" + page.getTotalElements());
        System.out.println("当前第几页" + page.getNumber());
        System.out.println("查询的当前页面的集合" + page.getContent());
    }

}

转载于:https://my.oschina.net/u/3592080/blog/1507522