设计模式-代理模式

设计模式-代理模式

什么是代理模式？

       代理模式的定义：使用一个代理将对象包装起来，然后用该代理取代原始对象。任何原始对象的调用都要通过代理。代理对象决定是否以及何时将方法调用转到原始对象上。

　　　　　　　　　　通俗的来讲代理模式就是我们生活中常见的中介。

举个例子来说明：假如说我现在想买一辆二手车，虽然我可以自己去找车源，做质量检测等一系列的车辆过户流程，但是这确实太浪费我得时间和精力了。我只是想买一辆车而已为什么我还要额外做这么多事呢？于是我就通过中介公司来买车，他们来给我找车源，帮我办理车辆过户流程，我只是负责选择自己喜欢的车，然后付钱就可以了。用图表示如下：

为什么要用代理模式？

• 中介隔离作用：在某些情况下，一个客户类不想或者不能直接引用一个委托对象，而代理类对象可以在客户类和委托对象之间起到中介的作用，其特征是代理类和委托类实现相同的接口。
• 开闭原则，增加功能：代理类除了是客户类和委托类的中介之外，我们还可以通过给代理类增加额外的功能来扩展委托类的功能，这样做我们只需要修改代理类而不需要再修改委托类，符合代码设计的开闭原则。代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后对返回结果的处理等。代理类本身并不真正实现服务，而是同过调用委托类的相关方法，来提供特定的服务。真正的业务功能还是由委托类来实现，但是可以在业务功能执行的前后加入一些公共的服务。例如我们想给项目加入缓存、日志这些功能，我们就可以使用代理类来完成，而没必要打开已经封装好的委托类。

有哪几种代理模式？

　　按照编译时还是运行时，确定代理对象，可以分为静态代理和动态代理两种

       静态代理是由程序员创建或特定工具自动生成源代码，在对其编译。在程序员运行之前，代理类.class文件就已经被创建了。

　　动态代理是在程序运行时通过反射机制动态创建的。

（静态代理和JDK动态代理）代理类和被代理类都要实现同一个接口

1.静态代理     

 第一步：创建一个接口

public interface ClothFactory {
    public void produceCloth();
}

 

第二步：创建被代理类，实现接口

public class NikeClothFactory implements ClothFactory {
    public NikeClothFactory() {
    }

    @Override
    public void produceCloth() {
        System.out.println("Nike正在生产衣服");
    }
}

 

第三步：创建代理类，实现接口

public class ProxyClothFactory implements ClothFactory {

    private ClothFactory factory;
    //需要用被代理类来实例化factory
    public ProxyClothFactory(ClothFactory factory) {
        this.factory = factory;
    }

    @Override
    public void produceCloth() {
        System.out.println("代理工厂正在做准备工作");
        factory.produceCloth();
        System.out.println("代理类正在做收尾工作");
    }
}

 

第四步：编写测试类

@Test
    public void test2()
    {
        NikeClothFactory nikeClothFactory=new NikeClothFactory();
        ProxyClothFactory proxyNikeClothFactory=new ProxyClothFactory(nikeClothFactory);
        proxyNikeClothFactory.produceCloth();
    }

 

结果

代理工厂正在做准备工作
Nike正在生产衣服
代理类正在做收尾工作

 

静态代理总结：

优点：可以做到在符合开闭原则的情况下对目标对象进行功能扩展。

缺点：我们得为每一个服务都得创建代理类，工作量太大，不易管理。同时接口一旦发生改变，代理类也得相应修改。                                             

2.JDK动态代理

需要解决的问题

①如何根据加载到内存中的被代理类动态的去创建一个代理类及其对象（Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)）

• ClassLoader loader:指定当前目标对象使用的类加载器,获取加载器的方法是固定的（loader.getClass().getClassLoader()）
• Class<?>[] interfaces:指定目标对象实现的接口的类型,使用泛型方式确认类型(loader.getClass().getInterfaces())
• InvocationHandler:指定动态处理器，执行目标对象的方法时,会触发事件处理器的方法(这个是解决问题②的关键)，需要传入一个InvocationHandler实现类的对象（可以使用匿名内部类的写法）也可以定义一个InvocationHandler实现类

②当通过代理类调用方法时，如何通过代理类调用被代理类同名的方法

 

　　在动态代理中我们不再需要再手动的创建代理类，我们只需要编写一个动态代理类就可以了。真正的代理对象由JDK再运行时为我们动态的来创建。

第一步：编写一个动态代理类（二选一即可）

InvocationHandler实现类，匿名内部类写法

public class ProxyFactory {

    /**
     *调用此方法返回一个代理类对象
     * @param obj 被代理类对象
     * @return
     */
    public static Object getProxyInstance (final Object obj)
    {
//        Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
//匿名内部类写法

        Object proxy = Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), new InvocationHandler() {

            /**
             * 当我们通过代理类调用被代理类的a方法时，会自动的调用如下方法invoke
             */
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                Object result = method.invoke(obj, args);
                return result;
            }
        });
        return proxy;
    }
}

定义一个InvocationHandler实现类

public class ProxyFactory {

    /**
     *调用此方法返回一个代理类对象
     * @param obj 被代理类对象
     * @return
     */
    public static Object getProxyInstance (final Object obj)
    {
        MyInvocationHandler myInvocationHandler=new MyInvocationHandler(obj);
        Object proxy = Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(),myInvocationHandler );
        return proxy;
    }
}
class MyInvocationHandler implements InvocationHandler{
    private Object object;

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

    /**
     * 当我们通过代理类调用被代理类的a方法时，会自动的调用如下方法invoke
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result = method.invoke(object, args);
        return result;
    }
}

第二步：编写测试类

@Test
    public void test1()
    {
       NikeClothFactory nikeClothFactory=new NikeClothFactory();
       ClothFactory proxyInstance =(ClothFactory)ProxyFactory.getProxyInstance(nikeClothFactory);
       proxyInstance.produceCloth();
    }

结果

Nike正在生产衣服

 

动态代理总结：

1）写起来很难

2）Jdk默认的动态代理，如果目标对象没有实现任何接口，是无法为他创建代理对象的

（代理对象和被代理对象唯一能产生的关联就是实现了同一个接口）

 

 

3、CGLIB代理

 

 JDK实现动态代理需要实现类通过接口定义业务方法，对于没有接口的类，如何实现动态代理呢，这就需要CGLib了。CGLib采用了非常底层的字节码技术，其原理是通过字节码技术为一个类创建子类，并在子类中采用方法拦截的技术拦截所有父类方法的调用，顺势织入横切逻辑。但因为采用的是继承，所以不能对final修饰的类进行代理。JDK动态代理与CGLib动态代理均是实现Spring AOP的基础。

 

第一步：创建CGLIB代理类

package com.orz.spring.bean;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;

/**
 * @author orz
 * @create 2020-10-22 11:41
 */
public class ProxyClothFactory implements MethodInterceptor {
    public  Object getProxyInstance( Object obj)
    {
        Enhancer enhancer=new Enhancer();
        enhancer.setSuperclass(obj.getClass());
        enhancer.setCallback(this);
        return enhancer.create();
    }
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {

        System.out.println("代理工厂正在做一些准备工作");

        Object result = methodProxy.invokeSuper(o, objects);

        System.out.println("代理工厂正在做一些收尾工作");
        return result;
    }
}

第二步：创建被代理类

public class NikeClothFactory {
    public void produceCloth()
    {
        System.out.println("Nike正在生产衣服");
    }
}

 

第三步：创建测试类

 

 

代理工厂正在做一些准备工作
Nike正在生产衣服
代理工厂正在做一些收尾工作

 

CGLIB代理总结： CGLIB创建的动态代理对象比JDK创建的动态代理对象的性能更高，但是CGLIB创建代理对象时所花费的时间却比JDK多得多。所以对于单例的对象，因为无需频繁创建对象，用CGLIB合适，反之使用JDK方式要更为合适一些。同时由于CGLib由于是采用动态创建子类的方法，对于final修饰的方法无法进行代理。

 

部分引用自https://www.cnblogs.com/daniels/p/8242592.html