SpringData讲义
SpringData讲义
1 SpringData概述
1.1 SpringData是什么
SpringData是spring提供对数据访问的技术。包括关系型数据库、非关系型数据库(No-sql数据库)、以及map-reduce(大数据Hadoop的内容)框架的访问。
本次教学,我们只针对SpringData对关系型数据库的支持进行讲解。
SpringData官方对关系型数据库的支持,可以通过JPA整合实现对数据库的操作。
本次教学我们以JPA为例,所以学习SpringData必须先学习JPA的相关知识。
SpringData 底层依然使用的是JPA,对JPA进行更深层次的封装
1.2 为什么要学习SpringData
SpringData对以上所提到的数据存储技术,提供了一套良好的API支持,让我们更加快速的完成对数据库的操作。
1.3 回顾JPA
@Test public void findAll(){ //1获得操作对象 EntityManager manager = JpaUtils.getEntityManager(); //2.获得JPQL查询对象 TypedQuery<Student> query = manager.createQuery("select s from Student s", Student.class); List<Student> students = query.getResultList(); for (Student student : students) { System.out.println(student); } manager.close(); } |
--说明:
以上代码我们看到,我们执行JPQL需要
(1) 先创建一个操作对象
(2) 获得查询对象Query实例对象
(3) 查询结束后,要关闭操作对象
(4) 关闭后再返还数据。
问题:我们完成一次操作,需要写很多的操作代码。
如果使用SpringData-JPA项目,完成以上的代码,可以实现DAO层零实现。
2 入门示例
2.1 需求
通过SpringData-jpa实现查询所有数据。
2.2 配置步骤说明
SpringData-jpa是基于Spring的,所以思路是:先配置Spring框架,再整合SpringData-jpa
(1)、导入包。(使用Maven导入)
(2)、配置Spring
(3)、配置SpringData-jpa,整合Spring
(4)、编写查询的实现代码
2.3 配置步骤
2.3.1 第一部分:搭建环境(创建项目导入包)
2.3.1.1 第一步:创建项目
|
2.3.1.2 第二步:导入Pom依赖
<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>cn.zj</groupId> <artifactId>SpringDate-dmoe01-start</artifactId> <version>0.0.1-SNAPSHOT</version> <packaging>war</packaging> <dependencies> <!-- SpringData-jpa框架依赖 --> <dependency> <groupId>org.springframework.data</groupId> <artifactId>spring-data-jpa</artifactId> <version>1.8.0.RELEASE</version> </dependency> <!-- hibernate-entity --> <dependency> <groupId>org.hibernate</groupId> <artifactId>hibernate-entitymanager</artifactId> <version>4.3.6.Final</version> </dependency>
<!-- spring的测试包 --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-test</artifactId> <version>4.0.9.RELEASE</version> </dependency> <!-- 单元测试 --> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.12</version> </dependency> </dependencies> </project> |
2.3.2 第二部分:配置Spring
需求:编写一个简单的DAO类,输出一句话,使用Spring容器创建对象
2.3.2.1 第一步:创建一个DAO类
package cn.zj.springdata.dao;
import org.springframework.stereotype.Repository;
@Repository public class UserDao {
public void findAll(){
System.out.println("查询所有用户成功!"); } } |
2.3.2.2 第二步:创建Spring配置文件
创建spring-data.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" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.3.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd">
<!-- 开启注解扫描 --> <context:component-scan base-package="cn.zj.springdata"/> </beans> |
2.3.2.3 第三步:创建一个测试类
导入junit类库。(快捷键ctrl+1)
package cn.zj.springdata.test;
import java.util.List;
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 cn.zj.springdata.dao.UserDao; import cn.zj.springdata.pojo.User;
@RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration("classpath:spring-data.xml") public class UserDAOTest {
@Autowired private UserDao userDao;
@Test public void findAll() { List<User> users = userDao.findAll(); for (User user : users) { System.out.println(user); } } } |
--测试成功
|
2.3.3 第三部分:整合SpringData-jpa
任何的数据库操作框架,和spring整合,都是为了使用spring容器里面的数据源。
问题:为什么需要使用spring容器的数据源?
答:因为只有使用spring容器里面的数据源,才能使用spring事物代理。
根据以上说明,既然SpringData-jpa框架也是一个操作关系型数据库的框架,那么我们也需要首先配置数据源,再整合。
整合思路为:
(1) 创建数据源
(2) 获得jpa的实体管理工厂
(3) 启动事物代理
(4) 整合SpringData-jpa
2.3.3.1 第一步:创建数据源
我们在这里使用druid数据源
导入druid的依赖以及mysql驱动包依赖
<!-- druid依赖 --> <dependency> <groupId>com.alibaba</groupId> <artifactId>druid</artifactId> <version>1.1.10</version> </dependency><!-- jdbc驱动依赖 --> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.40</version> </dependency> |
配置druid数据源到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-4.3.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd">
<!-- 开启注解扫描 --> <context:component-scan base-package="cn.zj.springdata"/>
<!-- 1、配置druid数据源到spring容器中 --> <bean name="dataSource" class="com.alibaba.druid.pool.DruidDataSource"> <!-- jdbc必须的四要素 --> <property name="driverClassName" value="com.mysql.jdbc.Driver"></property> <property name="url" value="jdbc:mysql://localhost:3306/jpa"></property> <property name="username" value="root"></property> <property name="password" value="root"></property> </bean> </beans> |
2.3.3.2 第二步:配置JPA实体管理工厂
说明:因为需要使用spring数据源,所以实体工厂要使用spring-orm-4.0.9.RELEASE.jar中整合spring的实体管理工厂代理类,创建实体管理工厂。
<!-- 2、配置jpa实体管理工厂 --> <bean name="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean"> <!-- 必须指定数据源 --> <property name="dataSource" ref="dataSource"/>
<!-- 必须指定jpa实体类所在的包 --> <property name="packagesToScan" value="cn.zj.springdata.pojo"/>
<!-- 必须指定jpa适配器。 问题:为什么需要指定适配器? 答:jpa是一种标准,基于JPA这个标准有多种框架。所以我们要通过适配器指定使用的是哪一个jpa框架 在这里我们使用的是hibernate这个框架。 所以指定的就是HibernateJpaVendorAdapter这个适配器 --> <property name="jpaVendorAdapter"> <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter"/> </property>
<!-- 设置框架的属性 --> <property name="jpaProperties"> <props> <!-- 配置数据库方言 --> <prop key="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</prop> <!-- 定义sql语句是否显示 --> <prop key="hibernate.show_sql">true</prop> <!-- 定义sql语句格式化 --> <prop key="hibernate.format_sql">true</prop> <!-- 设置hibernate自动更新功能 --> <prop key="hibernate.hbm2ddl.auto">update</prop> </props> </property> </bean> |
2.3.3.3 第三步:整合SpringData-jpa
<!-- 3、整合SpringData-jpa --> <jpa:repositories base-package="cn.zj.springdata.dao" entity-manager-factory-ref="entityManagerFactory"/> |
2.3.3.4 第四步:配置事物代理
<!-- 4、配置事物代理 --> <bean name="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager"> <property name="dataSource" ref="dataSource"></property> </bean>
<!-- 启动编程式事物 --> <tx:annotation-driven transaction-manager="transactionManager "/> |
2.3.4 第四部分:编程查询的实现代码
2.3.4.1 第一步:创建pojo,映射实体类
package cn.zj.springdata.pojo;
import java.io.Serializable;
import javax.persistence.Column; import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.GenerationType; import javax.persistence.Id; import javax.persistence.Table;
@Entity @Table(name="t_user") public class User {
@Id @GeneratedValue(strategy=GenerationType.IDENTITY) private Integer id;
@Column private String name;
@Column private String password;
public User() { super(); } // 补全get、set方法 } |
2.3.4.2 第二步:修改UserDAO类为JPA接口
注意:
SpringData-jpa操作接口,必须通过继承Repository接口,才能获得该DAO接口的动态对象
修改UserDAO接口
package cn.zj.springdata.dao;
import java.util.List; import org.springframework.data.repository.Repository; import cn.zj.springdata.pojo.User;
/** * 注意:SpringData-jpa操作接口,必须通过继承Repository接口,才能获得该DAO接口的动态对象 * * Repository<User, Integer> User 表示的是实体类, Integer:表示主键的数据类型 * */ public interface UserDAO extends Repository<User, Integer>{ /** * 查询所有对象 * @return */ List<User> findAll(); } |
2.3.4.3 第三步:修改测试类,查看查询结果
修改测试方法。
package cn.zj.springdata.test;
import static org.junit.Assert.*;
import java.util.List;
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 cn.zj.springdata.dao.UserDao; import cn.zj.springdata.pojo.User;
@RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration("classpath:spring-data.xml") public class UserDaoTest {
@Autowired private UserDao userDao;
@Test public void testFindAll() {
List<User> users = userDao.findAll(); for (User user : users) { System.out.println(user); } }
}
|
--测试成功
|
--问题:为什么我们定义的findAll方法能够查询到所有的数据呢?(重点)
答:SpringData-jpa定义一套规则,通过规则来实现DAO操作功能。
--规则如下:
--查询规则(方法的命名规则): 1、直接在接口中定义查询方法,查询方法以 find | read | get 开头; 2、涉及条件查询时,以By作为开始关键词,类的属性名首字母大写,作为查询条件,形如: findByName(String Name); 3、当有多条件查询时,使用规定的关键词连接各个属性,注意属性与参数个数、顺序一一对应,形如: findByNameAndPassword(String name,String password);
4、多条件查询更多示例
--其它规则: 我们知道Repository创建动态对象,必须使用的是SimpleJpaRepository。所以只要在接口中定义的方法以及父接口定义的方法一致,也可以获得对应的操作功能。如SimpleJpaRepository类定义有save的方法:
所以在我们的DAO也可以使用
|
3 Repository API的介绍
3.1 说明
根据以上的代码。我们知道其实学习Spring data-jpa配置成功后。剩下主要学习的内容就是Repository的相关类库了。
Repository的继承关系如下:
|
在了解这些类之前。我们先思考一个问题。就是我们自定义的Repository的方法名都是自己一个一个写的。
想法:我们能不能不写这些常用的单表的操作方法呢?
答:可以的。因为SpringData-Jpa已经将大部分的方法的声明,分别定义在Repository子接口中。我们只用继承它最后一个子接口JpaRepository就可以使用里面的所有已经定义好的访问。
根据继承关系图:可以使用的以下口接里面的所有定义方法
1、 CrudRepository接口:简单的增删改查的方法
2、 PagingAndSortingRepository接口:排序和分页的方法
3、 JpaRepository接口:增强的一些方法
3.2 示例代码
--UserRepository代码
package cn.zj.springdata.dao;
import org.springframework.data.jpa.repository.JpaRepository;
import cn.zj.springdata.pojo.User;
/** * 注意:SpringData-jpa通过继承Repository接口来获得DAO实例对象 * * Repository<User, Integer> User 表示的是实体类, Integer:表示主键的数据类型 * */ public interface UserRepository extends JpaRepository<User, Integer>{
}
|
--测试类UserRepositoryTest
package cn.zj.springdata.test;
import static org.junit.Assert.*;
import java.util.List;
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 cn.zj.springdata.dao.UserRepository; import cn.zj.springdata.pojo.User;
@RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration("classpath:spring-data.xml") public class UserRepositoryTest {
@Autowired private UserRepository userRepository;
@Test public void test1() {
List<User> users = userRepository.findAll(); for (User user : users) { System.out.println(user); } }
@Test public void test2() throws Exception { User user = new User(); user.setName("王五"); user.setPassword("123456");
System.out.println("插入前:"+user); userRepository.save(user); System.out.println("插入后:"+user); }
}
|
--测试成功!!!
UserRepository不用写任何代码,也可以实现常用的操作方法!!!
4 JPQL的支持
4.1 说明:
除了常用的方法以外,有时候我们需要使用JPQL查询。
SpringData-jpa是通过@Query注解,支持JPQL查询的。
4.2 示例代码
--操作接口代码
/** * 注意:SpringData-jpa通过继承Repository接口来获得DAO实例对象 * * Repository<User, Integer> User 表示的是实体类, Integer:表示主键的数据类型 * */ public interface UserRepository extends JpaRepository<User, Integer> { @Query("select u from User u where u.name = ?1") User findByName(String name); } |
--测试代码
package cn.zj.springdata.test;
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 cn.zj.springdata.dao.UserRepository; import cn.zj.springdata.pojo.User;
@RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration("classpath:spring-data.xml") public class UserRepositoryTest {
@Autowired private UserRepository userRepository;
@Test public void test1() {
User user = userRepository.findByName("张三"); System.out.println(user); } }
|
5 动态JPQL语句的支持-JpaSpecificationExecutor
5.1 说明
问题:以上编写JPQL的代码是在注解上面实现的。我们知道注解是不能条件拼接JPQL语句的。那么如果出现需要条件拼接JPQL语句要怎么实现呢?
答:SpringData-jpa是通过JpaSpecificationExecutor来实现JPQL的拼接的。
5.2 示例代码
--需求:根据条件查询,并且分页
--操作接口UserRepository
/** * 注意:SpringData-jpa通过继承Repository接口来获得DAO实例对象 * java接口是支持多继承的 * Repository<User, Integer> User 表示的是实体类, Integer:表示主键的数据类型 */ public interface UserRepository extends JpaRepository<User, Integer>, JpaSpecificationExecutor<User>{
} |
--测试类代码
package cn.zj.springdata.test;
import java.util.List;
import javax.persistence.criteria.CriteriaBuilder; import javax.persistence.criteria.CriteriaQuery; import javax.persistence.criteria.Path; import javax.persistence.criteria.Predicate; import javax.persistence.criteria.Root;
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.jpa.domain.Specification; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import cn.zj.springdata.dao.UserRepository; import cn.zj.springdata.pojo.User;
@RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration("classpath:spring-data.xml") public class UserRepositoryTest {
@Autowired private UserRepository userRepository;
@Test public void test1() {
User user = userRepository.findByName("张三"); System.out.println(user); }
// 分页查询 @Test public void test2() throws Exception {
//开发者自己使用Specification接口创建 匿名对象 Specification<User> spec = new Specification<User>() { /** * root :封装 实体对象 User的具体信息,可以通过获取实体属性得到一个Path对象 * query : 限制条件查询对象,把root获取的属性对应的Path对象进行封装 * cb:构建 Predicate 对象 * Predicate : 最终封装的条件对象 */ @Override public Predicate toPredicate(Root<User> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
//1,从root中获取实体User对象的name属性,并返回一个 Path对象 Path<String> path = root.get("name"); Path<Number> agePath = root.get("id");
//2,对path对象进行条件封装 Predicate predicate = cb.like(path, "%乔%");
Predicate gt = cb.gt(agePath, 10);
Predicate predicates = cb.and(predicate,gt);
return predicates; }
} ;
int currentPage = 0;//当前页,从0开始 int pageSize = 10;//没页条数 Pageable sort = new PageRequest(currentPage, pageSize);
Page<User> page = userRepository.findAll(spec, sort);
//获取分页数据 List<User> users = page.getContent();
for (User user : users) { System.out.println(user); } //获取总条数 long totalElements = page.getTotalElements(); System.out.println(totalElements); } }
|
6 Springmvc整合SpringData
6.1 说明
需求:从页面表单,提交数据,插入到数据库。
思路:
(1)配置springmvc
(2)将入门示例中的代码复制到项目中
(3)完成业务功能
6.2 整合步骤
6.2.1 第一部分:配置Springmvc(复习)
6.2.1.1 第一步:创建web项目
|
6.2.1.2 第二步:导入相关依赖
--导入springmvc、jsp相关依赖
<dependencies> <!-- 1、spring webmvc依赖 --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>4.3.2.RELEASE</version> </dependency> <!-- 3、jsp及servlet依赖 --> <dependency> <groupId>javax.servlet</groupId> <artifactId>servlet-api</artifactId> <version>2.5</version> <scope>provided</scope> </dependency> <dependency> <groupId>javax.servlet</groupId> <artifactId>jsp-api</artifactId> <version>2.0</version> <scope>provided</scope> </dependency> </dependencies> |
6.2.1.3 第三步:创建Springmvc配置文件
--创建spring-mvc.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" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.3.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd"> <mvc:annotation-driven/> <context:component-scan base-package="cn.zj"/>
</beans>
|
6.2.1.4 第四步:修改web.xml
<?xml version="1.0" encoding="UTF-8"?> <web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xml="http://www.w3.org/XML/1998/namespace" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_2_5.xsd ">
<!-- 配置编码过滤器 --> <filter> <filter-name>characterEncodingFilter</filter-name> <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<init-param> <param-name>encoding</param-name> <param-value>utf-8</param-value> </init-param> </filter> <filter-mapping> <filter-name>characterEncodingFilter</filter-name> <url-pattern>/*</url-pattern> </filter-mapping>
<!-- 配置springmvc核心控制器 --> <servlet> <servlet-name>dispatcherServlet</servlet-name> <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param> <param-name>contextConfigLocation</param-name> <param-value>classpath:spring-mvc.xml</param-value> </init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping> <servlet-name>dispatcherServlet</servlet-name> <url-pattern>*.do</url-pattern> </servlet-mapping> </web-app>
|
6.2.1.5 第五步:创建jsp页面
--创建登录页面login.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%> <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>Insert title here</title> </head> <body> <h3>登录页面</h3> <form action="/user/login.do" method="post"> 用户名:<input type="text" name="name"/> <br> 密码:<input type="password" name="password"/><br> <input type="submit" value="登录"> </form> </body> </html> |
--登录成功返回页面index.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%> <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>Insert title here</title> </head> <body> Hello world </body> </html> |
6.2.1.6 第六步:创建一个UserController类
package cn.zj.controller;
import org.springframework.stereotype.Controller; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod;
import cn.zj.pojo.User;
@Controller @RequestMapping("/user") public class UserController {
@RequestMapping(value="/login",method=RequestMethod.POST) public String login(User user){
System.out.println(user);
return "/index.jsp"; } }
|
6.2.2 第二部分:Spring-Data集成
6.2.2.1 第一步:拷贝SpringData-jpa相关依赖到pom.xml文件中
<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>cn.zj.springboot</groupId> <artifactId>SpringData-demo-05-springmvc</artifactId> <version>1.0</version> <packaging>war</packaging>
<dependencies> <!-- 1、spring webmvc依赖 --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>4.3.16.RELEASE</version> </dependency>
<!-- 3、jsp及servlet依赖 --> <dependency> <groupId>javax.servlet</groupId> <artifactId>servlet-api</artifactId> <version>2.5</version> <scope>provided</scope> </dependency> <dependency> <groupId>javax.servlet</groupId> <artifactId>jsp-api</artifactId> <version>2.0</version> <scope>provided</scope> </dependency>
<!-- SpringData-jpa框架依赖 --> <dependency> <groupId>org.springframework.data</groupId> <artifactId>spring-data-jpa</artifactId> <version>1.8.0.RELEASE</version> </dependency> <!-- hibernate-entity --> <dependency> <groupId>org.hibernate</groupId> <artifactId>hibernate-entitymanager</artifactId> <version>4.3.6.Final</version> </dependency>
<!-- druid依赖 --> <dependency> <groupId>com.alibaba</groupId> <artifactId>druid</artifactId> <version>1.1.10</version> </dependency>
<!-- jdbc驱动依赖 --> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.40</version> </dependency>
</dependencies> </project> |
6.2.2.2 第二步:拷贝SpringData-jpa配置文件
--注意:(1)修改包结构,保证SpringData-jpa能扫描到实体类和接口
(2)修改web.xml,确保能加载到该配置文件。
<?xml version="1.0" encoding="UTF-8"?> <web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xml="http://www.w3.org/XML/1998/namespace" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_2_5.xsd ">
<!-- 配置编码过滤器 --> <filter> <filter-name>characterEncodingFilter</filter-name> <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<init-param> <param-name>encoding</param-name> <param-value>utf-8</param-value> </init-param> </filter> <filter-mapping> <filter-name>characterEncodingFilter</filter-name> <url-pattern>/*</url-pattern> </filter-mapping>
<!-- 配置springmvc核心控制器 --> <servlet> <servlet-name>dispatcherServlet</servlet-name> <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param> <param-name>contextConfigLocation</param-name> <param-value>classpath:spring-*.xml</param-value> </init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping> <servlet-name>dispatcherServlet</servlet-name> <url-pattern>*.do</url-pattern> </servlet-mapping> </web-app>
|
6.2.2.3 第三步:拷贝User实体类、UserRepository接口
--只保留UserRepository接口中的save方法
package cn.zj.repository;
import org.springframework.data.repository.Repository;
import cn.zj.pojo.User;
/** * 注意:SpringData-jpa通过继承Repository接口来获得DAO实例对象 * * Repository<User, Integer> User 表示的是实体类, Integer:表示主键的数据类型 * */ public interface UserRepository extends JpaRepository<User, Integer> {
User findByNameAndPassword(String name,String password); } |
6.2.3 第三部分:完成业务代码
6.2.3.1 第一步:编写Service层代码
--创建UserService接口
package cn.zj.service;
import cn.zj.pojo.User;
public interface UserService {
User login(User user); } |
--编写实现类UserServiceImpl
package cn.zj.service.impl;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service;
import cn.zj.pojo.User; import cn.zj.repository.UserRepository; import cn.zj.service.UserService;
@Service public class UserServiceImpl implements UserService{
@Autowired private UserRepository userRepository;
@Override public User login(User user) {
return userRepository.findByNameAndPassword(user,getName(),user.getPassword()); }
} |
6.2.3.2 第二步:修改UserController代码
package cn.zj.controller;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Controller; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod;
import cn.zj.pojo.User; import cn.zj.service.UserService;
@Controller @RequestMapping("/user") public class UserController {
@Autowired private UserService userService;
@RequestMapping(value="/login",method=RequestMethod.POST) public String register(User user){ System.out.println(user);
User register = userService.login(user);
return "/index.jsp"; } }
|
6.2.3.3 第三步:测试
--测试结果
|
整合成功!!!
7 总结
在实际的开发中,持久层的框架通常使用的springdata-jpa和Mybatis。
Springdata-jpa是通过操作对象,来实现对数据库的操作。
好处:可以在不修改代码的情况下,在多个数据库中移植。
Mybatis核心理念是通过少量的代码,就能实现对数据库的操作。
动态sql技术,提供了复杂sql查询的功能。
JPA提供了一系列的API,能够完成基本的增删改查的操作。它的主要优势在于对单表的操作。同时也提供关联查询(导航查询)对多表的业务进行简单查询。
对于涉及多表查询、以及复杂的查询逻辑,特点就显示不出来。
Mybatis的动态sql技术,为复杂的查询提供了条件。因此Mybatis通常用来处理复杂的查询逻辑,以及涉及表相对较多的业务。