java框架 2 springboot 过滤器 拦截器 异常处理 事务管理 AOP

已于 2024-04-08 10:04:01 修改
阅读量1k 收藏 20
点赞数 14
分类专栏： 前端学java 文章标签： java spring boot 开发语言
于 2024-03-17 20:36:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lin_fightin/article/details/136662086
版权

Filter 过滤器

在这里插入图片描述
对所有请求都可以过滤。
在这里插入图片描述
实现Filter接口，重写几个方法，加上@WebFilter注解，表示拦截哪些路由，如上是所有请求都会拦截。
然后还需要在入口处加上@SvlterComponentScan注解，因为Filter是javaweb三大组件之一，并不是springboot的内容。
在这里插入图片描述
chain.doFilter是放行该请求的意思，如果没有将会卡在当前过滤器上。

过滤器链

一个服务可以配置多个过滤器，多个过滤器形成过滤器链。有点像koa的洋葱模型。

过滤器1执行 -> 过滤器2执行 -> 执行主要逻辑 -> 过滤器2放行后的逻辑执行 -> 过滤器1放行后的逻辑执行

那么怎么区分那个过滤器先执行呢？通过过滤器首字母排序来决定。

Interceptor拦截器

在这里插入图片描述

拦截器是Spring框架提供的，跟filter不一样。
使用：
在这里插入图片描述
实现HandlerInterceptor接口，重写方法，其中preHanldel是在controller执行前执行，返回值作为放行的条件。
postHandle是在controller执行后执行。
实现拦截器之后，还需要配置才能生效。
在这里插入图片描述
实现WebMvcConfigurer接口，然后使用@Configuration，这样springboot启动的时候会自动扫描该注解，生效该配置。
如上就是将拦截器注册，并指定其拦截的接口。

拦截器-拦截路径

在这里插入图片描述
可以通过addPathPatterns指定哪些路径需要拦截，通过excludePathPatterns指定哪些路径不需要拦截。

执行时机

上面说过，拦截器是spring框架提供的，而过滤器是tomcat框架提供的，如图。
在这里插入图片描述
如果都存在的话，会先执行过滤器，再执行拦截器的逻辑。
过滤器会拦截所有的请求资源，而拦截器只会拦截Spring环境中的资源。

案例 实现jwt登陆验证

安装对应依赖

	<dependency>
			<groupId>io.jsonwebtoken</groupId>
			<artifactId>jjwt</artifactId>
			<version>0.9.1</version>
		</dependency>

实现jwtUtils类

package com.example.demo.util;

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;

import java.util.Date;
import java.util.Map;

public class JwtUtils {
    private static String singKey = "test1234"; // 密钥
    private static long expire = 432000L; //过期时间

    public static String generatorToken(Map<String, Object> data) {
        String jwt = Jwts.builder()
                .addClaims(data)
                .signWith(SignatureAlgorithm.HS256, JwtUtils.singKey)
                .setExpiration(new Date(System.currentTimeMillis() + JwtUtils.expire))
                .compact();
        return jwt;
    }


    public static Claims parseToken(String token) {
        Claims calims = Jwts.parser()
                .setSigningKey(singKey)
                .parseClaimsJws(token)
                .getBody();
        return calims;
    }

}

使用jwt生成token

@Slf4j
@RestController
public class LoginController {

    @PostMapping("/login")
    public Result login(@RequestBody LoginUser body){
        Map<String, Object> data = new HashMap<>();
        log.info("{},{}", body.getName(),body.getPassword());
        data.put("name", body.getName());
        data.put("password", body.getPassword());
        String token = JwtUtils.generatorToken(data);
        return Result.success(token);
    };
}

使用对应的拦截器进行校验

@Component("loginInterceptor")
public class LoginInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest req, HttpServletResponse res, Object handler) throws Exception {
        System.out.println("preHandle....." + req.getRequestURL());
        String url = req.getRequestURL().toString();
        if(url.contains("login")){
            // 登陆接口不需要校验
            return true;
        }
        String token = req.getHeader("token");
        try {
            if (token != null) {
                Claims data = JwtUtils.parseToken(token);
                req.setAttribute("user", data);
                return true;
            } else {
                throw new Exception("token不存在或者过期");
            }
        } catch (Exception e) {
            Result error = Result.error("token is not exists or expire");
            res.addHeader("Content-Type", "application/json");
            res.getWriter().write(JSONObject.toJSONString(error));
            return false;
        }
    }
}

@Configuration
public class SpringMvcConfigure implements WebMvcConfigurer {

    @Resource(name="loginInterceptor")
    LoginInterceptor loginInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry){
        registry.addInterceptor(loginInterceptor).addPathPatterns("/**"); //该拦截器拦截所有请求
    }
}

登陆接口不需要验证，让该拦截器拦截对应请求，拿到token，进行解析，解析到用户数据就塞入req中，后续controller就可以拿到该用户信息。

异常处理

  • 程序开发过程中不可避免会碰到异常，有时候返回的信息并不是后端统一的信息。

在这里插入图片描述
像nest可以配置全局异常过滤器，会俘获所有的异常然后统一信息返回。

方案

java也可以定义全局异常处理器。
在这里插入图片描述

通过注解@RestControllerAdvice指定这是一个controller异常处理器,@RestControllerAdvicd中也包含@ResponseBody，表示所有的方法返回的值会被转为json传给前端(实际上所有的请求传输都是字符串，只不过设置了contentType为json，浏览器会自动识别contentType处理。)。通过@ExceptionHandler(Exception.class)指定拦截什么类型的异常，Exception.class就是指拦截所有的异常。

import com.example.demo.pojo.Result;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

@RestControllerAdvice
public class GlobalExceptionHandler {
    @ExceptionHandler(Exception.class)
    public Result ex(Exception ex){
        ex.printStackTrace();
        return Result.error("服务器报错: " + ex.getMessage());
    }
}

事务管理

在这里插入图片描述

在这里插入图片描述
springboot提供了@Transactional注解来开启事务。

回滚异常


@Transactional注解，可以传入值，可以控制出现什么异常的情况下，回滚事务。默认只有运行时异常才会处理。

事务传播行为

事务a方法调用事务b方法的时候
在这里插入图片描述
比如在a中调用b的方法，当a失败后，事务回滚，会导致b方法执行的逻辑也会回滚，事务传播行为默认是有则加入，也就是b方法会加入当前a方法的事务中。

将其改为REQUIRES_NEW，在a中调用b的时候，会先挂起a的事务，然后起一个b的事务，当a失败后，a执行的逻辑会回滚，但是b方法执行的逻辑如果没报错，会保留。

在这里插入图片描述

案例 删除一个部门，并将该部门下所有员工删除，不管删除失败成功都需要记录日志

如下，启用Propagation.REQUIRES_NEW，在调用创建日志方法的时候并不会受原本事务的影响

  @Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRES_NEW)
    public Result deleteDepts(Integer id) {
        try {
            this.dept.deleteDept(id);
            this.emp.deleteEmpByJobId(id); //删除员工表下该部门的员工
            return Result.success(0);
        } catch (Exception e) {
            return Result.error(e.getMessage());
        } finally {
            // 记录日志 也是一个事务方法，用REQUIRES_NEW则不会被上述逻辑影响，会正常记录日志
            logger.create(new Date(), "删除")
        }
    }

AOP

在这里插入图片描述
实现
在这里插入图片描述
编写AOP类，交给IOC容器管理。
通过joinPoint可以拿到原始方法。

AOP核心概念

在这里插入图片描述

  • 连接点，joinPoint，可以被AOP控制的方法，比如上图的list,delete,save等方法都属于连接点。
  • 通知，Advice，重复逻辑，比如上图的recordTime方法，共性逻辑（所有连接点都会执行）
  • 切入点：pointCut，顾名思义就是在哪里切入这个类，匹配连接点的条件。
  • 切面：描述通知与切入点的对应关系，如上图的@Around(切入点表达式)+recordTIme(通知)方法就是切面。
  • 目标对象：Target，AO类所应用的对象。
AOP的执行流程

AOP类是如何作用于目标对象的，
在这里插入图片描述
上述说过，AOP是通过动态代理实现的，如上，DeptServiceImpl类，是AOP的目标对象，他会根据通知，生成一个代理类，DeptServiceProxy，然后重新list方法，执行AOP类的逻辑，最后如上，通过@Autowired注入的deptService就不是DeptServiceImpl，而是DeptSerivceProxy这个代理对象，所以执行list方法的时候，就会执行代理对象list，从而执行通知的逻辑

通俗的说，AOP类会在不影响目标对象代码的基础上，基于目标对象，新增一些其他的逻辑，通过代理的形式生成一个新的类，交给IOC容器.

案例 记录每个controller的耗费时间

可以用拦截器做到，也可以用过滤器做到，也可以用AOP做到。

@Component
@Aspect
@Slf4j
public class TimeAspect {
    @Around("execution(* com.example.demo.controller.*.*(..))")
    public Object recordTime(ProceedingJoinPoint joinPoint) throws  Throwable{
        long begin = System.currentTimeMillis();
        Object object = joinPoint.proceed(); //调用原方法
        long end = System.currentTimeMillis();
        log.info(joinPoint.getSignature() + "执行耗时: {}ms", end- begin);
        return object; //返回
    }
}

在这里插入图片描述

AOP高阶
通知类型

上述我们使用的@Around就是通知类型。他的功能最强大，可以编写目标方法执行前的逻辑，也可以编写目标方法执行后的逻辑（可以拿到目标方法）

在这里插入图片描述
@Pointcut注解可以抽离公共的切入点表达式，服用切入点表达式
在这里插入图片描述

通知的执行顺序

当有多个通知都匹配到同一个切入点时，目标方法执行，多个通知方法都会执行。
跟过滤器一样，其实是根据AOP的类名字母排序有关，且@before和@after的执行顺序就跟洋葱模型一样，也是234 -> 432这样执行。
在这里插入图片描述

除此之外，还可以通过@Order注解来标记执行顺序。

切入点表达式

在这里插入图片描述
在这里插入图片描述

通配符号 * 和 …

在这里插入图片描述
如

 @Around("execution(* com.*.demo.controller.*.update*(*))")

* com表示 匹配任何返回值
com.*.demo表示二级包是任意的
controller.*表示controller下的类或者接口是任意的
update*表示以update开头的类或者接口
(*)表示匹配一个参数

上述表示 任何的返回值，com下任意的二级包里含有的demo三级包下的controller目录下的任意的以类或者接口下以update开头，且只能有一个参数的方法

如果换成…
即

 @Around("execution(* com..controller.*.update*(..))")

com…可以匹配任意层级的包
update*(…)表示匹配update开头的方法，且可以有任意参数。

上述表示 任何的返回值，com下任意的二级包里含有controller的目录，下的任意的以类或者接口下以update开头，且只能有一个参数的方法

多个切入点表达式可以用 || & 等组合。

@annotation

在这里插入图片描述
匹配标识有特定注解的方法
定义一个注解用来标识

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Mylog {
    
}

将execution切换成@annotation

public class TimeAspect {
    //@Around("execution(* com.example.demo.controller.*.*(..))")
    @Around("@annotation(com.example.demo.aop.Mylog)")
    public Object recordTime(ProceedingJoinPoint joinPoint) throws  Throwable{
        long begin = System.currentTimeMillis();
        Object object = joinPoint.proceed(); //调用原方法
        long end = System.currentTimeMillis();
        log.info(joinPoint.getSignature() + "执行耗时: {}ms", end- begin);
        return object; //返回
    }
}
连接点

对于@Around，只能通过ProceddingJoinPoint获取连接点信息，如下

在这里插入图片描述
对于其他四种通知
在这里插入图片描述
只能通过JoinPoint获取连接点信息。

@Aspect
@Component
@Slf4j
public class TimeAspect {
    @Around("execution(* com.example.demo.controller.*.*(..))")
    public Object recordTime(ProceedingJoinPoint joinPoint) throws  Throwable{
        long begin = System.currentTimeMillis();
        String className = joinPoint.getTarget().getClass().getName();
        Signature signature = joinPoint.getSignature();
        String methodName = signature.getName();
        Object[] args = joinPoint.getArgs();
        log.info("打印结果==={},{},{},{}", className, signature, methodName, Arrays.toString(args));
        Object object = joinPoint.proceed(); //调用原方法
        long end = System.currentTimeMillis();
        log.info(joinPoint.getSignature() + "执行耗时: {}ms", end- begin);
        return object; //返回
    }
}
案例 对增删改操作进行日志写入操作

使用AOP完成该功能。
定义注解

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface OperatorLog {
}

在增删改方法上加上该注解
编写AOP代码

@Component
@Aspect
@Slf4j
public class OperatorLog {

    // 通过注解获取request对象
    @Autowired
    private HttpServletRequest request;

    @Around("@annotation(com.example.demo.aop.OperatorLog)")
    public Object createLog(ProceedingJoinPoint joinPoint) throws Throwable {
        long begin = System.currentTimeMillis();
        Claims user = (Claims) request.getAttribute("user");
        String className = joinPoint.getTarget().getClass().getName();
        Signature signature = joinPoint.getSignature();
        String methodName = signature.getName();
        Object[] args = joinPoint.getArgs();
        Object object = joinPoint.proceed(); //调用原方法
        long time = begin -  System.currentTimeMillis();
        Log newLog = new Log((String) user.get("name"),time, methodName, Arrays.toString(args),className);
        log.info("插入一条日志: {}",newLog);
        Log.insertLogs(newLog);
        return object; //返回
    }
}

通过注解获取request对象，在拦截器的时候将user注入到req里面去，所以这里可以获取得到。然后插入一条日志。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

bean管理

获取bean对象

在这里插入图片描述

 @Autowired
    private ApplicationContext applicationContext; //AOP容器对象

    public void testGetBean(){
        EmpService emp1 = (EmpService)applicationContext.getBean("empServiceImpl"); // 根据bean的名称获取 需要强制转
        EmpService emp2 = applicationContext.getBean(EmpServiceImpl.class); // 根据bean的类型获取
        EmpService emp3 = applicationContext.getBean("empServiceImpl", EmpServiceImpl.class); //根据俄bean的名称+类型判断
        System.out.println(emp1);
        System.out.println(emp2);
        System.out.println(emp3);
    }

在这里插入图片描述可以看到，得到的bean都是同一个实例。

bean作用域

在这里插入图片描述
默认是singleton，也就是上述为什么多个bean都是同个实例的原因，如果设置为prototype，那么每次使用bean都会创建新的实例。

在定义Bean对象的时候，加上@Scope注解
在这里插入图片描述

@Scope("prototype")
@Service("empServiceImpl")
public class EmpServiceImpl implements EmpService {
}

这样在使用该bean对象的时候，每次都会创建新的。

第三方bean

在这里插入图片描述

@Baen能将方法返回的内容作为Bean对象，可以指定第三方Bean的名称，不指定默认是方法名。
方法参数可以注入IOC容器中的Bean对象

// 定义第三方bean
@Configuration
public class CommonConfig implements WebMvcConfigurer {

     // 声明第三方Bean，将当前方法返回值交给IOC容器管理，称为IOC Bean对象
    @Bean(name="TestBean") //不指定默认是方法名
    // 方法参数可以自动装填IOC容器里的Bean
    public List<String> testBean(EmpService empService){
       
}

使用的时候跟正常使用Bean就可以

   @Resource(name="TestBean")
    private List<String> TestBean;

在这里插入图片描述

自动配置

引入的第三方包，如果想使用其中的bean对象，需要指定，因为默认的@SpringBootApplication注解，只会扫描启动类以及下级的bean对象。

使用@ComponentScan在这里插入图片描述

通过数组的方式制定第三方包的包名。用得较少

使用@Import

在这里插入图片描述
一般第三方包会提供一个@Eablexx的注解，指定他这个包需要使用的bean对象，我们在引入的时候直接用@Import➕@Enablexxx注解即可引入。
在这里插入图片描述
第三方包定义的这个注解。

maven高级在这里插入图片描述
实践：将util模块抽离

在这里插入图片描述

  • 1 新建一个模块，然后定义utils包，这里需要引入对应依赖。
  • 2 原项目引入test-utils包，删除对应文件，然后在使用的时候引入test-utils下的类。
    在这里插入图片描述
    在这里插入图片描述
    这样就完成通用模块的拆分。
继承

在这里插入图片描述

在这里插入图片描述
在springboot工程，就有指定parent父工程。
在这里插入图片描述
一个工程只能继承一个父工程，但支持多层继承。
在这里插入图片描述

在这里插入图片描述

版本锁定

在这里插入图片描述
在这里插入图片描述
dependencyManagement只是指定该依赖的版本，并不是加入该依赖，子工程想要使用的时候需要引入，只是不需要指定版本。

在这里插入图片描述

自定义属性

在这里插入图片描述

聚合

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

coderlin_
关注
专栏目录
Spring Boot入门(25)：三位程序员谁能守护项目入口？- 过滤器、拦截器、监听器的对比及使用场景
**My Coding Family**
08-25 2035
Spring Boot 如何使用过滤器、拦截器、监听器对比及使用场景，一文带你吃透它。
Spring Boot入门(23)：记录接口日志再也不难！用AOP和自定义注解给Spring Boot加上日志拦截器！
**My Coding Family**
09-01 3368
基于AOP实现自定义注解拦截接口日志并入库，一文教会你。
SpringBoot的Filter过滤器
11-26
idea开发软件，实现SpringBoot项目的过滤器。写了博客，直接把代码也上传吧。比较简单，大家不要鄙视，为什么他要写50个字啊。
关于过滤器 Springboot中
lvkeyxx的博客
06-18 242
1.新建一个过滤器，如下 package com.lvkeyxx.config; import javax.servlet.*; import javax.servlet.annotation.WebFilter; import java.io.IOException; /** * 过滤器 * 注解方式，需要在启动类上添加 @ServletComponentScan注解 */ @We...
springboot 过滤器
最新发布
溪
08-10 852
/ 执行一些预处理操作 System . out . println("3Filter==Before the request...");// 调用下一个过滤器 filterChain . doFilter(servletRequest , servletResponse);// 执行一些后处理操作 System . out . println("3Filter==After the request...");} }
Springboot实现过滤器
一个菜鸡的博客
05-21 1万+
Springboot实现过滤器有以下俩种方式，第一种方式俩步走，即向spring容器注册filter 第一种： 1.Filter过滤器具体实现类 @Component @Slf4j public class MyTestFilter implements Filter { @Override public void init(FilterConfig filterConfig) throws ServletException { log.info("[ {} ] 创建
Springboot 过滤器
大新软件老杨
11-29 3642
Springboot的过滤器，在web开发中可以过滤指定的url 比如过拦截掉我们不需要的接口请求，同时也可以修改request和response内容 过滤器的应用场景： 1）过滤敏感词汇（防止sql注入） 2）设置字符编码 3）URL级别的权限访问控制 4）压缩响应信息
SpringBoot过滤器
舌尖上的蛋炒饭的博客
09-18 5227
SpringBoot过滤器 客服端与web资源之间的请求和响应都通过过滤器进行过滤。比如web前端和服务端进行交互，但端口号又不一样，这样就存在了跨域问题，可以通过配置过滤器解决 声明：Filter有很多种，我们就用WebFilter来入门 老规矩，先看源码,发现Filter接口有三个方法需要我们实现 // // Source code recreated from a .class file by IntelliJ IDEA // (powered by FernFlower decompiler) /
springboot下使用拦截器和过滤器
热门推荐
学习
07-01 4万+
1. 拦截器Interceptor Spring MVC的拦截器（Interceptor）和Filter不同，但是也可以实现对请求进行预处理，后处理。先介绍它的使用，只需要两步： 1.1 实现拦截器 实现拦截器可以自定义实现HandlerInterceptor接口，也可以通过继承HandlerInterceptorAdapter类，后者是前者的实现类。如果preHandle方法ret...
Spring Boot 整合Mybatis、Druid、PageHelper、Swagger 、AOP、过滤器、拦截器、thymeleaf 基础入门demo
02-28
**Spring Boot整合Mybatis、Druid、PageHelper、Swagger、AOP、过滤器与拦截器、Thymeleaf基础入门** 在现代Java开发中，Spring Boot以其简洁的配置和强大的功能，成为了主流的微服务框架。这个入门示例将帮助我们...
CXF3.0+Spring3.2 自定义拦截器
01-06
同时，Spring3.2是Spring框架的一个稳定版本，提供了丰富的依赖注入、AOP（面向切面编程）以及事务管理等功能，常被用于构建企业级应用。结合这两者，我们可以创建高度可扩展和模块化的系统。 自定义拦截器在CXF中...
利用java filter 实现业务异常拦截源码
10-15
利用java filter 实现业务异常拦截 跳转到错误信息提示页面 我们在做项目中肯定都会遇到自定义业务异常 ，然后将业务异常信息跳转的统一的信息提示页面的情况，比如我们在struts的时候我们会用到struts的异常处理机制，我们在业务层会跑出我们遇到业务处理异常 ，然后交由struts处理将提示信息到一个页面进行显示，来提示用户的相关操作，这里我们会根据以上情景设计一下怎么来显示该功能
Spring Boot 过滤器
Pastxu的小屋
04-24 1166
什么是过滤器？ Filter也称之为过滤器，它是Servlet技术中最实用的技术，WEB开发人员通过Filter技术，对web服务器管理的所有web资源：例如JSP，Servlet，静态图片文件或静态HTML文件进行拦截，从而实现一些特殊功能。例如实现URL级别的权限控制、过滤敏感词汇、压缩响应信息等一些高级功能。 Filter的执行原理 当客户端发出Web资源的请求时，Web服务器根据应用程序配置文件设置的过滤规则进行检查，若客户请求满足过滤规则，则对客户请求／响应进行拦截，对请求头和请求数据进行检
springboot过滤器
刘骐毓的博客
10-27 368
过滤器，顾名思义，能够过滤一切请求（而拦截器只能过滤action请求），包括静态资源的请求。 实现很简单： （1）写一个过滤器。过滤实现在doFilter方法里面。chain.doFilter(request, response)  表示过滤通过，能够往下执行。所以过滤操作要写在chain.doFilter(request, response) 前面，作一些条件判断，如果不符合条件，则不执行c...
Springboot——过滤器
梦想的边缘
08-12 1万+
Springboot——过滤器
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

coderlin_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值