[Java知识库]【设计模式】代理模式

代理模式：

• 为一个对象提供一个替身，以控制对这个对象的访问，通过代理对象访问目标对象，可以在不修改目标对象的前提下，给目标对象增强额外的功能。
• 静态代理、动态代理、Cglib代理

静态代理：需要定义接口或者父类，被代理对象与代理对象一起实现相同的接口或者继承相同的父类，然后调用相同的方法来调用目标对象的方法

代码实现：

//代理对象和被代理对象必须实现同一接口ITeacherDao
public interface ITeacherDao {
    void teach();
}

-------------------------------------------------------

//目标对象
public class TeacherDao implements ITeacherDao{
    @Override
    public void teach() {
        System.out.println("开始上课...");
    }
}

-------------------------------------------------------

//代理对象
public class TeacherDaoProxy implements ITeacherDao{
	//被代理的目标对象
    private ITeacherDao target;

    TeacherDaoProxy (ITeacherDao target){
        this.target = target;
    }

    @Override
    public void teach() {
        System.out.println("开始代理....");
        target.teach();
        System.out.println("代理结束....");
    }
}

-------------------------------------------------------

//通过调用代理对象来调用目标对象的方法
public class Client {
    public static void main(String[] args) {
        TeacherDao target = new TeacherDao();
        TeacherDaoProxy teacherDaoProxy = new TeacherDaoProxy(target);
        teacherDaoProxy.teach();
    }
}

• 优点：在不修改目标对象的前提下，能通过代理对象对目标功能扩展
• 缺点：因为代理对象需要需要和目标对象实现一样的接口，所以会有很多代理类，一旦接口增加方法，目标对象和代理对象都要维护

动态代理：

• 代理对象不需要实现接口，但是目标对象要实现接口，否则不能使用动态代理
• 代理对象的生成，是利用JDK的API，动态的在内存中构建代理对象

代码实现：

//目标对象实现的接口
public interface ITeacherDao {
    void teach();
    void sayHello(String name);
}

-------------------------------------------------------
//目标对象
public class TeacherDao implements ITeacherDao{

    @Override
    public void teach() {
        System.out.println("开始上课...");
    }

    @Override
    public void sayHello(String name) {
        System.out.println("hello " + name);
    }
}

-------------------------------------------------------

//代理对象工厂，通过传入目标对象，生成一个代理对象
public class ProxyFactory {
    //内部维护一个目标对象
    private Object target;

    //通过构造器，初始化目标对象
    public ProxyFactory(Object target){
        this.target = target;
    }

    //给目标对象生成一个代理对象
    public Object getProxyInstance(){
        /*
        public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
              //1、ClassLoader loader: 目标对象的加载器
              //2、Class<?>[] interfaces：目标对象实现的接口，让代理对象和目标对象拥有相同的方法
              //3、InvocationHandler h：用于提供被增强的代码
         */
        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 returnVal = method.invoke(target, args);
                        System.out.println("动态代理结束...");
                        return returnVal;
                    }
                });
    }

}

-------------------------------------------------------
    
//通过动态代理来调用目标对象方法
public class Client {
    public static void main(String[] args) {
        //创建目标对象
        ITeacherDao target = new TeacherDao();
        //把目标对象传入代理工厂，生成一个代理对象
        ITeacherDao proxyInstance = (ITeacherDao) new ProxyFactory(target).getProxyInstance();
        //通过代理对象调用我们目标对象的方法
        proxyInstance.teach();
        System.out.println("--------------------");
        proxyInstance.sayHello("Tom");
    }
}

Cglib代理：

静态代理和动态代理都需要目标对象实现一个接口，如果目标对象没有实现任何的接口。可以用cglib代理，运行时动态生成一个子类，重写了所有目标对象中非final的方法，在子类中采用拦截器的方式拦截父类方法的调用。

代理的类不能为final，如果对象的方法为final/static，那么就不会被拦截