学习Spring Data JPA
简介
Spring Data 是spring的一个子项目，在官网上是这样解释的：
Spring Data 是为数据访问提供一种熟悉且一致的基于Spring的编程模型，同时仍然保留底层数据存储的特殊特性。它可以轻松使用数据访问技术，可以访问关系和非关系数据库。
简而言之就是让访问数据库能够更加便捷。
Spring Data 又包含多个子项目：
Spring Data JPA
Spring Data Mongo DB
Spring Data Redis
Spring Data Solr
本文章主要介绍Spring Data JPA的相关知识：
传统方式访问数据库
使用原始JDBC方式进行数据库操作
创建数据表：
开发JDBCUtil工具类
获取Connection，释放资源，配置的属性放在配置文件中，通过代码的方式将配置文件中的数据加载进来。
package com.zzh.util;
import java.io.InputStream;
import java.sql.*;
import java.util.Properties;
public class JDBCUtil {
public static Connection getConnection() throws Exception {
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;
}
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();
}
}
}
}
建立对象模型和DAO
package com.zzh.dao;
import com.zzh.domain.Student;
import com.zzh.util.JDBCUtil;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
/**
* Created by zhao on 2017/5/22.
*/
public class StudentDAOImpl implements StudentDAO{
/**
* 查询学生
*/
@Override
public List<Student> query() {
List<Student> students = new ArrayList<>();
Connection connection = null;
PreparedStatement preparedStatement = null;
ResultSet resultSet = null;
String sql = "select * 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.setAge(age);
student.setName(name);
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的编程，同一个dao方法中有太多的重复代码。
使用Spring JdbcTemplate进行数据库操作
Spring内置模板JdbcTemplate的出现大大提高了开发效率。
- 创建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"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">
<context:property-placeholder location="classpath:db.properties"/>
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="${jdbc.driverClass}"/>
<property name="username" value="${jdbc.user}"/>
<property name="password" value="${jdbc.password}"/>
<property name="url" value="${jdbc.url}"/>
</bean>
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource"/>
</bean>
<bean id="studentDAO" class="com.zzh.dao.StudentDAOSpringJdbcImpl">
<property name="jdbcTemplate" ref="jdbcTemplate"/>
</bean>
</beans>
- 编写查询学生和保存学生方法
package com.zzh.dao;
import com.zzh.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;
public class StudentDAOSpringJdbcImpl implements StudentDAO{
private JdbcTemplate jdbcTemplate;
public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}
@Override
public List<Student> query() {
final List<Student> students = new ArrayList<>();
String sql = "select * from student";
jdbcTemplate.query(sql, new RowCallbackHandler() {
@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.setAge(age);
student.setName(name);
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()});
}
}
弊端分析
DAO中有太多的代码
DAOImpl有大量重复的代码
开发分页或者其他的功能还要重新封装
Spring Data
用上面的两种方式进行数据库操作可以感受到代码的重复性和易用性都是有缺点的，现在先以一个小例子进行spring data操作数据库的基本示范，之后再逐步分析他的具体功能。
小例子
添加pom依赖：
<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配置文件：beans-new.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">
<context:property-placeholder location="classpath:db.properties"/>
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="${jdbc.driverClass}"/>
<property name="username" value="${jdbc.user}"/>
<property name="password" value="${jdbc.password}"/>
<property name="url" value="${jdbc.url}"/>
</bean>
<!-- 配置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.zzh"/>
<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>
<!--事务管理器-->
<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
<property name="entityManagerFactory" ref="entityManagerFactory"/>
</bean>
<!--支持注解的事物-->
<tx:annotation-driven transaction-manager="transactionManager"/>
<!--spring data-->
<jpa:repositories base-package="com.zzh" entity-manager-factory-ref="entityManagerFactory"/>
<context:component-scan base-package="com.zzh"/>
</beans>
LocalContainerEntityManagerFactoryBean：
适用于所有环境的FactoryBean，能全面控制EntityManagerFactory配置，非常适合那种需要细粒度定制的环境。
jpaVendorAdapter：
用于设置JPA实现厂商的特定属性，如设置hibernate的是否自动生成DDL的属性generateDdl，这些属性是厂商特定的。目前spring提供HibernateJpaVendorAdapter，OpenJpaVendorAdapter，EclipseJpaVendorAdapter，TopLinkJpaVenderAdapter四个实现。
jpaProperties：
指定JPA属性；如Hibernate中指定是否显示SQL的“hibernate.show_sql”属性.
- 建立实体类Employee：
- 自定义接口并继承Repository接口
继承的Repository接口泛型里的第一个参数是要操作的对象，即Employee；第二个参数是主键id的类型，即Integer。
方法即为根据名字找员工，这个接口是不用写实现类的。为什么可以只继承接口定义了方法就行了呢，因为spring data底层会根据一些规则来进行相应的操作。
所以方法的名字是不能随便写的，不然就无法执行想要的操作。
package com.zzh.repository;
import com.zzh.domain.Employee;
import org.springframework.data.repository.Repository;
public interface EmployeeRepository extends Repository<Employee,Integer>{
Employee findByName(String name);
}
- 创建测试类
findByName方法体中先不用写，直接执行空的测试方法，我们的Employee表就自动被创建了，此时表中没有数据，向里面添加一条数据用于测试：
package com.zzh.repository;
import com.zzh.domain.Employee;
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 EmployeeRepositoryTest {
private ApplicationContext ctx = null;
private EmployeeRepository employeeRepository = null;
@Before
public void setUp() throws Exception {
ctx = new ClassPathXmlApplicationContext("beans-new.xml");
employeeRepository = ctx.getBean(EmployeeRepository.class);
}
@After
public void tearDown() throws Exception {
ctx = null;
}
@Test
public void findByName() throws Exception {
Employee employee = employeeRepository.findByName("zhangsan");
System.out.println("id:" + employee.getId() + " name:" + employee.getName() + " age:" + employee.getAge());
}
}
再执行测试类方法体中的内容：
Repository接口
Repository接口是Spring Data的核心接口，不提供任何方法
使用 @ RepositoryDefinition注解跟继承Repository是同样的效果，例如 @ RepositoryDefinition（domainClass = Employee.class, idClass = Integer.class)
Repository接口定义为：public interface Repository<T, ID extends Serializable> {}，Repository是一个空接口，标记接口；只要将自定义的接口继承Repository，就会被spring来管理。
Repository的子接口
CrudRepository ：继承 Repository，实现了CRUD相关的方法。
PagingAndSortingRepository : 继承 CrudRepository，实现了分页排序相关的方法。
JpaRepository ：继承 PagingAndSortingRepository ，实现了JPA规范相关的方法。
Repository中查询方法定义规则
上面一个例子中使用了findByName作为方法名进行指定查询，但是如果把名字改为其他没有规则的比如test就无法获得正确的查询结果。
有如下规则：
最右边是sql语法，中间的就是spring data操作规范，现在写一些小例子来示范一下：
先在employee表中初始化了一些数据：
在继承了Repository接口的EmployeeRepository接口中新增一个方法：
条件是名字以test开头，并且年龄小于22岁，在测试类中进行测试：
得到结果：
在换一个名字要在某个范围以内并且年龄要小于某个值：
测试类：
得到结果，只有test1和test2，因为在test1，test2和test3里面，年龄还要小于22，所以test3被排除了：
弊端分析：
对于按照方法名命名规则来使用的弊端在于：
方法名会比较长
对于一些复杂的查询很难实现
Query注解
只需要将 @ Query标记在继承了Repository的自定义接口的方法上，就不再需要遵循查询方法命名规则。
支持命名参数及索引参数的使用
本地查询
案例使用：
- 查询Id最大的员工信息：
@Query("select o from Employee o where id=(select max(id) from Employee t1)")
Employee getEmployeeById();
注意：Query语句中第一个Employee是类名
测试类：
@Test
public void getEmployeeByMaxId() throws Exception {
Employee employee = employeeRepository.getEmployeeByMaxId();
System.out.println("id:" + employee.getId() + " name:" + employee.getName() + " age:" + employee.getAge());
}
- 根据占位符进行查询
注意占位符后从1开始
@Query("select o from Employee o where o.name=?1 and o.age=?2")
List<Employee> queryParams1(String name, Integer age);
测试方法：
@Test
public void queryParams1() throws Exception {
List<Employee> employees = employeeRepository.queryParams1("zhangsan", 20);
for (Employee employee : employees) {
System.out.println("id:" + employee.getId() + " name:" + employee.getName() + " age:" + employee.getAge());
}
}
- 根据命名参数的方式
@Query("select o from Employee o where o.name=:name and o.age=:age")
List<Employee> queryParams2(@Param("name") String name, @Param("age") Integer age);
- like查询语句
@Query("select o from Employee o where o.name like %?1%")
List<Employee> queryLike1(String name);
@Test
public void queryLike1() throws Exception {
List<Employee> employees = employeeRepository.queryLike1("test");
for (Employee employee : employees) {
System.out.println("id:" + employee.getId() + " name:" + employee.getName() + " age:" + employee.getAge());
}
}
查询包含test的记录：
P.s 这里查询也得到了结果，不过我的idea却在sql语句里面提示有错，我怀疑是我的idea版本的问题，我的是2017.1.3版本的：
- like语句使用命名参数
@Query("select o from Employee o where o.name like %:name%")
List<Employee> queryLike2(@Param("name") String name);
本地查询
所谓本地查询，就是使用原生的sql语句进行查询数据库的操作。但是在Query中原生态查询默认是关闭的,需要手动设置为true：
@Query(nativeQuery = true, value = "select count(1) from employee")
long getCount();
方法是拿到记录数,这里使用的employee是表而不是类,也是原生态查询的特点。
更新操作整合事物使用
- 在dao中定义方法根据id来更新年龄（Modifying注解代表允许修改）
@Modifying
@Query("update Employee o set o.age = :age where o.id = :id")
void update(@Param("id") Integer id, @Param("age") Integer age);
要注意，执行更新或者删除操作是需要事物支持，所以通过service层来增加事物功能,在update方法上添加Transactional注解。
package com.zzh.service;
import com.zzh.repository.EmployeeRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service
public class EmployeeService {
@Autowired
private EmployeeRepository employeeRepository;
@Transactional
public void update(Integer id, Integer age) {
employeeRepository.update(id,age);
}
}
- 删除操作
删除操作同样需要Query注解，Modifying注解和Transactional注解
@Modifying
@Query("delete from Employee o where o.id = :id")
void delete(@Param("id") Integer id);
@Transactional
public void delete(Integer id) {
employeeRepository.delete(id);
}
CrudRepository接口
- 创建接口继承CrudRepository
package com.zzh.repository;
import com.zzh.domain.Employee;
import org.springframework.data.repository.CrudRepository;
public interface EmployeeCrudRepository extends CrudRepository<Employee,Integer>{
}
- 在service层中调用
@Autowired
private EmployeeCrudRepository employeeCrudRepository;
存入多个对象：
@Transactional
public void save(List<Employee> employees) {
employeeCrudRepository.save(employees);
}
创建测试类,将要插入的100条记录放在List中：
package com.zzh.repository;
import com.zzh.domain.Employee;
import com.zzh.service.EmployeeService;
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.SpringJUnit4ClassRunner;
import java.util.ArrayList;
import java.util.List;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({"classpath:beans-new.xml"})
public class EmployeeCrudRepositoryTest {
@Autowired
private EmployeeService employeeService;
@Test
public void testSave() {
List<Employee> employees = new ArrayList<>();
Employee employee = null;
for (int i = 0; i < 100; i++) {
employee = new Employee();
employee.setName("test" + i);
employee.setAge(100 - i);
employees.add(employee);
}
employeeService.save(employees);
}
}
为了不影响之前的employee表，现在在Employee类上面加上Table注解，指定一个新的表名，之前没有加这个注解默认使用了类名当作表名，也就是employee，现在指定新表test_employee。
执行测试类中的方法，控制台输出了很多插入语句，打开数据库查看，新表创建成功，同时插入了100条数据：
CrudRepository总结
可以发现在自定义的EmployeeCrudRepository中，只需要声明接口并继承CrudRepository就可以直接使用了。
PagingAndSortingRepository接口
该接口包含分页和排序的功能
带排序的查询：findAll(Sort sort)
带排序的分页查询：findAll(Pageable pageable)
自定义接口
package com.zzh.repository;
import com.zzh.domain.Employee;
import org.springframework.data.repository.PagingAndSortingRepository;
public interface EmployeePagingAndSortingRepository extends PagingAndSortingRepository<Employee, Integer> {
}
测试类
分页：
package com.zzh.repository;
import com.zzh.domain.Employee;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({"classpath:beans-new.xml"})
public class EmployeePagingAndSortingRepositoryTest {
@Autowired
private EmployeePagingAndSortingRepository employeePagingAndSortingRepository;
@Test
public void testPage() {
//第0页，每页5条记录
Pageable pageable = new PageRequest(0, 5);
Page<Employee> page = employeePagingAndSortingRepository.findAll(pageable);
System.out.println("查询的总页数："+ page.getTotalPages());
System.out.println("总记录数："+ page.getTotalElements());
System.out.println("当前第几页："+ page.getNumber()+1);
System.out.println("当前页面对象的集合："+ page.getContent());
System.out.println("当前页面的记录数："+ page.getNumberOfElements());
}
}
排序：
在PageRequest的构造函数里还可以传入一个参数Sort，而Sort的构造函数可以传入一个Order，Order可以理解为关系型数据库中的Order；Order的构造函数Direction和property参数代表按照哪个字段进行升序还是降序。
现在按照id进行降序排序：
@Test
public void testPageAndSort() {
Sort.Order order = new Sort.Order(Sort.Direction.DESC, "id");
Sort sort = new Sort(order);
Pageable pageable = new PageRequest(0, 5, sort);
Page<Employee> page = employeePagingAndSortingRepository.findAll(pageable);
System.out.println("查询的总页数："+ page.getTotalPages());
System.out.println("总记录数："+ page.getTotalElements());
System.out.println("当前第几页：" + page.getNumber() + 1);
System.out.println("当前页面对象的集合："+ page.getContent());
System.out.println("当前页面的记录数："+ page.getNumberOfElements());
}
可以看到id是从100开始降序排列。
JpaRepository接口
- 创建接口继承JpaRepository
package com.zzh.repository;
import com.zzh.domain.Employee;
import org.springframework.data.jpa.repository.JpaRepository;
public interface EmployeeJpaRepository extends JpaRepository<Employee,Integer>{
}
- 测试类
按id查找员工
package com.zzh.repository;
import com.zzh.domain.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.SpringJUnit4ClassRunner;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({"classpath:beans-new.xml"})
public class EmployeeJpaRepositoryTest {
@Autowired
private EmployeeJpaRepository employeeJpaRepository;
@Test
public void testFind() {
Employee employee = employeeJpaRepository.findOne(99);
System.out.println(employee);
}
}
查看员工是否存在
@Test
public void testExists() {
Boolean result1 = employeeJpaRepository.exists(25);
Boolean result2 = employeeJpaRepository.exists(130);
System.out.println("Employee-25: " + result1);
System.out.println("Employee-130: " + result2);
}
JpaSpecificationExecutor接口
Specification封装了JPA Criteria查询条件
没有继承其他接口。
自定义接口
这里要尤为注意，为什么我除了继承JpaSpecificationExecutor还要继承JpaRepository，就像前面说的，JpaSpecificationExecutor没有继承任何接口，如果我不继承JpaRepository，那也就意味着不能继承Repository接口，spring就不能进行管理，后面的自定义接口注入就无法完成。
package com.zzh.repository;
import com.zzh.domain.Employee;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
public interface EmployeeJpaSpecificationExecutor extends JpaSpecificationExecutor<Employee>,JpaRepository<Employee,Integer> {
}
测试类
测试结果包含分页，降序排序，查询条件为年龄大于50
package com.zzh.repository;
import com.zzh.domain.Employee;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import javax.persistence.criteria.*;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({"classpath:beans-new.xml"})
public class EmployeeJpaSpecificationExecutorTest {
@Autowired
private EmployeeJpaSpecificationExecutor employeeJpaSpecificationExecutor;
/**
* 分页
* 排序
* 查询条件: age > 50
*/
@Test
public void testQuery() {
Sort.Order order = new Sort.Order(Sort.Direction.DESC, "id");
Sort sort = new Sort(order);
Pageable pageable = new PageRequest(0, 5, sort);
/**
* root:查询的类型（Employee）
* query：添加查询条件
* cb:构建Predicate
*/
Specification<Employee> specification = new Specification<Employee>() {
@Override
public Predicate toPredicate(Root<Employee> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
Path path = root.get("age");
return cb.gt(path, 50);
}
};
Page<Employee> page = employeeJpaSpecificationExecutor.findAll(specification, pageable);
System.out.println("查询的总页数："+ page.getTotalPages());
System.out.println("总记录数："+ page.getTotalElements());
System.out.println("当前第几页：" + page.getNumber() + 1);
System.out.println("当前页面对象的集合："+ page.getContent());
System.out.println("当前页面的记录数："+ page.getNumberOfElements());
}
}
可以看到id是从50开始，而不是100，因为设定了查询条件age>50
总结
本篇文章首先介绍以原始的jdbc方式和Spring JdbcTemplate进行数据库相关操作，接着讲解了Spring Data Jpa的Repository接口和增删查改有关的注解，最后介绍了Repository的一些子接口相关的crud，分页和排序。
GitHub地址：SpringDataJpa
学习Spring Data JPA的更多相关文章
- 学习-spring data jpa
spring data jpa对照表 Keyword Sample JPQL snippet And findByLastnameAndFirstname - where x.lastname = ? ...
- 【Spring Data 系列学习】了解 Spring Data JPA 、 Jpa 和 Hibernate
在开始学习 Spring Data JPA 之前,首先讨论下 Spring Data Jpa.JPA 和 Hibernate 之前的关系. JPA JPA 是 Java Persistence API ...
- 一步步学习 Spring Data 系列之JPA（二）
继上一篇文章对Spring Data JPA更深( )一步剖析. 上一篇只是简单的介绍了Spring Data JPA的简单使用,而往往在项目中这一点功能并不能满足我们的需求.这是当然的,在业务中查询 ...
- Spring Data JPA 学习记录1 -- 单向1:N关联的一些问题
开新坑 开新坑了(笑)....公司项目使用的是Spring Data JPA做持久化框架....学习了一段时间以后发现了一点值得注意的小问题.....与大家分享 主要是针对1:N单向关联产生的一系列问 ...
- spring data jpa入门学习
本文主要介绍下spring data jpa,主要聊聊为何要使用它进行开发以及它的基本使用.本文主要是入门介绍,并在最后会留下完整的demo供读者进行下载,从而了解并且开始使用spring data ...
- Spring Data Jpa 入门学习
本文主要讲解 springData Jpa 入门相关知识, 了解JPA规范与Jpa的实现,搭建springboot+dpringdata jpa环境实现基础增删改操作,适合新手学习,老鸟绕道~ 1. ...
- spring boot学习(4) SpringBoot 之Spring Data Jpa 支持（1）
第一节:Spring Data Jpa 简介 Spring-Data-Jpa JPA(Java Persistence API)定义了一系列对象持久化的标准,目前实现这一规范的产品有Hibernate ...
- Spring Data JPA的基本学习之了解
Spring Data JPA 是 什 么 可以理解为JPA规范的再次封装抽象,底层还是使用了Hibernate的JPA技术实现,引用JPQL(Java Persistence Query Langu ...
- SpringBoot学习笔记：Spring Data Jpa的使用
更多请关注公众号 Spring Data Jpa 简介 JPA JPA(Java Persistence API)意即Java持久化API,是Sun官方在JDK5.0后提出的Java持久化规范(JSR ...
随机推荐
- CentOS 6.3安装配置supervisor进程管理工具
1. Supervisor是一个C/S系统,它可以在类unix操作系统让用户来监视和控制后台服务进程的数量,一个很重要的功能就是监控服务器的主要后台进程,并在出现问题是自动重启. 2. 根据服务器上的 ...
- RN项目中关于父子组件的通信
子组件向父组件传递数据 子控件中在相应的函数中.通过props.coallback的回调通知父组件. 父组件调用callback属性时行 绑定,并在方法中去解析使用获取到的值 . //子控件: < ...
- svn搭建相关
转载至:http://blog.163.com/longsu2010@yeah/blog/static/173612348201202114212933/ 安装步骤如下: 1.yum install ...
- SpringCloud 简单理解
0.SpringCloud,微服务架构.包括 服务发现(Eureka),断路器(Hystrix),服务网关(Zuul),客户端负载均衡(Ribbon).服务跟踪(Sleuth).消息总线(Bus).消 ...
- collections系列之Counter
collections模块中有一个叫做Counter的类,该类的作用就是计数器,Counter是对dict的加工,所有Counter继承了dict的方法 1.创建一个Counter,需要import ...
- pyhon模块之日志模块
#Auther Bob#--*--coding:utf-8--*-- import logging #python一共有5个级别的日志,debug.info.warning.error.critica ...
- forbidden
- Git 初始状操作指引
You have an empty repository To get started you will need to run these commands in your terminal. Ne ...
- 03 Maven 坐标与依赖
Maven 坐标与依赖 Maven 的一大功能是管理项目依赖.为了能自动化地解析任何一个 Java 构件, Maven 就必须将它们唯一标识,这就依赖管理的底层基础 一一 坐标.本章将详细分析 Mav ...
- document.body和document.documentElement区别
1.document.documentElement表示文档节点树的根节点,即<html> document.body是body节点 2. 页面具有 DTD,或者说指定了 DOCTYPE ...