关于SpringAOP的初步认识（个人理解）

PS：结合《Spring从入门到精通》（郭峰）这本书，谈谈对AOP
的一个初步认识，也向刚开始学习Spring的盆友推荐这本书，写的特别的好，适合初学者。
以下所有源代码均来自《Spring从入门到精通》这本书。

5.1 认识AOP
提到AOP，不得不说耦合性这个专业词语，耦合性就是使两种作用类型代码分离的理想，比如业务层和逻辑层，如果对耦合性不是特别的了解，可以了解一下Java基础部分中的Porxy代理模式，后续我可能也会对面向对象编程进行单元性的总结。
言归正传，AOP，从字面理解就是面向方面编程，不同于OOP（面向对象编程），举个例子来解释一下AOP的概念：基本上每个方法都要用日志进行记录（小程序一般不需要日志，大的项目为了方便以后的维护，需要写日志），如果按照面向对象的思想，就是每个对象都要有记录日志的这样一个行为，但是在每个方法中加入重复的日志代码，不符合基本的编程思想，所以在 AOP中，可以将记录日志看作是一个横切面，所有对这些方法的调用都要经过这个横切面，然后再这个横切面进行记录日志的操作，这样代码的重用率就非常高，这就是AOP的基本思想。

OOP与AOP的对比
一个应用程序分为核心关注点和横切关注点。核心关注点和具体应用的功能相关，而横切关注点存在于整个系统的范围内。

5.2 从一个输出日志的实例分析Java的代理机制
5.21 通用的日志输出方法

package Test;

import java.util.logging.Level;
import java.util.logging.Logger;

public class TimeBook implements TimeBookInterface{
    private Logger logger = Logger.getLogger(this.getClass().getName());
    public void doAuditing(String name){
        logger.log(Level.INFO, name + "开始审核数据。。");
        //审核数据的相关程序

        logger.log(Level.INFO, name + "审核数据结束。。");
    }
}

代码说明：
1.在业务逻辑中log4j作为日志的输出工具。
2.doAuditing方法用来处理实际业务中的实现方法（现在他们是没有分开的，耦合度很高）。
3.参数name，用来传入是谁执行了用logger.log()方法来实现日志输出的功能。
调用logger.log()实现日志的输出功能。
编写测试程序：

package Test;

public class Test {

    public static void main(String[] args) {
        TimeBook timebook = new TimeBook();
        timebook.doAuditing("张三");
    }

}

上面的代码实现了日志输出的功能，但是多个方法就需要在每个方法中编写多个重复的日志输出语句，非常麻烦，下面就用OOP的思想来编写日志输出。

5.2.2 通过面相接口编程实现日志输出
用OOP实现的思路就是：首先把执行的方法doAuditing()作为一个接口，下面用具体的实现类来实现它。
首先定义接口：

package Test;

public interface TimeBookInterface {
    public void doAuditing(String name);
}

然后是具体的实现类TimeBook ：

package Test;

import java.util.logging.Level;
import java.util.logging.Logger;

public class TimeBook implements TimeBookInterface{
    public void doAuditing(String name){
        //审核数据的相关程序
        ....
    }
}

编写一个代理类TimeBookProxy，用来实现日志的输出，在该类中针对前面的接口TimeBookInterface编程，而不是针对具体的类。

package Test;

import java.util.logging.Level;
import java.util.logging.Logger;

public class TimeBookProxy {
    private Logger logger = Logger.getLogger(this.getClass().getName());
    private TimeBookInterface tbi;
    //该类中针对前面的接口TimeBookInterface变成，而不是具体的类
    public TimeBookProxy(TimeBookInterface tbi) {
        this.tbi = tbi;
    }
    //实际业务处理
    public void doAuditing(String name){
    logger.log(Level.INFO, name + "开始审核数据。。");
    //审核数据的相关程序

    logger.log(Level.INFO, name + "审核数据结束。。");
}
}

修改测试程序，把类TimeBook当作参数传入代理类TimeBookProxy 中，从而实现对具体负责审核类TimeBook的调用：

package Test;

public class Test {

    public static void main(String[] args) {
        //针对接口进行编程
        TimeBookProxy tbp = new TimeBookProxy(new TimeBook());
        tbp.doAuditing("张三");
    }

}

和前面的对比，使用这种模式（在Java基础中叫做静态代理模式），把重用率很高的代码拿出来，用接口的实现类来编写。但是如果我不仅仅希望有人帮我把审计（auditing）的工作做了，我还希望有人帮我做其他的工作（比如翻译之类的），如果项目上线了，我怎么才能尽可能的少修改代码呢？ 下面是用AOP来解决。
5.2.3 使用Java的代理机制（动态代理）进行日志的输出
上面说到，我希望还有别的事情，也交给其他人去做，现在我需要一个类似于专门服务的家政公司。
Java提供的InvocationHandler接口可以实现这个功能，首先编写一个日志信息的代理类，实现接口InvocationHandler，然后和前面一个实例类似，编写一个接口，并且实现这个接口，在实现类中编写具体的考勤审核代码，最后编写测试类。
一个“家政公司”，LogProxy类，实现InvocationHandler，可以实现对任何接口实现日志信息的输出，即不光可以用人做审计，还可以实现让人做翻译。

package Test;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.logging.Level;
import java.util.logging.Logger;

public class LogProxy implements InvocationHandler{
    private Logger logger = Logger.getLogger(this.getClass().getName());
    private Object obj;
    //绑定特定的代理对象（代理什么都行，参考之前的动态代理代码，有化妆品代理，金融代理，看前台穿过来哪一个）
    public Object bind(Object obj){
        this.obj = obj;
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), (InvocationHandler) this);

    }
    //针对接口编程
    public Object invoke(Object proxy, Method method, Object[] args){
        Object result = null;

        try {
            logger.log(Level.INFO, args[0]+"开始审核数据。。。");
            result = method.invoke(obj, args);
            logger.log(Level.INFO, args[0]+"审核结束");
        } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            logger.log(Level.INFO, e.toString());
        }
        return result;

    }
}

一个接口TimeBookInterface

package Test;

public interface TimeBookInterface {
    public void doAuditing(String name);
}

一个具体的实现类TimeBook：

package Test;

import java.util.logging.Level;
import java.util.logging.Logger;

public class TimeBook implements TimeBookInterface{
    public void doAuditing(String name){
        //审核数据的相关程序
    }
}

然后是实现类

package Test;

public class Test {

    public static void main(String[] args) {
        //实现了对日志类（LogProxy）的重用
        LogProxy logproxy = new LogProxy();
        TimeBookInterface tbi = (TimeBookInterface) logproxy.bind(new TimeBook());
        tbi.doAuditing("张三");
    }

}

这三种是同样的输出结果，但是很明显第三种的耦合性最低。

【********************************************************】
以上所有观点只是我个人的理解，不能保证全部的正确，也希望有更深更正确理解的朋友可以指出来我的错误，在此先谢过了！