设计模式:代理模式(Proxy)

      代理模式提供了对目标对象另外的访问方式;即通过代理对象访问目标对象.这样做的好处是:可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能.同时减少对原有代码的入侵。

      

/**
 * @Author : haojiangt
 * @Description :Coder 程序员接口有编程这一个方法
 **/
public interface Coder {
    void programing();
}

/**
 * @Author : haojiangt
 * @Description :Java程序员实现Coder接口，实现programing方法
 **/
public class JavaCoder implements Coder{
    @Override
    public void programing() {
        System.out.println("I am programing by Java");
    }
}

-------------------------------------我是华丽的分割线---------------------------------------------------------------

/**
 * @Author : haojiangt
 * @Description :静态代理，
 *                   
 **/
public class ProxyCoder implements Coder{
   /**
     * 重载构造函数
     * 在实例化ProxyCoder时，注入一个Coder
     * @param coder
     */
    public ProxyCoder(Coder coder) {
        this.coder = coder;
    }

    /**
     * ProxyCoder具体代理programing的方式
     * 可以在被代理的方法执行前，执行后加入一些操作，同时又不会对之造成代码入侵
     */
    @Override
    public void programing() {
        System.out.println("I will program.");
        coder.programing();
        System.out.println("I have finished programing");
    }
    public static void main(String[] args){
        //实例化一个代理类，有代理类来执行这个方法
        Coder javaCoder = new JavaCoder();
        Coder proxyCoder = new ProxyCoder(javaCoder);
        proxyCoder.programing();
    }
}

-------------------------------------我是华丽的分割线---------------------------------------------------------------

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

/**
 * @Author : haojiangt
 * @Description :动态代理1.0
 * 我们不需要在手动去为每一个动作创建代理类，只需要创建一个动态处理器，实现InvocationHandler接口，重写invoke()方法
 * 完成之后只需要在使用时注入，就可以由jdk来为我们创建代理。
 **/
public class CoderBynamicProxy implements InvocationHandler{
    private Object object;

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

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("I will program.");
        Object result = method.invoke(object, args);
        System.out.println("I have finished programing");
        return result;
    }

    public static void main(String[] args){
        InvocationHandler coderBynamicProxy = new CoderDynamicProxy(new JavaCoder());

        Coder coder = (Coder) Proxy.newProxyInstance(new JavaCoder().getClass().getClassLoader(),
                new JavaCoder().getClass().getInterfaces(), coderBynamicProxy);
        coder.programing();
    }
}

-------------------------------------我是华丽的分割线---------------------------------------------------------------

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

/**
 * @Author : haojiangt
 * @Description : 动态代理2.0 我们将上面的代码进行整理，使得在产生代理是更加简洁。
 *                由原来的三个参数变为下面的一个参数，
 *                我自己是真机智-_-
 **/
public class ProxyFactory {
    private Object target;
    public ProxyFactory(Object target) {
        this.target = target;
    }

    public Object getProxyInstance() {
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("开始执行");
                        Object returnObject = method.invoke(target, args);
                        System.out.println("执行结束");
                        return null;
                    }
                });
    }

    public static void main(String[] args) {

        Coder javaCoder = (Coder) new ProxyFactory(new JavaCoder()).getProxyInstance();
        javaCoder.programing();
    }
}