SpringAop--相关名词--xml配置实现aop--注解实现aop(当下主流)

最新推荐文章于 2022-06-12 09:49:04 发布

Strong_shady

最新推荐文章于 2022-06-12 09:49:04 发布

阅读量100

点赞数 1

分类专栏：框架

本文链接：https://blog.csdn.net/Strong_shady/article/details/118766156

版权

框架专栏收录该内容

38 篇文章 1 订阅

订阅专栏

我们若想把一些代码统一的放在某些类的方法中，就衍生出aop。

配置实现aop：

xml配置：

   <bean id="logAspect" class="cn.itnls.aop.LogAspect"/>
   <aop:config>
      <aop:aspect ref="logAspect">
         <!--切入点 expression:表达式匹配要执行的方法，用来确定通知往哪写类哪些方法里切入。第一个*代表任何的返回值，.*.*(..))：impl包下的任何类的任何方法任何参数都切进去。-->
         <aop:pointcut id="logAspectPointCut" expression="execution(* cn.itnls.service.Impl.*.*(..))"/>
<!--         作用于方法开始之前-->
         <aop:before method="before" pointcut-ref="logAspectPointCut"/>
<!--         方法已经结束了-->
         <aop:after method="after" pointcut-ref="logAspectPointCut"/>
<!--         返回之后执行aspect代码，方法还未结束不能和around共存-->
         <aop:after-returning method="returning" pointcut-ref="logAspectPointCut"/>
         <aop:after-throwing method="throwing" pointcut-ref="logAspectPointCut"/>
<!--        把原来的代码覆盖，执行around相关代码，不能和returning共存， 用的少 -->
         <aop:around method="round" pointcut-ref="logAspectPointCut"/>
      </aop:aspect>
   </aop:config>

aop主类

public class LogAspect {

    public void before(){
        System.out.println("执行方法之前打印一条日志！ -- 自定义形式");
    }

    public void after(){
        System.out.println("执行方法之后打印一条日志！ -- 自定义形式");
    }

    public void round(){
        System.out.println("round打印一条日志！ -- 自定义形式");
    }

    public void returning(){
        System.out.println("returning打印一条日志！ -- 自定义形式");
    }

    public void throwing(){
        System.out.println("throwing打印一条日志！ -- 自定义形式");
    }
}

测试方法

 @Test
    public void iocTest1(){
        AbstractApplicationContext applicationContext =
                new ClassPathXmlApplicationContext("application.xml");
        IUserService iUserService  = applicationContext.getBean(IUserService.class);
        iUserService.findUserById(2);
    }

注解实现aop：

主类：

@Component
@Aspect
public class LogAspect {

    //方法执行前
    //若想让打了特定注解的方法上织入此通知，则：@Before("@annotation(该特定注解的全路径类名)")
    @Before("execution(* cn.itnls.service.Impl.*.*(..))")
    public void before(){
        System.out.println("执行方法之前打印一条日志！ -- 自定义形式");
    }
//  方法执行后，有没有异常都会执行
    @After("execution(* cn.itnls.service.Impl.*.*(..))")
    public void after(){
        System.out.println("执行方法之后打印一条日志！ -- 自定义形式");
    }
//环绕通知，会覆盖原有方法的内容
//    @Around("execution(* cn.itnls.service.Impl.*.*(..))")
//    public void round(){
//        System.out.println("round打印一条日志！ -- 自定义形式");
//    }

//    返回通知，返回之后进行切入，有异常就不执行了
    @AfterReturning("execution(* cn.itnls.service.Impl.*.*(..))")
    public void returning(){
        System.out.println("returning打印一条日志！ -- 自定义形式");
    }

//    发生异常会进行通知
    @AfterThrowing("execution(* cn.itnls.service.Impl.*.*(..))")
    public void throwing(){
        System.out.println("throwing打印一条日志！ -- 自定义形式");
    }
}

xml配置中：

<aop:aspectj-autoproxy/>

测试方法和配置相同

Joinpoint的使用

通过此方式对注解进行灵活配置，注解可以加一些参数辅助横切.拿到连接点，并处理连接点相关的内容

自定义注解：

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface LogAnnotation {
    String value() default "show";
}

Aspect通知类：

@Component
@Aspect
public class LogAspect {

    //方法执行前
    //若想让打了特定注解的方法上织入此通知，则：@Before("@annotation(该特定注解的全路径类名)")
    @Before("@annotation(cn.itnls.annotation.LogAnnotation)")
    public void before(){
        System.out.println("执行方法之前打印一条日志！ -- 自定义形式");
    }
//  方法执行后，有没有异常都会执行
    @After("@annotation(cn.itnls.annotation.LogAnnotation)")
    public void after(JoinPoint joinPoint){
        //获得代理对象
//        Object target = joinPoint.getTarget();
        //获得被代理对象
//        Object aThis = joinPoint.getThis();
        //
        MethodSignature signature = (MethodSignature)joinPoint.getSignature();
        Method method = signature.getMethod();
        LogAnnotation annotation = method.getAnnotation(LogAnnotation.class);

        String value = annotation.value();
        System.out.println(value);
        System.out.println("执行方法之后打印一条日志！ -- 自定义形式");
    }
//环绕通知，会覆盖原有方法的内容
//    @Around("execution(* cn.itnls.service.Impl.*.*(..))")
//    public void round(){
//        System.out.println("round打印一条日志！ -- 自定义形式");
//    }

//    返回通知，返回之后进行切入，有异常就不执行了
    @AfterReturning("@annotation(cn.itnls.annotation.LogAnnotation)")
    public void returning(){
        System.out.println("returning打印一条日志！ -- 自定义形式");
    }

//    发生异常会进行通知
    @AfterThrowing("@annotation(cn.itnls.annotation.LogAnnotation)")
    public void throwing(){
        System.out.println("throwing打印一条日志！ -- 自定义形式");
    }
}

被自定义注解标注的方法：

@Controller
public class UserController {
    @Autowired
    private IUserService userService;

    @LogAnnotation("show-ssr")
    public void showUser(Integer id){
        System.out.println(userService.findUserById(id));
    }
}

结果：
执行方法之前打印一条日志！ – 自定义形式
方法在执行
--------使用了--------
User{id=1, username=‘18’, password=‘15’}
returning打印一条日志！ – 自定义形式
show-ssr
执行方法之后打印一条日志！ – 自定义形式

环绕通知：

自己写的方法可以被切入的内容“环绕”起来，只要写了环绕通知，其他通知，包括自定义被通知的方法，都被覆盖掉了。

若想在方法前后加内容，并且内容有关联，就用环绕通知

先把其他通知都注释掉：

@Around("execution(* cn.itnls.service.Impl.*.*(..))")
    public void round(ProceedingJoinPoint pjp){
        System.out.println("round打印一条日志！ -- 自定义形式");
        try {
            pjp.proceed(); //★执行目标方法
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
        System.out.println("after");
    }

Strong_shady

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
SpringAop--相关名词--xml配置实现aop--注解实现aop(当下主流)

相关名词：通知、增强处理（Advice）:就是你想要增加的功能，也就是上说的安全、事物、日志、(开启关闭事务、回滚事务…)等。你给先定义好，然后再想用的地方用一下。包含Aspect的一段处理代码.连接点:就是spring允许你是通知（Advice/增加功能）的地方，那可就真多了，基本每个方法的前、后（两者都有也行），或抛出异常是时都可以是连接点，spring只支持方法连接点。其他如AspectJ还可以让你在构造器或属性注入时都行，不过那不是咱们关注的，只要记住，和方法有关的前前后后都是连接点。切入
复制链接

扫一扫