统一异常拦截和非法sql拦截

统一异常拦截

异常拦截的原因：

1，对于前端用户比较友好。通过统一异常拦截我们可以将后端的异常（没有try，catch住的）给拦截住，对于数据库报错，空指针等敏感报错，接口不会直接暴露给前端。

2，对后端比较友好。开发不用每次编码都进行try，catch，降低了开发的复杂度。将所有异常处理放在一个类中进行集中的统一处理，只需要修改一处，即可拦截所有的异常。

实现原理：

@RestControllerAdvice和@ExceptionHandler

    RestControllerAdvice：可以拦截所有的controller。

    ExceptionHandler：当一个Controller中有方法加ExceptionHandler之后，这个Controller其他方法中没有捕获的异常就会以参数的形式传入加了ExceptionHandler注解的那个方法中。

核心代码：

@RestControllerAdvice
@Slf4j
public class ExceptionAdvice {
    @ResponseBody
    @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
    @ExceptionHandler(Exception.class)
    public JSONObject exceptionHandler(Exception e){
        log.error("执行异常",e);
        if (e instanceof MethodArgumentNotValidException){
            MethodArgumentNotValidException exception = (MethodArgumentNotValidException)e;
            return JSONObjectUtil.error(exception.getBindingResult().getFieldError().getDefaultMessage());
        }
        else if(e instanceof ServiceException){
            ServiceException exception = (ServiceException) e;
            return JSONObjectUtil.error(exception.getMessage());
        }
        else {
            return JSONObjectUtil.error("内部错误，请联系管理员！");
        }
    }

制造一个错误，运行结果：

不加之前：

加上ExceptionAdvice：

异常分为系统异常和业务异常。

系统异常：不可预知的异常，数据库报错，比如说程序空指针。

业务异常：可以预制的异常。比如说该传验证码没传，该传某个参数没传。

aop切面实现操作记录（操作留痕）

业务场景：

    用户每次在系统中进行update操作都需要形成操作记录。

实现原理：

ioc+aop

核心代码：

定义切点：

/**
 * 操作记录切点
 *
 * @author LYX
 * @date 2022/12/03
 */
@Aspect
@Component
@DependsOn("springFactoryUtils")
public class OperationRecord{

    private  static Map<String, jiLuService> beanMap = SpringFactoryUtils.getBeanMap(jiLuService.class);

    /**
     * 1，定义切点
     * 2，定义切点之前执行
     * 3，定义切点之后执行
     */
    @Pointcut("@annotation(com.example.lyxtest.annotation.Log)")
    public void logPointCut() {
    }
    /**
     * 在切点之前执行
     *
     * @param joinPoint 连接点
     * @param log       日志
     */
    @Before("logPointCut() && @annotation(log)")
    public void beforePointCut(JoinPoint joinPoint, Log log){
        //获取到方法入参
        Object[] args = joinPoint.getArgs();
        jiLuService jiLuService = beanMap.get(log.handleType());
        jiLuService.before(args,log);
    }
    /**
     * 在切点之后执行
     *
     * @param joinPoint 连接点
     * @param result    结果
     */
    @AfterReturning(returning = "result",pointcut = " @annotation(com.example.lyxtest.annotation.Log)")
    public void afterPointCut(JoinPoint joinPoint,Object result){
        JSONObject outJson = (JSONObject) result;
        if(200 == Integer.valueOf(outJson.get("code").toString())){
            //获得方法入参
            Object[] args = joinPoint.getArgs();
            //获取handle
            MethodSignature signature = (MethodSignature)joinPoint.getSignature();
            String handle = signature.getMethod().getAnnotation(Log.class).handleType();
            jiLuService jiLuService = beanMap.get(handle);
            jiLuService.after(args,signature);
        }
    }
}

实现类：

/**
 * 操作记录实现类
 *
 * @author LYX
 * @date 2022/12/03
 */
@Component
@Slf4j
public abstract class RecordService {

    /**
     * 之前
     *
     * @param args arg游戏
     */
    public  void before(Object[] args, Log loga){
        log.info("handle：{}，入参：{}",loga.handleType(), args);
    };

    /**
     * 后
     *
     * @param args      arg游戏
     * @param signature 签名
     */
    public abstract void after(Object[] args, MethodSignature signature);
}

具体操作：

/**
 * 部门查询handle
 *
 * @author LYXLYX
 * @date 2022/12/03
 */
@Component("yhcx")
@Slf4j
public class yhcxHandle extends RecordService {
    @Override
    public void after(Object[] args, MethodSignature signature) {
        User user = (User) args[0];
        log.info("操作功能：{}，操作值：{}",signature.getMethod().getAnnotation(Log.class).czgn(),String.valueOf(user));
    }
}

Controller层中插入@Log注解：

@Log(handleType = "yhcx",czgn = "部门查询")

定义注解：

/**
 * 日志
 *
 * @author LYX
 * @date 2022/12/03
 */
@Target({ElementType.PARAMETER, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented

public @interface Log {

    /**
     * 处理类型
     *
     * @return
     */
    String handleType() default "";

    /**
     * 操作功能
     */
    String czgn() default "";
}

结果展示：

非法sql拦截

业务场景：

不带where条件的更新和删除在生产环境中是非常危险的，比如说使用了when这种条件语句，如果这些都交给开发人员去用代码去判断会增加很多工作量。针对 update 和 delete 语句 作用: 阻止恶意的全表更新删除

实现原理：

mybatis-plus官方自带插件，地址：防全表更新与删除插件 | MyBatis-Plus

核心代码：

/**
 * mybatis +配置
 *
 * @author LYX
 * @date 2022/12/03
 */
@Configuration
public class MybatisPlusConfig {
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new BlockAttackInnerInterceptor());
        return interceptor;
    }
}