JavaSE反射-静态代理模式

        首先，我们要知道什么是代理模式。代理模式通俗的来讲就是：一个接口有两个实现子类，一个子类负责真实业务的实现，另一个子类负责其辅助业务的实现（辅助类）。有关代理模式的讲解我就不在这里进行了。

        对于基础的代理模式，其中的工厂类只能针对于一组代理对象，如果稍微进行需求的修改，就会使开发端修改大量代码，十分繁琐，而且如果存在多组代理对象，那么就会多出大量的重复代码。

        其实我们可以运用泛型和反射来极大的优化基础的代理模式，使得在程序的运行过程中。工厂只需要用户提供代理类与实现类就可以了。这样显得十分的方便。

import java.lang.reflect.Constructor;

interface Isubject{
    void eat();
}

class RealEat implements Isubject{//实际实现类
    @Override
    public void eat() {
        System.out.println("真实工作");
    }
}

class ProxySubject implements Isubject{//代理类
    private Isubject isubject;

    public ProxySubject(Isubject isubject){
        super();
        this.isubject = isubject;
    }
    public void BeforeEat(){
        System.out.println("辅助工作1");
    }
    public void afterEat(){
        System.out.println("辅助工作2");
    }

    @Override
    public void eat() {
        this.BeforeEat();
        this.isubject.eat();
        this.afterEat();
    }
}

class Factory{//工厂类
    public Factory(){}//工具类构造方法私有

    public static <T> T GetInstance(String RealClass, String ProxyClass){//取得RealClass的对象
        T ret = null;
        T RealSubject = GetRealSubject(RealClass);//先拿到RealClass的对象
        try {
            Class<?> cls = Class.forName(ProxyClass);//拿到ProxyClass的类对象
            Constructor constructor = cls.getDeclaredConstructor(cls.getInterfaces()[0]);//拿到了代理类的有参构造方法
            ret = (T) constructor.newInstance(RealSubject);//调用ProxyClass的构造方法，给ProxyClass中的RealClass属性赋值
        }catch (Exception e){
            e.printStackTrace();
        }
        return ret;//返回ProxyClass对象
    }

    public static <T> T GetRealSubject(String RealClass){
        Class<?> cls;
        T ret = null;
        try{
            cls = Class.forName(RealClass);//拿到RealClass的类对象
            ret = (T)cls.newInstance();//因为RealClass是无参构造，所以直接创建对象
        }catch (Exception e){
            e.printStackTrace();
        }
        return ret;//返回
    }

}


public class Main{
    public static void main(String[] args){
        Isubject realEat = Factory.GetInstance("RealEat","ProxySubject");//接收ProxyClass对象
        realEat.eat();//调用eat()方法
    }
}

        但是，这种方式代理类只实现了一个接口。有一定的局限性。在下篇博客里我会介绍动态的代理模式。