校招准备（九）：spring框架相关知识点

最新推荐文章于 2022-12-11 21:53:32 发布

qq_40493277

最新推荐文章于 2022-12-11 21:53:32 发布

阅读量1.2k

点赞数

分类专栏： java笔记

本文链接：https://blog.csdn.net/qq_40493277/article/details/102667379

版权

java笔记专栏收录该内容

14 篇文章 2 订阅

订阅专栏

2.spring框架知识点

2.1spring模块，讲讲你理解的spring，为什么使用spring，常用注解：

深入理解Spring4框架

Spring由20多个模块组成，它们可以分为核心容器（Core Container）、数据访问/集成（Data Access/Integration）、Web、面向切面编程（AOP, Aspect Oriented Programming）、设备（Instrumentation）、消息发送（Messaging）和测试（Test）。

4.1 核心容器
　　核心容器包含spring-core、spring-beans、spring-context、spring-context-support和spring-expression (Spring Expression Language，Spring表达式语音)这些模块。

　　spring-core和spring-beans构成了框架最基础的部分，包括控制反转和依赖注入功能。BeanFactory是工厂模式的一个很成熟的实现。

　　spring-context是基于spring-core和spring-beans构建的，它提供了一种以框架风格来访问对象的方式，类似于JNDI注册。ApplicationContext接口是spring-context的焦点。spring-context-support为集成第三方库（如定时器Quartz）提供支持。spring-expression提供了一种强大的表达式语言，可以在运行时查询和操作对象。

4.2 AOP和设备
　　spring-aop模块提供了一个AOP面向切面编程的实现。比如，允许开发者定义方法拦截器和切入点，以此来将业务逻辑和系统服务进行解耦。

　　spring-aspects模块提供与AspectJ的集成。

　　spring-instrument模块提供了在普通应用服务器中使用到的类设备支持和加载器实现。spring-instrument-tomcat模块包含了Spring的Tomcat设备代理。

4.3 消息发送
　　Spring 4包含了一个spring-messaging模块，它对Spring集成项目Message、MessageChannel和MessageHandler进行了重要的抽象，它是基于消息发送应用的基础。

4.4 数据访问/集成
　　数据访问/集成层包含JDBC（spring-jdbc）、ORM（spring-orm）、OXM（spring-oxm）、JMS（spring-jms）和事务（spring-tx）模块。

4.5 Web
　　Web层包含spring-web、spring-webmvc、spring-websocket和spring-webmvc-portlet模块。其中，spring-web提供了面向Web集成的基本特性，比如文件上传功能。Spring-webmvc模块包含了Spring的MVC和REST Web Service实现。Spring-webmvc-portlet模块提供了在Portlet环境下的MVC实现。

4.6 测试
　　Spring-test模块支持Spring组建JUnit和TestNG的单元测试和集成测试。

spring简化java开发。spring的核心就是通过控制反转（Inversion of Control）依赖注入（Dependency Injection）、面向切面编程aop（Aspect Oriented Programming）、和模版技术，解耦业务与系统服务，消除重复代码。借助aop，可以将遍布应用的关注点（如事物和安全）从它们的应用对象中解耦出来。

spring中，应用生存于spring容器中,spring 容器创建对象，装配它们，管理它们的整个生命周期。spring容器通过依赖注入，管理构成应用的组件，它会创建相互协作的组件之间的关联

在默认情况下， Spring应用上下文中所有bean都是作为以单例。

为什么使用spring：

它提供了一个Web应用程序的基本框架"，然后说它是工厂和容器，提供了IoC，

因为任何一个大型应用程序都包含很多组件（components），组件之间互相调用，并且在运行时并非所有组件都必须创建。如果没有一个整体的结构（框架），程序将会变得混乱、难以维护。假如不使用Spring，那么每次需要调用另一个组件的时候就new一个对象，或者getInstance得到一个实例。当组件越来越多，程序规模越来越大，这种方式会让组件之间的耦合度很高，难以维护。

Spring框架基于BeanFactory，把模块的配置信息（bean definition）统一管理起来（有的模块可以根据需要创建，若不调用则不创建），同时，还把模块的配置参数也统一管理（每个模块不必自己读配置参数，由Spring加载）。程序结构变清晰很多。在此基础上，加上依赖注入的功能，即Spring负责把模块依赖的其他模块推送（push）进来，而不是模块自己去拉取（pull），所以是一个"反转（IoC）"，进一步简化了大型应用程序开发。

Spring提供一个容器/工厂，统一管理模块的定义，根据需要创建。
把模块的配置参数统一管理，模块不需要自行读取配置。
Spring提供依赖注入，把依赖的模块自动推送进来，不需要模块自己拉取。
此外，Spring提供了对很多其他第三方框架的集成功能，减少了样板代码（boilerplate）

　Spring的IOC和AOP两大核心功能可以大大降低应用系统的耦合性、简化开发流程。

　　Spring框架技术可在不同层次上起作用，比如IOC管理普通的POJO对象、AOP增强了系统服务和其它组件（事务、MVC、JDBC、ORM和远程调用等）。Spring的一大特点就是基于接口编程，它是非侵入式的服务。用户端绑定接口使用JAVA EE服务，而非直接绑定服务，而且应用也可以使用不同的服务（Hibernate、MyBatis等）。我们可以根据自己的需要，使用Spring的一部分服务，而不必使用完整的Spring系列项目。

Spring有如下优点：
1.低侵入式设计，代码污染极低
2.独立于各种应用服务器，基于Spring框架的应用，可以真正实现Write Once,Run Anywhere的承诺
3.Spring的DI机制降低了业务对象替换的复杂性，提高了组件之间的解耦
4.Spring的AOP支持允许将一些通用任务如安全、事务、日志等进行集中式管理，从而提供了更好的复用
5.Spring的ORM和DAO提供了与第三方持久层框架的良好整合，并简化了底层的数据库访问
6.Spring并不强制应用完全依赖于Spring，开发者可自由选用Spring框架的部分或全部

2.2springioc依赖注入和aop原理、思想、优点？

依赖倒置原则，根据需求来
依赖注入：把底层类作为参数传入上层类，实现上层类对下层类的控制。

1、控制反转是应用于软件工程领域中的，在运行时被装配器对象来绑定耦合对象的一种编程技
巧，对象之间耦合关系在编译时通常是未知的。在传统的编程方式中，业务逻辑的流程是由应用
程序中的早已被设定好关联关系的对象来决定的。在使用控制反转的情况下，业务逻辑的流程是
由对象关系图来决定的，该对象关系图由装配器负责实例化，这种实现方式还可以将对象之间的
关联关系的定义抽象化。而绑定的过程是通过“依赖注入”实现的。
2、控制反转是一种以给予应用程序中目标组件更多控制为目的设计范式，并在我们的实际工作
中起到了有效的作用。
3、依赖注入是在编译阶段尚未知所需的功能是来自哪个的类的情况下，将其他对象所依赖的功
能对象实例化的模式。这就需要一种机制用来激活相应的组件以提供特定的功能，所以依赖注入
是控制反转的基础。否则如果在组件不受框架控制的情况下，框架又怎么知道要创建哪个组件？
4、在 Java 中依然注入有以下三种实现方式：
1.构造器注入
2.Setter 方法注入
3.接口注入

Spring 中的 org.springframework.beans 包和 org.springframework.context 包构成了
Spring 框架 IOC 容器的基础。
BeanFactory 接口提供了一个先进的配置机制，使得任何类型的对象的配置成为可能。
ApplicationContex 接口对 BeanFactory（是一个子接口）进行了扩展，在 BeanFactory 的基
础上添加了其他功能，比如与 Spring 的 AOP 更容易集成，也提供了处理 message resource
的机制（用于国际化）、事件传播以及应用层的特别配置，比如针对 Web 应用的
WebApplicationContext。

关于 Spring AOP (AspectJ) 你该知晓的一切

通知主要分5种类型，分别是前置通知@Before、后置通知@AfterReturning、异常通知@AfterThrowing、最终通知 @After以及环绕通知@Around，下面

5、BeanFactory 和 ApplicationContext 有什么区别？
BeanFactory 可以理解为含有 bean 集合的工厂类。BeanFactory 包含了种 bean 的定义，以
便在接收到客户端请求时将对应的 bean 实例化。
BeanFactory 还能在实例化对象的时生成协作类之间的关系。此举将 bean 自身与 bean 客户端
的配置中解放出来。BeanFactory 还包含了 bean 生命周期的控制，调用客户端的初始化方法
（initialization methods）和销毁方法（destruction methods）。
从表面上看，application context 如同 bean factory 一样具有 bean 定义、bean 关联关系的
设置，根据请求分发 bean 的功能。但 application context 在此基础上还提供了其他的功能。
1.提供了支持国际化的文本消息
2.统一的资源文件读取方式
3.已在监听器中注册的 bean 的事件
以下是三种较常见的 ApplicationContext 实现方式：
1、ClassPathXmlApplicationContext：从 classpath 的 XML 配置文件中读取上下文，并生成
上下文定义。应用程序上下文从程序环境变量中取得。
ApplicationContext context = new ClassPathXmlApplicationContext(“application.xml”);
2、FileSystemXmlApplicationContext ：由文件系统中的 XML 配置文件读取上下文。
ApplicationContext context = new FileSystemXmlApplicationContext(“application.xml”);
3、XmlWebApplicationContext：由 Web 应用的 XML 文件读取上下文。

2.3springbean的生命周期以及作用域：

https://blog.csdn.net/qq_40917230/article/details/80257892

spring中Bean的作用域
作用域   描述
singleton(单例)：   指一个 Bean 容器中只存在一份，context 只存在一份
prototype（原型）：   每次请求（每次使用）创建新的实例，destroy 方式不生效
request（请求）：   每次 http 请求创建一个实例且仅在当前 request 内有效
session（会话）：   （同上）在一次Http Session中，容器会返回该Bean的同一实例。而对不同的Session请求则会创建新的实例，该bean实例仅在当前Session内有效。
global Session：   基于 portlet 的 web 中有效（portlet 定义了 global session），如果是 web 中，同 session

五种作用域中，request、session和global session三种作用域仅在基于web的应用中使用（不必关心你所采用的是什么web应用框架），只能用在基于web的Spring ApplicationContext环境。

通过scope注解实现修改作用域：@Scope(ConfigurableListableBeanFactory.SCOPE_PROTOTYPE)

2.4spring实现事务：

想要使用事务的步骤为：
1、获取连接 Connection con = DriverManager.getConnection()
2、开启事务con.setAutoCommit(true/false);
3、执行CRUD
4、提交事务/回滚事务 con.commit() / con.rollback();
5、关闭连接 conn.close();
采用Spring 事务后，只需要关注第3步的实现，其他的步骤都是Spring 完成。
Spring事务的本质其实就是 AOP 和数据库事务，Spring 将数据库的事务操作提取为切面，通过AOP的方式增强事务方法。

2.5spring如何简化开发的？

2.6

在 Spring 框架中，在配置文件中设定 bean 的依赖关系是一个很好的机制，Spring 容器还可以
自动装配合作关系 bean 之间的关联关系。这意味着 Spring 可以通过向 Bean Factory 中注入
的方式自动搞定 bean 之间的依赖关系。自动装配可以设置在每个 bean 上，也可以设定在特定
的 bean 上。

使用@Autowired 注解来自动装配指定的
bean。

在 Spring 框架中共有 5 种自动装配，让我们逐一分析。
1.no：这是 Spring 框架的默认设置，在该设置下自动装配是关闭的，开发者需要自行在 bean
定义中用标签明确的设置依赖关系。
2.byName：该选项可以根据 bean 名称设置依赖关系。当向一个 bean 中自动装配一个属性时，
容器将根据 bean 的名称自动在在配置文件中查询一个匹配的 bean。如果找到的话，就装配这
个属性，如果没找到的话就报错。
3.byType：该选项可以根据 bean 类型设置依赖关系。当向一个 bean 中自动装配一个属性时，
容器将根据 bean 的类型自动在在配置文件中查询一个匹配的 bean。如果找到的话，就装配这
个属性，如果没找到的话就报错。
4.constructor：造器的自动装配和 byType 模式类似，但是仅仅适用于与有构造器相同参数的
bean，如果在容器中没有找到与构造器参数类型一致的 bean，那么将会抛出异常。
5.autodetect：该模式自动探测使用构造器自动装配或者 byType 自动装配。首先，首先会尝试
找合适的带参数的构造器，如果找到的话就是用构造器自动装配，如果在 bean 内部没有找到相
应的构造器或者是无参构造器，容器就会自动选择 byTpe 的自动装配方式。

2.7Spring中用了哪些设计模式

Spring 框架中使用到了大量的设计模式，下面列举了比较有代表性的：
1、代理模式—在 AOP 和 remoting 中被用的比较多。
2、单例模式：在 spring 配置文件中定义的 bean 默认为单例模式。
3、模板模式：用来解决代码重复的问题。
比如. RestTemplate, JmsTemplate, JpaTemplate。
4、委派模式：Spring 提供了 DispatcherServlet 来对请求进行分发。
5、工厂模式：BeanFactory 用来创建对象的实例，贯穿于 BeanFactory / ApplicationContext
接口的核心理念。
6、代理模式：AOP 思想的底层实现技术，Spring 中采用 JDK Proxy 和 CgLib 类库。

2.8spring常用注解：

基于@Value注解的自动装配以及properties文件读取@Value("${jdbc.url}") private String url;

//标注成员变量
@Autowired
private UserDao userDao;
//标注构造方法
@Autowired
public UserServiceImpl(UserDao userDao){
this.userDao=userDao;
}
//标注set方法
@Autowired
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}

与@Autowried具备相同功效的还有@Resource，默认按 byName模式自动注入,由J2EE提供，需导入Package: javax.annotation.Resource，可以标注在成员变量和set方法上，但无法标注构造函数。@Resource有两个中重要的属性：name和type。Spring容器对于@Resource注解的name属性解析为bean的名字，type属性则解析为bean的类型。因此使用name属性，则按byName模式的自动注入策略，如果使用type属性则按 byType模式自动注入策略。倘若既不指定name也不指定type属性，Spring容器将通过反射技术默认按byName模式注入。

//@Autowired标注成员变量
@Autowired
@Qualifier("userDao")
private UserDao userDao;
//上述代码等价于@Resource
@Resource(name=“userDao”)
private UserDao userDao;//用于成员变量

//也可以用于set方法标注
@Resource(name=“userDao”)
public void setUserDao(UserDao userDao) {
this.userDao= userDao;
}
@Scope注明作用域，value指明是哪种作用域，除了SingletonBean外，其它Bean还使用proxyMode指明哪种代理模式创建，这里没有接口，因此使用CGLib代理生成

3.springmvc

3.1springmvc架构的好处，如何处理多个请求

什么是mvc
MVC即Model-View-Controller，将应用按照Model（模型）、View（视图）、Controller（控制）这样的方式分离。

    视图(View)：代表用户交互界面，对于Web应用来说，可以是HTML，也可能是jsp、XML和Applet等。一个应用可能有很多不同的视图，MVC设计模式对于视图的处理仅限于视图上数据的采集和处理，以及用户的请求，而不包括在视图上的业务流程的处理。业务流程的处理交予模型(Model)处理。

    模型(Model)：是业务的处理以及业务规则的制定。模型接受视图请求的数据，并返回最终的处理结果。业务模型的设计是MVC最主要的核心。MVC设计模式告诉我们，把应用的模型按一定的规则抽取出来，抽取的层次很重要，抽象与具体不能隔得太远，也不能太近。MVC并没有提供模型的设计方法，而只是组织管理这些模型，以便于模型的重构和提高重用性。

    控制(Controller)：可以理解为从用户接收请求, 将模型与视图匹配在一起，共同完成用户的请求。划分控制层的作用也很明显，它清楚地告诉你，它就是一个分发器，选择什么样的模型，选择什么样的视图，可以完成什么样的用户请求。控制层并不做任何的数据处理。
springMVC中，一般Controller、service、DAO层的scope均是singleton；每个请求都是单独的线程,即使同时访问同一个Controller对象，因为并没有修改Controller对象，相当于针对Controller对象而言，只是读操作，没有写操作，不需要做同步处理。
这样每个request请求过来的时候，都调用同一个实例来处理。如果要保存状态可以使用threadlocal。

3.2为什么使用mvc
SpringMVC是一种基于Java，实现了Web MVC设计模式，请求驱动类型的轻量级Web框架，即使用了MVC架构模式的思想，将Web层进行职责解耦。基于请求驱动指的就是使用请求-响应模型，框架的目的就是帮助我们简化开发，SpringMVC也是要简化日常Web开发。（处理业务数据的对象和显示业务数据的视图之间存在紧密耦合）

3.3springmvc流程

【spring mvc】springmvc在tomcat中的执行过程

一、WEB容器在启动时，它会为每个WEB应用程序都创建一个对应的ServletContext对象（每个web应用程序唯一），它代表当前web应用web容器提供其一个全局的上下文环境，其为后面的spring IoC容器提供宿主环境；

二、读取web.xml

服务器软件或容器如（tomcat）加载项目中的web.xml文件，通过其中的各种配置来启动项目，只有其中配置的各项均无误时，项目才能正确启动。web.xml有多项标签，在其加载的过程中顺序依次为：context-param >> listener >> fileter >> servlet。（同类多个节点以出现顺序依次加载）
1、ServletContext创建后，通过启动WebApplicationContext的Servlet（org.springframework.web.context.ContextLoaderServlet）或Web容器监听器（org.springframework.web.context.ContextLoaderListener）触发初始化WebApplicationContext事件，这个就是spring的ioc容器；(application context的初始化过程，可参考：http://www.cnblogs.com/hantalk/p/6647772.html）
2、容器会读取context-param(springmvc中可以没有这个context-param，即WebApplicationContext不用配置具体数据)，spring以WebApplicationContext.ROOTWEBAPPLICATIONCONTEXTATTRIBUTE为属性Key，context-param为属性value对并存入servletContext；servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE,this.context);
3、读取listener创建监听，根据指定的类路径来实例化过滤器filter；
4、初始化web.xml中的dispatcherservlet

首先，利用WebApplicationContext.ROOTWEBAPPLICATIONCONTEXTATTRIBUTE从ServletContext中获取之前的WebApplicationContext作为自己上下文的parent上下文。
然后，读取/WEB-INF/[servlet名字]-servlet.xml文件，初始化自己持有的上下文。初始化完毕后，spring也将dispatcherservlet的上下文存到ServletContext中。
DispatcherServlet主要用作职责调度工作，本身主要用于控制流程，

SpringMVC从request到controller过程详解

DispatcherServlet这个类是整个SpringMVC的入口，在这个类之前做工作的其实是J2EE。首先一个WEB程序的入口其实是web.xml，一个请求过来，J2EE会先来这个文件中寻找合适的servlet-mapping，找到了就交给对应的Servlet处理。SpringMVC也需要在这里配一个Servlet，并且声明处理一些请求，简单点来说，我们都会让SpringMVC处理所有的请求，所以请求映射的地方就会写‘/*’，

这样配置一下，所有的请求就都会交给DispatcherServlet来处理了，也就是交给SpringMVC来处理了。1的过程就这么简单，想看代码实现的话可以翻翻Tomcat的代码。好，那接下来我们这篇文章重点，过程2和过程3的实现原理，也就是DispatcherServlet的处理过程。

DispatcherServlet是一个标准的Servlet

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进行渲染视图（即将模型数据填充至视图中）。
11、DispatcherServlet响应用户。

3.4springmvc全局异常处理：

3.5springmvc拦截器如何使用和实现原理：

SpirngMvc中的Interceptor主要是通过HandlerInterceptor和WebRequestInterceptor来实现，

HandlerInterceptor主要是下面三个方法：

public interface HandlerInterceptor {
    boolean preHandle(HttpServletRequest var1, HttpServletResponse var2, Object var3) throws Exception;

    void postHandle(HttpServletRequest var1, HttpServletResponse var2, Object var3, ModelAndView var4) throws Exception;

    void afterCompletion(HttpServletRequest var1, HttpServletResponse var2, Object var3, Exception var4) throws Exception;
}

//WebRequestInterceptor
void preHandle(WebRequest request) throws Exception;
void postHandle(WebRequest request, ModelMap model) throws Exception;
void afterCompletion(WebRequest request, Exception ex) throws Exception;

（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 渲染了对应的视图之后执行。这个方法的主要作用是用于进行资源清理工作的。

不同点

WebRequestInterceptor的入参WebRequest是包装了HttpServletRequest 和HttpServletResponse的，通过WebRequest获取Request中的信息更简便。
2.WebRequestInterceptor的preHandle是没有返回值的，说明该方法中的逻辑并不影响后续的方法执行，所以这个接口实现就是为了获取Request中的信息，或者预设一些参数供后续流程使用。
3.HandlerInterceptor的功能更强大也更基础，可以在preHandle方法中就直接拒绝请求进入controller方法。

拦截器与过滤器的区别：

过滤器：依赖于servlet容器。在实现上基于函数回调，可以对几乎所有请求进行过滤，但是缺点是一个过滤器实例只能在容器初始化时调用一次。使用过滤器的目的是用来做一些过滤操作，获取我们想要获取的数据，比如：在过滤器中修改字符编码；在过滤器中修改HttpServletRequest的一些参数，包括：过滤低俗文字、危险字符等。

拦截器：依赖于web框架，在SpringMVC中就是依赖于SpringMVC框架。在实现上基于Java的反射机制，属于面向切面编程（AOP）的一种运用。由于拦截器是基于web框架的调用，因此可以使用spring的依赖注入（DI）进行一些业务操作，同时一个拦截器实例在一个controller生命周期之内可以多次调用。但是缺点是只能对controller请求进行拦截，对其他的一些比如直接访问静态资源的请求则没办法进行拦截处理。
springmvc拦截器使用和原理理解

3.6SpringMVC构建全局异常处理器

在开发中，不管是dao层、service层还是controller层，都有可能抛出异常，在springmvc中，能将所有类型的异常处理从各处理过程解耦出来，既保证了相关处理过程的功能较单一，也实现了异常信息的统一处理和维护。

SpringMVC提供全局异常处理器进行统一的异常处理，一个系统只能有一个异常处理器。

系统的dao、service、controller层出现异常的时候都throws Exception向上抛，最后由SpringMVC前端控制器交由异常处理器进行异常处理（对异常进行包装处理）。如下如所示：

在这里插入图片描述

如上图所示，如果没有全局异常处理器，不管是dao层、Service层还是Controller层出现异常时，会直接将异常信息返回到客户端，而这些异常信息不经过包装，可能会包含项目的包名、SQL查询语句、数据库的IP信息等，这将会造成严重的安全隐患。恶意用户可以通过发送不正确的查询语句时，从异常信息中提取可以危害到服务端安全的信息，造成服务端出现安全威胁。

因此我们需要统一的异常处理器，在异常信息返回客户端之前，对异常信息进行包装，展示必要的信息。异常处理器的功能就是对异常信息进行重新包装，再返回给SpringMVC前端控制器。

4.springboot

4.1springboot如何做到的简化配置？

4.2如何实现starter

4.3

5.mybatis

拦截器原理，不使用dofilter会怎样？
什么时候使用事务，只有读用事务吗？
只有运行时异常才会使当前事务回滚。

看完让你彻底理解 WebSocket 原理：

WebSocket是HTML5出的东西（协议），也就是说HTTP协议没有变化。是一个新协议，跟HTTP协议基本没有关系，只是为了兼容现有浏览器的握手规范而已（websocket与http）

另外Html5是指的一系列新的API，或者说新规范，新技术。Http协议本身只有1.0和1.1，而且跟Html本身没有直接关系。。通俗来说，你可以用HTTP协议传输非Html数据。

首先 WebSocket 是基于 HTTP 协议的，或者说借用了 HTTP 协议来完成一部分握手。

WebSocket 的其他特点：

建立在 TCP 协议之上，服务器端的实现比较容易。
与 HTTP 协议有着良好的兼容性。默认端口也是80和443，并且握手阶段采用 HTTP 协议，因此握手时不容易屏蔽，能通过各种 HTTP 代理服务器。
数据格式比较轻量，性能开销小，通信高效。
可以发送文本，也可以发送二进制数据。
没有同源限制，客户端可以与任意服务器通信。
协议标识符是ws（如果加密，则为wss），服务器网址就是 URL。

Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议。

而 WebSocket 则不同，它是一个完整的应用层协议，包含一套标准的 API 。

SpringBoot2.0集成WebSocket，实现后台向前端推送信息

Spring Boot整合websocket实现群聊，点对点聊天

qq_40493277

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
1
评论
校招准备（九）：spring框架相关知识点

2.spring框架知识点2.1spring模块，讲讲你理解的spring，为什么使用spring，常用注解：深入理解Spring4框架Spring由20多个模块组成，它们可以分为核心容器（Core Container）、数据访问/集成（Data Access/Integration）、Web、面向切面编程（AOP, Aspect Oriented Programming）、设备（...
复制链接

扫一扫