代理模式与动态代理

/**
 * 代理模式（静态代理）
 *
 * @author 17122
 */
public class StaticProxy {
    public static void main(String[] args) {
        People people = new Programmer();
        people.sayHello();
    }
}
interface People {
    /**
     * sayHello方法
     */
    void sayHello();
}
class Student implements People {
    @Override
    public void sayHello() {
        System.out.println("Hello I am a Student");
    }
    public void study() {
        System.out.println("Study");
    }
}
class Programmer implements People {
    @Override
    public void sayHello() {
        System.out.println("Hello I am a Programmer");
    }
    public void playCode() {
        System.out.println("Play code");
    }
}
复制代码

/**
 * 动态代理
 *
 * @author 17122
 */
public class DynamicProxy {
    public static void main(String[] args) {
        Boos boos = new Boos();
        Worker worker = new Worker();
        getDynamicProxy(worker, Worker.class);
        getDynamicProxy(boos, Boos.class);
    }
    /**
     * 动态代理实现方法
     *
     * @param obj
     * @param clazz
     */
    public static void getDynamicProxy(Object obj, Class clazz) {
        MyInvocationHandler myInvocationHandler = new MyInvocationHandler(obj);
        Courier instance = (Courier) Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), myInvocationHandler);
        instance.takeSomething();
    }
}
/**
 * 快递员
 */
interface Courier {
    /**
     * 取东西
     */
    void takeSomething();
}
class Worker implements Courier {
    @Override
    public void takeSomething() {
        System.out.println("Worker take Something");
    }
}
class Boos implements Courier {
    @Override
    public void takeSomething() {
        System.out.println("Boos take Something");
    }
}
class MyInvocationHandler implements InvocationHandler {
    /**
     * 被代理的目标类
     */
    private Object target;
    /**
     * 构造方法 放入目标类
     *
     * @param target
     */
    public MyInvocationHandler(Object target) {
        this.target = target;
    }
    /**
     * Returns an instance of a proxy class for the specified interfaces that dispatches method invocations to the specified invocation handler.
     * 返回指定接口的代理类实例，该接口将方法调用分派给指定的调用处理程序。
     *
     * @param proxy  the class loader to define the proxy class  定义代理类的类装入器
     * @param method the list of interfaces for the proxy class to implement  代理类要实现的接口列表
     * @param args   the invocation handler to dispatch method invocations to  将方法调用分派到的调用处理程序
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        Object result = method.invoke(target, args);
        return result;
    }
}
复制代码