Spring笔记：AOP基础

Spring笔记：AOP基础

AOP

引入AOP

　　面向对象的开发过程中，我们对软件开发进行抽象、分割成各个模块或对象。例如，我们对API抽象成三个模块，Controller、Service、Command，这很好地解决了业务级别的开发，但是对于系统级别的开发我们很难聚集。比如每一个模块需要打印日志、代码监控、异常检测等。我们只能将日志代码嵌套在各个对象上，无法关注日志本身。

　　为了更好地将系统系统级别的代码抽离出来，去掉和对象的耦合，就产生了AOP（面向切面）。如下图，OOP是一种横向扩展，AOP是一种纵向扩展。AOP依赖OOP，进一步将系统级别的代码抽象出来，进行纵向排列，实现低耦合。

 

AOP的家庭成员

• 　PointCut：:即在哪个地方进行切入，它可以指定一个点，也可以指定多个点。
• 　Advice：连接点，在切入点（PointCut）干什么，比如打印日志、执行缓存、处理异常等。
• 　Advisor/Aspect：PointCut与Advice形成了切面Aspect，这个概念本身即代表切面的所有元素，Proxy技术会将切面植入到代码中。
• 　Proxy:代理，相当于一个管理部分，它管理了AOP如何融入OOP。

NOTE：Aspect虽然是面向切面核心思想的重要组成部分，但是其思想的践行者是Proxy，也是实现AOP的难点与核心所在。

 

技术实现Proxy

静态代理

　　设计模式中讲过代理模式，此处不在赘述。

　　之所以称为静态dialing，是因为静态与动态是有代理产生的时间来决定，静态代理产生于代码编译阶段，即一旦代码运行就不变了。

　　

　　举个例子，我们实现一个简单的日志管理系统：

public interface IPerson {
    public void doSomething();
}

public class Person implements IPerson {
    public void doSomething(){
        System.out.println("I want wo sell this house");
    }
}

public class PersonProxy {
    private IPerson iPerson;
    private final static Logger logger = LoggerFactory.getLogger(PersonProxy.class);

    public PersonProxy(IPerson iPerson) {
        this.iPerson = iPerson;
    }
    public void doSomething() {
        logger.info("Before Proxy");
        iPerson.doSomething();
        logger.info("After Proxy");
    }

    public static void main(String[] args) {
        PersonProxy personProxy = new PersonProxy(new Person());
        personProxy.doSomething();
    }
}

　　通过代理类我们可以将日志代码集成到了目标类，但从上面我们可以看出它具有很大的局限性：需要固定的类编写接口（或许还可以接受，毕竟有提倡面向接口编程），需要实现接口的每一个函数（不可接受），同样会造成代码的大量重复，将会使代码更加混乱。

动态代理

　　SpringAOP是动态代理的典范，我们需要先熟悉一下动态代理的相关概念。

　　Mybatis中，Mapper仅仅是一个接口，而不是一个包含逻辑的实现类，我们知道一个接口是无法去执行的，那么它是如何运行的呢？这不是违反了教科书所说的接口不能运行的道理吗？

　　答案就是动态代理，不妨先来看一下Mapper到底是什么东西。

　　很显然Mapper产生了代理类，这个代理类是MyBatis为我们创建。

代理模式

　　所谓的代理模式就是在原有的服务上多加了一个占位，通过这个占位去控制服务的访问。

　　举例子，假设你是一个公司的工程师，能提供一些技术服务，公司的客服是一个美女，他不懂技术。而我是一个客户，徐你们公司提供技术服务。显然，我只会找你们公司的客服，和客服沟通，而不是找你沟通。客服会根据公司的规章制度和业务规则来决定找不找你服务。那么此时客服就等同于你的代理，她通过和我的交流来控制对你的访问，当然他也可以提供一些你们公司对外的服务。而我只能通知他的代理访问你。对我而言，我跟本不需要认识你，只需要认识客服就可以了。事实上，站在我的角度，我会认为客服就是代表你们公司，而不管真正为我服务的你是怎么样的。

　　其次，为什么要用代理模式呢？通过代理可以控制如何访问真正的服务对象，提供额外的服务。另外有机会通过重写一些类来满足特定的需要，正如客服也可以根据公司的业务规则，提供一些服务，这个时候就不需要你劳你大驾了。

　　一般来说，代理分为两种，一种是JDK反射机制提供的代理，另一种是CGLIB代理。

JDK动态代理

　　JDK的动态代理，是由JDK的Java.lang.reflect包提供支持的，我们需要完成几个步骤：

• 　　编写服务类和接口，这个是真正的服务提供者，在JDK代理中接口是必须的。
• 　　编写代理类，提供绑定和代理方法。

　　JDK最大的缺点就是需要提供接口，而MyBatis的Mapper就是一个接口它采用的就是JDK的动态代理。我们先给一个服务接口。

public interface HelloService{
   public void sayHello(String name);  
}

　　然后，写一个实现类

public class HelloServiceImpl implements HelloService{
    public void sayHello(String name)
    {
        System.out.println("Hello"+name);
    }  
}

　　现在我们写一个代理类，提供真实对象的绑定和代理方法。代理类的要求是实现InvocationHandler接口的代理方法。

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class HelloServiceProxy implements InvocationHandler
{
    /**
     * 真实服务对象
     */
    private Object target;

    /**
     * 绑定委托对象，并返回一个代理类
     * @param target
     * @return
     */
    public Object bind(HelloService target)
    {
        this.target=target;
        //取得代理对象
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
    }

    /**
     *
     * @param proxy  代理对象
     * @param method  被调用的方法
     * @param args  方法的参数
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("*****我是JDK动态代理*****");
        Object result = null;
        //反射方法前调用
        System.out.println("我准备说Hello");
        //执行方法，相当于调用HelloServiceImp类的sayHello方法
        result = method.invoke(target,args);
        //反射方法后调用
        System.out.println("我说过Hello了");
        return result;
    }

}

　下面这段代码让JDK产生一个代理对象，第一个参数是类加载器，第二个参数是接口(代理对象挂在哪一个接口下)，第三个参数代表当前类，表示使用当前类的代理方法作为对象的代理执行者。

　　Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),this);

　一旦绑定后，在进入代理对象方法调用的时候就会到HelloServiceProxy的代理方法上，代理方法有三个参数，第一个proxy是代理对象，第二个是当前调用的方法、第三个是方法的参数。

　我们可以用下面这段代码测试一下动态代理的效果：

public class HelloServiceMain {
    public static void main(String[] args) {
        HelloServiceProxy helloHandler = new HelloServiceProxy();
        HelloService proxy = (HelloService) helloHandler.bind(new HelloServiceImpl());
        proxy.sayHello(",ms");
    }
}

 效果是这样的：

输出：
*****我是JDK动态代理*****
我准备说Hello
Hello,ms
我说过Hello了

CGLIB动态代理

　　JDK提供的动态代理存在一个缺陷，就是你必须提供接口才可以使用，为了克服缺陷，我们可以使用开源框架——CGLIB，它是一种流行的动态代理。