Spring（2） ---- AOP

1.1AOP

OOP (Object Orientend Programming) 面向对象编程：将程序中所有参与模块都抽形成对象，然后通过对象之间的相互调用完成特定的功能。

AOP（Aspect Orientend Programming） 面向切面编程：AOP是对OOP的一种补充，是在另外一个维度上抽象出对象，具体是指程序运行时动态将非业务代码切入到业务代码中，实现了业务代码和非业务代码的解耦和。

业务代码：方法的操作动作，核心

非业务代码：不影响方法的结果，比如：打印日志

public class CalImpl implements Cal {
    @Override
    public int add(int num1, int num2) {
        System.out.println("add方法参数是" + num1 + "," + num2); //非业务代码
        int result = num1 + num2; // 业务代码
        System.out.println("add方法的结果是" + result);//非业务代码
        return result;
}


//业务代码和非业务代码卸载一个方法中耦合度太高
//AOP实现业务代码和非业务代码分离，运行方法时将非业务代码注入--> 解耦

public interface Cal {
    public int add(int num1,int num2);
    public int sub(int num1,int num2);
    public int mul(int num1,int num2);
    public int div(int num1,int num2);
}

import org.springframework.stereotype.Component;

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

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

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

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

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.stereotype.Component;

import java.util.Arrays;

@Component //Bean注入IOC容器
@Aspect //切入点
@EnableAspectJAutoProxy //动态代理
public class LoggerAspect {
    /**
     * 参数日志
     */
    @Before("execution(public int com.southwind.aop.CalImpl.*(..))")
    public void before(JoinPoint joinPoint){
        String name = joinPoint.getSignature().getName();
        String args = Arrays.toString(joinPoint.getArgs());
        System.out.println(name + "方法的参数是" + args);
    }

    @AfterReturning(value = "execution(public int com.southwind.aop.CalImpl.*(..))",returning = "result")
    public void afterReturn(JoinPoint joinPoint,Object result){
        String name = joinPoint.getSignature().getName();
        System.out.println(name + "方法的结果是" + result);
    }
}

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Test {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext("com.southwind.aop");
        Cal cal = (Cal) applicationContext.getBean("calImpl");
        System.out.println(cal.add(1, 1));
        System.out.println(cal.sub(2, 1));
        System.out.println(cal.mul(3, 3));
        System.out.println(cal.div(10, 2));
    }
}

AOP 基于 IoC，将业务对象和切面对象分别注入到 IoC 中，同时业务对象只写业务代码，切面对象只写非业务代码，从而在代码层面实现业务代码和非业务代码的解耦合，通过 IoC 再将业务代码和非业务代码整合到一起即可，开发时解耦，运行时合并。

如何整合？通过代理对象，将业务对象注入到 IoC 中，将切面对象也注入到 IoC 中，由 IoC 负责根据业务对象和切面对象创建出一个动态代理对象，分别去完成业务代码和非业务代码的执行。

1、业务对象和切面对象必须注入到 IoC 中

2、切面对象需要添加切面注解以及动态代理注解