AOP编程
问题：
代码混乱：
越来越多的非业务需求（日志和验证等）加入后，原有的业务方法急剧膨胀，每个方法在处理核心逻辑的同事还必须兼顾其他多个关注点。
代码分散：以日志需求为例，只是为了满足这个单一需求，就不得不在多个模块（方法）里面多次重复相同的日志代码，如果日志需求发生变化，必须修改所有模块。
先看使用动态代理：
package logan.study.aop.helloworld; public interface ArithmeticCalculator { int add(int i, int j); int sub(int i, int j); int mul(int i, int j); int div(int i, int j); }
package logan.study.aop.helloworld; public class ArithmeticCalculatorImpl implements ArithmeticCalculator { @Override public int add(int i, int j) { // TODO Auto-generated method stub int result = i + j; return result; } @Override public int sub(int i, int j) { // TODO Auto-generated method stub int result = i - j; return result; } @Override public int mul(int i, int j) { // TODO Auto-generated method stub int result = i * j; return result; } @Override public int div(int i, int j) { // TODO Auto-generated method stub int result = i / j; return result; } }
package logan.study.aop.helloworld; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; import java.util.Arrays; 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:正在返回的那个对象，一般情况下，在invok方法中都不使用该对象 * method：正在被调用的方法 * args：调用方法时传入的参数 */ @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { // TODO Auto-generated method stub String methodName = method.getName(); //日志 System.out.println("The method "+ methodName + "begin with " + Arrays.asList(args)); //执行方法 Object result = method.invoke(target, args); //日志 System.out.println("The method " + methodName + "end with result = " + result); //返回 return result; } }; proxy = (ArithmeticCalculator) Proxy.newProxyInstance(loader, interfaces, h); return proxy; } }
package logan.study.aop.helloworld; public class Main { public static void main(String[] args) { // TODO Auto-generated method stub ArithmeticCalculator target = new ArithmeticCalculatorImpl(); ArithmeticCalculator proxy = new ArithmeticCalculatorLoggingProxy(target).getLoggingProxy(); int result = proxy.add(1, 2); System.out.println("-->"+result); result = proxy.div(8, 2); System.out.println("-->"+result); } }
返回的结果：
The method addbegin with [1, 2] The method addend with result = 3 -->3 The method divbegin with [8, 2] The method divend with result = 4 -->4
但是使用动态代理比较麻烦，有没有更简单的方法来实现呢？
AOP（Aspect-Oriented-Programming，面向切面编程）是一种新的方法论，是对传统OOP（Object-Oriented-Programming，面向对象编程）的补充。
AOP的主要编程对象是切面（Aspect），而切面是模块化横切关注点。
在应用AOP编程时，仍然需要定义公共功能，但是可以明确地定义这个功能在哪里，以什么方式应用，并且不必修改受影响的类，这样一来，横切关注点就被模块化到特殊的对象（切面）里。
AOP好处：
-每个事物逻辑错位与一个位置，代码不分散，便于维护和升级
-业务模块更简洁，只包含核心的业务代码
AOP术语
切面（Aspect）：横切关注点（跨越应用程序多个模块的功能）被模块化的特殊对象。
通知（Advice）：切面必须要完成的工作。
目标（Target）：被通知的对象。
代理（Proxy）：向目标对象应用通知之后创建的对象。
连接点（Joinpoint）：程序执行的每个特定位置：如类某个方法调用前，调用后，方法抛出异常等等，连接点由两个信息确定：方法表示的程序的执行点，相对点表示的方位，例如ArithmeticCalculator#add()方法执行前的连接点执行点为ArithmeticCalculator#add();方位为该方法执行前的位置。
切点（pointcut）：每个类都拥有多个连接点，例如：ArithmethicCalculator的所有方法实际上都是连接点，即连接点是程序类中客观存在的事务，AOP通过切点定位到特定的连接点。类比：连接点相当于数据库中的记录，切点相当于查询条件，切点和连接点不是一对一关系，一个切点匹配多个连接点，切点通过org.springframework.aop.Pointcut接口进行描述，它使用类和方法作为连接点的查询条件。