代理模式

代理模式

 给某一个对象提供一个代理对象，并由代理对象控制原对象的引用。

 有些时候，一个客户不想或者不能直接引用一个对象，可以通过代理对象在客户端和目标对象之前起到中介作用。代理模式的角色：

1.抽象对象角色

声明了目标对象和代理对象共同的接口，这样一来在任何可以使用目标对象的地方都可以使用代理对象。

2.目标对象角色

定义了代理对象所代表的目标对象

3.代理对象角色

代理对象内部含有目标对象的引用，从而可以在任何时候操作目标对象，代理对象提供一个目标对象相同的接口，以便可以在任何时候替代目标对象。

静态代理实例

假如一个接口里面有一个方法，想在调用这个接口的前后加东西，就可以使用代理模式。静态代理是代理模式最简单的实现，定义一个静态代理接口

public interface StaticHelloWorld {
    void print();
} 

实现类

public class StaticHelloWorldImpl implements StaticHelloWorld{

    @Override
    public void print() {
        System.out.println("hello world");
    }

} 

代理对象，重点在于代理对象和实际对象实现的是同一个接口，希望在任何时候让代理对象替代实际对象

public class StaticProxy implements StaticHelloWorld{
    
    private StaticHelloWorldImpl staticHelloWorldImpl;
    
    public StaticProxy(){
        if(staticHelloWorldImpl == null){
            staticHelloWorldImpl = new StaticHelloWorldImpl();
        }
    }
    
    public void print() {
        System.out.println("before HelloWorld");
        staticHelloWorldImpl.print();
        System.out.println("after HelloWorld");
    }

}

main

public static void main(String[] args) {
        StaticProxy proxy = new StaticProxy();
        proxy.print();
    }

结果是

before HelloWorld
hello world
after HelloWorld

静态代理的缺点

静态代理的特点是静态代理的代理类是程序员创建的，程序运行前静态代理的.class文件已经存在了。这种模式在代理量比较小时还可以，但是代理量大了就有很大的缺点：

1.代理内容无法复用，如果想换一种代理内容，比如在helloworld前后不想输入before和after..，想输出别的东西，那么就必须重新写一个代理对象。这样容易造成代理对象的膨胀。

2.接口里面新增了一个方法，实际对象实现了这个方法，代理对象也必须新增内容，去给这个新增方法增加代理内容。

动态代理实例

动态代理接口

public interface DynamicHelloWorld {
    String print();
}

动态代理接口的实现

public class DynamicHelloWorldImpl implements DynamicHelloWorld{

    public String print() {
        System.out.println("hello world");
        return "DynamicHelloWorldImpl";
    }

}

动态代理类，在java中动态代理需要实现InvocationHandler接口。该接口只有一个invoke方法。

第一种

public class DynamicProxy implements InvocationHandler
{
    private Object target;
    
    public Object newInstance(Object target)
    {
        this.target = target;
        
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), 
                target.getClass().getInterfaces(), this);
    }
    
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable
    {
        System.out.println("Before DynamicProxy");
        method.invoke(target, args);
        System.out.println("After DynamicProxy");
        return null;
    }
}

第二种 

public class DynamicProxy implements InvocationHandler
{
    private Object target;
    
    public DynamicProxy(Object target)
    {
        this.target = target;
    }
    
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable
    {
        System.out.println("Before DynamicProxy");
        method.invoke(target, args);
        System.out.println("After DynamicProxy");
        return null;
    }
}

第一种main函数

public class DynamicTestMain
{
    public static void main(String[] args) throws Exception
    {
        DynamicProxy dp = new DynamicProxy();
        DynamicHelloWorld dhwi = new DynamicHelloWorldImpl();
        DynamicHelloWorld dhw = (DynamicHelloWorld)dp.newInstance(dhwi);
        dhw.print();
    }
}

第二种main函数

public class DynamicTestMain
{
    public static void main(String[] args) throws Exception
    {
        DynamicHelloWorld dhwi = new DynamicHelloWorldImpl();
        InvocationHandler ih = new DynamicProxy(dhwi);
        DynamicHelloWorld dhw = 
                (DynamicHelloWorld)Proxy.
                newProxyInstance(DynamicHelloWorld.class.getClassLoader(), 
                                 new Class<?>[]{DynamicHelloWorld.class}, ih);
        dhw.print();
    }
}

不管哪种写法，运行结果都是一样的：

Before DynamicProxy
Enter DynamicHelloWorldImpl.print()
After DynamicProxy

 动态代理，利用动态编译+反射技术，把实际对象的方法调用转换成对传入的InvocationHandler接口实现类的invoke方法的调用。

动态代理的优缺点

优点：

1.类少了

2.代理内容的实现类可以复用，可以给A接口用，也可以给B接口用。

缺点：

只能针对于接口生成代理，不能针对一个类生成代理。如果想要为某一个单独的类实现一个代理可以考虑GGLIB技术。