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