springmvc-机制(拦截器、aop、异常)
Spring-mvc知识 概念 Spring Web MVC是一种基于Java的实现了Web MVC设计模式的请求驱动类型的轻量级Web框架，即使用了MVC架构模式的思想，将web层进行职责解耦，基于请求驱动指的就是使用请求-响应模型，框 架的目的就是帮助我们简化开发，Spring Web MVC也是要简化我们日常Web开发的。
图1 Spring Web MVC核心架构图 理解这张图之前我们得先知道以下的几个名词：前端控制器（DispatcherServlet）、请求到处理器映射（HandlerMapping）、处理器适配器 （HandlerAdapter）、视图解析器（ViewResolver）、处理器或页面控制器（Controller）、验证器（ Validator）、命令对象（Command 请求参数绑定到的对象就叫命令对象）、表单对象（Form Object 提供给表单展示和提交到的对象就叫表单对象）
步骤解析： 核心架构的具体流程步骤如下： 1、 首先用户发送请求——>DispatcherServlet，前端控制器收到请求后自己不进行处理，而是委托给其他的解析器进行处理，作为统一访问点，进行全局的流程控制； 2、 DispatcherServlet——>HandlerMapping， HandlerMapping将会把请求映射为HandlerExecutionChain对象（包含一个Handler处理器（页面控制器）对象、多个 HandlerInterceptor拦截器）对象，通过这种策略模式，很容易添加新的映射策略；
3、 DispatcherServlet——>HandlerAdapter，HandlerAdapter将会把处理器包装为适配器，从而支持多种类型的处理器，即适配器设计模式的应用，从而很容易支持很多类型的处理器；
4、 HandlerAdapter——>处理器功能处理方法的调用，HandlerAdapter将会根据适配的结果调用真正的处理器的功能处理方法，完成功能处理；并返回一个ModelAndView对象（包含模型数据、逻辑视图名）；
5、 ModelAndView的逻辑视图名——> ViewResolver， ViewResolver将把逻辑视图名解析为具体的View，通过这种策略模式，很容易更换其他视图技术；
6、 View——>渲染，View会根据传进来的Model模型数据进行渲染，此处的Model实际是一个Map数据结构，因此很容易支持其他视图技术；
7、返回控制权给DispatcherServlet，由DispatcherServlet返回响应给用户，到此一个流程结束。
当然以上步骤中并没有去说明拦截器、事务、安全性，其描述的是具体的对象的流程，前者所说的是框架对象，所以使用的技术和原理则不一样。 HandlerInterceptor拦截器
概念
SpringMVC 中的Interceptor 拦截器也是相当重要和相当有用的，它的主要作用是拦截用户的请求并进行相应的处理，其他的作用比如通过它来进行权限验证，或者是来判断用户是否登陆，日志记录，或者限制时间点访问。
Interceptor实现类及其方法 SpringMVC 中的Interceptor 拦截请求是通过HandlerInterceptor 来实现的。在SpringMVC 中定义一个Interceptor 非常简单，主要有两种方式，第一种方式是要定义的Interceptor类要实现了Spring 的HandlerInterceptor 接口，或者是这个类继承实现了HandlerInterceptor 接口的类，比如Spring 已经提供的实现了HandlerInterceptor 接口的抽象类HandlerInterceptorAdapter ；第二种方式是实现Spring的WebRequestInterceptor接口，或者是继承实现了WebRequestInterceptor的类。
HandlerInterceptor 接口中定义了三个方法，我们就是通过这三个方法来对用户的请求进行拦截处理的。
（1 ）preHandle (HttpServletRequest request, HttpServletResponse response, Object handle) 方法。该方法将在请求处理之前进行调用。SpringMVC 中的Interceptor 是链式的调用的，在一个应用中或者说是在一个请求中可以同时存在多个Interceptor 。每个Interceptor 的调用会依据它的声明顺序依次执行，而且最先执行的都是Interceptor 中的preHandle 方法，所以可以在这个方法中进行一些前置初始化操作或者是对当前请求的一个预处理，也可以在这个方法中进行一些判断来决定请求是否要继续进行下去。该方法的返回值是布尔值Boolean 类型的，当它返回为false 时，表示请求结束，后续的Interceptor 和Controller 都不会再执行；当返回值为true 时就会继续调用下一个Interceptor 的preHandle 方法，如果已经是最后一个Interceptor 的时候就会是调用当前请求的Controller 方法。
（2 ）postHandle (HttpServletRequest request, HttpServletResponse response, Object handle, ModelAndView modelAndView) 方法，由preHandle 方法的解释我们知道这个方法包括后面要说到的afterCompletion 方法都只能是在当前所属的Interceptor 的preHandle 方法的返回值为true 时才能被调用。postHandle 方法，顾名思义就是在当前请求进行处理之后，也就是Controller 方法调用之后执行，但是它会在DispatcherServlet 进行视图返回渲染之前被调用，所以我们可以在这个方法中对Controller 处理之后的ModelAndView 对象进行操作。postHandle 方法被调用的方向跟preHandle 是相反的，也就是说先声明的Interceptor 的postHandle 方法反而会后执行，这和Struts2 里面的Interceptor 的执行过程有点类型。Struts2 里面的Interceptor 的执行过程也是链式的，只是在Struts2 里面需要手动调用ActionInvocation 的invoke 方法来触发对下一个Interceptor 或者是Action 的调用，然后每一个Interceptor 中在invoke 方法调用之前的内容都是按照声明顺序执行的，而invoke 方法之后的内容就是反向的。
（3 ）afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handle, Exception ex) 方法，该方法也是需要当前对应的Interceptor 的preHandle 方法的返回值为true 时才会执行。顾名思义，该方法将在整个请求结束之后，也就是在DispatcherServlet 渲染了对应的视图之后执行。这个方法的主要作用是用于进行资源清理工作的。 我们的系统日志的拦截在这个方法中，可以记录日志的相关的参数，检测方法的执行。
拦截器的配置
图2系统springmvc拦截器 这三个方法的代码可以参考Interceptor.java 拦截器日志模块运用 1. 获取MAC地址 2. 获取用户请求的参数 3. 获取异常 4. 获取其所操作的所有的类
可以访问LogInterceptor.java AOP的原理与实现 概念
AOP 是OOP的延续，是Aspect Oriented Programming的缩写，意思是面向切面编程。可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术。 AOP实际是GoF设计模式的延续，设计模式孜孜不倦追求的是调用者和被调用者之间的解耦，AOP可以说也是这种目标的一种实现。
我们现在做的一些非业务，如：日志、事务、安全等都会写在业务代码中(也即是说，这些非业务类横切于业务类)，但这些代码往往是重复，复制——粘贴式的代码会给程序的维护带来不便，AOP就实现了把这些业务需求与系统需求分开来做。这种解决的方式也称代理机制。
先来了解一下AOP的相关概念，《Spring参考手册》中定义了以下几个AOP的重要概念，结合以上代码分析如下：
切面（Aspect）：官 方的抽象定义为“一个关注点的模块化，这个关注点可能会横切多个对象”，在本例中，“切面”就是类TestAspect所关注的具体行为，例 如，AServiceImpl.barA()的调用就是切面TestAspect所关注的行为之一。“切面”在ApplicationContext 中来配置。
连接点（Joinpoint） ：程序执行过程中的某一行为，例如，UserService.get的调用或者UserService.delete抛出异常等行为。
通知（Advice） ：“切面”对于某个“连接点”所产生的动作，例如，TestAspect中对com.spring.service包下所有类的方法进行日志记录的动作就是一个Advice。其中，一个“切面”可以包含多个“Advice”，例如ServiceAspect。
切入点（Pointcut） ：匹配连接点的断言，在AOP中通知和一个切入点表达式关联。例如，TestAspect中的所有通知所关注的连接点，都由切入点表达式execution(* com.spring.service.*.*(..))来决定。
spring MVC原理及配置
spring MVC原理及配置springmvc原理及配置springmvc原理及配置1.springmvc详述：springmvc就是spring提供更多的一个强悍而有效率的web框架。
借助注释，springmvc提供更多了几乎就是pojo的研发模式，使控制器的研发和测试更加直观。
这些控制器通常不轻易处置命令，而是将其委托给spring上下文中的其他bean，通过spring的倚赖转化成功能，这些bean被转化成至控制器中。
springmvc主要由dispatcherservlet、处理器映射、处理器(控制器)、视图解析器、视图组成。
他的两个核心是两个核心：处理器映射：选择使用哪个控制器来处理请求视图解析器：选择结果应该如何渲染通过以上两点，springmvc确保了如何挑选掌控处置命令和如何挑选视图展现出输入之间的松耦合。
2.springmvc运行原理这里写图片描述(2)找寻处理器：由dispatcherservlet控制器查阅一个或多个handlermapping，找出处置命令的controller。
(3)调用处理器：dispatcherservlet将请求提交到controller。
(4)(5)调用业务处置和回到结果：controller调用业务逻辑处置后，回到modelandview。
3.springmvc接口解释（1）dispatcherservlet接口：spring提供的前端控制器，所有的请求都有经过它来统一分发。
在dispatcherservlet将请求分发给springcontroller 之前，需要借助于spring提供的handlermapping定位到具体的controller。
（2）handlermappingUSB：能够完成客户请求到controller映射。
（3）controller接口：须要为mammalian用户处置上述命令，因此同时实现controllerUSB时，必须确保线程安全并且可以器重。
springbootspringmvc拦截器拦截POST、PUT、DELETE请求参数和响。。。
springbootspringmvc拦截器拦截POST、PUT、DELETE请求参数和响。
1.操作⽇志实体类@Document(collection = "operation_log")@Getter@Setter@ToStringpublic class OperationLog extends BaseEntityWithId {private String userId; // 操作⼈private String resource; // 操作的资源private String requestMethod; // 请求⽅式private String beanName; // 操作的类private String methodName; // 操作的模块private String requestParams; // 请求的参数private String responseData; // 返回数据}2.拦截器package com.vian.admin.config;import com.alibaba.fastjson.JSON;import com.vian.admin.entity.OperationLog;import com.vian.admin.event.OperationLogEvent;import com.vian.core.configuration.event.EventPublisher;import com.vian.microservice.security.SecurityUtils;import lombok.extern.slf4j.Slf4j;import ng.JoinPoint;import ng.annotation.AfterReturning;import ng.annotation.Aspect;import ng.annotation.Before;import ng.annotation.Pointcut;import org.springframework.beans.factory.annotation.Autowired;import ponent;import org.springframework.web.context.request.RequestContextHolder;import org.springframework.web.context.request.ServletRequestAttributes;import javax.servlet.http.HttpServletRequest;@Aspect@Component@Slf4jpublic class RequestLogAspect {@Autowired private EventPublisher eventPublisher;private ThreadLocal<OperationLog> logThreadLocal = new ThreadLocal<>();//拦截web下所有⽅法@Pointcut("execution(* com.vian.admin.web..*.*(..))")public void pointcut() {("拦截请求start");}@Before("pointcut()")public void doBefore(JoinPoint joinPoint) {ServletRequestAttributes attributes =(ServletRequestAttributes) RequestContextHolder.getRequestAttributes();HttpServletRequest request = attributes.getRequest();String beanName = joinPoint.getSignature().getDeclaringTypeName();String methodName = joinPoint.getSignature().getName();String uri = request.getRequestURI();String userId = SecurityUtils.getCurrentUserId();//get⽅法不记录⽇志if ("GET".equals(request.getMethod())) {return;}//请求参数Object[] paramsArray = joinPoint.getArgs();("请求⽇志拦截：userId={}, uri={}, method={}, request={}",userId,uri,request.getMethod(),paramsArray);// 组装⽇志数据OperationLog optLog = new OperationLog();optLog.setUserId(userId);optLog.setResource(uri);optLog.setRequestMethod(request.getMethod());optLog.setBeanName(beanName);optLog.setMethodName(methodName);optLog.setRequestParams(argsArrayToString(paramsArray));logThreadLocal.set(optLog);}@AfterReturning(returning = "result", pointcut = "pointcut()") public void doAfterReturning(Object result) {try {// 处理完请求，从线程变量中获取⽇志数据，并记录到dbOperationLog optLog = logThreadLocal.get();if (null != optLog) {optLog.setResponseData(JSON.toJSONString(result));eventPublisher.publish(new OperationLogEvent(this, optLog)); }} catch (Exception e) {log.error("***操作请求⽇志记录失败doAfterReturning()***", e); } finally {// 清除threadlocallogThreadLocal.remove();}}/*** 请求参数拼装** @param paramsArray* @return*/private String argsArrayToString(Object[] paramsArray) {String params = "";if (paramsArray != null && paramsArray.length > 0) {for (int i = 0; i < paramsArray.length; i++) {Object jsonObj = JSON.toJSON(paramsArray[i]);params += jsonObj.toString() + " ";}}return params.trim();}}测试结果：。
Java三大器之拦截器（Interceptor）的实现原理及代码示例
Java三⼤器之拦截器（Interceptor）的实现原理及代码⽰例1，拦截器的概念java⾥的拦截器是动态拦截Action调⽤的对象，它提供了⼀种机制可以使开发者在⼀个Action执⾏的前后执⾏⼀段代码，也可以在⼀个Action执⾏前阻⽌其执⾏，同时也提供了⼀种可以提取Action中可重⽤部分代码的⽅式。
在AOP中，拦截器⽤于在某个⽅法或者字段被访问之前，进⾏拦截然后再之前或者之后加⼊某些操作。
⽬前，我们需要掌握的主要是Spring的拦截器，Struts2的拦截器不⽤深究，知道即可。
2，拦截器的原理⼤部分时候，拦截器⽅法都是通过代理的⽅式来调⽤的。
Struts2的拦截器实现相对简单。
当请求到达Struts2的ServletDispatcher时，Struts2会查找配置⽂件，并根据配置实例化相对的拦截器对象，然后串成⼀个列表（List），最后⼀个⼀个的调⽤列表中的拦截器。
Struts2的拦截器是可插拔的，拦截器是AOP的⼀个实现。
Struts2拦截器栈就是将拦截器按⼀定的顺序连接成⼀条链。
在访问被拦截的⽅法或者字段时，Struts2拦截器链中的拦截器就会按照之前定义的顺序进⾏调⽤。
3，⾃定义拦截器的步骤第⼀步：⾃定义⼀个实现了Interceptor接⼝的类，或者继承抽象类AbstractInterceptor。
第⼆步：在配置⽂件中注册定义的拦截器。
第三步：在需要使⽤Action中引⽤上述定义的拦截器，为了⽅便也可以将拦截器定义为默认的拦截器，这样在不加特殊说明的情况下，所有的Action都被这个拦截器拦截。
4，过滤器与拦截器的区别过滤器可以简单的理解为“取你所想取”，过滤器关注的是web请求；拦截器可以简单的理解为“拒你所想拒”，拦截器关注的是⽅法调⽤，⽐如拦截敏感词汇。
4.1，拦截器是基于java反射机制来实现的，⽽过滤器是基于函数回调来实现的。
（有⼈说，拦截器是基于动态代理来实现的）4.2，拦截器不依赖servlet容器，过滤器依赖于servlet容器。
面试中怎么回答SpringIOC，AOP
⾯试中怎么回答SpringIOC，AOP你对spring的理解？答：spring最重要的两个机制就是IOC控制反转和AOP⾯向切⾯编程。
IOC容器获取对象是程序在加载xml配置⽂件时通过反射调⽤构造函数来创建对象（我们开始学就是在xml⾥配置的），讲到控制反转就要讲它的依赖注⼊模式，DI依赖注⼊是控制反转的⼀个具体例⼦，在xml⽂件中依赖注⼊机制是通过ref属性将其他bean放到当前bean对象，注⼊⽅式有通过配置xml⽂件注⼊和注解注⼊，在xml⽂件⾥注⼊：属性注⼊（property）、构造器注⼊（constructor-arg）、⾃动装配通过对bean的autowrite属性指定（byName、byType）注解注⼊：有autowrite、resource、component等@Autowired和@Resource两个注解的区别：1)、@Autowired默认按照byType⽅式进⾏bean匹配，@Resource默认按照byName⽅式进⾏bean匹配2)、@Autowired是Spring的注解，@Resource是J2EE的注解，IOC（控制反转），将类的创建和依赖关系写配置⽂件⾥，由配置⽂件注⼊，实现了松耦合。
传统的创建对象的⽅法是直接通过 new 关键字，⽽ spring 则是通过 IOC 容器来创建对象，也就是说我们将创建对象的控制权交给了 IOC 容器。
IOC 让程序员不再关注怎么去创建对象，⽽是关注与对象创建之后的操作，把对象的创建、初始化、销毁等⼯作交给spring容器来做。
（软件设计中的“耦合”指，两个功能函数之间的依赖程度。
⽐如，你设计的⼀个程序，需要你编写10个功能函数来实现。
如果这10个功能中，有9个功能都要调取第10个功能函数X10，那么，当你在修改X10时，你就要考虑修改完成后，是否会对其它9个功能函数有影响，为了查看是否有不好影响，你就要对其它9个功能函数，⼀个⼀个进⾏测试。
SpringAOP示例与实现原理总结——传统springaop、基于切面注入、基于@Asp。。。
SpringAOP⽰例与实现原理总结——传统springaop、基于切⾯注⼊、基于@Asp。
⼀、代码实践1）经典的Spring Aop经典的spring aop，是基于动态代理技术的。
实现⽅式上，最常⽤的是实现MethodInterceptor接⼝来提供环绕通知，创建若⼲代理，然后使⽤ProxyBeanFactory配置⼯⼚bean，⽣成拦截器链，完成拦截。
⽰例如下：1package demo.spring;23import org.aopalliance.intercept.MethodInterceptor;4import org.aopalliance.intercept.MethodInvocation;5import org.junit.Test;6import org.junit.runner.RunWith;7import org.springframework.beans.factory.annotation.Autowired;8import org.springframework.test.context.ContextConfiguration;9import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;1011 @RunWith(SpringJUnit4ClassRunner.class)12 @ContextConfiguration("classpath:spring-config.xml")13public class TraditionalSpringAopDemo {14 @Autowired15private Service proxy;1617 @Test18public void test() {19 proxy.execute("hello world!");20 }21 }2223interface Service {24void execute(String str);25 }2627class ServiceImpl implements Service {28 @Override29public void execute(String str) {30 System.out.println("execute invoke: " + str);31 }32 }3334class Interceptor1 implements MethodInterceptor {35 @Override36public Object invoke(MethodInvocation methodInvocation) throws Throwable {37 System.out.println("interceptor1,before invoke");38 Object ret = methodInvocation.proceed();39 System.out.println("interceptor1,after invoke");40return ret;41 }42 }4344class Interceptor2 implements MethodInterceptor {45 @Override46public Object invoke(MethodInvocation methodInvocation) throws Throwable {47 System.out.println("interceptor2,before invoke");48 Object ret = methodInvocation.proceed();49 System.out.println("interceptor2,after invoke");50return ret;51 }52 }xml⽂件配置：1<?xml version="1.0" encoding="UTF-8"?>2<beans xmlns="/schema/beans"3 xmlns:xsi="/2001/XMLSchema-instance"4 xmlns:context="/schema/context"5 xmlns:aop="/schema/aop"6 xsi:schemaLocation="/schema/beans /schema/beans/spring-beans.xsd /schema/context /schema/context/sprin 78<context:component-scan base-package="demo.spring"/>910<bean class="demo.spring.ServiceImpl" id="service"></bean>11<bean class="demo.spring.Interceptor1" id="interceptor1"></bean>12<bean class="demo.spring.Interceptor2" id="interceptor2"></bean>13<bean class="org.springframework.aop.framework.ProxyFactoryBean" id="proxy">14<property name="target" ref="service"/>15<property name="interceptorNames">16<list>17<value>interceptor1</value>18<value>interceptor2</value>19</list>20</property>21</bean>22</beans>结果：interceptor1,before invokeinterceptor2,before invokeexecute invoke: hello world!interceptor2,after invokeinterceptor1,after invoke可以看到拦截链的执⾏过程与拦截器顺序的关系。
SpringMVC目录结构配置
SpringMVC目录结构配置SpringMVC是一种常见的Java Web框架，它遵循MVC（Model-View-Controller）设计模式，用于构建灵活可扩展的Web应用程序。
SpringMVC的目录结构对于项目的开发和维护非常重要，下面会详细介绍SpringMVC的标准目录结构以及配置方式。
1.标准目录结构1.1 src/main/java：主要用于存放Java源代码。
1.2 src/main/resources：主要用于存放配置文件和资源文件。
1.3 src/main/webapp：主要用于存放Web应用的静态资源。
1.4 src/test/java：主要用于存放测试用例的Java源代码。
1.5 src/test/resources：主要用于存放测试用例的配置文件和资源文件。
2.详细解析2.1 src/main/java目录src/main/java目录是存放Java源代码的默认目录，它包括以下几个子目录：- config：用于存放Spring配置类，如配置数据库连接、配置事务管理等。
- interceptor：用于存放SpringMVC的拦截器。
- model：用于存放数据模型相关的实体类。
- util：用于存放工具类。
- web：用于存放SpringMVC的控制器。
2.2 src/main/resources目录src/main/resources目录是存放配置文件和资源文件的默认目录，它包括以下几个子目录：- static：用于存放静态资源文件，如CSS、JavaScript、图片等。
- templates：用于存放模板文件，如HTML、Thymeleaf模板等。
- application.properties：存放项目的配置信息，如数据库配置、端口配置等。
- logback.xml：存放日志配置，如日志级别、输出路径等。
- mapper：存放MyBatis的Mapper.xml文件。
spring、spring-mvc学习总结
Spring资料总结目录--------------------1.什么是spring2.Spring有什么特点?3.Spring的有哪些模块?各个模块的作用?4.控制反转(IOC)和依赖注入(DI)的区别?5.BeanFacotry对象的作用(IOC容器的作用)?6.使用FileSystemXmlApplicationContext,ClassPathXmlApplicationContext加载ApplicationContext.xml文件代码?7.BeanFactory跟ApplicationContext区别?8.依赖注入的四种方式(set,构造器,接口,注解)?9.Bean组件的作用域范围(singleton,prototype,request,session,globalsession)?10.Bean组件装配方式(byName,bType,constructor,default)?11.Bean组件的生命周期?12.在Web环境中怎么加载applicationContext.xml文件(Servlet监听器)?在web如何获取应用上下文WebApplicationContext?13.Spring对DAO模块支持?有什么优点?14.Spring的DAO模板增删查改数据代码?15.Spring对ORM模块的支持?有什么优点?16.Spring整合Hibernate模块的增删查改数据代码?17.Spring整合Ibatis模块的增删查改数据代码?18.Spring整合Mybatis模块的增删查改数据代码?19.Spring的全局事务(JTA)和局部事务(JDBC)的区别?20.Spring事务实现的方式有哪些,优缺点?21.编程式事务的特点?声明式事务的特点?22.事务7大传播属性?指定事务策略的格式代码?23.在Spring中事务管理器的实现方式有哪些?24.在Spring中事务管理器的实现方式有哪些?25.AOP的概念(切面,连接点,通知[顾问],切入点,[引入,关注点],目标对象,代理对象,织入目标)26.AOP在Spring中的作用?27.AOP中的通知有哪些?各有什么特点(前置型,后置型,环绕型,最终型,异常);28.AOP的特点和优缺点?29.AOP三种代理方式(动态代理,CGLIB代理,代理工厂bean)30.Execution配置的通用切入点的示例?31.在项目组,你们是如何使用AOP的?32.说说你对IOC的理解33.如何在Spring中使用JNDI的数据源?34.Spring如何整合Struts1.x?35.Spring如何整合Struts2.x?36.Spring如何整合Hibernate?37.Spring如何整合IBatis?38.Spring如何整合MyBatis?39.Spring的JDBC跟传统的JDBC的区别?41.Spring有哪些核心类?42.SpringMVC的工作机制?43.Hibernate中update和saveOrUpdate的区别?44.SpringMVC有哪些核心类,作用?45.SpringMVC数据如何校验,错误信息在页面如何呈现?46.SpringMVC注解标签有哪些?47.SpringMVC的特点(优点)?48.SpringMVC有哪些控制器组件?49.SpringMVC如何处理上传文件?如何使用ajax异步请求?50.Spring在视图中的标签有哪些?51.SpringAOP的注解标签有哪些?52.Spring如何配置连接池?53.连接池DBCP,C3P0,PROXOOL三个的区别---------------------------1.什么是Spring?答：Spring是一个开源的控制反转(Inversion of Control ,IoC)和面向切面(AOP aspect oriene program)的容器框架.它的主要目的是简化企业开发;Spring的设计思想是，单例模式和工厂模式;2.Spring有什么特点?答：轻量级,低侵入的设计Spring的DI机制降低了业务对象替换的复杂性Spring不依赖于web容器，独立于各种应用服务器，Write Once,Run Anywhere(一次编译到处运行)高度开放性:Spring并不完全依赖于Spring，开发者可自由选用Spring框架的部分或全部，它的架构仍然是内在稳定的3.Spring的有哪些模块?各个模块的作用?答：Spring Core：Spring的基石，提供了Spring的最主要的核心机制：控制反转和依赖注入Spring Context：提供了Spring的上下文信息，如：国际化，验证等Spring Web支持：简化了处理多部分请求Spring MVC框架支持：一个全功能的构建Web应用程序的MVC实现，MVC容纳了大量视图技术，其中包括JSP、Velocity等。
springboot拦截器执行两次的解决方案
springboot拦截器执⾏两次的解决⽅案springboot拦截器执⾏两次原因是：org.springframework.boot.autoconfigure.web.servlet.error.BasicErrorController.error也是⼀个controller路径为/error@Configurationpublic class MVCConfig extends WebMvcConfigurationSupport {//⾃定义的拦截器@Beanpublic SecurityInterceptor getSecurityInterceptor() {return new SecurityInterceptor();}@Overridepublic void addInterceptors(InterceptorRegistry registry) {//添加拦截器InterceptorRegistration registration = registry.addInterceptor(getSecurityInterceptor());//排除的路径registration.excludePathPatterns("/login");registration.excludePathPatterns("/logout");//将这个controller放⾏registration.excludePathPatterns("/error");//拦截全部registration.addPathPatterns("/**");}}Springboot拦截器原理根据当前请求，找到**HandlerExecutionChain**** 【可以处理请求的handler以及handler的所有拦截器】先来顺序执⾏所有拦截器的 preHandle⽅法如果当前拦截器prehandler返回为true。
Spring框架——AOP（面向切面编程）详解
Spring框架——AOP（⾯向切⾯编程）详解1 AOP概述●AOP(Aspect-Oriented Programming，⾯向切⾯编程)：是⼀种新的⽅法论，是对传统 OOP(Object-Oriented Programming，⾯向对象编程)的补充。
●AOP编程操作的主要对象是切⾯(aspect)，⽽切⾯模块化横切关注点。
●在应⽤AOP编程时，仍然需要定义公共功能，但可以明确的定义这个功能应⽤在哪⾥，以什么⽅式应⽤，并且不必修改受影响的类。
这样⼀来横切关注点就被模块化到特殊的类⾥——这样的类我们通常称之为“切⾯”。
●AOP的好处：○每个事物逻辑位于⼀个位置，代码不分散，便于维护和升级○业务模块更简洁，只包含核⼼业务代码2 AOP术语2.1 横切关注点 从每个⽅法中抽取出来的同⼀类⾮核⼼业务。
（抽离到⽅法中处理⾮核⼼业务）2.2 切⾯(Aspect) 封装横切关注点信息的类，每个关注点体现为⼀个通知⽅法。
2.3 通知(Advice) 切⾯必须要完成的各个具体⼯作2.4 ⽬标(Target) 被通知的对象2.5 代理(Proxy) 向⽬标对象应⽤通知之后创建的代理对象2.6 连接点(Joinpoint) 横切关注点在程序代码中的具体体现，对应程序执⾏的某个特定位置。
例如：类某个⽅法调⽤前、调⽤后、⽅法捕获到异常后等。
在应⽤程序中可以使⽤横纵两个坐标来定位⼀个具体的连接点：2.7 切⼊点(pointcut)： 定位连接点的⽅式。
每个类的⽅法中都包含多个连接点，所以连接点是类中客观存在的事物。
如果把连接点看作数据库中的记录，那么切⼊点就是查询条件——AOP可以通过切⼊点定位到特定的连接点。
切点通过org.springframework.aop.Pointcut 接⼝进⾏描述，它使⽤类和⽅法作为连接点的查询条件。
3 AspectJ3.1 简介AspectJ：Java社区⾥最完整最流⾏的AOP框架。
Spring的常见问题及答案
Spring的常见问题及答案⽬录Spring 概述依赖注⼊Spring beansSpring注解Spring数据访问Spring⾯向切⾯编程（AOP）Spring MVCSpring 概述1. 什么是spring?Spring 是个java企业级应⽤的开源开发框架。
Spring主要⽤来开发Java应⽤，但是有些扩展是针对构建J2EE平台的web应⽤。
Spring 框架⽬标是简化Java企业级应⽤开发，并通过POJO为基础的编程模型促进良好的编程习惯。
2. 使⽤Spring框架的好处是什么？轻量：Spring 是轻量的，基本的版本⼤约2MB。
控制反转：Spring通过控制反转实现了松散耦合，对象们给出它们的依赖，⽽不是创建或查找依赖的对象们。
⾯向切⾯的编程(AOP)：Spring⽀持⾯向切⾯的编程，并且把应⽤业务逻辑和系统服务分开。
容器：Spring 包含并管理应⽤中对象的⽣命周期和配置。
MVC框架：Spring的WEB框架是个精⼼设计的框架，是Web框架的⼀个很好的替代品。
事务管理：Spring 提供⼀个持续的事务管理接⼝，可以扩展到上⾄本地事务下⾄全局事务（JTA）。
异常处理：Spring 提供⽅便的API把具体技术相关的异常（⽐如由JDBC，Hibernate or JDO抛出的）转化为⼀致的unchecked 异常。
3. Spring由哪些模块组成 ?以下是Spring 框架的基本模块：Core moduleBean moduleContext moduleExpression Language moduleJDBC moduleORM moduleOXM moduleJava Messaging Service(JMS) moduleTransaction moduleWeb moduleWeb-Servlet moduleWeb-Struts moduleWeb-Portlet module4. 核⼼容器（应⽤上下⽂) 模块。