SSM

Spring

IOC（控制反转）& DI（依赖注入）

IOC是容器            ，用来装Spring创建的Bean对象            。

Bean注入方式 Set方法注入 构造器注入 @Autowared自动注入 <!-- SpringBean的注入方式 --> <!-- 手动装配 --> <!-- == set方法注入 --> <bean id="hello" class="com.dzqc.smbms.entity.SUser"> <property name="userCode" value="hello"></property> <property name="userName" value="Spring"></property> <property name="role"> <bean class="com.dzqc.smbms.entity.SRole"> <property name="roleCode" value="这里是注入的实例对象"></property> <property name="roleName" value="这里是注入的实例对象的值"></property> </bean> </property> <property name="role" ref="myRole"></property> </bean> <bean name="myRole" class="com.dzqc.smbms.entity.SRole"> <property name="roleName" value="管理员"></property> <property name="roleCode" value="SMBMS_ADMIN"></property> </bean> <!-- == 带参构造器注入 --> <bean name="constructor" class="com.dzqc.smbms.entity.SUser"> <constructor-arg name="userName" value="这是通过构造器注入的userName"></constructor-arg> <constructor-arg name="userCode" value="这是通过构造器注入的userCode"></constructor-arg> </bean> <!-- 自动装配 --> <!-- == 配置包扫描  
 
  
 
  
 
  
 
  
 
  
 
，并使用注解进行注入 --> <context:component-scan base-package="com.dzqc.smbms"> <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/> </context:component-scan>

IOC和DI的区别：

IOC是什么：是控制反转











，将new对象的权力由调用程序交给第三方IOC容器
  
  
  
  
  
  ，控制权被转移给了IOC容器  
  
  
  
  
  
，在调用程序看来
 


 


 


 


 


 

，new对象的动作由主动变成了被动
 
 
 
 
 
 ，所以叫做控制反转  
 
  
 
  
 
  
 
  
 
  
 
。

DI是什么：依赖注入   
   
   
   
   
   
，将IOC容器中new出来的对象注入进调用程序











。

IOC和ID的区别：IOC和DI是一体的
 

 

 

 

 

 
，DI是IOC的另一种表现形式

 

 

 

 

 

 ，是同一事件不同层面的解读
  
  
  
  
  
  。

AOP（面向切面编程）

一
  
  
  
  
  
  、AOP编程思想 1.1 什么是AOP

​ AOP （Aspect Orient Programming）,直译过来就是 面向切面编程  
  
  
  
  
  
。AOP是一种编程思想            ，基于面向对象编程思想（OOP）的补充
 


 


 


 


 


 

。面向对象编程将程序抽象成了各个切面
 
 
 
 
 
 。

1.2 为什么需要AOP

​ 在开发过程中
 
 

 
 

 
 

 
 

 
 

 
 
，存在某段多次重复的代码











，以面向过程编程方式的话                  ，我们会将这段代码抽象成一个方法 
 
 
 
 
 
 
 
 
 
 
 
，在需要的位置调用该方法   
   
   
   
   
   
。当这段代码需要修改时

















，我们就只需要改变这一个方法就够了
 

 

 

 

 

 
。

​ 但需求不是一成不变的            ，如果后期需要新增一个需求  
 
  
 
  
 
  
 
  
 
  
 
，又需要在多处进行修改











，就需要再抽象一个方法
  
  
  
  
  
  ，然后在需要的位置再分别调用这个方法

 

 

 

 

 

 。又或者  
  
  
  
  
  
，我们在业务过程中删除这个方法
 


 


 


 


 


 

，我们就需要删除掉每一个地方的调用            。

​ 在这种情况之下
 
 
 
 
 
 ，我们就可以通过使用AOP来解决
 
 

 
 

 
 

 
 

 
 

 
 
。

1.3 AOP实现方法分类

​ 首先我们要知道AOP的目的   
   
   
   
   
   
，AOP要达到在开发者不修改源代码的前提下
 

 

 

 

 

 
，去为系统中的业务添加某种通用的功能











。

​ AOP的实现方式大致可以分为两类：

静态AOP实现 静态AOP实现是在编译阶段就对程序源代码进行修改

 

 

 

 

 

 ，生成了静态的AOP代理类            ，即生成的*.class文件已经被修改
 
 

 
 

 
 

 
 

 
 

 
 
，需要使用特定的编译方式进行编译                  。代表性的静态AOP实现方式如：AspectJ 动态AOP实现 AOP框架在运行阶段动态生成代理对象 
 
 
 
 
 
 
 
 
 
 
 
。即在内存中以JDK动态代理的方式











，或CGlib动态生成AOP代理类                  ，典型的技术如：SpringAOP

















。 类别 机制 原理 静态AOP 静态织入 在编译前 
 
 
 
 
 
 
 
 
 
 
 
，切面直接以字节码的形式编译入目标代码的字节码文件中

















，对性能无影响            ，但灵活性不够            。 动态AOP JDK动态代理 在运行期间  
 
  
 
  
 
  
 
  
 
  
 
，目标类加载之后为接口动态生成代理类











，将切面织入到代理类中
  
  
  
  
  
  ，相对于静态AOP更灵活一些  
 
  
 
  
 
  
 
  
 
  
 
。但切入点需要实现接口  
  
  
  
  
  
，对系统的性能有一定影响











。 动态字节码生成 CGlib 在运行期间
 


 


 


 


 


 

，目标类加载之后
 
 
 
 
 
 ，动态生成目标类的子类   
   
   
   
   
   
，然后将切面的逻辑加入到子类中
 

 

 

 

 

 
，相对于JDK动态代理的方式

 

 

 

 

 

 ，CGlib不需要接口也可以实现织入            ，但是当扩展类的实例方法使用final修饰时无法进行织入
  
  
  
  
  
  。 二 
  
  
  
  
  
 、AOP的专有名词

AOP中的特性术语大致有一下几种：

增强|建议(Advice)：AOP框架中的增强处理
 
 

 
 

 
 

 
 

 
 

 
 
，通知表述了切面在何时执行以及如何执行增强处理  
  
  
  
  
  
。 连接点(join point) ：连切点表示应用程序执行过程中能够插入切面的一个点











，这个点可以是方法的调用 


 


 


 


 


 


、异常的抛出
 


 


 


 


 


 

。在SpringAOP中                  ，连接点总是方法的调用
 
 
 
 
 
 。 切点(PointCut)：可以插入增强处理的连接点   
   
   
   
   
   
。 切面(Aspect)：切面是增强和切点的结合
 

 

 

 

 

 
。 引入(Introduction)：引入允许我们想现有的类添加新的方法或属性

 

 

 

 

 

 。 织入(Weaving)：将增强处理添加到目标对象中 
 
 
 
 
 
 
 
 
 
 
 
，并创建一个被增强对象

















，这个过程就是织入            。 目标对象(Target)：增强的目标对象            ，原始对象
 
 

 
 

 
 

 
 

 
 

 
 
。 代理对象(Proxy)：加入了增强的对象  
 
  
 
  
 
  
 
  
 
  
 
，是由AOP增强后生成的代理对象











。

SpringAOP在AOP的基础上又多出几个延伸概念：

前置增强(MethodBeforeAdvice)：在连接点执行前进行增强                  。 环绕增强(MethodInterceptor)：在连接点前后都执行增强 
 
 
 
 
 
 
 
 
 
 
 
。 异常增强(ThrowsAdvice)：连接点抛出异常时进行增强

















。 返回值增强(AfterReturingAdvice)：连接点产生返回值后进行增强            。 三
 
 
 
 
 
 、认识SpringAOP 3.1 SpringAOP的特点

​ AOP的框架有很多











，实现方式各不相同
  
  
  
  
  
  ，Spring的AOP则是通过动态代理进行实现的  
 
  
 
  
 
  
 
  
 
  
 
。下面简单对代理模式进行介绍











。

3.2 SpringAOP使用与实现 Spring原生API：实现 MethodBeforeAdvice接口  
   
   
   
   
   
 、AfterReturningAdvice接口  
  
  
  
  
  
，重写对应的方法
 


 


 


 


 


 

，并配置增强类与切入点类
 
 
 
 
 
 ，可以实现AOP操作
  
  
  
  
  
  。 自定义切面类：自定义切面类与增强方法   
   
   
   
   
   
，使用配置声明切面类并关联切点
 

 

 

 

 

 
，实现AOP 注解实现AOP：使用@Aspect声明切面类

 

 

 

 

 

 ，@Pointcut声明切入点            ，使用@Before@After....注解实现增强方法
 
 

 
 

 
 

 
 

 
 

 
 
，并配置自动代理











，来实现AOP  
  
  
  
  
  
。

Execution表达式：

​ 声明具体方法的位置的表达式 ：返回值 包路径.类名.方法名(参数列表)

代理模式

​ 代理模式分为两种：

静态代理：需要为每个角色创建对应的代理对象
 


 


 


 


 


 

。 动态代理：自动为每个目标角色生成对应的代理对象
 
 
 
 
 
 。 静态代理

​ 被代理类接口：

package com.dzqc.smbms.proxy; /** * 游戏接口 */ public interface Game { public void gameStart(); public void gameOver(); }

被代理类：

package com.dzqc.smbms.proxy; public class Mario implements Game{ @Override public void gameStart() { System.out.println("超级马里奥                  ，游戏开始！"); } @Override public void gameOver() { System.out.println("够不着旗杆 
 
 
 
 
 
 
 
 
 
 
 
，游戏结束"); } }

代理类：

package com.dzqc.smbms.proxy; /** * 本类为 静态代理 类 * 代理类 需要 持有 目标对象 */ public class GameStaticProxy implements Game{ private Game targetGame; public Game getProxy(Game targetGame){ this.targetGame = targetGame; return this; } @Override public void gameStart() { System.out.println("游戏机启动"); System.out.println("游戏启动！"); targetGame.gameStart(); System.out.println("游戏进行中

















，mario他跳起来了"); } @Override public void gameOver() { System.out.println("mario 打败了魔王            ，找到了旗杆  
 
  
 
  
 
  
 
  
 
  
 
，要爬旗杆   
   
   
   
   
   
。 "); targetGame.gameOver(); System.out.println("真菜











，不玩了
  
  
  
  
  
  ，破游戏什么时候关服！"); } }

测试类：

package com.dzqc.smbms.proxy; import org.junit.Test; import java.lang.reflect.Proxy; public class ProxyTest { @Test public void staticProxy(){ Mario mario = new Mario(); GameStaticProxy gameStaticProxy = new GameStaticProxy(); Game marioProxy = gameStaticProxy.getProxy(mario); marioProxy.gameStart(); marioProxy.gameOver(); } }

测试结果：

游戏机启动 游戏启动！ 超级马里奥  
  
  
  
  
  
，游戏开始！ //原始内容 游戏进行中
 


 


 


 


 


 

，mario他跳起来了 mario 打败了魔王
 
 
 
 
 
 ，找到了旗杆   
   
   
   
   
   
，要爬旗杆
 

 

 

 

 

 
。 够不着旗杆
 

 

 

 

 

 
，游戏结束 //原始内容 真菜

 

 

 

 

 

 ，不玩了            ，破游戏什么时候关服！ JDK动态代理

​ JDK动态代理的实现逻辑大致如下：

接口与被代理类与上述一致

 

 

 

 

 

 。

代理类：

package com.dzqc.smbms.proxy; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; /** * JDK代理类 */ public class GameJDKProxy implements InvocationHandler { private Game targetGame; public GameJDKProxy(Game targetGame){ this.targetGame = targetGame; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { String name = method.getName(); if (name.equals("gameStart")){ Object o = gameStart(method, args); }else { Object o = gameOver(method, args); } return null; } private Object gameStart(Method method , Object[] args) throws Throwable{ System.out.println("mario游戏启动了"); Object invoke = method.invoke(targetGame, args); System.out.println("正在操作mario通水管"); return null; } private Object gameOver(Method method , Object[] args) throws Throwable{ System.out.println("水管打不通"); Object invoke = method.invoke(targetGame, args); System.out.println("什么破游戏！"); return null; } }

测试类：

package com.dzqc.smbms.proxy; import org.junit.Test; import java.lang.reflect.Proxy; public class ProxyTest { @Test public void jdkProxy(){ Mario mario = new Mario(); GameJDKProxy gameJDKProxy = new GameJDKProxy(mario); // 使用JDK动态代理类获取代理对象 Game marioProxy = (Game) Proxy.newProxyInstance( this.getClass().getClassLoader(), //类加载器 new Class[]{Game.class}, // 代理接口的字节码文件 gameJDKProxy// 自己的代理类
 
 

 
 

 
 

 
 

 
 

 
 
，进行目标方法扩充 ); marioProxy.gameStart(); marioProxy.gameOver(); } }

测试结果

mario游戏启动了 超级马里奥











，游戏开始！ //原始内容 正在操作mario通水管 水管打不通 够不着旗杆                  ，游戏结束 //原始内容 什么破游戏！

​ 由上述代码不难看出 
 
 
 
 
 
 
 
 
 
 
 
，动态代理的实现需要以下几点：

JDK动态代理需要声明接口            。想要创建一个动态代理类

















，就必须给这个类声明一个接口            ，否则无法在Proxy.newProxyInstance时传入对应的接口类字节码文件
 
 

 
 

 
 

 
 

 
 

 
 
。 在代理类中需要通过构造传入原有的bean  
 
  
 
  
 
  
 
  
 
  
 
，因为处理完附加功能外











，需要执行原有bean中的方法
  
  
  
  
  
  ，以实现代理的目的











。 CGlib动态代理

代理类：

package com.dzqc.smbms.proxy; import org.springframework.cglib.proxy.Enhancer; import org.springframework.cglib.proxy.MethodInterceptor; import org.springframework.cglib.proxy.MethodProxy; import java.lang.reflect.Method; public class GameCglibProxy implements MethodInterceptor { private Game targetGame; public GameCglibProxy(Game targetGame){ this.targetGame = targetGame; } /** * 获取代理对象 * @return */ public Game getProxy(){ // 获取cglib操作类 Enhancer enhancer = new Enhancer(); // 指定代理类 的 父类类型  
  
  
  
  
  
，要代理哪个类就使用哪个类做代理类的父类 enhancer.setSuperclass(Mario.class); // 指定代理对象
 


 


 


 


 


 

，把当前代理类作为代理对象 enhancer.setCallback(this); // 创建并返回代理对象 return (Game) enhancer.create(); } /** * 代理增强的实际操作处 */ @Override public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable { String name = method.getName(); if (name.equals("gameStart")){ gameStart(method , objects); }else { gameOver(method , objects); } return null; } private Object gameStart(Method method , Object[] args) throws Throwable{ System.out.println("魂斗罗启动！！！！"); Object invoke = method.invoke(targetGame, args); System.out.println("正在操作Mario和魂斗罗兄弟决斗"); return null; } private Object gameOver(Method method , Object[] args) throws Throwable{ System.out.println("Mario挖了下水道
 
 
 
 
 
 ，坑了魂斗罗兄弟"); Object invoke = method.invoke(targetGame, args); System.out.println("不要串台！"); return null; } }

测试类：

package com.dzqc.smbms.proxy; import org.junit.Test; import java.lang.reflect.Proxy; public class ProxyTest { @Test public void cglibProxy(){ Mario mario = new Mario(); GameCglibProxy gameCglibProxy = new GameCglibProxy(mario); Game proxy = gameCglibProxy.getProxy(); proxy.gameStart(); proxy.gameOver(); } }

测试结果：

魂斗罗启动！！！！ 超级马里奥   
   
   
   
   
   
，游戏开始！ //原始内容 正在操作Mario和魂斗罗兄弟决斗 Mario挖了下水道
 

 

 

 

 

 
，坑了魂斗罗兄弟 够不着旗杆

 

 

 

 

 

 ，游戏结束 //原始内容 不要串台！

​ 由上述代码不难看出            ，CGlib在进行动态代理的过程中
 
 

 
 

 
 

 
 

 
 

 
 
，对被实现的类要求较少











，而且更为灵活                  ，使用者可以根据实际情况进行选择                  。

SPring MVC

MVC是什么？MVC是设计模式 
 
 
 
 
 
 
 
 
 
 
 
，包含Model（模型） 

 

 

 

 

 

、View（视图）

 

 

 

 

 

 、Controller（控制器） 
 
 
 
 
 
 
 
 
 
 
 
。

SpringMVC就是基于MVC设计模式创建的一个控制层框架

















，用来简化视图与后台的数据交互工作            ，并且规范开发方式

















。SpringMVC是对Servlet的封装  
 
  
 
  
 
  
 
  
 
  
 
，可将SpringMVC的本质看作Servlet            。

SpringMVC核心组件

前端控制器|中央处理器（DispatcherServlet）：用来调度整个MVC的请求走向  
 
  
 
  
 
  
 
  
 
  
 
。 处理器适配器（HandlerAdapter）：用来适配请求路径对应的处理器 处理器映射器（HandlerMapping）：用来查找请求路径对应的处理器方法 处理器（Controller | Handler）：处理请求的方法 视图解析器（ViewResolver）：解析视图            、返回路径 
 

 
 

 
 

 
 

 
 

 
 

、请求转发与响应的解析器 视图（View）：页面 拦截器（Interceptor）：拦截请求

SpringMVC第一个程序

处理请求以及响应

参数传递

类需要使用@Controller注解











，在类中声明一个Handler方法
  
  
  
  
  
  ，在方法的参数列表中声明需要的参数  
  
  
  
  
  
，在Handler方法被调用时
 


 


 


 


 


 

，就可以正确传入对应的参数











。

常用简单数据类型：String
 
 
 
 
 
 ，Integer   
   
   
   
   
   
，Char
 

 

 

 

 

 
，Boolean

 

 

 

 

 

 ，Byte            ，Short
 
 

 
 

 
 

 
 

 
 

 
 
，Long











，Float                  ，Double
  
  
  
  
  
  。 复杂数据类型： 对象：对象在进行参数传递时 
 
 
 
 
 
 
 
 
 
 
 
，参数列表中声明的为对象

















，在传参的过程中            ，传递的是对象中声明的属性名  
  
  
  
  
  
。 数组：数组在进行传参时  
 
  
 
  
 
  
 
  
 
  
 
，数组的参数名需要多次出现











，每次出现给数组赋一个 值
 


 


 


 


 


 

。 http://localhost:9999/ssm/arr?arr=name1&arr=name2&arr=name3 List集合：在进行参数传递时
  
  
  
  
  
  ，因为List集合是个接口  
  
  
  
  
  
，所以需要在List类型的参数前加上@RequestParam注解
 


 


 


 


 


 

，在参数传递时
 
 
 
 
 
 ，与数组传参方式一致
 
 
 
 
 
 。 map集合：在进行参数传递时   
   
   
   
   
   
，需要加上@RequestParam注解
 

 

 

 

 

 
，参数在拼接时

 

 

 

 

 

 ，只需将key和value的值按照普通传参的方式拼接在地址栏或参数列表中   
   
   
   
   
   
。 响应 页面跳转 只响应数据：数据接口            ，在Handler方法上需要添加@ResponseBody注解
 
 

 
 

 
 

 
 

 
 

 
 
，添加完成后











，返回值不会被视图解析器进行解析                  ，在返回时可以按照正常的数据进行返回
 

 

 

 

 

 
。 默认页面返回：默认的响应方式 
 
 
 
 
 
 
 
 
 
 
 
，本质上是请求转发

















，在Handler方法进行return后            ，会将返回的数据转发至DispatcherServlet  
 
  
 
  
 
  
 
  
 
  
 
，然后由DispatcherServlet调度视图解析器











，解析返回值中的数据与视图并响应

 

 

 

 

 

 。 重定向：重定向可以重定向到任意路径
  
  
  
  
  
  ，只需要在返回值上











、ModelAndView的视图名前 加上 redirect  
  
  
  
  
  
，这里的重定向与Servlet的重定向功能保持一致
 


 


 


 


 


 

，流程有变动            。在Handler（处理器）方法进行返回后
 
 
 
 
 
 ，将请求转发至DispatcherServlet（中央处理器）   
   
   
   
   
   
，由DispatcherServlet（中央处理器）调度HttpServletResponse（响应）
 

 

 

 

 

 
，由HttpServletResponse（响应）进行重定向操作
 
 

 
 

 
 

 
 

 
 

 
 
。

SpringMVC基本配置

在web.xml种配置 dispatcherServlet

<!-- 配置中央处理器

 

 

 

 

 

 ，与Servlet一起初始化 --> <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> </servlet> <servlet-mapping> <servlet-name>dispatcherServlet</servlet-name> <url-pattern>/</url-pattern> </servlet-mapping> <!-- 配置SpringIOC容器 --> <listener> <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> </listener> <context-param> <param-name>contextConfigLocation</param-name> <param-value>classpath:applicationContext.xml</param-value> </context-param>

在Spring文件当中配置

<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd 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/mvc/spring-mvc.xsd "> <!-- 配置包扫描,扫描所有使用Controller注解的类 --> <context:component-scan base-package="com.dzqc.smbms"> <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/> </context:component-scan> <!-- 处理器适配器 --> <bean name="handlerAdapter" class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter"></bean> <!-- 处理器映射器 --> <bean name="handlerMapping" class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping"></bean> <!-- 视图解析器 --> <bean name="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver"> <property name="prefix" value="/views/"></property> <property name="suffix" value=".jsp"></property> </bean> <!-- 配置静态资源过滤器 --> <mvc:default-servlet-handler/> <mvc:resources location="/statics/" mapping="/static/*"></mvc:resources> <!-- 文件上传解析器 --> <bean name="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver"> <!-- 最大支持文件大小            ，此处配置50MB大小限制 --> <property name="maxUploadSize" value="52428800"></property> </bean> </beans>

SpringMVC文件上传

依赖：

<!-- 文件上传 --> <dependency> <groupId>commons-fileupload</groupId> <artifactId>commons-fileupload</artifactId> <version>1.4</version> </dependency>

Restful风格接口

Rest注解：

@RestController @GetMapping @PostMapping @PutMapping @DeleteMapping @PathVariable

SpringMVC工作流程

准备工作：

/* 在SpringMVC首次刷新或重新加载时
 
 

 
 

 
 

 
 

 
 

 
 
，会调用SpringMVC初始化策略 */ protected void onRefresh(ApplicationContext context) { this.initStrategies(context); } /** 初始化策略方法 */ protected void initStrategies(ApplicationContext context) { this.initMultipartResolver(context); // 初始化文件上传解析器 this.initLocaleResolver(context); // 初始化本地解析器 this.initThemeResolver(context); // 初始化中心解析器 this.initHandlerMappings(context); // 初始化处理器映射器 this.initHandlerAdapters(context); // 初始化处理器适配器 this.initHandlerExceptionResolvers(context); // 初始化处理器异常解析器 this.initRequestToViewNameTranslator(context); // 初始化 请求视图 翻译器 this.initViewResolvers(context); // 初始化视图解析器 this.initFlashMapManager(context); // 初始化 映射刷新管理器 }

2：请求处理流程

DispathcerServlet（前端控制器）接收请求 ：DispatcherServlet 通过 doService()方法 接收用户请求











。调用 doDispatch() 方法进行请求调度                  。 DispatcherServlet（前端控制器）调用HandlerMapping（处理器映射器）：DispatcherServlet 通过getHandler() 调用HandlerMapping获取HandlerExecutionChain HandlerMapping将（HandlerExecutionChain）处理器执行链返回给DispatcherServlet DispathcerServlet(前端控制器)通过HandlerAdapter(处理器适配器)











，获取对应的Handler处理器方法 
 
 
 
 
 
 
 
 
 
 
 
。 HandlerAdapter(处理器适配器)调用Handler处理器方法                  ，处理用户请求

















。 Handler处理器方法将返回值返回给HandlerAdapter（处理器适配器） HandlerAdapter将Handler处理器方法的返回值以ModelAndView的形式返回给DispatherServlet： DispatcherServlet将ModelAndView交给ViewResolver（视图解析器）解析            。 ViewResolver(视图解析器)将ModelAndView中的数据渲染到View(视图)中  
 
  
 
  
 
  
 
  
 
  
 
。 ViewResolver返回的视图信息到DispatcherServlet











。 DispatcherServlet将视图信息及返回值返回给客户端
  
  
  
  
  
  。

MyBAtis

​ MyBatis是一款轻量级的ORM（对象关系映射）（持久化）框架 
 
 
 
 
 
 
 
 
 
 
 
，能够将JDBC相关的持久化代码通过配置文件的形式实现

















，提高开发效率  
  
  
  
  
  
。

实现原理：工厂模式

手机工厂：MI            ，IPHONE  
 
  
 
  
 
  
 
  
 
  
 
，HUAWEI

简单工厂

工厂对象：

抽象实体：

具体实体：

工厂方法

抽象工厂：

抽象产品：

实体工厂：

实体产品：

抽象工厂

MyBatis基本应用

MyBatis使用分为

配置文件（mybatis-config.xml） mapper接口 与mapper接口对应的mapper.xml映射文件 MyBatis的基本配置(MyBatis-config.xml) MyBatis数据源配置 <!-- 环境配置标签 default中引用的为默认使用的环境 --> <environments default="development"> <!-- 环境标签 id 唯一











，不可重复 --> <environment id="development"> <!-- 事务管理器配置 --> <transactionManager type="JDBC"/> <!-- 数据源配置 type默认为POOLED（默认启用数据库连接池模式） 
  
  
  
  
  
  ，UNPOOLED 不启用连接池 --> <dataSource type="POOLED"> <!-- 属性标签  
  
  
  
  
  
，该处属性为数据源配置属性 --> <property name="driver" value="com.mysql.cj.jdbc.Driver"/> <property name="url" value="jdbc:mysql://localhost:3306/smbms_3"/> <property name="username" value="root"/> <property name="password" value="root"/> </dataSource> </environment> </environments> 数据库连接池 （druid c3p0） 映射文件配置 <mappers> <!-- 映射文件的地址
 


 


 


 


 


 

，引用相对路径 --> <mapper resource="mappers/SUserMapper.xml"></mapper> </mappers> 其他配置 <!-- MyBatis别名配置 只能配置实体类 --> <typeAliases> <!-- <typeAlias type="com.dzqc.smbms.entity.SUser" alias="u"></typeAlias>--> <package name="com.dzqc.smbms.entity"/> </typeAliases> <settings> <!-- 配置控制台日志组件 --> <setting name="logImpl" value="STDOUT_LOGGING"/> </settings> MyBatis整合Log4J MyBatis主要构件

获取资源：Resources.getResourceAsStream("MyBatis-config.xml");

SqlSessionFactoryBuilder：构建工厂的建筑队
 
 
 
 
 
 ，需要给资源后   
   
   
   
   
   
，调用build方法才能构建工厂
 


 


 


 


 


 

。

SqlSessionFactory：工厂建好后
 

 

 

 

 

 
，调用openSession方法

 

 

 

 

 

 ，产出SqlSession

SqlSession：产出的SqlSession可以通过Mapper接口的字节码（.class）来获取SqlSession中生产的代理对象            ，从而操作数据库
 
 
 
 
 
 。

MyBatis映射文件

基本标签 <select id="唯一
 
 

 
 

 
 

 
 

 
 

 
 
，不可重复" parameterType="参数类型" resultType="返回值类型" resultMap="" >查询SQL</select> <insert id="唯一











，不可重复" parameterType="" keyColumn="" keyProperty="" useGeneritedKeys="true">插入语句</insert> <update id="唯一                  ，不可重复" parameterType="" >修改语句</update> <delete id="唯一 
 
 
 
 
 
 
 
 
 
 
 
，不可重复" parameterType="" >删除语句</delete> 动态SQL 判断条件成立时

















，会向SQL后拼接的条件语句 自动判断            ，如果where中包含的有任意一个或多个成立  
 
  
 
  
 
  
 
  
 
  
 
，就会自动向SQL后拼接 where 











， 并将中的拼接语句之前的关键字进行适当的截取   
   
   
   
   
   
。 ：拼接SQL的动态字段
  
  
  
  
  
  ，常用属性有 perfix   
  
  
  
  
  
， suffix 
 


 


 


 


 


 

， perfixOverrides
 
 
 
 
 
 ，suffixOverrides
 

 

 

 

 

 
。 ：自动拼接Set关键字   
   
   
   
   
   
，并截取中的后缀内容

 

 

 

 

 

 。 ：column：要遍历的循环体内容
 

 

 

 

 

 
，item：每次循环到的元素

 

 

 

 

 

 ，open：开始时自动拼接的内容            ，close：结束时自动拼接的内容
 
 

 
 

 
 

 
 

 
 

 
 
，seprector：分隔符











，自动在每个元素后面拼接的内容            。 ResultMap

resultMap是MyBatis实现ORM特性的一个最重要的标签
 
 

 
 

 
 

 
 

 
 

 
 
。

基础查询 - 基本映射

代表主键列 ：column - 数据库列名                   ， property：实体类属性名

普通列 ：column - 数据库列名  
 
 
 
 
 
 
 
 
 
 
 
， property：实体类属性名

外联查询 - 一对一查询 <association property="role" javaType="srole" column="u.userRole"> <id column="userRole" property="id"></id> <result column="roleCode" property="roleCode"></result> <result column="roleName" property="roleName"></result> </association> <association property="role" javaType="srole" column="userRole" select="com.dzqc.smbms.mapper.SRoleMapper.selectById" > </association>

property：实体类的属性名

column：外关联字段的字段名

javaType：property对应的实体类的类型











。

select：外关联查询的方法

外联查询 - 一对多查询 <collection property="roleUsers" column="id" javaType="list" ofType="suser" select="com.dzqc.smbms.mapper.ISUserMapper.selectByRoleId"> </collection>

property：实体类的属性名

column：外关联字段的字段名

javaType：一对多关联集合类型                  。

ofType：一对多关联集合中存放的数据的类型 
 
 
 
 
 
 
 
 
 
 
 
。

select：外关联查询的方法

MyBatis 一级缓存与二级缓存

事务管理

Spring事务管理

什么是事务：事务的本身其实就是一组业务逻辑

















，在业务逻辑当中包含有针对于数据库持久化的操作

















。在事务当中的所有业务逻辑被视为一个整体            。

事务的特性（ACID） 原子性（Atomicity）：事务中所有的操作            ，被视为一个整体  
 
  
 
  
 
  
 
  
 
  
 
，一组业务逻辑中一旦有一点出现异常或失败











，那么所有的业务逻辑都被视为失败  
 
  
 
  
 
  
 
  
 
  
 
。原子性保证了事务当中的业务逻辑要么全部成功
  
  
  
  
  
  ，要么全部失败











。 一致性（Consistency）：事务的操作  
  
  
  
  
  
，不能破坏数据库中的数据完整性
 


 


 


 


 


 

，在事务执行之前或执行之后
 
 
 
 
 
 ，数据库都处于一致的状态
  
  
  
  
  
  。在事务中一旦对数据进行持久化   
   
   
   
   
   
，那么持久化的数据一定符合该数据库的所有规范
 

 

 

 

 

 
，不会破坏数据库中数据的完整性  
  
  
  
  
  
。 持久性（Durability）：事务中的数据一旦被提交

 

 

 

 

 

 ，在之后的操作中都可以查询到            ，无论出现什么故障都不会导致数据的损坏或丢失（物理损坏除外
 
 

 
 

 
 

 
 

 
 

 
 
，存储介质损坏）
 


 


 


 


 


 

。 隔离性（Isolation）：数据库允许多个事务同时执行











，事务之间的数据相互不会有影响
 
 
 
 
 
 。 事务的隔离级别

事务不隔离会产生的问题：

脏读：当前事务读到了其他事务未提交的数据

幻读（虚读）：当前事务重复读取同样的数据                  ，读取到了其他事务新增的数据 
 
 
 
 
 
 
 
 
 
 
 
，导致短时间内两次读取的数据不一致   
   
   
   
   
   
。

不可重复读：当前事务读到了其他事务已提交的数据

















，在短时间            ，两次查询的结果不一致
 

 

 

 

 

 
。

读未提交(read-uncommitted)：默认隔离级别  
 
  
 
  
 
  
 
  
 
  
 
，允许当前事务读取其他事务未提交的数据











，在该隔离级别中
  
  
  
  
  
  ，脏读                  、幻读 
 
 
 
 
 
 
 
 
 
 
 
、不可重复读都有可能出现

 

 

 

 

 

 。 读已提交(read-committed)：允许当前事务读取其他事务已提交的数据  
  
  
  
  
  
，在该隔离级别下
 


 


 


 


 


 

，脏读不会出现
 
 
 
 
 
 ，幻读和不可重复读有可能出现            。 可重复读(Repeatable-read)：允许当前数据读取其他事务新增的数据   
   
   
   
   
   
，不读取其他事务提交的修改数据（不允许修改操作）
 
 

 
 

 
 

 
 

 
 

 
 
。在该事务隔离级别下
 

 

 

 

 

 
，脏读与不可重复读不会出现

 

 

 

 

 

 ，幻读有可能会出现











。 串行化(Serializable)：最高的事务隔离级别            ，脏读

















、幻读            、不可重复读都不会出现
 
 

 
 

 
 

 
 

 
 

 
 
，但是运行效率低











，一般不使用                  。 Spring事务 编程式事务

优点：对事务的操作精细                  ，能够更加精确的对事务进行管理

缺点：对代码的侵入度高 
 
 
 
 
 
 
 
 
 
 
 
，在后期进行维护 
 
  
 
  
 
  
 
  
 
  
 
 、功能变更时会提高维护难度 
 
 
 
 
 
 
 
 
 
 
 
。

声明式事务 事务传播机制

事务传播机制一共有7种

















。

requierd：如果当前没有事务

















，就新建一个事务            ，如果已存在一个事务中  
 
  
 
  
 
  
 
  
 
  
 
，加入到这个事务中











，(事务默认传播机制)            。 supports：支持当前事务
  
  
  
  
  
  ，如果没有当前事务  
  
  
  
  
  
，就以非事务方法执行  
 
  
 
  
 
  
 
  
 
  
 
。 mandatory：使用当前事务
 


 


 


 


 


 

，如果没有当前事务
 
 
 
 
 
 ，就抛出异常











。 required_new：新建事务   
   
   
   
   
   
，如果当前存在事务
 

 

 

 

 

 
，把当前事务挂起
  
  
  
  
  
  。 not_supported：以非事务方式执行操作

 

 

 

 

 

 ，如果当前存在事务            ，就把当前事务挂起  
  
  
  
  
  
。 never：以非事务方式执行操作
 
 

 
 

 
 

 
 

 
 

 
 
，如果当前事务存在则抛出异常
 


 


 


 


 


 

。 nested：如果当前存在事务











，则在嵌套事务内执行
 
 
 
 
 
 。如果当前没有事务                  ，则执行与propagation_required类似的操作