拦截器和过滤器的区别以及AOP概念
项目中aop的使用
项目中aop的使用项目中AOP的使用AOP（面向切面编程）是一种编程范式，用于解耦和提高代码的可维护性。
在一个项目中，AOP可以用于处理一些横切关注点，如日志记录、性能监控、事务管理等。
1.AOP的工作原理AOP的实现机制是通过动态代理或者字节码增强来实现的。
在项目中，一般使用动态代理来生成代理对象，并在横切逻辑执行时插入额外的逻辑。
2.AOP的核心概念在AOP中，有以下几个核心概念：- 切面（Aspect）：负责定义横切关注点的逻辑和处理行为。
- 连接点（Join point）：在程序执行过程中可以插入切面的地点，例如方法的调用、异常抛出等。
- 切点（Pointcut）：用于定义连接点的集合。
- 通知（Advice）：横切逻辑的具体实现代码，如在方法调用前后执行的代码。
- 目标对象（Target）：被代理的对象。
- 织入（Weaving）：将切面织入到目标对象中的过程。
3.使用场景AOP在项目中有很多应用场景，下面列举几个常见的场景：-日志记录：在方法的调用前后打印日志，用于系统的调试和运行时记录。
-安全性检查：在方法的调用前进行权限检查，以防止非法访问。
-性能监控：在方法的调用前后记录方法的执行时间，用于分析和优化系统性能。
-事务管理：在方法的调用前后进行事务的开启和提交/回滚，保证数据的一致性和完整性。
-异常处理：在方法执行时自动捕获异常并进行处理，如抛出错误信息或者进行补偿操作。
4.AOP的实现方式在项目中，可以使用不同的技术来实现AOP，例如：-基于注解的AOP：通过在目标方法上添加注解，使用注解解析器来解析注解并执行相应逻辑。
-基于XML配置的AOP：通过在XML配置文件中定义切面、切点和通知，使用AOP框架来实现切面织入。
-基于拦截器的AOP：通过定义拦截器，在方法执行前后进行拦截和处理。
5.AOP框架的选择在项目中，可以选择合适的AOP框架来实现AOP的功能。
常见的AOP 框架包括Spring AOP、AspectJ、JBoss AOP等。
SpringBoot使用过滤器、拦截器、切面（AOP），及其之间的区别和执行顺序
SpringBoot使⽤过滤器、拦截器、切⾯（AOP），及其之间的区别和执⾏顺序先上代码，下⾯的demo中包含多个拦截器、过滤器，以及切⾯的前置通知/后置通知/环绕通知：下⾯总结⼀下相关原理：⾸先了解⼀下SpringMVC的执⾏流程具体流程如下1. ⽤户发起请求到前端控制器（Controller）2. 前端控制器没有处理业务逻辑的能⼒，需要找到具体的模型对象处理（Handler），到处理器映射器（HandlerMapping）中查找Handler对象（Model）。
3. HandlerMapping返回执⾏链，包含了2部分内容：① Handler对象、②拦截器数组4. 前端处理器通过处理器适配器包装后执⾏Handler对象。
5. 处理业务逻辑。
6. Handler处理完业务逻辑，返回ModelAndView对象，其中view是视图名称，不是真正的视图对象。
7. 将ModelAndView返回给前端控制器。
8. 视图解析器（ViewResolver）返回真正的视图对象（View）。
9. （此时前端控制器中既有视图⼜有Model对象数据）前端控制器根据模型数据和视图对象，进⾏视图渲染。
10. 返回渲染后的视图（html/json/xml）返回。
11. 给⽤户产⽣响应。
核⼼就是DispatcherServlet核⼼控制器，我们看源码可知道DispatcherServlet是Servlet的⼦类下⾯⽤⼀张图说⼀下过滤器、Servlet容器、拦截器、AOP、Controller之间的关系然后具体执⾏流程如下：拦截器和过滤器的区别1、拦截器不依赖与servlet容器是SpringMVC⾃带的，过滤器依赖于Servlet容器。
2、拦截器是基于java的反射机制的，⽽过滤器是基于函数回调。
3、拦截器只能对action请求起作⽤，⽽过滤器则可以对⼏乎所有的请求起作⽤。
4、拦截器可以访问controller上下⽂、值栈⾥的对象，⽽过滤器不能访问。
.NETCore过滤器和拦截器
.NETCore过滤器和拦截器
拦截器Filter 共有五种 Authorization Fileter、Resource Fileter、 Exception Filter 、Action Filter、 Result Filter
Exception Filter 当出现异常时进⼊此⽅法，可在这针对不同的异常做相关处理并返回指定数据，避免直接把错误暴露给⽤户
Action Filter 设置
在⽅法前后会跳转到OnActionExecuted和OnActionExecuting两个⽅法，⽅便追踪接⼝执⾏情况
Authonization Filter
权限控制过滤器通过Authonization Filter 可以实现复杂的权限⾓⾊认证、登录授权等操作
Resource Filter 进⾏资源缓存、防盗链等操作。
Result Filter
结果过滤器，可以对结果进⾏格式化、⼤⼩写转换等⼀系列操作。
使⽤Result Filter 需要实现 IResult 抽象接⼝，接⼝要求实现
OnResultExecuting ⽅法和OnResultExecuted ⽅法
AOP 拦截器即动态代理
C# 中可以⽤来做AOP 的开源类库有若⼲个，⽐较流⾏的： Castle DynamicProxy 、 Fody、Mono。
Cecil
这些类库之所以能够实现AOP是因为他们有动态修改IL代码的能⼒，这种能⼒⼜被称为IL weaving。
还有的类库把AOP和Dependency Injection 结合在了⼀起，通过服务器上注册⼀个拦截器（Interceptor）的⽅式达到AOP的⽬的，例如：
Castle Windsor
Autofac。
JAVAWEB面试题（含答案）
1、jsp和servlet的区别、共同点、各自应用的范围？？JSP是Servlet技术的扩展，本质上就是Servlet的简易方式。
JSP编译后是“类servlet”。
Servlet和JSP最主要的不同点在于，Servlet的应用逻辑是在Java文件中，并且完全从表示层中的HTML里分离开来。
而JSP的情况是Java和HTML可以组合成一个扩展名为.jsp的文件。
JSP侧重于视图，Servlet主要用于控制逻辑。
在struts框架中,JSP位于MVC设计模式的视图层,而Servlet位于控制层.2、cookie和session的作用、区别、应用范围，session的工作原理Cookie:主要用在保存客户端，其值在客户端与服务端之间传送，不安全，存储的数据量有限。
Session:保存在服务端，每一个session在服务端有一个sessionID作一个标识。
存储的数据量大，安全性高。
占用服务端的内存资源。
3、jstl是什么？优点有哪些？？JSTL（JSP Standard Tag Library，JSP标准标签库)是一个不断完善的开放源代码的JSP标签库，由四个定制标记库（core、format、xml和sql）和一对通用标记库验证器（ScriptFreeTLV和PermittedTaglibsTLV）组成。
优点有：最大程序地提高了WEB应用在各应用服务器在应用程序服务器之间提供了一致的接口，最大程序地提高了1、在应用程序服务器之间提供了一致的接口，之间的移植。
2、简化了JSP和WEB应用程序的开发。
3、以一种统一的方式减少了JSP中的scriptlet代码数量，可以达到没有任何scriptlet 代码的程序。
在我们公司的项目中是不允许有任何的scriptlet代码出现在JSP中。
4、允许JSP设计工具与WEB应用程序开发的进一步集成。
相信不久就会有支持JSTL的IDE 开发工具出现。
4、j2ee的优越性主要表现在哪些方面？MVC模式a、J2EE基于JAVA技术，与平台无关b、J2EE拥有开放标准，许多大型公司实现了对该规范支持的应用服务器。
javaweb中监听器、过滤器、拦截器以及AOP的先后顺序和理解
javaweb中监听器、过滤器、拦截器以及AOP的先后顺序和理解java web三⼤器：过滤器、拦截器、监听器（spring框架）spring、springMVC与springBoot的关系详见：⼀、启动顺序监听器---》过滤器---》拦截器案例理解：接到上级命令，要求对电话进去监听，过滤出恐怖分⼦，然后，拦截他们的恐怖袭击⾏动。
配置位置：监听器、过滤器⼀般配置在web.xml中，拦截器⼀般配置在springmvc.xml配置⽂件中⼆、概念监听器：Servlet的监听器Listener，它是实现了javax.servlet.ServletContextListener接⼝的服务器端程序，它也是随web应⽤的启动⽽启动，只初始化⼀次，随web应⽤的停⽌⽽销毁。
主要作⽤是：做⼀些初始化的内容添加⼯作、设置⼀些基本的内容、⽐如⼀些参数或者是⼀些固定的对象等等Filter过滤器：过滤器拦截web访问url地址。
严格意义上讲，filter只是适⽤于web中，依赖于Servlet容器，利⽤Java的回调机制进⾏实现。
Filter过滤器：和框架⽆关，可以控制最初的http请求，但是更细⼀点的类和⽅法控制不了。
过滤器可以拦截到⽅法的请求和响应(ServletRequest request, ServletResponse response)，并对请求响应做出像响应的过滤操作，⽐如设置字符编码，鉴权操作等⽐如：（不是login.do的地址请求，如果⽤户没有登陆都过滤掉）,或者在传⼊servlet或者struts的action前统⼀设置字符集，或者去除掉⼀些⾮法字符。
主要为了减轻服务器负载，减少压⼒。
Interceptor拦截器：拦截器拦截以 .action结尾的url，拦截Action的访问。
Interfactor是基于Java的反射机制（APO思想）进⾏实现，不依赖Servlet容器。
拦截器可以在⽅法执⾏之前(preHandle)和⽅法执⾏之后(afterCompletion)进⾏操作，回调操作(postHandle)，可以获取执⾏的⽅法的名称，请求(HttpServletRequest)Interceptor：可以控制请求的控制器和⽅法，但控制不了请求⽅法⾥的参数(只能获取参数的名称，不能获取到参数的值)（⽤于处理页⾯提交的请求响应并进⾏处理，例如做国际化，做主题更换，过滤等）。
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容器。
过滤器、拦截器应用场景、区别和使用
过滤器、拦截器应⽤场景、区别和使⽤
应⽤场景
过滤器的应⽤：字符编码转换，敏感词过滤、登陆权限验证、资源访问权限等
拦截器的应⽤：AOP、需要有⼀些业务逻辑（需要注⼊Bean等）
区别
1. 过滤器配置再web.xml中、拦截器配置springmvc的配置⽂件中（即在DispatcherServlet的contextConfigLocation属性指定⽂件所在位
置，默认加载的是：/WEB-INF/servlet名称-servlet.xml(springmvc-servlet.xml)）
2. 过滤器基于函数回调、拦截器基于反射
3. 过滤器⼏乎对所有请求起作⽤，拦截器只对⽬标执⾏⽅法（action⽅法）起作⽤
4. 过滤器：对请求进⾏预处理、再交给Servlet处理并且⽣成响应，最后Filter再对服务器响应进⾏后处理
拦截器：可以再⽅法执⾏前调⽤（preHandle）、⽅法执⾏后（postHandle）、视图页⾯渲染后（afterCompletion）
执⾏流程
过滤器初始化-》（客户端请求过来）dofilter处理请求-》到达dispatchServlet，在⽬标⽅法执⾏前preHandle-》（放⾏，返回true）执⾏⽬标⽅法-》（正常返回，异常则不执⾏）postHandle-》（⽆论⽬标⽅法是否执⾏或者执⾏是否出现异常，都会执⾏）afterCompletion-》dofilter 处理响应-》客户端加载页⾯。
AOP事务管理的原理与及三种实现方式
AOP事务管理的原理与及三种实现方式AOP（Aspect-Oriented Programming）即面向切面编程，是一种软件开发方法，主要用于解决分散在一个应用程序中的横切关注点（cross-cutting concerns）问题。
事务管理是AOP的一个典型应用场景，它主要用于保证一系列操作的原子性、一致性和隔离性。
本文将详细介绍AOP事务管理的原理以及三种常见的实现方式。
一、AOP事务管理原理1.拦截器执行顺序首先，AOP框架通过拦截器机制，将事务相关的拦截器按照一定的顺序进行执行。
常见的拦截器有前置拦截器（Before）、后置拦截器（After）、异常拦截器（AfterThrowing）、返回拦截器（AfterReturning）等。
2.事务传播和隔离级别在方法级别的事务管理中，每个被拦截的方法可以有不同的事务传播行为和隔离级别。
事务传播行为指的是当一个方法调用另外一个方法时，如何处理事务；隔离级别指的是事务之间的隔离程度。
3.事务切面的应用通过拦截器机制，将事务注解或者配置文件中的事务属性传递给事务管理器，然后由事务管理器根据事务属性进行事务操作。
实际应用中，可以使用Spring框架提供的AOP事务管理功能来实现对方法级别的事务控制。
根据AOP事务管理的原理，常见的AOP事务管理的实现方式有基于注解的方式、基于XML配置的方式和基于编程的方式。
1.基于注解的方式优点：（1）简单方便，只需在方法上加上注解即可进行事务管理。
（2）灵活可控，通过注解可以更细粒度地控制事务的传播行为和隔离级别。
（3）清晰明了，注解能够直观地体现出事务的特性。
缺点：（1）侵入性较强，需要在代码中添加注解。
（2）不能对第三方库中的方法进行事务管理。
2.基于XML配置的方式基于XML配置的方式是通过在配置文件中定义事务管理器、事务通知以及切点表达式等信息，来实现对方法级别的事务控制。
通过AOP框架读取配置文件，将事务相关的信息应用到需要进行事务管理的方法上。
Spring面试题（超详细，2021收集，答案简短好背）
Spring⾯试题（超详细，2021收集，答案简短好背）1.restcontroller 和controller有什么区别？答：restcontroller=controller+@resposebody2.controller是单例的吗？答：默认是的。
scope可设置成多例，作⽤域：singleton（单例）、prototype（多例）3.过滤器拦截器有什么区别？答：过滤器依赖servlet容器，基于函数回调实现，在容器初始化时调⽤⼀次，⼏乎可以过滤所有资源包括静态⽂件。
拦截器基于web框架⽐如springmvc，基于反射实现运⽤aop，可以多次调⽤，但只能拦截controller，⽆法拦截静态⽂件。
4.spring bean的⽣命周期？答：加载bean定义、bean⼯⼚处理器、实例化、属性赋值、aware接⼝扩展、beanpost前置处理器、初始化、beanpost后置处理器-bean的使⽤销毁5.spring bean的初始化怎么做？答：1.配置init-method @Bean(init-method="xx") 2.实现InitializingBean⽅法afterPropertiesSet，3。
加@PostConstruct 顺序：postConstruct>afterPropertiesSet>init-method6.简单说下IOC和AOP？答：ioc就是权限控制反转，创建对象交给spring容器来做，便于管理。
aop就是⾯向切⾯编程，它通过动态代理为spring对象增加功能。
⽐如增加⽇志切⾯，spirng的事务以及拦截器都是运⽤了aop。
7.spring的动态代理⽤哪种实现？答：spring默认是采⽤jdk的动态代理，如果想要⽤cglib可以通过配置⽂件的⽅式指定。
8.jdk代理和cglib代理有什么区别？答：jdk代理利⽤反射对实现接⼝的类⽣成代理，⽽cglib则利⽤字节码技术⽣成⼀个⼦类。
过滤器（Filter）和拦截器（Interceptor）的执行顺序和区别
过滤器（Filter）和拦截器（Interceptor）的执⾏顺序和区别⽬录⾸先建⽴⼀个SpringBoot⼯程，增加⼀个IndexController供测试使⽤。
@Controllerpublic class IndexController {@GetMapping("/hello")@ResponseBodypublic String index(){return "hello";}}过滤器 Filter过滤器（ Filter），是 JavaEE 的标准，依赖于 Servlet 容器，使⽤的时候是配置在 SpringMVC 框架中是配置在web.xml ⽂件中的，可以配置多个，执⾏的顺序是根据配置顺序从上到下。
在 SpringBoot 项⽬中也可以采⽤注解的形式实现。
Servlet中的过滤器Filter是实现了javax.servlet.Filter接⼝的服务器端程序，主要的⽤途是设置字符集、控制权限、控制转向、做⼀些业务逻辑判断等。
其⼯作原理是，只要你在web.xml⽂件配置好要拦截的客户端请求，它都会帮你拦截到请求，此时你就可以对请求或响应(Request、Response)统⼀配置请求编码以及过滤⼀些⾮法参数，垃圾信息，简化操作；同时还可进⾏逻辑判断，如⽤户是否已经登陆、有没有权限访问该页⾯等等⼯作。
它是随你的web应⽤启动⽽启动的，只初始化⼀次，以后就可以拦截相关请求，只有当你的web应⽤停⽌或重新部署的时候才销毁。
Filter可以认为是Servlet的⼀种“加强版”，它主要⽤于对⽤户请求进⾏预处理，也可以对HttpServletResponse进⾏后处理，是个典型的处理链。
Filter也可以对⽤户请求⽣成响应，这⼀点与Servlet相同，但实际上很少会使⽤Filter向⽤户请求⽣成响应。
使⽤Filter完整的流程是：Filter对⽤户请求进⾏预处理，接着将请求交给Servlet进⾏处理并⽣成响应，最后Filter再对服务器响应进⾏后处理。
过滤器，拦截器，aop区别与使用场景
过滤器，拦截器，aop区别与使⽤场景1. 什么是过滤器过滤器，顾名思义就是起到过滤筛选作⽤的⼀种事物，只不过相较于现实⽣活中的过滤器，这⾥的过滤器过滤的对象是客户端访问的web资源，也可以理解为⼀种预处理⼿段，对资源进⾏拦截后，将其中我们认为的杂质（⽤户⾃⼰定义的）过滤，符合条件的放⾏，不符合的则拦截下来。
1.1 过滤器常见使⽤场景统⼀设置编码过滤敏感字符登录校验URL级别的访问权限控制数据压缩1.2 springboot整合过滤器bean注⼊⽅式a) 编写Filterpublic class HeFilter implements Filter {@Overridepublic void init(FilterConfig filterConfig) throws ServletException {}@Overridepublic void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)throws IOException, ServletException {System.out.println("您已进⼊filter过滤器，您的请求正常，请继续遵规则...");chain.doFilter(request, response);}@Overridepublic void destroy() {}}b) 编写Filter配置类@Configurationpublic class ServletConfig {@Beanpublic FilterRegistrationBean heFilterRegistration() {FilterRegistrationBean registration = new FilterRegistrationBean(new HeFilter());registration.addUrlPatterns("/*");return registration;}}注解⽅式@Slf4j@Component// filterName就是当前类名称，还有⼀个urlPattens的参数，这个参数表⽰要过滤的URL上的后缀名，是多参数，可以⽤数组表⽰。
详解SpringBootAOP拦截器（Aspect注解方式）
详解SpringBootAOP拦截器（Aspect注解⽅式）常⽤⽤于实现拦截的有：Filter、HandlerInterceptor、MethodInterceptor第⼀种Filter属于Servlet提供的，后两者是spring提供的，HandlerInterceptor属于Spring MVC项⽬提供的，⽤来拦截请求，在MethodInterceptor之前执⾏。
实现⼀个HandlerInterceptor可以实现接⼝HandlerInterceptor，也可以继承HandlerInterceptorAdapter类，两种⽅法⼀样。
这个不在本⽂范围，具体使⽤之前已经写过SpringBoot的（SpringMVC的使⽤⼀样，区别只是配置）MethodInterceptor是AOP项⽬中的拦截器，它拦截的⽬标是⽅法，即使不是Controller中的⽅法。
实现MethodInterceptor拦截器⼤致也分为两种，⼀种是实现MethodInterceptor接⼝，另⼀种利⽤Aspect的注解或配置。
关于实现MethodInterceptor接⼝的这种⽅法，还需要在配置⽂件中做配置，在SpringMVC中使⽤还可以，在SpringBoot中使⽤起来似乎没有那么⽅便。
本⽂主要还是说Aspect注解⽅式，个⼈觉得这种⽅法才⽐较灵活，与配置与⼯程整个代码都没有耦合（你添加⼀个类，做⼏个注解就可以⽤了，⽆需在其他地⽅再做什么），更易应⽤。
⾸先为你的SpringBoot项⽬添加maven依赖，让其⽀持aop（其实就是⾃动引⼊aop需要的⼀些jar）在pom.xml中添加依赖：<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-aop</artifactId></dependency>然后创建Aspect测试类：package com.shanhy.sboot.aop;import ng.JoinPoint;import ng.annotation.After;import ng.annotation.Aspect;import ng.annotation.Before;import org.springframework.core.annotation.Order;import ponent;@Aspect // FOR AOP@Order(-99) // 控制多个Aspect的执⾏顺序，越⼩越先执⾏@Componentpublic class TestAspect {@Before("@annotation(test)")// 拦截被TestAnnotation注解的⽅法；如果你需要拦截指定package指定规则名称的⽅法，可以使⽤表达式execution(...)，具体百度⼀下资料⼀⼤堆 public void beforeTest(JoinPoint point, TestAnnotation test) throws Throwable {System.out.println("beforeTest:" + ());}@After("@annotation(test)")public void afterTest(JoinPoint point, TestAnnotation test) {System.out.println("afterTest:" + ());}}这样就完成了，然后创建⼀个Controller验证⼀下：@RestController@RequestMapping("/test")public class TestController {@TestAnnotation(name="abc")@RequestMapping("/show")public String show() {return "OK";}@RequestMapping("/show2")public String show2() {return "OK2";}}此时我们访问show请求，就会被拦截，控制台会打印输出。
java面试题框架篇
java面试题框架篇1.Spring框架1.1Spring两大核心：IOC与AOPIOCIOC全称Inversion of Control，即“控制反转”，这是一种设计思想。
对象创建的权利由Spring框架完成，由容器管理对象的生命周期。
1.原来的对象的创建都是由用户自己手动创建,这样的方式耦合性肯定高，如果类发生了变化,则代码都得修改。
2.现在所有的对象都交给Spring容器管理，用户无需关心对象是如何实例化，容器负责对象的注入即可，以后几乎不用修改任何代码，降低了代码的耦合性。
spring容器怎么创建bean对象？spring容器，这个容器指的就是ConCurrentHashMap。
Spring的IOC有三种注入方式：构造器注入, setter方法注入, 根据注解注入。
DIDI的意思是依赖注入，和控制反转是同一个概念的不同角度的描述，即应用程序在运行时依赖IOC容器来动态注入对象需要的外部资源。
注入方式1.set方式注入2.构造方法注入3.基于配置文件注入<bean id ="c"class="cn.spring.Cat"/><bean id ="dog"class="cn.spring.Dog"><property name ="token" value ="111"/><constructor-arg name ="cat" ref ="c"/></bean>4.基于注解开发@Resource@AutowiredAOPAOP(Aspect Oriented Programming)意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。
AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。
aop拦截private方法
aop拦截private方法AOP拦截private方法AOP（Aspect Oriented Programming）是一种编程思想，可以在程序运行过程中动态地将一些公共的行为注入到目标方法中。
AOP可以通过拦截器（Interceptor）来实现对方法的拦截和处理。
在一般的情况下，AOP只能拦截public方法，但是有时我们也希望能够拦截private方法。
本文将介绍如何使用AOP来拦截private方法。
一、AOP简介AOP是一种编程范式，它的核心思想是将系统功能分为核心功能和横切功能。
核心功能指的是系统的主要业务逻辑，而横切功能指的是与核心功能无关但是又需要在核心功能上进行拓展的功能。
AOP 通过将横切功能与核心功能解耦，使得系统的代码更加清晰、易于维护。
二、AOP的实现原理AOP的实现原理是通过动态代理实现的。
在Java中，动态代理可以通过Java自带的Proxy类和第三方库如CGLIB来实现。
在AOP中，我们可以通过动态代理技术来在方法调用前后插入额外的逻辑，从而实现方法的拦截和处理。
三、拦截private方法的实现由于private方法无法直接被外部调用，所以我们无法直接对其进行拦截和处理。
但是，我们可以通过反射技术来绕过private修饰符的限制，从而实现对private方法的拦截。
1. 首先，我们需要获取目标类的Class对象。
可以通过Class.forName()方法或者目标类的实例对象的getClass()方法来获取。
2. 然后，我们可以通过Class对象的getDeclaredMethod()方法来获取目标类中的private方法。
该方法可以接受方法名和参数类型作为参数，返回一个Method对象。
3. 接下来，我们可以通过Method对象的setAccessible()方法来设置private方法的可访问性。
4. 最后，我们可以通过Method对象的invoke()方法来调用private方法，并在调用前后插入额外的逻辑。
java开发框架面试题整理
Java开发框架面试Struts2热点面试题？1. 简述Struts2 的工作流程:①. 请求发送给StrutsPrepareAndExecuteFilter②. StrutsPrepareAndExecuteFilter 判定该请求是否是一个Struts2 请求③. 若该请求是一个Struts2 请求，则StrutsPrepareAndExecuteFilter 把请求的处理交给ActionProxy④. ActionProxy 创建一个ActionInvocation 的实例，并进行初始化⑤. ActionInvocation 实例在调用Action 的过程前后，涉及到相关拦截器（Intercepter）的调用。
⑥. Action 执行完毕，ActionInvocation 负责根据struts.xml 中的配置找到对应的返回结果。
调用结果的execute 方法，渲染结果。
⑦. 执行各个拦截器invocation.invoke() 之后的代码⑧. 把结果发送到客户端2. Struts2 拦截器和过滤器的区别：①、过滤器依赖于Servlet容器，而拦截器不依赖于Servlet容器。
②、Struts2 拦截器只能对Action 请求起作用，而过滤器则可以对几乎所有请求起作用。
③、拦截器可以访问Action 上下文(ActionContext)、值栈里的对象(ValueStack)，而过滤器不能.④、在Action 的生命周期中，拦截器可以多次调用，而过滤器只能在容器初始化时被调用一次。
3. 为什么要使用Struts2 & Struts2 的优点：①. 基于MVC 架构，框架结构清晰。
②. 使用OGNL: OGNL 可以快捷的访问值栈中的数据、调用值栈中对象的方法③. 拦截器: Struts2 的拦截器是一个Action 级别的AOP, Struts2 中的许多特性都是通过拦截器来实现的, 例如异常处理，文件上传，验证等。
springmvc拦截器（定义、配置以及执行流程）
springmvc拦截器（定义、配置以及执⾏流程）⼀、拦截器概念springmvc中的拦截器（interceptor）类似于Servlet中的过滤器（Filter），它主要⽤于拦截⽤户请求并做相应的处理。
在实际项⽬中会经常使⽤到拦截器，例如在购物⽹站中通过拦截器可以拦截未登录的⽤户，禁⽌其购买商品，或者使⽤它来验证已登录⽤户是否有相应的操作权限（即权限验证），记录请求信息的⽇志等应⽤。
所谓拦截器，就是能够在进⾏某个操作之前拦截请求，如果请求符合条件就允许在往下执⾏。
⽐如说，海关就是⼀个拦截器，他拦截进出⼝的货物，如果货物满⾜进出⼝条件，则放⾏，否则就拦截，退回处理。
⼆、拦截器定义和配置使⽤在springmvc中要使⽤拦截器，就需要对拦截器类进⾏定义和配置，通常拦截器类可以通过两种⽅式来定义。
第⼀种通过实现HandleInterceptor接⼝，或者继承HandleInterceptor接⼝的实现类HandleInterceptorAdapter来定义；第⼆种通过实现WebRequestInterceptor接⼝，或继承WebRequestInterceptor接⼝的实现类来定义。
1、拦截器的定义：以实现HandleInterceptor接⼝为例public class LoginInterceptor implements HandlerInterceptor {@Overridepublic boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {//做⼀些操作⽅法返回类型为布尔值return false;}@Overridepublic void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {//做⼀些操作}@Overridepublic void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {//做⼀些操作}}从以上可以看出，⾃定义的拦截器类实现了HandlerInterceptor接⼝，并且实现了接⼝中的三个⽅法。
SpringBoot使用过滤器和拦截器分别实现REST接口简易安全认证示例代码详解
SpringBoot使⽤过滤器和拦截器分别实现REST接⼝简易安全认证⽰例代码详解本⽂通过⼀个简易安全认证⽰例的开发实践，理解过滤器和拦截器的⼯作原理。
很多⽂章都将过滤器（Filter）、拦截器（Interceptor）和监听器（Listener）这三者和Spring关联起来讲解，并认为过滤器（Filter）、拦截器（Interceptor）和监听器（Listener）是Spring提供的应⽤⼴泛的组件功能。
但是严格来说，过滤器和监听器属于Servlet范畴的API，和Spring没什么关系。
因为过滤器继承⾃javax.servlet.Filter接⼝，监听器继承⾃javax.servlet.ServletContextListener接⼝，只有拦截器继承的是org.springframework.web.servlet.HandlerInterceptor接⼝。
上⾯的流程图参考⾃⽹上资料，⼀图胜千⾔。
看完本⽂以后，将对过滤器和拦截器的调⽤过程会有更深刻理解。
⼀、安全认证设计思路有时候内外⽹调⽤API，对安全性的要求不⼀样，很多情况下外⽹调⽤API的种种限制在内⽹根本没有必要，但是⽹关部署的时候，可能因为成本和复杂度等问题，内外⽹要调⽤的API会部署在⼀起。
实现REST接⼝的安全性，可以通过成熟框架如Spring Security或者 shiro 搞定。
但是因为安全框架往往实现复杂（我数了下Spring Security，洋洋洒洒⼤概有11个核⼼模块，shiro的源码代码量也⽐较惊⼈）同时可能要引⼊复杂配置（能不能让⼈痛快⼀点），不利于中⼩团队的灵活快速开发、部署及问题排查。
很多团队⾃⼰造轮⼦实现安全认证，本⽂这个简易认证⽰例参考⾃我所在的前⼚开发团队，可以认为是个基于token的安全认证服务。
⼤致设计思路如下：1、⾃定义http请求头，每次调⽤API都在请求头⾥传⼈⼀个token值2、token放在缓存（如redis）中，根据业务和API的不同设置不同策略的过期时间3、token可以设置⽩名单和⿊名单，可以限制API调⽤频率，便于开发和测试，便于紧急处理异状，甚⾄临时关闭API4、外⽹调⽤必须传⼈token，token可以和⽤户有关系，⽐如每次打开页⾯或者登录⽣成token写⼊请求头，页⾯验证cookie和token有效性等在Spring Security框架⾥有两个概念，即认证和授权，认证指可以访问系统的⽤户，⽽授权则是⽤户可以访问的资源。
拦截器和过滤器的执行顺序和区别
拦截器和过滤器的执⾏顺序和区别为了⽅便查看，再写⼀遍⽅便⾃⼰⽇后看：过滤器和拦截器的区别： ⼀、过滤器Filter是JavaEE标准，在Servlet的规范中定义的，是Servlet容器⽀持的，是属于Servlet容器的，依赖Servlet容器；拦截器Interceptor是Spring的组件之⼀，是属于Spring框架的，依赖于Spring框架，归Spring管理，配置在Spring的⽂件中，因此能使⽤Spring⾥的任何资源和对象，例如Service对象、数据源、事务管理等，所以可以通过Spring的IOC注⼊⽅式注⼊即可，⽽Filter不可以。
（若⽤配置⽂件⽅式配置，Filter配置在web.xml中，Interceptor配置在Spring MVC的配置⽂件中。
多个过滤器的执⾏顺序跟在web.xml⽂件中定义的先后关系有关。
多个拦截器它们之间的执⾏顺序跟在SpringMVC的配置⽂件中定义的先后顺序有关。
）⼆、过滤器Filter是基于函数回调实现；拦截器是基于java的反射机制实现，属于⾯向切⾯编程（AOP）的⼀种运⽤。
三、拦截器（依赖Spring框架所以）只能对Controller请求进⾏拦截⽽对其他的⼀些⽐如直接访问静态资源的请求则没办法进⾏拦截处理，⽽过滤器则可以对⼏乎所有的请求起作⽤。
四、拦截器（是Spring组件之⼀）所以可以访问action上下⽂、值栈⾥的对象，⽽过滤器不能访问。
五、在action的⽣命周期中，拦截器可以多次被调⽤，⽽过滤器只能在容器初始化是被调⽤⼀次。
拦截器可以获取IOC容器中的各个bean，⽽过滤器就不⾏，这点很重要，在拦截器⾥注⼊⼀个service，可以调⽤业务逻辑过滤器包裹住servlet，servlet包裹住拦截器过滤器Filter@Overridepublic void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {System.out.println("before...");chain.doFilter(request, response);System.out.println("after...");}拦截器Interceptor 继承HandlerInterceptor后如下@Overridepublic boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {System.out.println("preHandle");return true;}@Overridepublic void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {System.out.println("postHandle");}@Overridepublic void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {System.out.println("afterCompletion");}过滤器的触发时机是容器后，servlet之前，所以过滤器的doFilter(ServletRequest request, ServletResponse response, FilterChain chain)的⼊参是ServletRequest ，⽽不是httpservletrequest。
拦截器（Interceptor）与过滤器（Filter）
拦截器（Interceptor）与过滤器（Filter）⽬录⼀、⽤户的普通Http请求执⾏顺序⼆、过滤器、拦截器添加后的执⾏顺序三、拦截器（Interceptor）的基本定义 拦截器是⾯向切⾯（AOP）编程中应⽤的⼀种统⼀处理⽅案，就是在你的Controller、Servie或者⼀个Method调⽤⼀个Method，或者在Method调⽤⼀个Method之后，统⼀的进⾏处理的⽅案，基于Java的反射机制。
拦截器，在AOP（Aspect-Oriented Programming）中可以⽤于在某个⽅法或者字段被访问之前，进⾏拦截，然后在之前或者之后加⼊某些统⼀的处理⽅法。
拦截是AOP的⼀种具象的实现⽅式。
拦截器将很多service或者Controller中共有的⾏为提炼出来，在某些⽅法执⾏的前后执⾏，提炼为通⽤的处理⽅式，让被拦截的⽅法都能享受这⼀共有的功能，让代码更加简洁，同时，当共有的功能需要发⽣调整、变动的时候，不必修改很多的类或者⽅法，只要修改这个拦截器就可以了，可复⽤性很强。
Spring MVC 中的Interceptor拦截请求是通过HandlerInterceptor来实现的。
四、拦截器（Interceptor）必须实现的三个⽅法 1）总览 2）preHandle（HttpServletRequest request， HttpServletResponse response， Object handle）⽅法 该⽅法将在请求处理之前进⾏调⽤。
SpringMVC 中的Interceptor 是链式的调⽤的，在⼀个应⽤中或者说是在⼀个请求中可以同时存在多个Interceptor 。
每个Interceptor 的调⽤会依据它的声明顺序依次执⾏，⽽且最先执⾏的都是Interceptor 中的preHandle ⽅法，所以可以在这个⽅法中进⾏⼀些前置初始化操作或者是对当前请求的⼀个预处理，也可以在这个⽅法中进⾏⼀些判断来决定请求是否要继续进⾏下去。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
过滤器，是在java web中，你传入的request,response提前过滤掉一些信息，或者提前设置
一些参数，然后再传入servlet或者struts的 action进行业务逻辑，比如过滤掉非法url（不
是login.do的地址请求，如果用户没有登陆都过滤掉）,或者在传入servlet或者 struts的action前统一设置字符集，或者去除掉一些非法字符
拦截器，是在面向切面编程的就是在你的service或者一个方法，前调用一个方法，或者在
方法后调用一个方法比如动态代理就是拦截器的简单实现，在你调用方法前打印出字符串（或者做其它业务逻辑的操作），也可以在你调用方法后打印出字符串，甚至在你抛出异
常的时候做业务逻辑的操作。
拦截器与过滤器的区别：
1. 拦截器是基于java的反射机制的，而过滤器是基于函数回调。
2. 拦截器不依赖与servlet容器，过滤器依赖与servlet容器。
3. 拦截器只能对action请求起作用，而过滤器则可以对几乎所有的请求起作用。
4. 拦截器可以访问action上下文、值栈里的对象，而过滤器不能访问。
5. 在action的生命周期中，拦截器可以多次被调用，而过滤器只能在容器初始化时被
调用一次
执行顺序：过滤前 - 拦截前 - Action处理 - 拦截后 - 过滤后。
个人认为过滤是一个横向的过程，首先把客户端提交的内容进行过滤(例如未登录用户不能访问内部页面的处理)；过滤
通过后，拦截器将检查用户提交数据的验证，做一些前期的数据处理，接着把处理后的数
据发给对应的Action；Action处理完成返回后，拦截器还可以做其他过程(还没想到要做啥)，再向上返回到过滤器的后续操作。
面向切面编程（AOP是Aspect Oriented Program的首字母缩写），我们知道，面向对象的特点是继承、多态和封装。
而封装就要求将功能分散到不同的对象中去，这在软件设计中
往往称为职责分配。
实际上也就是说，让不同的类设计不同的方法。
这样代码就分散到一
个个的类中去了。
这样做的好处是降低了代码的复杂程度，使类可重用。
但是人们也发现，在分散代码的同时，也增加了代码的重复性。
什么意思呢？比如说，我们在两个类中，可能都需要在每个方法中做日志。
按面向对象的设计方法，我们就必须
在两个类的方法中都加入日志的内容。
也许他们是完全相同的，但就是因为面向对象的设
计让类与类之间无法联系，而不能将这些重复的代码统一起来。
也许有人会说，那好办啊，我们可以将这段代码写在一个独立的类独立的方法里，然后
再在这两个类中调用。
但是，这样一来，这两个类跟我们上面提到的独立的类就有耦合了，它的改变会影响这两个类。
那么，有没有什么办法，能让我们在需要的时候，随意地加入
代码呢？这种在运行时，动态地将代码切入到类的指定方法、指定位置上的编程思想就是
面向切面的编程。
一般而言，我们管切入到指定类指定方法的代码片段称为切面，而切入到哪些类、哪些方法则叫切入点。
有了AOP，我们就可以把几个类共有的代码，抽取到一个切片中，等到
需要时再切入对象中去，从而改变其原有的行为。
这样看来，AOP其实只是OOP的补充而已。
OOP从横向上区分出一个个的类来，而AOP
则从纵向上向对象中加入特定的代码。
有了AOP，OOP变得立体了。
如果加上时间维度，
AOP使OOP由原来的二维变为三维了，由平面变成立体了。
从技术上来说，AOP基本上是通过代理机制实现的。
AOP在编程历史上可以说是里程碑式的，对OOP编程是一种十分有益的补充。