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

<artifactId>SpringDate-dmoe01-start</artifactId>

<version>0.0.1-SNAPSHOT</version>

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

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

<version>1.8.0.RELEASE</version>

</dependency>

<groupId>org.hibernate</groupId>

<artifactId>hibernate-entitymanager</artifactId>

<version>4.3.6.Final</version>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-test</artifactId>

<version>4.0.9.RELEASE</version>

</dependency>

<groupId>junit</groupId>

<artifactId>junit</artifactId>

</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驱动包依赖

<groupId>com.alibaba</groupId>

<artifactId>druid</artifactId>

</dependency>

<groupId>mysql</groupId>

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

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

</bean>

</beans>

2.3.3.2 第二步：配置JPA实体管理工厂

说明：因为需要使用spring数据源，所以实体工厂要使用spring-orm-4.0.9.RELEASE.jar中整合spring的实体管理工厂代理类，创建实体管理工厂。

<!-- 必须指定jpa适配器。

问题：为什么需要指定适配器？

答：jpa是一种标准，基于JPA这个标准有多种框架。所以我们要通过适配器指定使用的是哪一个jpa框架

在这里我们使用的是hibernate这个框架。

所以指定的就是HibernateJpaVendorAdapter这个适配器

-->

</property>

<props>

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

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

</props>

</property>

</bean>

2.3.3.3 第三步：整合SpringData-jpa

<jpa:repositories base-package="cn.zj.springdata.dao" entity-manager-factory-ref="entityManagerFactory"/>

2.3.3.4 第四步：配置事物代理

</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相关依赖

<groupId>org.springframework</groupId>

<artifactId>spring-webmvc</artifactId>

<version>4.3.2.RELEASE</version>

</dependency>

<groupId>javax.servlet</groupId>

<artifactId>servlet-api</artifactId>

<scope>provided</scope>

</dependency>

<groupId>javax.servlet</groupId>

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

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

<title>Insert title here</title>

</head>

<body>

用户名：<input type="text" name="name"/> <br>

密码：<input type="password" name="password"/><br>

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

<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文件中

<groupId>cn.zj.springboot</groupId>

<artifactId>SpringData-demo-05-springmvc</artifactId>

<groupId>org.springframework</groupId>

<artifactId>spring-webmvc</artifactId>

<version>4.3.16.RELEASE</version>

</dependency>

<groupId>javax.servlet</groupId>

<artifactId>servlet-api</artifactId>

<scope>provided</scope>

</dependency>

<groupId>javax.servlet</groupId>

<scope>provided</scope>

</dependency>

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

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

<version>1.8.0.RELEASE</version>

</dependency>

<groupId>org.hibernate</groupId>

<artifactId>hibernate-entitymanager</artifactId>

<version>4.3.6.Final</version>

</dependency>

<groupId>com.alibaba</groupId>

<artifactId>druid</artifactId>

</dependency>

<groupId>mysql</groupId>

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

</dependency>

</dependencies>

</project>

6.2.2.2 第二步：拷贝SpringData-jpa配置文件

--注意：（1）修改包结构，保证SpringData-jpa能扫描到实体类和接口

（2）修改web.xml，确保能加载到该配置文件。

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

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

<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通常用来处理复杂的查询逻辑，以及涉及表相对较多的业务。