【Javaspring 学习笔记】面向切面编程——AOP

1、aop:aspect oriented programming 面向切面编程

2、aop在spring中的作用：

    提供声明式服务（事务）

    允许用户实现自定义切面

3、在不改变原有代码的情况下，增加新的功能.是一种横向的编程（代理类中横插进来一些代码）

4、AOP的好处：

 （1）、使得真实角色处理的业务更加纯粹，不再关注一些公共的事情

 （2）、公共的业务由代理来完成，实现业务的分工

 （3）、公共业务发生扩展中，

5、关注点：增加某个业务：如日志、安全、缓存、事务等

6、切面：aspect 一个关注点的模块化

7、连接点：一个方法的执行

8、通知：在切面的某个特点的连接点执行的动作

9、使用spring实现aop

第一种实现方式： 

public class Log  implements MethodBeforeAdvice {
    /**
     *
     * @param method 被调用方法对象
     * @param objects 调用方法的参数
     * @param o 被调用方法的目标对象
     * @throws Throwable
     */
    public void before(Method method, Object[] objects, Object o) throws Throwable {
        System.out.println(o.getClass().getName()+"的"+method.getName()+"被实现");
    }
}

第二种实现方式：注解

首先建一个切面类，声明切点在哪

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

/**
 * @author 贺文杰
 * 2018/8/1 7:57
 */
@Component
@Aspect //声明切面
public class UserAspect {


    /**
     *  声明切点
     */
    @Pointcut(value = "execution(* com.hewenjie.service.*.*(..))")
    public void pointCut(){}

    /**
     * 前置通知
     * @param joinPoint
     */
    @Before(value = "pointCut()")
    public void doBefore(JoinPoint joinPoint){ //连接点 程序执行的点，用于链接程序的方法
        //获取程序的方法名
        String name=joinPoint.getSignature().getName();
        System.out.println(name);
        //获取程序的方法参数
        Object[] args= joinPoint.getArgs();
        System.out.println(args.toString());
    }

    /**
     * 后置通知
     * @param joinPoint
     */
    @After(value = "pointCut()")
    public  void doAfter(JoinPoint joinPoint){
        //获取程序的方法名
        String name=joinPoint.getSignature().getName();
        System.out.println(name);
        //获取程序的方法参数
        Object[] args= joinPoint.getArgs();
        System.out.println(args.toString());
    }

 

在主函数中调用的时候，就会执行前置后置的方法。

  /**
     * 环绕通知
     * @param proceedingJoinPoint
     */
    @Around(value = "pointCut()")
    public void  around(ProceedingJoinPoint proceedingJoinPoint)
    {
        try {
            //拦截切点后，继续执行
            proceedingJoinPoint.proceed();
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
    }