【Spring】Spring Data JPA
原始JDBC操做數據庫
傳統JDBC方式實現數據庫操做java
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
接口定義mysql
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實現操做數據庫的測試代碼。spring
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操做。sql
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操做數據庫的測試代碼。apache
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中的一個子模塊。session
JPA是一套標準接口，而Hibernate是JPA的實現。app
Spring Data JPA 底層默認實現是使用Hibernate。框架
Spring DataJPA 的首個接口就是Repository，它是一個標記接口。只要咱們的接口實現這個接口，那麼咱們就至關於在使用SpringDataJPA了。
只要咱們實現了這個接口，咱們就可使用"按照方法命名規則"來進行查詢。
JPA是用來簡化數據庫操做的。Spring Data JPA能夠支持關係型數據庫也支持非關係型數據庫。
入門示例
可使用Spring配置方式或者使用Spring Boot方式。
一、首先介紹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時，驗證建立數據庫表結構，只會和數據庫中的表進行比較，不會建立新表，可是會插入新值。
二、傳統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。
一、建立實體
經過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;
}
}
二、定義數據訪問接口
好比：定義下面這麼一個方法，就能夠在外界使用了。
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層進行處理。
三、方法調用
通過上面兩步即實現了對數據庫的基本操做，能夠在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
3) 添加註解能到達到不用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
相關文章
- 1. [Spring] Spring Data JPA
- 2. JPA(7) spring-data-jpa
- 3. JPA---Spring-data-JPA---Hibernate
- 4. 【Spring-data-jpa】Spring-data-jpa與spring，jpa，Hibernate的關係總結
- 5. Spring Boot+Spring Data JPA+Spring Cache
- 6. Spring Data 系列(三) Spring+JPA(spring-data-commons)
- 7. Spring Data JPA
- 8. spring data jpa
- 9. spring Data JPA
- 10. spring-data-jpa
- 更多相關文章...
- • Spring JDBCTemplate簡介 - Spring教程
- • Spring體系結構詳解 - Spring教程
- • Spring Cloud 微服務實戰(三) - 服務註冊與發現
- • IntelliJ IDEA中SpringBoot properties文件不能自動提示問題解決
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. [Spring] Spring Data JPA
- 2. JPA(7) spring-data-jpa
- 3. JPA---Spring-data-JPA---Hibernate
- 4. 【Spring-data-jpa】Spring-data-jpa與spring，jpa，Hibernate的關係總結
- 5. Spring Boot+Spring Data JPA+Spring Cache
- 6. Spring Data 系列(三) Spring+JPA(spring-data-commons)
- 7. Spring Data JPA
- 8. spring data jpa
- 9. spring Data JPA
- 10. spring-data-jpa