设计模式之代理模式

/**
 * 接口
 */
interface Subject {
    public void dosomething();
}

/**
 * 真实主题类
 */
class RealSubject implements Subject {
    // 真实主题类的核心操作
    @Override
    public void dosomething() {
        System.out.println("真实主题需要做的事情");
    }
}

/**
 * 代理类
 */
class ProxySubject implements Subject {
    // 真实主题类作为代理类的一个成员属性
    private RealSubject realSubject;
    
    public ProxySubject(RealSubject realSubject) {
        this.realSubject = realSubject;
    }
    
    // 整个业务的全部操作由代理类实现
    @Override
    public void dosomething() {
        this.doBefore();
        this.realSubject.dosomething();
        this.doAfter();
    }
    public void doBefore() {
        System.out.println("做准备工作");
    }
    public void doAfter() {
        System.out.println("做结束工作");
    }
}

public class TestProxy {
    public static void main(String[] args) {
        RealSubject realSubject = new RealSubject();
        Subject subject = new ProxySubject(realSubject);
        subject.dosomething();
    }
}

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

/**
 * 接口
 */
interface Subject {
    public void dosomething();
}

/**
 * 真实主题类
 */
class RealSubject implements Subject {
    // 真实主题类的核心操作
    @Override
    public void dosomething() {
        System.out.println("真实主题需要做的事情");
    }
}

/**
 * 动态代理类
 */
class MyInvocationHandler implements InvocationHandler {

    // 目标对象
    private Object target;
    
    /**
     * 绑定业务对象，并返回一个代理类对象
     * @param target
     * @return 目标对象的代理类对象
     */
    public Object bind(Object target) {
        this.target = target;
        
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), 
                target.getClass().getInterfaces(), this);
    }
    
    /**
     * 代理对象执行的完整操作
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        Object result = null;
        System.out.println("核心业务操作之前的准备操作");
        // 调用核心业务操作
        result = method.invoke(this.target, args);
        System.out.println("核心业务操作之后的结束操作");
        return result;
    }
}
 

public class TestProxy {
    public static void main(String[] args) {
        RealSubject realSubject = new RealSubject();
        MyInvocationHandler proxy = new MyInvocationHandler();
        Subject subject = (Subject) proxy.bind(realSubject);
        subject.dosomething();
    }
}

import java.lang.reflect.Method;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

/**
 * 真实主题类
 */
class RealSubject {
    // 真实主题类的核心操作
    public void dosomething() {
        System.out.println("真实主题需要做的事情");
    }
}

class SubjectCglib implements MethodInterceptor {

    // 目标类
    private Object target;
    
    /**
     * 绑定目标对象，动态生成一个新的类，使用父类的无参构造方法创建一个指定了特定回调的代理对象
     * @param target
     * @return 代理对象
     */
    public Object getInstance(Object target) {
        this.target = target;
        
        // 增强器，动态代码生成器
        Enhancer enhancer = new Enhancer();
        enhancer.setCallback(this);
        // 设置生成类的父类类型
        enhancer.setSuperclass(this.target.getClass());
        // 动态生成字节码并返回代理对象
        return enhancer.create();
    }
    
    @Override
    public Object intercept(Object object, Method method, Object[] args,
            MethodProxy methodProxy) throws Throwable {
        System.out.println("核心业务操作之前的准备操作");
        Object result = methodProxy.invoke(object, args);
        System.out.println("核心业务操作之后的结束操作");
        return result;
    }
}

public class TestProxy {
    public static void main(String[] args) {
        SubjectCglib subjectCglib = new SubjectCglib();
        RealSubject subject = (RealSubject) subjectCglib.getInstance(new RealSubject());
        subject.dosomething();
    }
}