静态代理、动态代理（AOP 底层实现机制）

代理模式可以分为：

• 静态代理
• 动态代理（AOP底层机制）

1、静态代理

  静态代理，就是通过一个“中介”来帮我们实现一些功能，就按租房子来说，房东和我们都是通过中介来进行交易的，那么这个中介就是静态代理，代理可以帮助我们实现一些繁琐的事项，而我们和房东的功能就比较纯粹。下面我们可以通过代码来实现一下这个例子。

接口实现

// 租房子这一事件的接口
package com.lxc.apo;

public interface Rent {
    void rent();
}

“房东的实现”

package com.lxc.apo;

public class Host implements Rent {

    public void rent() {

        System.out.println("房东要出租房子");
    }
}

代理

package com.lxc.apo;

//中介（代理）
public class Proxy implements Rent {

    //房东
    private Host host;

    public void setHost(Host host) {
        this.host = host;
    }

    public void rent() {
        lookHouse();
        host.rent();
        fare();
    }
//中介实现繁琐的事项
    private void lookHouse(){
        System.out.println("中介带你看房");
    }

    private void money(){
        System.out.println("收取中介费");
    }
}

我们租房子测试

package com.lxc.apo;

public class YouSelf {
    public static void main(String[] args) {
        //房子
        Host host = new Host();
        //中介
        Proxy proxy = new Proxy();
        //中介代理你进行租房子
        proxy.setHost(host);
        proxy.rent();
    }
}

运行结果展示

上面可以看到，代理替我们实现了租房子，而且实现了别的业务，这样的好处有：

1. 可以使真实角色的业务更加纯粹，不需要关注一些公共的事项
2. 扩展公共的业务可以更加集中和方便
3. 代理替我们实现了公共的业务，实现了业务的分工

  那么缺点也因此诞生了，如果有很多个我们，代理也会有很多个，这样会使工作量变大，开发效率变低，这对一个码农来说可是致命的缺点，那么我们就可以通过 动态代理来避免这些问题。

2、动态代理

  动态代理和静态代理的不同就是，静态代理的代理类是我们事先写好的，而动态代理的类是自动成的。在此之前我们需要了解动态代理涉及的两个类：

• InvocationHandler
• Proxy

1、InvocationHandler

  该接口中仅定义了一个方法Object：invoke(Object obj,Method method,Object[] args）。在实际使用时，第一个参数 obj 一般是指代理类，method 是被代理的方法，args为该方法的参数数组。这个抽象方法在代理类中动态实现。

2、Proxy

Proxy提供了创建动态代理类和实例的静态方法，它也是由这些方法创建的所有动态代理类的超类。

newProxyInstance(ClassLoader loader, 类<?>[] interfaces, InvocationHandler h)

返回指定接口的代理类的实例，该接口将方法调用分派给指定的调用处理程序。

---

代码实现：

租房这一抽象的事件

package com.lxc.apo;

public interface Rent {
    void rent();
}

真实角色房东

package com.lxc.apo;

public class Host implements Rent {

    public void rent() {

        System.out.println("房东要出租房子");
    }
}

动态代理类生成的接口对象

package com.lxc.apo;

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

public class InvocationHandlerProxy implements InvocationHandler {
    private Rent rent;

    //动态生成代理类
    public Object getProxy() {
        return Proxy.newProxyInstance(this.getClass().getClassLoader(), rent.getClass().getInterfaces(), this);
    }

    //proxy:代理类
    //method ：代理类的调用处理程序的方法 的对象
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        loolHuse();
        Object result = method.invoke(rent, args);
        money();
        return result;
    }

    private void loolHuse() {

        System.out.println("中介带你看房子");
    }

    private void money() {

        System.out.println("收取中介费");

    }

    public void setRent(Rent rent) {

        this.rent = rent;

    }
}

进行测试

package com.lxc.apo;

public class Test {
    public static void main(String[] args) {
        Host host = new Host();
        InvocationHandlerProxy ihp = new InvocationHandlerProxy();
        ihp.setRent(host);
        Rent proxy = (Rent) ihp.getProxy();//动态
        proxy.rent();
    }
}

上面就是动态代理的实现，动态代理的好处也有以下几点：

1. 可以使真实角色更加纯粹，不用去关注一些公共的事情；
2. 公共的业务由代理来完成，实现业务的分工；
3. 公共业务的要扩展的话，可以更加集中和方便；
4. 一个动态代理，一般代理一类的业务，一个动态代理可以代理多个类，代理接口；