设计模式-结构型-代理模式

1、定义

代理模式：为其他对象提供一种代理以控制对这个对象访问

写法

公共部分

public interface ILawsuit {

    //提交申请
    void submit();

    //举证
    void burden();

    //辩护
    void defend();

    //诉讼完成
    void finish();

}

public class XiaoMin implements ILawsuit {

    @Override
    public void submit() {
        //小民申请仲裁
        System.out.println( "老板年底拖欠工资，特此申请仲裁！" );
    }

    @Override
    public void burden() {
        //小民提交证据
        System.out.println( "这是合同书和过去一年的银行工资流水！" );
    }

    @Override
    public void defend() {
        //铁证如山
        System.out.println( "证据确凿，不需要再说什么！" );
    }

    @Override
    public void finish() {
        //结果
        System.out.println( "诉讼成功，判决老板即日起七天内结算工资！" );
    }

}

1、静态代理

/**
 * 代理类
 */
public class Lawyer implements ILawsuit {

    private ILawsuit mLawsuit;

    public Lawyer(ILawsuit mLawsuit) {
        this.mLawsuit = mLawsuit;
    }

    @Override
    public void submit() {

    }

    @Override
    public void burden() {

    }

    @Override
    public void defend() {

    }

    @Override
    public void finish() {

    }
}

public class TestMain {

    public static void main(String[] args) {

        ILawsuit xiaomin = new XiaoMin();

        //静态代理
        ILawsuit lawyer = new Lawyer( xiaomin );

        lawyer.submit();

        lawyer.burden();

        lawyer.defend();

        lawyer.finish();

    }

}

2、动态代理 公共部分

public class DynamicProxy implements InvocationHandler {

    private Object obj;

    public DynamicProxy(Object obj) {
        this.obj = obj;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result = method.invoke( obj,args );
        return result;
    }
}

例子1

public class TestMain {

    public static void main(String[] args) {

        ILawsuit xiaomin = new XiaoMin();

        //动态代理
        DynamicProxy proxy = new DynamicProxy( xiaomin );

        //获取小民的classLoader
        ClassLoader loader = xiaomin.getClass().getClassLoader();
        //动态代理一个代理律师
        ILawsuit lawyer = (ILawsuit) Proxy.newProxyInstance( loader, new Class[]{ILawsuit.class}, proxy );

        lawyer.submit();
        lawyer.burden();
        lawyer.defend();
        lawyer.finish();

    }

}

2、优化封装

public class SubjectProxy<T> {

    //获得动态实例
    public T newInstance(Object obj) {
        DynamicProxy proxy = new DynamicProxy( obj );
        ClassLoader loader = obj.getClass().getClassLoader();
        Class superclazz = getSuperclass();
        return (T) Proxy.newProxyInstance( loader, new Class[]{superclazz}, proxy );
    }

    //Java 得到泛型中得到T.class
    private Class getSuperclass() {
        return (Class<T>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];
    }

}

public class TestMain {

    //为其他对象提供一种代理以控制对这个对象的访问
    public static void main(String[] args) {

        ILawsuit xiaomin = new XiaoMin();

        SubjectProxy<ILawsuit> subjectProxy = new SubjectProxy<ILawsuit>();

        ILawsuit lawyer = subjectProxy.newInstance( xiaomin );

        lawyer.submit();
        lawyer.burden();
        lawyer.defend();
        lawyer.finish();

    }

}

代码示例

https://github.com/yinlingchaoliu/23-design-pattern