Spring AOP

简介

AOP：Aspect Oriented Programming 面向切面编程
优点：

• 降低模块之间的耦合度
• 使系统更加容易拓展
• 更好的代码复用
• 非业务代码更加集中，便于统一管理
• 业务代码更加简洁纯粹

AOP是对面向队形编程的一个补充，在运行时，动态的将代码切入到累的制定方法，指定位置上的编程思想就是面向切面编程，将不同方法的同一位置抽象成一个切面对象，对该切面对象进行编程就是AOP。

使用示例

• 创建maven工程，pom.xml添加依赖

		<dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.3.25.RELEASE</version>
        </dependency>
		<dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>4.3.25.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>4.3.25.RELEASE</version>
        </dependency>

• 创建一个计算器接口Cal，定义4个方法。

原始方式

public interface Cal {
    int add(int num1, int num2);

    int sub(int num1, int num2);

    int mul(int num1, int num2);

    int div(int num1, int num2);
}

public class CalImpl implements Cal {
    public int add(int num1, int num2) {
        System.out.println("add方法参数是["+num1+","+num2+",]");
        int result=num1+num2;
        System.out.println("add方法的结果是"+result);
        return result;
    }

    public int sub(int num1, int num2) {
        System.out.println("sub方法参数是["+num1+","+num2+",]");
        int result=num1-num2;
        System.out.println("sub方法的结果是"+result);
        return result;
    }

    public int mul(int num1, int num2) {
        System.out.println("mul方法参数是["+num1+","+num2+",]");
        int result=num1*num2;
        System.out.println("mul方法的结果是"+result);
        return result;
    }

    public int div(int num1, int num2) {
        System.out.println("div方法参数是["+num1+","+num2+",]");
        int result=num1/num2;
        System.out.println("div方法的结果是"+result);
        return result;
    }
}

上述代码中，日志信息和业务逻辑的耦合性很高，不利于系统的维护，使用AOP进行优化，
如何使用AOP？
使用动态代理来实现

给业务代码找一个代理，打印日志信息的工作交个代理来做，这样的话业务代码就只需要关注自身的业
务即可。

创建动态代理类,实现InvocationHandler接口

public class MyInvacationHandler implements InvocationHandler {
    //接收委托对象
    private Object obj;
    //返回代理对象
    public  Object bind(Object obj){
        this.obj=obj;
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(),this);
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println(method.getName()+"方法的参数是："+ Arrays.toString(args));
        Object result=method.invoke(this.obj,args);
        System.out.println(method.getName()+"结果是"+result);
        return result;
    }
}

业务方法：

public class CalImpl implements Cal {
    public int add(int num1, int num2) {
        int result=num1+num2;
        return result;
    }

    public int sub(int num1, int num2) {
        int result=num1-num2;
        return result;
    }

    public int mul(int num1, int num2) {
        int result=num1*num2;
        return result;
    }

    public int div(int num1, int num2) {
        int result=num1/num2;
        return result;
    }
}

main 方法：

	  public static void main(String[] args) { 

        Cal cal=new CalImpl();
        MyInvacationHandler invacationHandler=new MyInvacationHandler();
        Cal cal1=(Cal)invacationHandler.bind(cal);
        cal1.add(1,1);
        cal1.sub(2,1);
        cal1.mul(2,1);
        cal1.div(4,2);
    }

以上是通过动态代理实现aop的过程，比较复杂，不好理解，spring 框架对Aop进行了封装，使用spring 框架可以用面向对象的思想来实现aop
spring 框架中不需要创建InvocationHandler，只需要创建一个切面对象，将所欲偶的非业务代码在切面对象中完成即可，Spring 框架底层会自动根据切面类以及目标类生成一个代理对象。

创建LoggerAspect切面类

@Aspect
@Component
public class LoggerAspect {

    @Before("execution (public int com.youzm.impl.CalImpl.*(..))")
    public  void  before(JoinPoint joinPoint){
        String name=joinPoint.getSignature().getName();
        String args=Arrays.toString(joinPoint.getArgs());
        System.out.println(name+"方法的参数是："+ args);
    }
   @After("execution (public int com.youzm.impl.CalImpl.*(..))")
    public  void after(JoinPoint joinPoint){
        String name=joinPoint.getSignature().getName();
        System.out.println(name+"执行完毕");
    }
    @AfterReturning(value = "execution (public int com.youzm.impl.CalImpl.*(..))",returning = "result")
    public void afterReturning(JoinPoint joinPoint,Object result){
        String name=joinPoint.getSignature().getName();
        System.out.println(name+"方法结果是"+result);
    }

      @AfterThrowing(value = "execution (public int com.youzm.impl.CalImpl.*(..))",throwing = "ex")
    public void afterThrowing(JoinPoint joinPoint,Exception ex){
          String name=joinPoint.getSignature().getName();
          System.out.println(name+"方法抛出异常"+ex);
      }
}

类定义添加的注解：

• ```@Aspect````:表示该类是切面类
• ```@Component``：将该类的对象注入到ioc容器

具体方法出添加的注解：

• @Before：表示⽅法执⾏的具体位置和时机。

CalImpl也需要添加@Component，交给ioc容器管理

	@Component
	public class CalImpl implements Cal 

Spring.xml中进行配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
 http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
 http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.3.xsd
">
    <!--自动扫描-->
    <context:component-scan base-package="com.youzm"></context:component-scan>

    <!--使Aspect注解生效，为目标类自动生成代理对象-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

</beans>

context:component-scan将com.youzm包中的所有类进行扫描，如果该类添加@Component，则将该类扫描的ioc容器中。

aop:aspectj-autoproxy让spring框架结合切面类和目标类自动生成动态代理对象。

使用：

	public static void main(String[] args) {
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("spring-aop.xml");
        Cal cal=(Cal)applicationContext.getBean("calImpl");
        cal.add(1,5);

    }

• 切面：横切关注点被模块化的抽象对象
• 通知：切面对象完成的工作
• 目标：被通知的对象，被横切的对象
• 代理：切面，通知，目标混合之后的对象
• 连接点：同志要插入业务代码的集体位置
• 切点：aop通过切点定位到连接点

参考视频：B站楠哥–spring