AOP前奏

1. 需求1-日志：在程序执行期间追踪正在发生的活动
2. 需求2-验证：希望计算器只能处理正整数的运算

public class Main {
    public static void main(String args[]) {
        ArithmeticCalculator arithmeticCalculator = null;
        arithmeticCalculator = new ArithmeticCalculatorImpl();
        int result = arithmeticCalculator.add(1, 2);
        System.out.println("-->" + result);
        result = arithmeticCalculator.sub(2, 1);
        System.out.println("-->" + result);
    }
}
public interface ArthmeticCalculator {
    int add(int i, int j);
    int sub(int i, int j);
    int mul(int i, int j);
    int div(int i, int j);
}
public class ArthmeticCalculatorImpl implements ArthmeticCalculator {
    @Override
    public int add(int i, int j) {
        System.out.println("The method add begins with[" + i + "," + j + "]");
        int result = i + j;
        System.out.println("The method add ends with " + result);
        return result;
    };
    @Override
    public int sub(int i, int j) {
        System.out.println("The method sub begins with[" + i + "," + j + "]");
        int result = i - j;
        System.out.println("The method sub ends with " + result);
        return result;
    };
    @Override
    public int mul(int i, int j) {
        System.out.println("The method mul begins with[" + i + "," + j + "]");
        int result = i * j;
        System.out.println("The method mul ends with " + result);
        return result;
    };
    @Override
    public int div(int i, int j) {
        System.out.println("The method div begins with[" + i + "," + j + "]");
        int result = i / j;
        System.out.println("The method div ends with " + result);
        return result;
    };
}

上面代码的问题

• 代码混乱：越来越多的非业务需求（日志和验证等）加入后，原有的业务方法急剧膨胀，每个方法在处理核心逻辑的同时还要兼顾其他多个关注点。

• 代码分散：已日志的需求为例，只是为了满足这个单一需求，就不得不再多个模块（方法）里多次重复相同的日志代码，如果日志发生变化，必须修改所有的模块

  使用动态代理解决上述问题

• 代理设计模式的原理：使用一个代理将对象包装起来，然后用该代理对象取代原始对象，任何对原始对象的调用都要通过代理，代理对象决定是否以及何时将方法调用转到原始对象上

-调用者发起调用
-验证代理，验证参数
-日志代理，方法日志开始
-计算器
-日志代理，方法日志结束
-返回结果给调用者

public class ArthmeticCalculatorImpl implements ArthmeticCalculator {
    @Override
    public int add(int i, int j) {
        int result = i + j;
        return result;
    };
    @Override
    public int sub(int i, int j) {
        int result = i - j;
        return result;
    };
    @Override
    public int mul(int i, int j) {
        int result = i * j;
        return result;
    };
    @Override
    public int div(int i, int j) {
        int result = i / j;
        return result;
    };
}
public class Main {
    public static void main(String args[]) {
        ArithmeticCalculator target = new ArithmeticCalculatorImpl();
        ArithmeticCalculatorLoggingProxy proxy = new ArithmeticCalculatorLoggingProxy(target)
            .getLoggingProxy();
        int result = proxy.add(1, 2);
        System.out.println("-->" + result);
        result = proxy.sub(2, 1);
        System.out.println("-->" + result);
    }
}
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.lang.reflect.Method;
public class ArithmeticCalculatorLoggingProxy {
    // 要代理的对象
    private ArithmeticCalculator target;
    public ArithmeticCalculatorLoggingProxy(ArithmeticCalculator target) {
        this.target = target;
    }
    public ArithmeticCalculator getLoggingProxy() {
        ArithmeticCalculator proxy = null;
        // 代理对象由哪一个类加载起负责加载
        ClassLoader loader = target.getClass().getClassLoader();
        // 代理对象的类型，即其中由那些方法
        Class[] interfaces = new Class[]{ArithmeticCalculator.class}
        // 当调用代理对象其中的方法时，该执行的代码
        InvocationHandler h = new InvocationHandler() {
            /**
            * proxy : 正在返回的那个代理对象，一般情况下，在invoke方法中都不使用此对象
            * method ：正在被调用的方法
            * args ：调用方法是传入的参数
            */
            @Override
            public Object invoke(Object proxy, Method method, Object[] args)
                throws Throwable {
                String methodName = method.getName();
                System.out.println("The method " + methodName + " begins with " 
                                   + Arrays.asList(args));
                Object result = null;
                try {
                    // 前置通知
                    result = method.invoke(target, args);
                    // 返回通知
                } catch (Exception e) {
                    e.printStackTrace();
                    // 异常通知
                }
                // 后置通知,因为可能异常所以可能拿不到结果
                System.out.println("The method " + methodName + " ends with " 
                                   + result);
                return result;
            }
        }
        proxy = Proxy.newProxyInstance(loader, )
    }
}

AOP 简介

• AOP（Aspect-Oriented Programming，面向切面编程）：是一种新的方法论，是对传统OOP（Object-Oriented Programming，面向对象编程）的补充。
• AOP的主要编程对象是切面（aspect），而切面模块化横切关注点。
• 在应用AOP编程时，仍然需要定义公共功能，但可以明确的定义这个功能在哪里，以什么方式应用，并且不必修改受到影响的类。这样一来横切关注点就被模块化到特殊的对象（切面）里。
• AOP的好处

-每个事物逻辑位于一个位置，代码不分散，便于维护
-业务模块更简洁，只包含核心业务代码

AOP术语

• 切面（Aspect）：横切关注点（跨越应用程序多个模块的功能）被模块化的特殊对象
• 通知（Advice）：切面必修要完成的工作
• 目标（Target）：被通知的对象
• 代理（Proxy）：向目标对象应用通知之后创建的对象
• 连接点（JoinPoint）：程序执行的某个特定的位置：如类某个方法调用前，调用后，方法抛出异常后等。连接点由两个信息确定，方法表示程序的执行点（方位执行的位置）；相对点表示的方位（方位为该方法执行前的位置）。

• 切点（pointcut）：每个类都拥有多个连接点，例如ArithmeticCalculator所有的方法都是连接点，即连接点是程序类中客观存在的事务。AOP通过切点定位到特定的连接点。类比：连接点相当于数据库中的纪录，切点相当于查询条件。切点与连接点不是一对一的关系，一个切点匹配多个连接点，切点通过org.springframework.aop.Pointcut接口进行描述，它使用类和方法作为连接点的查询条件。

  Spring前置通知

  Spring AOP

• AspectJ：Java社区里最完整最流行的AOP框架。

• 在Spring2.0以上版本中，可以使用基于AspectJ注解或基于XML配置的AOP

  在Spring中启用AspectJ注解支持

• 要在Spring应用中使用AspectJ注解，必须在classpath下包含AspectJ的类库：aopalliance.jar，aspectj.weaver.jar和spring-aspects.jar

• 将aopSchema添加到根元素中
• 要在SpringIOC容器中启用AspectJ注解支持，只要在Bean配置文件中定义一个空的xml元素
• 当SpringIOC容器侦测到Bean配置文件中的元素时，会自动为与AspectJ切面匹配的Bean创建代理。

用AspectJ注解声明切面

• 要在Spring中声明AspectJ切面，只需要在IOC容器中将切面声明为Bean实例，当在SpringIOC容器中初始化AspectJ切面之后，SpringIOC容器将会为那些与AspectJ切面相匹配的Bean创建代理。
• 在AspectJ注解中，切面只是一个带有@Aspect注解的Java类。
• 通知是标注有某种注解的简单Java方法。
• AspectJ支持5种类型的通知注解：

-@before，在方法执行之前执行
-@After ，在方法执行之后执行
-@AfterReturning：返回通知，在方法返回结果之后执行
-@AfterThrowwing：异常通知，在方法抛出异常之后
-@Around：环绕通知，围绕着方法执行

利用方法签名便携ApectJ切点表达式

• 最典型的切入点表达式时根据方法的签名来匹配的各种方法

-execution com.lijunyang.model.ArithmeticCalculator.(..) 第一个匹配任意修饰符以及任意返回值，第二个表示任意方法
-execution public com.lijunyang.model.ArithmeticCalculator.(…) 匹配ArithmeticCalculator接口的所有公共有方法
-execution public double com.lijunyang.model.ArithmeticCalculator.(…) 匹配返回值是double的方法
-execution public double com.lijunyang.model.ArithmeticCalculator.(double,..)匹配第一个参数是double的任意方法

// src/beans.xml
<beans>
    <context:component-scan base-package="com.lijunyang.model" />
    <aop:aspectj-autoproxy />
</beans>

// src/com/lijunyang/test/Main.java
public class Main {
    public static void main(String args[]) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
        ArthmeticCalculator arthmeticCalculator = ctx.getBean(ArthmeticCalculator.class);
        int result = arthmeticCalculator.add(1, 2);
        System.out.println("result: " + result);
    }
}
// src/com/lijunyang/model/LoggingAspect.java
import org.springframework.stereotype.Component;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowwing;
import java.awt.List;
import java.util.Arrays;
@Aspect
@Component
public class LoggingAspect {
    /*
    @Around("execution(public int com.lijunyang.model.ArithmeticCalculator.add(int, int))")
    public Object AroundMethod(ProceedingJoinPoint pjd) {
        Object result = null;
        String methodName = pjd.getSignature().getName();
        try {
            result = pjd.proceed();
        }catch(Throwable e) {
            throw new RuntimeException(e);
        }
        return result;
    }
    */
    // @Before("execution(public int com.lijunyang.model.ArithmeticCalculator.add(int, int))")
    @Before("execution(public int com.lijunyang.model.ArithmeticCalculator.*(int, int))")
    public void beforeMethod(JoinPoint joinPoint){
        String methodName = joinPoint.getSignature().getName();
        List<Object> args = Arrays.asList(joinPoint.getArgs());
        System.out.println("The " + methodName + " begins with " + args);
    }
    @After("execution(public int com.lijunyang.model.ArithmeticCalculator.*(int, int))")
    public void afterMethod(JoinPoint joinPoint) {
        // 后置通知：在目标方法执行后（无论是否发生异常），执行的通知。
        // 在后置通知中还不能访问目标方法的执行结果
        String methodName = joinPoint.getSignature().getName();
        System.out.println("The " + methodName + " ends ");
    }
    @AfterReturning("execution(* com.lijunyang.model.ArithmeticCalculator.*(int, int))"
                   ,returning="result")
    public void afterReturningMethod(JoinPoint joinPoint, Object result) {
        // 返回通知可以获取到返回值
        // 当异常时，不执行
        String methodName = joinPoint.getSignature().getName();
        System.out.println("The " + methodName + " ends " + result);
    }
    @AfterThrowwing(value="execution(* com.lijunyang.model.ArithmeticCalculator.*(int, int))"
                   ,throwing=ex)
    public void afterReturningMethod(JoinPoint joinPoint,NullPointerException ex) {
         String methodName = joinPoint.getSignature().getName();
        System.out.println("The " + methodName + " occurs exception: " + ex);
    }
}
// src/com/lijunyang/model/ArthmeticCalculator.java
public interface ArthmeticCalculator {
    int add(int i, int j);
    int sub(int i, int j);
    int mul(int i, int j);
    int div(int i, int j);
}
// src/com/lijunyang/model/ArthmeticCalculatorImpl.java
import org.springframework.stereotype.Component;
@Component("arthmeticCalculator")
public class ArthmeticCalculatorImpl implements ArthmeticCalculator {
    @Override
    public int add(int i, int j) {
        System.out.println("The method add begins with[" + i + "," + j + "]");
        int result = i + j;
        System.out.println("The method add ends with " + result);
        return result;
    };
    @Override
    public int sub(int i, int j) {
        System.out.println("The method sub begins with[" + i + "," + j + "]");
        int result = i - j;
        System.out.println("The method sub ends with " + result);
        return result;
    };
    @Override
    public int mul(int i, int j) {
        System.out.println("The method mul begins with[" + i + "," + j + "]");
        int result = i * j;
        System.out.println("The method mul ends with " + result);
        return result;
    };
    @Override
    public int div(int i, int j) {
        System.out.println("The method div begins with[" + i + "," + j + "]");
        int result = i / j;
        System.out.println("The method div ends with " + result);
        return result;
    };
}

AOP的优先级与重用切点表达式

@order(1) // 通过这个设置优先级，值越小优先级越高
@Aspect
@Component
public class VlidationAspect {
    // @Before("execution(public int com.lijunyang.model.ArithmeticCalculator.*(int, int))")
    @Before("LoggingAspect.declareJointPointExpression()")
    public void validateArgs(JoinPoint joinPoint) {
        System.out.println("validate:" + Arrays.asList(joinPoint.getArgs()));
    }
}
@order(2)
@Aspect
@Component
public class LoggingAspect {
    @Pointcut("execution(public int com.lijunyang.model.ArithmeticCalculator.*(..))")
    public void declareJointPointExpression() {}
    /*
    @Around("execution(public int com.lijunyang.model.ArithmeticCalculator.add(int, int))")
    public Object AroundMethod(ProceedingJoinPoint pjd) {
        Object result = null;
        String methodName = pjd.getSignature().getName();
        try {
            result = pjd.proceed();
        }catch(Throwable e) {
            throw new RuntimeException(e);
        }
        return result;
    }
    */
    // @Before("declareJointPointExpression()")
    @Before("execution(public int com.lijunyang.model.ArithmeticCalculator.*(int, int))")
    public void beforeMethod(JoinPoint joinPoint){
        String methodName = joinPoint.getSignature().getName();
        List<Object> args = Arrays.asList(joinPoint.getArgs());
        System.out.println("The " + methodName + " begins with " + args);
    }
    @After("declareJointPointExpression()")
    public void afterMethod(JoinPoint joinPoint) {
        // 后置通知：在目标方法执行后（无论是否发生异常），执行的通知。
        // 在后置通知中还不能访问目标方法的执行结果
        String methodName = joinPoint.getSignature().getName();
        System.out.println("The " + methodName + " ends ");
    }
    @AfterReturning("declareJointPointExpression()"
                   ,returning="result")
    public void afterReturningMethod(JoinPoint joinPoint, Object result) {
        // 返回通知可以获取到返回值
        // 当异常时，不执行
        String methodName = joinPoint.getSignature().getName();
        System.out.println("The " + methodName + " ends " + result);
    }
    @AfterThrowwing(value="declareJointPointExpression()"
                   ,throwing=ex)
    public void afterReturningMethod(JoinPoint joinPoint,NullPointerException ex) {
         String methodName = joinPoint.getSignature().getName();
        System.out.println("The " + methodName + " occurs exception: " + ex);
    }
}

引用通知（内容缺失）

• 引入通知是一种特殊的通知类型，它通过为接口提供实现类，允许对象动态的实现接口，就像对象已经在运行时扩展了实现类一样。
• 引入通知可以使用两个实现类MaxCalculatorImpl和MinCalculatorImpl，让ArthmeticCalculatorImpl动态的实现MaxCalculator和MinCalculator接口，而这与从MaxCalculatorImpl和MinCalculatorImpl实现多继承的效果相同，但却不需要修改ArthmeticCalculatorImpl的源代码。
• 引入通知也必须在切面中声明
• 在切面中，通过任意字段添加@DeclareParents注解来引入声明。
• 注解类型的value属性表示那些类是当前引入通知的目标，value属性值也可以是一个AspectJ类型的表达式，以将一个即可引入到多个类中，defaultImpl属性中指定了这个接口的使用实现类

基于配置文件的方式配置AOP

// src/beans.xml
<beans>
    <bean id="arithmeticCalculator" class="com.lijunyang.model.ArithmeticCalculatorImpl" />
    <bean id="vlidationAspect" class="com.lijunyang.model.VlidationAspect"/>
    <bean id="loggingAspect" class="com.lijunyang.model.LoggingAspect" />
    <aop:config>
        <aop:pointcut id="pointcut"
        expression="execution(* com.lijunyang.model.ArithmeticCalculator.*(int, int))" />
        <aop:aspect ref="vlidationAspect" order="1">
            <aop:before method="validateArgs" pointcut-ref="pointcut" />
        </aop:aspect>
        <aop:aspect ref="loggingAspect" order="2">
            <aop:before method="beforeMethod" pointcut-ref="pointcut" />
            <aop:before method="afterMethod" pointcut-ref="pointcut" />
            <aop:before method="afterReturningMethod"
                returning="result" pointcut-ref="pointcut" />
            <aop:before method="afterTorowingMethod" 
                 throwing="ex" pointcut-ref="pointcut" />
           <!--<aop:around method="aroundMethod" pointcut-ref="pointcut" />-->
        </aop:aspect>
    </aop:config>
</beans>