通知的知识点

通知的讲解

关于AOP通知的讲解

第一类：

• @Before(“pointcut()”)
• @AfterReturning(“pointcut()”)
• @AfterThrowing(“pointcut()”)
• @After(“pointcut()”)

可以记录程序执行的各个过程. 为日志提供记录.

第二类：

• @Around(“pointcut()”)
  可以控制目标方法是否执行. 环绕通知可以控制业务流转的过程!!!

例子:

1. 权限的校验
2. 缓存系统
3. 异常的处理等
   ProceedingJoinPoint 只能用在around环绕中

通知中常用的API

需求:

1. 获取当前的目标对象的类型.
2. 获取当前的方法名称
3. 获取当前传递的参数.
   常见报错: ProceedingJoinPoint is only supported for around advice ProceedingJoinPoint 只能用到环绕通知中.

//1.前置通知: 在目标方法执行之前执行.
    @Before("pointcut()")
    public void before(JoinPoint joinPoint){//连接点:获取方法中的数据
        Class targetClass = joinPoint.getTarget().getClass();
        String methodName = joinPoint.getSignature().getName();
        String className = joinPoint.getSignature().getDeclaringTypeName();
        Object[] objs = joinPoint.getArgs();
        System.out.println("我是前置通知!!!!");
        System.out.println("类型:"+ targetClass);
        System.out.println("方法名称:"+methodName);
        System.out.println("类的名称:"+className);
        System.out.println("方法中携带的参数:"+ Arrays.toString(objs));
    }

编辑SpringAop1

package com.jt.aop;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

import java.util.Arrays;

@Component//将该类交给容器管理
@Aspect //标识该
@Order(2)
public class SpringAop {
    /**
     * 公式：切面=切入点表达式+通知方法
     * 切入点表达式：如果目标对象满足切入点表达式的判断（if），则spring自动为其创建代理对象
     * 通知方法：对目标方法进行扩展的封装方法
     * 目标对象的beanID：userServiceImpl
     * 切入点表达式：
     *      1.bean("bean的id")
     * AOP规则;
     * */
//    @Pointcut("bean(userServiceImpl)")
//    @Pointcut("within(com.jt.service.*)")
//    @Pointcut("within(com.jt.service..*)")
//    @Pointcut("within(com.*.service..*)")
//    @Pointcut("execution(* com.jt.service.UserServiceImpl.addUser())")
//    @Pointcut("execution(* com.jt.service..*.*(..))")
    @Pointcut("@annotation(com.jt.anno.Wxin)")
    public void pointcut(){
    }

    //1.前置通知：在目标方法执行之前执行
    //@Before("pointcut()")
    public void before(JoinPoint joinPoint){//连接点：获取方法中的数据
        //获取目标对象的类型
        Class targetClass = joinPoint.getTarget().getClass();
        //获取方法名称
        String name1 = joinPoint.getSignature().getName();
        String name2 = joinPoint.getSignature().getDeclaringTypeName();
        Object[] objs = joinPoint.getArgs();
        System.out.println("我是前置通知");
        System.out.println("类型："+targetClass);
        System.out.println("方法名称："+name1);
        System.out.println("类的名称："+name2);
        System.out.println("方法中携带的参数："+ Arrays.toString(objs));
    }

//    2.后置通知：在目标方法执行之后执行
    //通过 returning = "result" 获取目标方法的返回值，当做参数传递给result
    //@AfterReturning(value = "pointcut()",returning = "result")
    public void afterReturn(Object result){
        System.out.println("我是后置通知:"+result);
    }

    //3.异常通知：目标方法执行报错时，执行该通知
    //@AfterThrowing(value = "pointcut()",throwing = "exception")
    public void afterThrowing(Exception exception){
        System.out.println("我是异常通知");
        System.out.println("我是异常信息"+exception.getMessage());
        exception.printStackTrace();
    }

    //4.最终通知：目标方法之后都要执行的通知
    //@After("pointcut()")
    public void after(){
        System.out.println("最终通知都要执行");
    }
    //5.重点掌握 环绕通知：在目标方法执行前后都要执行，控制目标方法
    @Around("pointcut()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("环绕通知执行前");
        //底层调用动态代理的invoke方法，执行目标方法
        Object result = joinPoint.proceed();
        System.out.println("环绕通知执行后");
        return result;
    }
}

编辑SpringAop2

package com.jt.aop;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

@Component
@Aspect //标识切面类
@Order(1)//aop第一个执行，数字越小越靠前
public class StringAop2 {

    //通过环绕通知 指定切入点表达式
    @Around("@annotation(com.jt.anno.Wxin)")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        //1.如果有下一个通知，则执行通知方法，没有通知，则执行目标方法
        System.out.println("执行环绕通知B开始");
        Object result = joinPoint.proceed();
        System.out.println("执行环绕通知B结束");
        return result;
    }
}

关于代理对象生成策略说明

默认策略:

1. Spring中默认采用的动态代理的规则是JDK代理,如果被代理者没有接口.则自动使用CGLIB
2. 如果需要修改为cglib代理,则添加如下代码

@EnableAspectJAutoProxy(proxyTargetClass = true)//启用AOP

SpringBoot中默认代理模式采用CGLIB代理.如果需要修改为JDK代理则需要修改配置文件即可

• 为什么学习spring框架 让程序设计实现松耦合.
• 什么是面向接口编程 以后对象中的属性一般写接口. java中多态的体现. 属性类型更加的灵活 松耦合.
• 什么是IOC Ioc全称Inversion of
  Control，即“控制反转”，这是一种设计思想。对象创建的权利由Spring框架完成.由容器管理对象的生命周期.
• Spring容器启动方式 1. xml方式 2.注解方式
• 什么时候使用工厂模式: 1.对象不能直接实例化的时候. 2.spring框架整合其它第三方框架时使用. FactoryBean
• 单例多例问题: 默认条件下是单例模式 @Scope(“prototype”)
• 懒加载规则: 1. 默认条件下 懒加载无效 添加注解@Lazy 有效. 只对单例模式有效. spring生命周期管理 4个过程:
  1.对象创建 2. 对象初始化 @PostConstruct 3. 业务调用 4.对象销毁 @PreDestroy
• Spring中依赖注入的注解@Autowired 1.默认按照类型注入 2.可以按照名称注入 @Qualifier(“cat”)
  @Resource java中的注解.
• 10.MVC 设计思想 View 视图层 Model业务层 Control 控制层 根据MVC设计思想: 层级代码结构 Controller/Service/Mapper|Dao @Value spring为属性动态赋值
  基本类型和String和集合(几乎不用) 动态代理 JDK动态代理/CGLib动态代理

AOP 面向切面编程 在不改变源码的条件下对方法进行扩展.
AOP常见注解

1. @Aspect 标识切面
2. @Pointcut 标识切入点表达式 4种写法 2种常用
3. 五个通知注解
4. @EnableAspectJAutoProxy(proxyTargetClass = true) //开启AOP
5. 排序注解 @Order