Spring基础

一、Spring概述

1.1 Spring是什么

Spring是分层的Java SE/EE应用full-stack轻量级开源框架，以IoC（Inverse Of Control反转控制）和AOP（Aspect Oriented Programming面向切面编程）为内核。

提供了展现层SpringMVC和持久层Spring JDBCTemplate以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的Java EE企业应用开源框架。

1.2 Spring开发框架

1997年：EJB是Spring的前身

Rod Johnson：Spring之父

2017年：Spring5.0

1.3 Spring优势

1. 方便解耦，简化开发

   通过Spring提供的IoC容器，可以将对象间的依赖关系交由Spring进行控制，避免硬编码所造成的过度耦合。用户也不必再为单例模式类、属性文件解析等这些很底层的需求编写代码，可以更专注于上层的应用。

2. AOP编程的支持

   通过Spring的AOP功能，方便进行面向切面编程，许多不容易用传统OOP实现的功能可以通过AOP轻松实现。

3. 声明式事物的支持

   可以将我们从单调烦闷的事务管理代码中解脱出来，通过声明式方式灵活的进行事务管理，提高开发效率和质量。

4. 方便程序的测试

   可以用非容器依赖的编程方式进行几乎所有的测试工作，测试不再是昂贵的操作，而是随手可做的事情。

5. 方便集成各种优秀框架

   Spring对各种优秀框架（Struts、Hibernate、hessian、Quartz等）的支持。

6. 降低JavaEE API的使用难度

   Spring对JavaEE API（如JDBC、JavaMail、远程调用等）进行了薄薄的封装曾，使这些API的使用难度大大降低。

7. Java源码是经典学习范例

   Spring的源代码设计精妙、结构清晰、匠心独拥，处处体现着大师对Java设计模式灵活运用以及对Java技术的高深造诣。它的源代码无疑是Java技术的最佳实践的范例。

1.4 Spring的体系结构

二、Spring快速入门

• 导入Spring开发的基本包坐标
• 编写Dao接口和实现类
• 创建Spring核心配置文件，applicationContext.xml
• 在Spring配置文件中配置UserDaoImpl
• 使用Spring的API获得Bean实例

三、Spring配置文件

3.1 Bean标签的基本配置

• 用于配置对象交由Spring来创建
• 默认情况下它调用的是类中的无参构造函数，如果没有无参构造函数则不能创建成功
• 基本属性
  • id：Bean实例在Spring容器中的唯一标识
  • class：Bean的全限定名称

3.2 Bean标签范围配置

• scope：指对象的作用范围，取值如下

  • singleton：默认的，单值的
  • prototype：多例的
  • request：web项目中，Spring创建一个Bean对象，将对象存入到request域中
  • session：web项目中，Spring创建一个Bean对象，将对象存入到session域中
  • global session：web项目中，应用在Portlet环境，如果没有Portlet环境那么globalSession相当于session

• 当scope的取值为singleton时

  • Bean的实例化个数：1个
  • Bean的实例化时机：当Spring核心文件被加载时，实例化配置的Bean实例
  • Bean的生命周期
    • 对象创建：当应用加载，创建容器时，对象就被创建了
    • 对象运行：只要容器在，对象一直活着
    • 对象销毁：当应用卸载，销毁容器时，对象就被销毁了

• 当scope的取值为prototype时

  • Bean的实例化个数：多个

  • Bean的实例化时机：当调用getBean()方法时实例化Bean

  • Bean的生命周期

    • 对象创建：当使用对象时，创建新的对象实例
    • 对象运行：只要对象在使用着，就一直活着
    • 对象销毁：当对象长时间不用时，被Java的垃圾回收器回收

3.3 Bean生命周期配置

• init-method：指定类中的初始化方法名称
• destroy-method：指定类中销毁方法名称

3.3 Bean实例化三种方式

• 无参构造方法实例化
• 工厂静态方法实例化
• 工厂实例方法实例化

3.4 Bean的依赖注入分析

• 目前UserService实例和UserDao实例都存在与Spring容器中，当前的做法是在容器外部获得UserService 实例和UserDao实例，然后在程序中进行结合
• 因为UserService和UserDao都在Spring容器中，而最终程序直接使用的是UserService，所以可以在Spring容器中，将UserDao设置到UserService内部

3.5 Bean的依赖注入概念

• 依赖注入（Dependency Injection）：是Spring框架核心IOC的具体体现
• 在编写程序时，通过控制反转，把对象的创建交给了Spring，但是代码中不可能出现没有依赖的情况。IOC解耦只是降低他们的依赖关系，但不会消除。例如：业务层仍会调用持久层的方法
• 这种业务层和持久层的依赖关系，在使用Spring之后，就让Spring来维护了，简单地说，就是坐等框架把持久层对象传入业务层，而不用我们自己去获取

3.6 Bean的依赖注入方式

• 构造方法

  <bean id="userService" class="com.itheima.service.impl.UserServiceImpl">
      <constructor-arg name="userDao" ref="userDao"></constructor-arg>
  </bean>
  

• set方法

  • 引入P命名空间

    xmlns:p="http://www.springframework.org/schema/p"
    

  • 修改注入方式

    <bean id="userService" class="com.itheima.service.impl.UserServiceImpl" p:userDao-ref="userDao"></bean>
    

3.7 Bean的依赖注入的数据类型

• 除了对象的引用可以注入，普通数据类型，集合等都可以在容器中进行注入

3.8 引入其他配置文件（分模块开发）

• 实际开发中，Spring的配置内容非常多，这就导致Spring配置很繁杂且体积很大，所以，可以将部分配置拆解到其他配置文件中，而在Spring主配置文件通过import标签进行加载

  <import resource="applicationContext-xxx.xml"/>
  

四、Spring相关API

4.1 ApplicationContext的继承体系

• applicationContext：接口类型，代表应用上下文，可以通过其实例获得Spring容器中的Bean对象

4.2 ApplicationContext的实现类

• ClassPathXmlApplicationContext：从类的根路径下加载配置文件（推荐）
• FileSystemXmlApplicationContext：从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置
• AnnotationConfigApplicationContext：当使用注解配置容器对象时，需要使用此类来创建Spring容器，用来读取注解

4.3 getBean()方法使用

• public Object getBean(String name)
• public T getBean(class requiredType)

4.4 知识要点

• ApplicationContext app = new ClasspathXmlApplicationContext(“xml文件”)
• app.getBean(“id”)
• app.getBean(Class)

五、Spring配置数据源

5.1 数据源（连接池）的作用

• 数据源（连接池）是提高程序性能的
• 事先实例化数据源，初始化部分连接资源
• 使用连接资源时从数据源中获取
• 使用完毕后将连接资源归还给数据源
• 常见数据源（连接池）：DBCP、C3P0、BoneCP、Druid

5.2 数据源开发步骤

• 导入数据源的坐标和数据库驱动坐标
• 创建数据源对象
• 设置数据源的基本连接数据
• 使用数据源获取连接资源和归还连接资源

5.3 数据源手动创建

• 创建配置文件jdbc.properties的方式

ResourceBundle rb = ResourceBundle.getBundle("jdbc");
String driver = rb.getString("jdbc.driver");
String url = rb.getString("jdbc.url");
String username = rb.getString("jdbc.username");
String password = rb.getString("jdbc.password");
// 创建数据源对象、设置连接参数、获取连接
ComboPooledDataSource dataSource = new ComboPooledDataSource();
dataSource.setDriverClass(driver);
dataSource.setJdbcUrl(url);
dataSource.setUser(username);
dataSource.setPassword(password);
Connection connection = dataSource.getConnection();
System.out.println(connection);
connection.close();

5.4 Spring配置数据源

• 可以将DataSource的创建权交由Spring容器去完成

    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/db1"></property>
        <property name="user" value="root"></property>
        <property name="password" value="1234"></property>
    </bean>

5.5 抽取jdbc配置文件

• applicationContext.xml加载jdbc.properties配置文件获得连接信息
• 首先，需要引入context命名空间和约束路径
  • 命名空间：xmlns:context=“http://www.springframework.org/schema/context”
  • 约束路径
    • http://www.springframework.org/schema/context
    • http://www.springframework.org/schema/context/spring-context.xsd

<?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.xsd">
    <!--加载外部的properties文件-->
    <context:property-placeholder location="classpath:jdbc.properties"/>
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driver}"></property>
        <property name="jdbcUrl" value="${jdbc.url}"></property>
        <property name="user" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>
</beans>

六、Spring注解开发

6.1 Spring原始注解

• Spring是轻代码而重配置的框架，配置比较繁重，影响开发效率，所以注解开发是一种趋势，注解代替xml配置文件可以简化配置，提高开发效率
• Spring原始注解主要是替代的配置

注解	说明
@Component	使用在类上用于实例化Bean
@Controller	使用在web层类上用于实例化Bean
@Service	使用在service层类上用于实例化Bean
@Repository	使用在dao层类上用于实例化Bean
@Autowired	使用在字段上用于根据类型依赖注入
@Qualifier	结合@Autowired一起使用用于根据名称进行依赖注入
@Resource	相当于@Autowired+@Qualifier，按照名称进行注入
@Value	注入普通属性
@Scope	标注Bean的作用范围
@PostConstruct	使用在方法上，标注该方法是Bean的初始化方法
@PreDestroy	使用在方法上，标注该方法是Bean的销毁方法

• 使用注解进行开发时，需要在applicationContext.xml中配置组件扫描，作用是指定哪个包及其子包下的Bean需要进行扫面以便识别使用注解配置的类、字段和方法

<context:component-scan base-package="com.itheima"/>

6.2 Spring新注解

• 使用上面的注解还不能全部替代xml配置文件，还有其他配置需要注解替代
  • 非自定义的Bean配置：bean
  • 加载properties文件的配置：context:property-placeholder
  • 组件扫描的配置：context:component-scan
  • 引入其他文件：import
• Spring新注解

注解	说明
@Configuration	用于指定当前类是一个Spring配置类，当创建容器时会从该类上加载注解
@ComponentScan	用于指定Spring在初始化容器时要扫描的包
@Bean	使用在方法上，标注将该方法的返回值存储到Spring容器中
@PropertySource	用于加载.properties文件中的配置
@Import	用于导入其他配置类

6.3 Spring整合Junit

6.3.1 原始Junit测试Spring的问题

• 在测试类中，每个测试方法都有以下两行代码

  ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
  IAccountService as = ac.getBean("accountService",IAccountService.class);
  

• 这两行代码的作用是获取容器，如果不写的话，会提示空指针异常

6.3.2 问题解决思路

• 让SpringJunit负责创建Spring容器，但是需要将配置文件的名称告诉它
• 将需要进行测试的Bean直接在测试类中注入

6.3.3 Spring集成Junit步骤

• 导入Spring集成Junit的坐标
• 使用@Runwith注解替换原来的运行期
• 使用@ContextConfiguration指定配置文件或配置类
• 使用@Autowired注入需要测试的对象
• 创建测试方法进行测试

七、Spring与Web环境集成

7.1 ApplicationContext应用上下文获取方式

• 应用上下文对象是通过new ClasspathXmlApplicationContext（Spring配置文件）方式获取的，但是每次从容器中获得Bean时都要编写new ClasspathXmlApplicationContext（Spring配置文件），这样的弊端是配置文件加载多次，应用上下文对象创建多次
• 在Web项目中，可以使用ServletContextListener监听Web应用的启动，我们可以在Web应用启动时，就加载Spring的配置文件，创建应用上下文对象ApplicationContext，将其存储到最大的域servletContext域中，这样就可以在任意位置从域中获得应用上下文ApplicationContext对象了

7.2 Spring提供获取应用上下文的工具

• Spring提供一个监听器ContextLoaderListener就是对上述功能的封装，该监听器内部加载Spring配置文件，创建应用上下文对象，并存储到ServletContext域中，提供了一个客户端工具WebApplicationContextUtils，供使用者获得应用上下文对象
• 使用过程
  • 在web.xml中配置ContextLoaderListener监听器（导入spring-web坐标）
  • 使用WebApplicationContextUtils获得应用上下文对象ApplicationContext

七、SpringMVC

7.1 SpringMVC概述

• SpringMVC是一种基于Java的实现MVC设计模型的请求驱动类型的轻量级Web框架，属于SpringFrameWork的后续产品，已经融合在SpringWebFlow中
• SpringMVC已经成为目前最主流的MVC框架之一，支持RESTful编程风格的请求

7.2 SpringMVC开发步骤

• 导入SpringMVC相关坐标
• 配置SpringMVC核心控制器DispathcerServlet
• 创建Controller类和视图界面
• 使用注解配置Controller类中业务方法的映射地址
• 配置SpringMVC核心文件spring-mvc.xml
• 客户端发起请求测试

7.3 SpringMVC流程图

八、SpringMVC组件解析

8.1 SpringMVC的执行流程

1. 用户发送请求至前端控制器DispatcherServlet
2. DispatcherServlet收到请求调用HandlerMapping处理器映射器
3. 处理器映射器找到具体的处理器（可以根据xml配置、注解进行查找），生成处理器对象及处理器拦截器，一并返回给DispatcherServlet
4. DispatcherServlet调用HandlerAdapter处理器适配器
5. HandlerAdapter经过适配调用具体的处理器（Controller，也叫后端控制器）
6. Controller执行完成返回ModelAndView
7. HandlerAdapter将Controller执行结果ModelAndView返回给DispatcherServlet
8. DispatcherServlet将ModelAndView传给ViewReslover视图解析器
9. ViewReslover解析后返回具体View
10. DispatcherServlet根据View进行渲染视图（即将模型数据填充至视图中）。DispatcherServlet响应用户

8.2 SpringMVC组件解析

• 前端控制器：DispatcherServlet
  • 用户请求到达前端控制器，它就相当于 MVC 模式中的 C，DispatcherServlet 是整个流程控制的中心，由它调用其它组件处理用户的请求，DispatcherServlet 的存在降低了组件之间的耦合性
• 处理器映射器：HandlerMapping
  • HandlerMapping 负责根据用户请求找到 Handler 即处理器，SpringMVC 提供了不同的映射器实现不同的 映射方式，例如：配置文件方式，实现接口方式，注解方式等
• 处理器适配器：HandlerAdapter
  • 通过 HandlerAdapter 对处理器进行执行，这是适配器模式的应用，通过扩展适配器可以对更多类型的处理器进行执行
• 处理器：Handler
  • 它就是我们开发中要编写的具体业务控制器。由 DispatcherServlet 把用户请求转发到 Handler。由 Handler 对具体的用户请求进行处理
• 视图解析器：View Resolver
  • View Resolver负责将处理结果生成 View 视图，View Resolver 首先根据逻辑视图名解析成物理视图名，即具体的页面地址，再生成 View 视图对象，最后对 View 进行渲染将处理结果通过页面展示给用户
• 视图：View
  • SpringMVC 框架提供了很多的 View 视图类型的支持，包括：jstlView、freemarkerView、pdfView等。最常用的视图就是 jsp。一般情况下需要通过页面标签或页面模版技术将模型数据通过页面展示给用户，需要由程序员根据业务需求开发具体的页面

8.3 SpringMVC注解解析

• @RequestMapping：用于建立请求URL和请求处理方法之间的对应关系

  • 位置
    • 类上：请求URL的第一级访问目录。此处不写的话，就相当于应用的根目录
    • 方法上：请求URL的第二级访问目录，与类上使用@RequestMapping标注的一级目录一起组成访问虚拟路径
  • 属性
    • value：用于指定请求的URL，和path属性是一样的
    • method：用于指定请求的方式
    • params：用于指定限制请求参数的条件，支持简单的表达式。要求请求参数的key和value必须和配置的一模一样

• MVC命名空间引入

  • 命名空间：

    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    

  • 约束地址

    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context.xsd
    http://www.springframework.org/schema/mvc
    http://www.springframework.org/schema/context/spring-mvc.xsd
    

• 组件扫描

  • SpringMVC基于Spring容器，所以在进行SpringMVC操作时，需要将Controller存储到Spring容器中，如果使用@Controller注解标注的话，就需要使用context:component-scan base-package="com.itheima.controller"进行组件扫描

九、SpringMVC的数据响应

9.1 SpringMVC的数据响应方式

• 页面跳转
  • 直接返回字符串
  • 通过ModelAndView对象返回
• 回写数据
  • 直接返回字符串
  • 返回对象或集合

9.2 页面跳转

• 返回字符串形式：此种方式会将返回的字符串与视图解析器的前后缀拼接后跳转
  • 转发：forward：/WEB-INF/views/index.jsp
  • 重定向：redirect：/index.jsp

@RequestMapping("/quick")
public String quickMethod(){
    return "index";
}

<property name="prefix" value="/WEB_INF/views/"></property>
<property name="suffix" value=".jsp"></property>

• 通过ModelAndView对象返回
  • new ModelAndView()：新建对象
  • modelAndView.addObject()：设置模型数据
  • modelAndView.setViewName：设置视图名称

9.3 回写数据

• 直接返回字符串
  • 通过SpringMVC框架注入的response对象，使用response.getWriter().print(“Hello World”)回写数据，此时不需要视图跳转，业务方法返回值为void
  • 将需要回写的字符串直接返回，但此时需要通过@ResponseBody注解告知SpringMVC框架，方法返回的字符串不是跳转是直接在http响应体中返回
• 返回对象或集合
  • 在方法上添加@ResponseBody就可以返回json格式的字符串，但是这样配置比较麻烦，配置的代码比较多，因此，我们可以使用mvc的注解驱动代替上述配置
  • mvc:annotation-driven
  • 在SpringMVC的各个组件中，处理器映射器、处理器适配器、视图解析器称为SpringMVC的三大组件。在Spring-xml.xml使用mvc:annotation-driven自动加载RequestMappingHandlerMapping（处理器映射器）和RequestMappingHandlerAdapter（处理器适配器），集成jackson进行对象或集合的json格式字符串的转换

十、SpringMVC获得请求数据

10.1 获得请求参数

• 客户端请求参数的格式是：name=value&name=value…
• 服务器端要获得请求的参数，有时还需要进行数据的封装，SpringMVC可以接收如下类型的参数：
  • 基本类型参数
  • POJO类型参数
  • 数组类型参数

10.2 获得基本参数类型

• Controllelr中的业务方法的基本参数名称与请求参数的name一致，参数值会自动映射匹配

  @RequestMapping("/quick")
  @ResponseBody
  public void quickMethod(String username,int age) throws Exception {
      System.out.println(username);
      System.out.println(age);
  }
  

10.3 获得POJO类型参数

• Controllelr中的业务方法的POJO参数名称与请求参数的name一致，参数值会自动映射匹配

@RequestMapping("/quick")
@ResponseBody
public void quickMethod(User user) throws Exception {
    System.out.println(user);
}

10.4 获得数组类型参数

• Controllelr中的业务方法的数组名称与请求参数的name一致，参数值会自动映射匹配

@RequestMapping("/quick")
@ResponseBody
public void save(String[] strs){
    System.out.println(Arrays.asList(strs));
}

10.5 获得集合类型参数

• 获得集合参数：获得集合参数时，要将集合参数包装到一个POJO中才可以。

  <form action="${pageContext.request.contextPath}/quick12" method="post">
  	<input type="text" name="userList[0].username"><br>
  	<input type="text" name="userList[0].age"><br>
  	<input type="text" name="userList[1].username"><br>
  	<input type="text" name="userList[1].age"><br>
  	<input type="submit" value="提交"><br>
  </form>
  

  @RequestMapping("/quick12")
  @ResponseBody
  public void quickMethod12(Vo vo) throws IOException {
  	System.out.println(vo.getUserList());
  }
  

• 当使用ajax提交时，可以指定contentType为json形式，那么在方法参数位置使用@RequestBody可以直接接收集合数据而无需使用POJO进行包装

  @RequestMapping("/quick15")
  @ResponseBody
  public void save15(@RequestBody List<User> userList){
  	System.out.println(userList);
  }
  

10.6 请求数据乱码问题

• 当post请求时，数据会出现乱码，我们可以设置一个过滤器来进行编码的过滤。

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

10.7 参数绑定注解@RequestParam

• 当请求的参数名称与Controller的业务方法参数名称不一致时，就需要通过@RequestParam注解显示的绑定

  <form action="${pageContext.request.contextPath}/user/quick" method="post">
  	<input type="text" name="name"><br/>
  	<input type="submit" value="提交">
  </form>
  

  @RequestMapping("/quick")
  @ResponseBody
  public void save(@RequestParam("name") String username){
  	System.out.println(username);
  }
  

• 注解@RequestParam还有如下参数可以使用

  • value：请求参数名称
  • required：指定请求参数是否必须包括，默认是true，提交时如果没有此参数则报错
  • defaultValue：当没有指定请求参数时，使用指定的默认值赋值

10.8 获得Restful风格的参数

• Restful是一种架构风格、设计风格，而不是标准，只是提供了一组设计原则和约束条件。主要用于客户端和服务器交互类的软件，基于这个风格设计的软件可以更简洁，更有层次，更易于实现缓存机制。
• Restful风格的请求时使用“url+请求方式”表示一次请求目的，HTTP协议里面四个表示操作方式的动词如下
  • GET：用于获取资源
  • POST：用于新建资源
  • PUT：用于更新资源
  • DELETE：用于删除资源
• 例如
  • /user/1 GET：得到id=1的user
  • /user/1 DELETE：删除id=1的user
  • /user/1 PUT：更新id=1的user
  • /user POST：新增user
• 上述url地址/user/1中的1就是要获得的请求参数，在SpringMVC中可以使用占位符进行参数绑定。地址user/1可以写成/user/{id}，占位符{id}对应的就是1的值。在业务方法中我们可以使用@PathVariable注解进行占位符的匹配获取工作

http://localhost:8080/spring-mvc/user/quick/zhangsan

@RequestMapping("/quick/{name}")
@ResponseBody
public void quickMethod(@PathVariable(value = "name",requied = true) String name){
	System.out.println(name);
}

10.9 自定义类型转换器

• SpringMVC默认已经提供了一些常用的类型转换器，例如客户端提交的字符串转换成int类型进行参数设置
• 但是不是所有的数据类型都提供了转换器，没有提供的就需要自定义转换器，例如：日期类型的数据就需要自定义转换器
• 自定义类型转换器的开发步骤
  • 定义转换器类实现Convert接口
  • 在配置文件中声明转换器
  • 在中引用转换器

10.10 获得Servlet相关API

• SpringMVC支持使用原始ServletAPI对象作为控制器方法的参数进行注入，常用的对象如下
  • HttpServletRequest
  • HttpServletResponse
  • HttpSession

@RequestMapping("/quick")
@RespondeBody
public void quickMethod(HttpServletRequest request,HttpServletResponse response,HttpSession session){
    System.out.println(request);
    System.out.println(response);
    System.out.println(session);
}

10.11 获得请求头

• @RequestHeader：使用@RequestHeader可以获得请求头信息，相当于web阶段学习的request.getHeader()name
  • value：请求头名称
  • required：是否必须携带此请求头

@RequestMapping("/quick")
@ResponseBody
public void save(@RequestHeader(value = "User-Agent",required = false) String user_agent){
	System.out.println(user_agent);
}

• @CookieValue：使用@CookieValue可以获得指定cookie的值

  • value：指定cookie的名称

  • required：是否必须携带此cookie

10.12 文件上传

• 文件上传客户端三要素
  • 表单项type=“file”
  • 表单的提交方式是post
  • 表单的enctype属性是多部分表单形式，及enctype=“multipart/form-data”

    <form action="${pageContext.request.contextPath}/user/quick22" method="post" enctype="multipart/form-data">
        <input type="text" name="username"><br>
        <input type="file" name="upload"><br>
        <input type="submit" name="提交">
    </form>

• 文件上传原理
  • 当form表单修改为多部份表单时，request.getParameter()将失效
  • enctype="application/x-www-form-urlencoded"时，form表单的正文内容格式是：key=value&key=value
  • 当form表单的enctype取值为Multipart/form-data时，请求正文内容就变成多部份形式

10.13 单文件上传步骤

• 导入fileupload和io的坐标
• 配置文件上传解析器
• 编写文件上传代码

10.14 多文件上传

• 多文件上传，只需要将页面修改为多个文件上传项，将方法参数MultipartFile类型修改为MultipartFile[]即可

<h1>多文件上传测试</h1>
<form action="${pageContext.request.contextPath}/quick21" method="post" enctype="multipart/form-data">
	名称：<input type="text" name="name"><br>
	文件1：<input type="file" name="uploadFiles"><br>
	文件2：<input type="file" name="uploadFiles"><br>
	文件3：<input type="file" name="uploadFiles"><br>
	<input type="submit" value="提交"><br>
</form>

十一、Spring JdbcTemplate基本使用

11.1 JdbcTemplate概述

• 它是Spring框架中提供的一个对象，是对原始繁琐的Jdbc API对象的简单封装。Spring框架为我们提供了很多的操作模板类。例如：操作关系型数据的JdbcTemplate和HibernateTemplate，操作NoSQL数据库的RedisTemplate，操作消息队列的JmsTemplate等等

11.2 JdbcTemplate开发步骤

• 导入spring-jdbc和spring-tx坐标
• 创建数据库表和实体
• 创建JdbcTemplate对象
• 执行数据库操作

11.3 Spring产生JdbcTemplate对象

从容器中获得JdbcTemplate进行添加操作

@Test 
public void testSpringJdbcTemplate() throws PropertyVetoException { 
    ApplicationContext applicationContext = new  ClassPathXmlApplicationContext("applicationContext.xml");
    JdbcTemplate jdbcTemplate = applicationContext.getBean(JdbcTemplate.class); 
    jdbcTemplate.update("insert into account values(?,?)","lucy",5000); 
}

十二、Spring练习环境搭建

12.1 Spring环境搭建步骤

• 创建工程（Project&Module）
• 导入静态页面（jsp）
• 导入需要的坐标（pom.xml）
• 创建包结构（controller、service、dao、domain、utils）
• 导入数据库脚本（sql）
• 创建POJO类
• 创建配置文件（applicationContext.xml、spring-mvc.xml、jdbc.properties、log4j.properties）

12.2 角色列表展示

• 点击角色管理菜单发送请求到服务器端（修改角色管理菜单的url地址）
• 创建RoleController和showList()方法
• 创建RoleService和showList()方法
• 创建RoleDao和findAll()方法
• 使用JdbcTemplate完成查询操作
• 将查询数据存储到Model中
• 转发到role-list.jsp页面进行展示

12.3 用户添加

• 点击列表页面新建按钮跳转到角色添加页面
• 输入角色信息，点击保存按钮，表单数据提交服务器
• 编写RoleController的save()方法
• 编写RoleService的save()方法
• 编写RoleDao的save()方法
• 使用JdbcTemplate保存Role数据到sys_role
• 跳转回角色列表页面

12.4 用户删除

• 点击用户列表的删除按钮，发送请求到服务器端
• 编写UserController的deleteById()方法
• 编写UserService的deleteById()方法
• 编写UserDao的deleteById()方法
• 编写UserDao的deleteRelByUid()方法
• 跳回当前用户列表页面

十三、SpringMVC拦截器

13.1 拦截器（interceptor）的作用

• SpringMVC的拦截器类似于Servlet开发中的过滤器Filter，用于对处理器进行预处理和后处理
• 将拦截器按一定的顺序联结成一条链，这条链称为拦截器链（Interceptor Chain）。在访问被拦截的方法或字段时，拦截器链中的拦截器就会按其之前定义的顺序被调用。拦截器也是AOP思想的具体体现。

13.2 拦截器和过滤器的区别

区别	过滤器（Filter）	拦截器（Interceptor）
使用范围	是servlet规范中的一部分，任何Java Web工程都可以使用	是SpringMVC框架自己的，只有使用了SpringMVC框架的工程才能用
拦截范围	在url-pattern中配置了/*之后，可以对所有要访问的资源拦截	在<mvc:mapping path=“” />中配置了/**之后，也可以对所有资源进行拦截，但是可以通过<mvc:exclude-mapping path=“” />标签排除不需要拦截的资源

13.3 拦截器快速入门

• 创建拦截器类实现HandlerInterceptor接口
• 配置拦截器
• 测试拦截器的拦截效果

13.4 拦截器方法

• preHandle()：方法将在请求处理之前调用，该方法的返回值是Boolean类型的，当他返回false时，表示请求结束，后续的Interceptor和Controller都不会再执行；当返回值为true时就会继续调用下一个Interceptor的preHandle方法
• postHandle()：刚方法实在当前请求进行处理之后被调用，前提是preHandle方法的返回值为true。它会在DispatcherServlet进行试图返回渲染之前被调用，所以我们可以在这个方法中对Controller处理之后的ModelAndView对象进行操作
• afterConpletion()：该方法将在整个请求结束后，也就是在DispatcherServlet渲染了对应的视图之后执行，前提是preHandle方法的返回值为true

十四、SpringMVC异常处理机制

14.1 异常处理的思路

• 系统中异常包括两类：预期异常和运行时异常RuntimeException，前者通过捕获异常从而获取异常信息，后者主要通过规范代码开发、测试等手段减少运行时异常的发生
• 系统的Dao、Service、Controller出现异常都通过throws Exception向上抛出，最后由SpringMVC前端控制器交由异常处理器处理

14.2 异常处理两种方式

• 使用SpringMVC提供的简单异常处理器SimpleMappingExceptionResolver
• 实现Spring的异常处理接口HandlerExceptionResolver自定义自己的异常处理器

14.3 简单异常处理器SimpleMappingExceptionResolver

• SpringMVC已经定义好了该类型转换器，在使用时可以根据项目情况进行相应异常与视图的映射配置

<!--配置异常处理器-->
<bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
    <property name="defaultErrorView" value="error"></property>
    <property name="exceptionMappings">
        <map>
            <entry key="java.lang.ClassCastException" value="error1"></entry>
            <entry key="com.itheima.exception.MyException" value="error2"></entry>
        </map>
    </property>
</bean>

14.4 自定义异常处理步骤

• 创建异常处理器类实现HandlerExceptionResolver
• 配置异常处理器
• 编写异常页面
• 测试异常跳转

十五、Spring AOP

15.1 Spring的AOP简介

15.1.1 什么是AOP

• AOP为Aspect Oriented Programming的缩写，意思为面向切面编程，是通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术
• AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间耦合度降低，提高程序的可用性，同时提高了开发效率

15.1.2 AOP的作用及其优势

• 作用：在程序运行期间，在不修改源码的情况下对方法进行功能增强
• 优势：减少重复代码，提高开发效率，并且便于维护

15.1.3 AOP的底层实现

• 实际上，AOP的底层是通过Spring提供的动态代理技术实现的。在运行期间，Spring通过动态代理技术动态的生成代理对象，代理对象方法执行时进入增强功能的介入，再去调用目标对象的方法，从而完成功能的增强

15.1.4 AOP的动态代理技术

• JDK代理：基于接口的动态代理技术
• cglib代理：基于父类的动态代理技术

15.1.4 JDK的动态代理

• 目标类接口

public interface TargetInterface {
	public void method();
}

• 目标类

public class Target implements TargetInterface {
	@Override
	public void method() {
		System.out.println("Target running....");
	}
}

• 动态代理代码

Target target = new Target(); //创建目标对象
//创建代理对象
TargetInterface proxy = (TargetInterface) Proxy.newProxyInstance(target.getClass() .getClassLoader(),
target.getClass().getInterfaces(),new InvocationHandler(){ 
	@Override public Object invoke(Object proxy, Method method, Object[] args)
	throws Throwable { 
		System.out.println("前置增强代码..."); 
		Object invoke = method.invoke(target, args); 
		System.out.println("后置增强代码..."); 
		return invoke; 
		} 
	} 
);

• 调用代理对象的方法测试

proxy.method();

15.1.5 cglib的动态代理

		// 1、创建增强器
        Enhancer enhancer = new Enhancer();
        // 2、设置父类（目标）
        enhancer.setSuperclass(Target.class);
        // 3、设置回调函数
        enhancer.setCallback(new MethodInterceptor() {
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                advice.before();// 执行前置
                Object invoke = method.invoke(target, args);
                advice.after();// 执行后置
                return invoke;
            }
        });
        // 4、创建代理对象
        Target proxy = (Target)enhancer.create();
        proxy.save();

15.1.6 AOP相关概念

• Spring的AOP实现底层就是对上面的动态代理的代码进行了封装，封装后我们只需要对需要关注的部分进行代码编写，并通过配置的方式完成指定目标的方法增强
• AOP相关术语
  • Target（目标对象）：代理的目标对象
  • Proxy（代理）：一个类被AOP织入增强后，就产生一个结果代理类
  • Joinpoint（连接点）：连接点是指那些被拦截到的点。在Spring中，这些点指的是方法，因为Spring只支持方法类型的连接点
  • Pointcut（切入点）：切入点指的是我们要对那些Joinpoint进行拦截的定义
  • Advice（通知/增强）：通知指的是拦截到Joinpoint之后所要做的事情
  • Aspect（切面）：切入点和通知（引介）的结合
  • Weaving（织入）：把增强应用到目标对象来创建新的代理对象的过程。Spring采用动态代理织入，而AspectU采用编译期织入和类装载器织入

15.1.7 AOP开发明确的事项

• 需要编写的内容
  • 编写核心业务代码（目标类的目标方法）
  • 编写切面类，切面类中有通知（增强功能方法）
  • 在配置文件中，配置织入关系，将通知与连接点进行结合
• AOP技术实现的内容
  • Spring框架监控切入点方法的执行。一旦监控到切入点方法被运行，便使用代理机制，动态创建目标对象的代理对象，根据通知类别，在代理对象的对应位置，将通知对应的功能织入，完成完整的代码逻辑运行
• AOP底层使用哪些代理方式
  • 在Spring中，框架会根据目标类是否实现了接口来决定采用哪些动态代理方式

15.2 基于XML的AOP开发

15.2.1 快速入门

• 导入AOP相关坐标
• 创建目标接口和目标类（内部有切点）
• 创建切面类（内部有增强方法）
• 将目标类和切面类的对象创建权交给spring
• 在applicationContext.xml中配置织入关系
• 测试代码

15.2.2 XML配置AOP详解

• 切点表达式的写法

  • 表达式语法：execution([修饰符] 返回值类型 包名.类名.方法名(参数))
  • 访问修饰符可以省略
  • 返回值类型、包名、类名、方法名可以使用星号*代表任意
  • 包名与类名之间一个点.代表当前包下的类，两个点…表示当前包及其子包下的类
  • 参数列表可以使用两个点…表示任意个数，任意类型的参数

• 通知的类型

  • 通知的配置语法：<aop:通知类型 method=“切面类中方法名” pointcut=“切点表达式”/>

  名称	标签	说明
  前置通知	aop:before	用于配置前置通知。指定增强的方法在切入点方法之前执行
  后置通知	aop:after-returning	用于配置后置通知。指定增强的方法在切入点方法之后执行
  环绕通知	aop:around	用于配置环绕通知。指定增强的方法在切入点方法之前和之后都执行
  异常抛出通知	aop:throwing	用于配置异常抛出通知。指定增强的方法在出现异常时执行
  最终通知	aop:after	用于配置最终通知。无论增强方式执行是否有异常都会执行

• 切点表达式的抽取

  • 当多个增强的切点表达式相同时，可以将切点表达式进行抽取，在增强中使用pointcut-ref属性代替pointcut属性来引用抽取后的切点表达式

15.3 基于注解的AOP开发

15.3.1 快速入门

• 创建目标接口和目标类（内部有切点）
• 创建切面类（内部有增强方法）
• 将目标类和切面类的对象创建权交给Spring
• 在切面类中使用注解配置织入关系
• 在配置文件中开启组件扫描和AOP的自动代理
• 测试

15.3.2 注解配置AOP详解

名称	标签	说明
前置通知	@Before	用于配置前置通知。指定增强的方法在切入点方法之前执行
后置通知	@After-returning	用于配置后置通知。指定增强的方法在切入点方法之后执行
环绕通知	@Around	用于配置环绕通知。指定增强的方法在切入点方法之前和之后都执行
异常抛出通知	@AftetThrowing	用于配置异常抛出通知。指定增强的方法在出现异常时执行
最终通知	@After	用于配置最终通知。无论增强方式执行是否有异常都会执行

切点表达式的抽取

• 同xml配置aop一样，我们可以将切点表达式抽取。抽取方式是在切面内定义方法，在该方法上使用@Pointcut注解定义切点表达式，然后再增强注解中进行引用

十六、Spring事务控制

16.1 编程式事务控制相关对象

16.1.1 PlatformTransactionManager接口

• PlatformTransactionManager接口：Spring的事务管理器，它提供了我们常用的操作事务的方法

方法	说明
TransactionStatus getTransaction(TransactionDefination defination)	获取事务的状态信息
void commit(TransactionStatus status)	提交事务
void rollback(TransactionStatus status)	回滚事务

• PlatformTransactionManager是接口类型，不同的Dao层技术有不同的实现类

16.1.2 TransactionDefinition

• TransactionDefinition是事务的定义信息对象

方法	说明
int getIsolationLevel()	获得事物的隔离级别
int getPropogationBehavior	获得事务的传播行为
int getTimeout()	获得超时时间
boolean isReadOnly()	是否只读

• 事务隔离级别：设置隔离级别，可以解决事务并发产生的问题，如脏读、不可重复读和虚读
  • ISOLATION_DEFAULT
  • ISOLATION_READ_UNCOMMITTED
  • ISOLATION_READ_COMMITED
  • ISOLATION_PEREATABLE_READ
  • ISOLATION_SERIALIZABLE
• 事务传播行为
  • REQUIRED：如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中（默认值）
  • SUPPORTS：支持当前事务，如果当前没有事务，就以非事务方式执行
  • MANDATORY：使用当前的事物，如果当前没有事务，就抛出异常
  • REQUERS_NEW：新建事务，如果当前在事务中，把当前事务挂起
  • NOT_SUPPORTED：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起
  • NEVER：以非事务方式运行，如果当前存在事务，抛出异常
  • NESTED：如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行REQUIRED类似的操作
  • 超时时间：默认值是-1，没有超时限制。如果有，以秒为单位进行设置
  • 是否只读：建议查询时设置为只读

16.1.2 TransactionStatus

方法	说明
boolean hasSavepoint()	是否存储回滚点
boolean isCompleted	事务是否完成
boolean isNewTransaction()	是否是新事物
boolean isRollbackOnly()	事务是否回滚

16.2 基于XML的声明式事务控制

16.2.1 什么是声明式事务控制

• Spring的声明式事务就是采用声明的方式来处理事务。这里所说的声明，就是在配置文件中声明，用在Spring配置文件中声明式的处理事务来代替代码处的处理事务
• 声明式事务处理的作用
  • 事务管理不侵入开发的组件。具体来说，业务逻辑对象不会意识到正在事务管理之中。因为事务管理是属于系统层面的服务，而不是业务逻辑的一部分，如果想要改变事务管理策略的话，也只需要在定义文件中重新配置即可
  • 在不需要事务管理的时候，只要在设定文件上修改一下，即可移去事务管理服务，无需改变代码重新编译，这样维护起来方便
• Spring声明式事务控制底层就是AOP

16.2.2 声明式事务控制的实现

• 声明式事务控制明确事项
  • 谁是切点？
  • 谁是通知？
  • 配置切面？

16.2.3 切点方法的事务参数配置

    <!--通知 事务的增强-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="*"/>
        </tx:attributes>
    </tx:advice>

• 其中，tx:method代表切点方法的事务参数的配置
  • name：切点方法名称
  • isolation：事务的隔离级别
  • propogation：事务的传播行为
  • timeout：超时时间
  • read-only：是否只读

16.3 基于注解的声明式事务控制

16.3.1 使用注解配置声明式事务控制

<context:component-scan base-package="com.itheima"/>
<!--事务的注解驱动-->
<tx:annotation-driven/>

16.3.2 注解配置声明式事务控制解析

• 使用 @Transactional 在需要进行事务控制的类或是方法上修饰，注解可用的属性同 xml 配置方式，例如隔离 级别、传播行为等
• 注解使用在类上，那么该类下的所有方法都使用同一套注解参数配置
• 使用在方法上，不同的方法可以采用不同的事务参数配置
• Xml配置文件中要开启事务的注解驱动

十七、MyBatis

17.1 MyBatis的简介

17.1.1 原始jdbc操作

• 查询数据

//注册驱动
Class.forName("com.mysql.jdbc.Driver");
//获得连接
Connection connection = DriverManager.getConnection("jdbc:mysql:///test","root","1234");
//获得statement
PreparedStatement statement = connection.prepareStatement("sqlect id,username,password from user");
//执行查询
ResultSet resuletSet = statement.executeQuery();
//遍历结果集
while(resuleSet.next()){
    //封装实体
    User user = new User();
    user.setId(resultSet.getInt("id"));
    user.setUsername(resultSet.getString("username"));
    user.setPassword(resultSet.getString("password"));
    //user实体封装完毕
    System.out.println(user);
}
//释放资源
resultSet.close();
statement.close();
connection.close();

• 插入数据

//模拟实体对象
User user = new User();
user.setId(2);
user.setUsername("tom");
user.setPassword("lucy");
//注册驱动
Class.forName("com.mysql.jdbc.Driver");
//获得连接
Connection connection = DriverManager.getConnection("jdbc:mysql:///test","root","1234");
//获得statement
PreparedStatement statement = connection.prepareStatement("insert into user(id,username,password) values(?,?,?)");
//执行查询
//设置占位符参数 
statement.setInt(1,user.getId());
statement.setString(2,user.getUsername());
statement.setInt(1,user.getPassword());
//执行更新操作
statement.executeUpdate();
//释放资源
statement.close();
connection.close();

17.1.2 原始jdbc操作的分析

• 原始jdbc开发存在一些问题
  • 数据库连接创建、释放频繁造成系统资源浪费从而影响性能
  • sql语句在代码中硬编码，造成代码不宜维护，实际应用sql变化的可能较大，sql变动需要改变java代码
  • 查询操作时，需要手动将结果集中的数据封装到实体中。插入操作时，需要手动将实体的数据设置到sql语句的占位符位置
• 解决方案
  • 使用数据库连接池初始化连接资源
  • 将sql语句抽取到xml配置文件中
  • 使用反射、内省等底层技术，自动将实体与表进行属性与字段的自动映射

17.1.3 什么是MyBatis

• mybatis是一个优秀的基于java的持久层框架，它内部封装了jdbc，使开发者只需要关注sql语句本身，而不需要花费精力去处理加载驱动、创建连接、创建statement等繁杂的过程
• mybatis通过xml或注解的方式将要执行的各种statement配置起来，并通过java对象和statement中sql的动态参数进行映射生成最终执行的sql语句
• 最后mybatis框架执行sql并将结果映射为java对象并返回。采用ORM思想解决了实体和数据库映射的问题，对jdbc进行了封装，屏蔽了jdbc api底层访问细节，使我们不用与jdbc api打交道，就可以完成对数据库的持久化操作。

17.2 MyBatis的快速入门

• 添加MyBatis的坐标
• 创建user数据表
• 编写User实体类
• 编写映射文件UserMapper.xml
• 编写核心文件SqlMapConfig.xml
• 编写测试类

17.3 MyBatis的的映射文件概述

17.4 MyBatis的的增删改查操作

17.4.1 插入数据

• 插入语句使用insert标签
• 在映射文件中使用parameterType属性指定要插入的数据类型
• Sql语句中使用#{实体属性名}方式引用实体中的属性值
• 插入操作使用的API是sqlSession.insert(“命名空间.id”，实体对象)
• 插入操作设计数据库数据变化，所以要使用sqlSession对象显示的提交事务

17.4.2 修改数据

• 插入语句使用update标签
• 修改操作使用sqlSessionn.update(“命名空间.id”，实体对象)

17.4.3 删除数据

• 插入语句使用delete标签
• Sql语句中使用#{任意字符串}方式引用传递的单个参数
• 删除操作使用sqlSessionn.delete(“命名空间.id”，实体对象)

17.5 MyBatis的核心配置文件概述

17.5.1 MyBatis核心配置文件层级关系

• configuration配置
  • properties属性
  • settings设置
  • typeAliases类型别名
  • typeHandles类型处理器
  • objectFactory对象工厂
  • plugins插件
  • environments环境
    • environment环境变量
      • transactionManager事务管理器
      • dataSource数据源
  • databaseIdPrivider数据库厂商标识
  • mapper映射器

17.5.2 MyBatis常用配置解析

• environments标签：数据库环境的配置，支持多环境配置

  • 事务管理器的类型有两种

    • JDBC：这个配置就是直接使用了JDBC 的提交和回滚设置，它依赖于从数据源得到的连接来管理事务作用域
    • MANAGED：这个配置几乎没做什么。它从来不提交或回滚一个连接，而是让容器来管理事务的整个生命周期（比如JEE 应用服务器的上下文）。 默认情况下它会关闭连接，然而一些容器并不希望这样，因此需要将 closeConnection 属性设置 为 false 来阻止它默认的关闭行为。

  • 数据源（dataSource）类型有三种

    • UNPOOLED：这个数据源的实现只是每次被请求时打开和关闭连接
    • POOLED：这种数据源的实现利用“池”的概念将 JDBC 连接对象组织起来
    • JNDI：这个数据源的实现是为了能在如 EJB 或应用服务器这类容器中使用，容器可以集中或在外部配置数据源，然后放置 一个 JNDI 上下文的引用

  <environments default="development">//默认环境名称
      <environment id="development">//指定当前环境的名称
        <transactionManager type="JDBC"/>//指定事务管理类型是JDBC
        <dataSource type="POOLED">//指定当前数据源类型是连接池
          <property name="driver" value="${driver}"/>
          <property name="url" value="${url}"/>
          <property name="username" value="${username}"/>
          <property name="password" value="${password}"/>
        </dataSource>
      </environment>
  </environments>
  

• mapper标签：该标签的作用是加载映射的，加载方式有如下几种

  • 使用相对于类路径的资源引用，例如：
  • 使用完全限定资源定位符（URL），例如：
  • 使用映射器接口实现类的完全限定类名，例如：
  • 将包内的映射器接口实现全部注册为映射器，例如：

• properties标签

  • Properties标签 实际开发中，习惯将数据源的配置信息单独抽取成一个properties文件，该标签可以加载额外配置的properties文件

  <!--加载外部properties-->
  <properties resource="jdbc.properties"></properties>
  
  <dataSource type="POOLED">
                  <property name="driver" value="com.mysql.jdbc.Driver"/>
                  <property name="url" value="jdbc:mysql://localhost:3306/test"/>
                  <property name="username" value="root"/>
                  <property name="password" value="1234"/>
  </dataSource>
  

• typeAliases标签：类型别名是为Java类型设置的一个短的名字

  <typeAliases>
      <typeAlias type="com.itheima.domain.User" alias="user"></typeAlias>
  </typeAliases>
  

  • mybatis框架已经为我们设置好一些常用的类型别名

    别名	数据类型
    string	String
    long	Long
    int	Integer
    double	Double
    boolean	Boolean
    …	…

17.6 MyBatis的相应API

17.6.1 SqlSession工厂构建器SqlSessionFactoryBuilder

• 常用API：SqlSessionFactory build(InputStream inputStream)：通过加载mybatis的核心文件的输入流的形式构建一个SqlSessionFactory对象

  String resource = "org/mybatis/builder/mybatis-config.xml";
  InputStream inputStream = Resources.getResourceAsStream(resource);
  SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
  SqlSessionFactory factory = builder.build(inputStream);
  

• 其中，Resources工具类，这个类在org.apache.ibatis.io包中。Resources类帮助你从类路径下、文件系统或一个web URL中加载资源文件

17.6.2 SqlSession工厂对象SqlSessionFactory

• SqlSessionFactory有多个方法创建SqlSession实例

  方法	解释
  openSession()	默认开启一个事务，但事务不会自动提交
  openSession(boolean autoCommit)	参数为是否自动提交

17.6.3 SqlSession会话对象

• SqlSession实例在MyBatis中是非常强大的一个类。主要功能有执行语句、提交或回滚事务和获取映射器实例

• 执行语句的方法主要有

  <T> T selectOne(String statement, Object parameter)
  <E> List<E> selectList(String statement, Object parameter)
  int insert(String statement, Object parameter)
  int update(String statement, Object parameter)
  int delete(String statement, Object parameter)
  

• 操作事务的主要方法有

  void commit()
  void rollback()
  

17.7 MyBatis的Dao层实现

17.7.1 传统开发方式

1. 编写UserDao接口

   public interface UserDao {
       List<User> findAll() throws IOException;
   }
   

2. 编写UserDaoImpl实现

   public class UserDaoImpl implements UserDao {
   	public List<User> findAll() throws IOException {
   		InputStream resourceAsStream = Resources.getResourceAsStream("SqlMapConfig.xml");
   		SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
   		SqlSession sqlSession = sqlSessionFactory.openSession();
   		List<User> userList = sqlSession.selectList("userMapper.findAll");
   		sqlSession.close();
   		return userList;
   	}
   }
   
   

3. 测试传统开发方式

   @Test
   public void testTraditionDao() throws IOException {
   	UserDao userDao = new UserDaoImpl();
   	List<User> all = userDao.findAll();
   	System.out.println(all);
   }
   

17.7.2 代理开发方式

• 采用 Mybatis 的代理开发方式实现 DAO 层的开发，这种方式是企业的主流
• Mapper 接口开发方法只需要程序员编写Mapper 接口（相当于Dao 接口），由Mybatis 框架根据接口定义创建接 口的动态代理对象，代理对象的方法体同上边Dao接口实现类方法
• Mapper 接口开发需要遵循以下规范：
• Mapper.xml文件中的namespace与mapper接口的全限定名相同
• Mapper接口方法名和Mapper.xml中定义的每个statement的id相同
• Mapper接口方法的输入参数类型和mapper.xml中定义的每个sql的parameterType的类型相同
• Mapper接口方法的输出参数类型和mapper.xml中定义的每个sql的resultType的类型相同

17.8 MyBatis映射文件深入

17.8.1 动态sql语句

• ：我们根据实体类的不同取值，使用不同的 SQL语句来进行查询。比如在 id如果不为空时可以根据id查询，如果 username 不同空时还要加入用户名作为条件。这种情况在我们的多条件组合查询中经常会碰到

  <select id="findByCondition" parameterType="user" resultType="user">
  	select * from User
  	<where>
  		<if test="id!=0">
  			and id=#{id}
  		</if>
  		<if test="username!=null">
  			and username=#{username}
  		</if>
  	</where>
  </select>
  

• ：循环执行sql的拼接操作，例如：SELECT * FROM USER WHERE id IN (1,2,5)

  <select id="findByIds" parameterType="list" resultType="user">
  	select * from User
  	<where>
  		<foreach collection="array" open="id in(" close=")" item="id" separator=",">
  			#{id}
  		</foreach>
  	</where>
  </select>
  

17.8.2 SQL片段抽取

• SQL片段抽取：Sql 中可将重复的 sql 提取出来，使用时用 include 引用即可，最终达到 sql 重用的目的

  <!--抽取sql片段简化编写-->
  <sql id="selectUser" select * from User</sql>
  <select id="findById" parameterType="int" resultType="user">
  	<include refid="selectUser"></include> where id=#{id}
  </select>
  <select id="findByIds" parameterType="list" resultType="user">
  	<include refid="selectUser"></include>
  	<where>
  		<foreach collection="array" open="id in(" close=")" item="id" separator=",">
  			#{id}
  		</foreach>
  	</where>
  </select>
  

17.8 MyBatis映射文件深入

17.8.1 typeHandlers标签

• 无论是在MyBatis在预处理（PreparedStatement）中设置一个参数时，还是从结果集中取出一个值时，都会用类型处理器将获取的值以合适的方式转换成Java类型

  类型处理器	Java类型	JDBC类型
  BooleanTypeHandler	java.lang.Boolean,boolean	数据库兼容的BOOLEAN
  ByteTypeHandler	java.lang.Byte,byte	数据库兼容的NUMERIC或BYTE
  ShortTypeHandler	java.lang.Short,short	数据库兼容的UMERIC或SHORT INTEGER
  IntegerTypeHandler	java.lang.Integer,integer	数据库兼容的UMERIC或INTEGER
  LongTypeHandler	java.lang.Long,long	数据库兼容的UMERIC或LONG INTEGER

• 可以重写类型处理器或创建自己的类型处理器来处理不支持的或非标准的类型。具体做法为：实现org.apache.ibatis.type.TypeHandler接口，或继承一个很便利的类org.apache.ibatis.type.BaseTypeHandler，然后可以选择性地将它映射到一个JDBC类型。例如需求：一个Java中的Date数据类型，将其存储到数据库中是一个时间的毫秒数，取出来时转换成java地Date，即java地Date与数据库地varchar毫秒值之间转换。

• 开发步骤

  • 定义转换类继承类BaseTypeHandler
  • 覆盖4个未实现的方法，其中setNonNullParameter为java程序设置数据到数据里的回调方法，getNullableResult为查询时mysql的字符串类型转换成java的Type类型的方法
  • 在MyBatis核心配置文件中进行注册
  • 测试转换是否正确

17.8.2 plugins标签

• MyBatis可以使用第三方的插件来对功能进行扩展，分页助手PageHelper是将分页的复杂操作进行封装，使用简单的方式即可获得分页的相关数据
• 开发步骤
  • 导入PageHelper的坐标
  • 在mybatis核心配置文件中配置PageHelper插件
  • 测试分页数据获取

17.9 MyBatis注解开发

• @Insert：实现新增
• @Update：实现更新
• @Delete：实现删除
• @Select：实现查询
• @Result：实现结果集封装
• @Results：可以与@Result一起使用，封装多个结果集
• @One：实现一对一结果集封装
• @Many：实现一对多结果集封装

十八、SSM框架整合

18.1 原始整合方式

18.1.1 创建账户表

create database ssm;
create table account(
	id int primary key auto_increment,
    name varchar(100),
    money double(7,2)
);

18.1.2 创建Maven工程

18.1.3 导入Maven坐标

18.1.4 创建Maven工程

18.1.5 编写Mapper接口

public interface AccountMapper {
    // 保存账户数据
    void save(Account account);
    // 查询账户数据
    List<Account> findAll();
}

18.1.6 编写Service接口

18.1.7 编写Service接口实现

18.1.8 编写Controller

18.1.9 编写添加页面

18.1.10 编写列表页面

18.1.11 编写配置文件

• Spring配置文件：applicationContext.xml
• SpringMVC配置文件：spring-mvc.xml
• MyBatis映射文件：AccountMapper.xml
• MyBatis核心文件：sqlMapConfig.xml
• 数据库连接信息文件：jdbc.properties
• Web.xml文件：web.xml
• 日志文件：log4j.xml

18.1.12 测试

18.2 Spring整合MyBatis

18.2.1 整合思路

//将SessionFactory交给Spring容器管理，从容器中获得执行操作的Mapper实例即可
SqlSession sqlSession = MyBatisUtils.openSession();
AccountMapper accountMapper = sqlSession.getMapper(AccountMapper.class);
accountMapper.save(account);
//将事务的控制交给Spring容器进行声明式事务控制
sqlSession.commit();
sqlSession.close();

18.2.2 将SqlSessionFactory配置到Spring容器中

<!--加载properties文件-->
<properties resource="jdbc.properties"></properties>
<!--配置数据源-->
<bean id="datasource" class="com.mchange.v2.c3p0.ComboPooledDatasource"></bean>
	<property name="driverClass" value="${jdbc.driver}"/>
	<property name="jdbcUrl" value="${jdbc.url}"/>
	<property name="user" value="${jdbc.username}"/>
	<property name="password" value="${jdbc.password}"/>
</bean>
<!--配置MyBatis的SqlSessionFactory-->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
	<property name="dataSource" ref="dataSource"/>
	<property name="configLocation" value="classpath:sqlMapConfig.xml"/>
</bean>

18.2.3 配置声明式事务控制

<!--声明式事务控制-->
<!--平台事务管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
	<property name="dataSource" ref="datasource"></property>
</bean>
<!--配置事务增强-->
<tx:advice id="txAdvice">
	<tx:attributes>
		<tx:method name="*"></tx:method>
        </tx:attributes>
</tx:advice>
<!--事务的aop织入-->
<aop:config>
	<aop:advisor advice-ref="txAdvice" pointcut="execution(* com.itheima.service.*.*(..))"></aop:advisor>
</aop:config>