Java 设计模式之代理模式

1、静态代理

被代理对象和代理对象都要实现相同的接口或者继承相同的父类。

不需要修改被代理对象就可以实现对功能的扩展，缺点是如果接口发生变化，比如增加新方法，被代理对象和代理对象都需要维护。

1）首先定义一个接口

public interface ITeachTask {
    void teach();
}

2）被代理对象的类

public class TeachTask implements ITeachTask{
    @Override
    public void teach() {
        System.out.println("teaching");
    }
}

3）代理对象

/**
 * 代理对象，实现接口，
 * 不需要修改被代理对象
 * 但是如果接口发生变更，需要同时维护代理对象
 */
public class TeachProxy implements ITeachTask{
    private ITeachTask teachTask;

    public TeachProxy(ITeachTask teachTask) {
        this.teachTask = teachTask;
    }

    @Override
    public void teach() {
        System.out.println("proxy teach start");
        teachTask.teach();
        System.out.println("proxy teach end");
    }
}

4）测试

/**
 * 静态代理模式
 */
public class Test {
    public static void main(String[] args) {
        TeachTask teachTask = new TeachTask();
        TeachProxy proxy = new TeachProxy(teachTask);
        proxy.teach();
    }
}

2、JDK 代理

利用 Java API 动态生成代理对象，Proxy.newProxyInstance()方法动态生成代理类和代理对象，因为这个方法的第二个参数，有一个局限性，就是被代理对象必须要实现某个接口。

/**
 * 代理对象不需要实现接口，但是目标对象一定要实现接口
 * 
 */
public class ProxyFactory {
    private Object object;

    public ProxyFactory(Object object) {
        this.object = object;
    }

    public Object getProxyObject() {
        Object proxyObject = Proxy.newProxyInstance(object.getClass().getClassLoader()
                , object.getClass().getInterfaces()
                , new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("jdk proxy start");
                        Object returnValue = method.invoke(object, args);
                        System.out.println("jdk proxy end");
                        return returnValue;
                    }
                });
        return proxyObject;
    }
}

测试类：

public class Test {
    public static void main(String[] args) {
        ITeachTask teachTask = new TeachTask();
        ITeachTask proxy = (ITeachTask) new ProxyFactory(teachTask).getProxyObject();
        proxy.teach();
    }
}

3、CGLIB 代理

需要引入cglib jar 包，这里用的是3.1版本，maven 依赖为：

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.1</version>
</dependency>

创建一个子类对象从而实现对目标对象功能的扩展。

1）被代理对象

public class TeachTask {
    public void teach() {
        System.out.println("teaching");
    }
}

2）代理

public class ProxyFactory implements MethodInterceptor {
    private Object object;

    public ProxyFactory(Object object) {
        this.object = object;
    }

    public Object getProxyObject() {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(object.getClass());
        enhancer.setCallback(this);
        return enhancer.create();
    }

    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        System.out.println("cglib proxy start");
        //执行目标对象的方法
        Object returnValue = methodProxy.invokeSuper(obj, args);
        System.out.println("cglib proxy end");
        return returnValue;
    }
}

测试代码：

public class Test {

    public static void main(String[] args) {
        TeachTask teachTask = new TeachTask();
        TeachTask proxyObject = (TeachTask) new ProxyFactory(teachTask).getProxyObject();
        proxyObject.teach();
    }
}