【结构型模式-代理模式】

时间：2024-07-11 07:26:22

概述

由于某些原因需要给某对象提供一个代理以控制该对象的访问。这时，访问对象不适合或者不能直接引用目标对象，代理对象作为访问对象与目标对象之间的中介。
Java中的代理按照代理类生成时机不同又分为静态代理和动态代理。静态代理代理类在编译期就生成，而动态代理类则是在Java运行时动态生成。动态代理又有JDK代理和CGLib代理两种。

结构

代理（Proxy）模式分为三种角色：

  • 抽象主题（Subject）类：通过接口或抽象类声明真实主题和代理对象实现的业务方法。
  • 真实主题（Real Subject）类：实现了抽象主题中的具体业务，是代理对象所代表的真实对象，是最终要引用的对象。
  • 代理（Proxy）类：提供了与真实主题相同的接口，其内部含有对真实主题的引用，它可以访问、控制或拓展真实主题的功能。
    在这里插入图片描述
静态代理
package com.syn.proxy.static_proxy;

/*卖票规范*/
public interface SellTickets {
    void sell();
}


package com.syn.proxy.static_proxy;

/*火车站卖票*/
public class TrainStation implements  SellTickets{
    @Override
    public void sell() {
        System.out.println("火车站卖票.");
    }
}


package com.syn.proxy.static_proxy;

/*代理点*/
public class Proxypoint implements SellTickets{

    private TrainStation trainStation = new TrainStation();
    @Override
    public void sell() {
        System.out.println("代理收取费用.");
        trainStation.sell();
    }
}

package com.syn.proxy.static_proxy;

/*客户端买票*/
public class Client {
    public static void main(String[] args) {
        /*创建代理类*/
        Proxypoint proxypoint = new Proxypoint();
        /*买票*/
        proxypoint.sell();
    }
}

在这里插入图片描述

JDK动态代理
package com.syn.proxy.jdk_proxy;

/*卖票规范*/
public interface SellTickets {
    void sell();
}


package com.syn.proxy.jdk_proxy;

/*火车站卖票*/
public class TrainStation implements SellTickets {
    @Override
    public void sell() {
        System.out.println("火车站卖票.");
    }
}


package com.syn.proxy.jdk_proxy;

import com.syn.proxy.static_proxy.SellTickets;
import com.syn.proxy.static_proxy.TrainStation;

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

/*获取代理对象的工厂类*/
public class ProxyFactory {
    /*声明目标对象*/
    private TrainStation trainStation = new TrainStation();

    public SellTickets getProxyObject(){
        /*返回代理对象*/
        SellTickets proxyObject  =  (SellTickets) Proxy.newProxyInstance(
                /*用于加载代理类，可以通过目标对象获取类加载器*/
                trainStation.getClass().getClassLoader(),
                /*代理类实现的接口字节码对象*/
                trainStation.getClass().getInterfaces(),
                /*代理对象的调用处理程序*/
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("代理收费(JDK动态版本).");
                        /*执行目标对象方法*/
                        Object object = method.invoke(trainStation,args);
                        return object;
                    }
                }
        );
        return proxyObject;
    }
}


package com.syn.proxy.jdk_proxy;

import com.syn.proxy.static_proxy.SellTickets;

public class Client {
    public static void main(String[] args) {
        /*创建代理工厂*/
        ProxyFactory proxyFactory = new ProxyFactory();
        /*使用工厂获取代理对象*/
        SellTickets proxyObject = proxyFactory.getProxyObject();
        /*调用目标方法*/
        proxyObject.sell();
    }
}

在这里插入图片描述

CDLIB动态代理

对于上面的案例，如果没有定义SellTickets接口，只定义了TrainStation。很显然JDK动态代理便无法使用了，因为JDK动态代理要求必须定义接口，对接口进行代理。
CGLIB是一个功能强大，高性能的代码生成包，它为没有实现接口的类提供代理，为JDK的动态代理提供了很好的补充。
需要引入maven包

    <dependencies>
        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>3.1</version>
        </dependency>
    </dependencies>

package com.syn.proxy.cglib_proxy;


/*火车站卖票*/
public class TrainStation{
    public void sell() {
        System.out.println("火车站卖票.");
    }
}


package com.syn.proxy.cglib_proxy;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/*代理对象工厂*/
public class ProxyFactory implements MethodInterceptor {
    /*声明火车站对象*/
    private TrainStation trainStation = new TrainStation();

    public TrainStation getProxyObject(){
        /*创建Enhancer对象，类似于JDK代理中的Proxy类*/
        Enhancer enhancer = new Enhancer();
        /*设置父类的字节码对象*/
        enhancer.setSuperclass(TrainStation.class);
        /*设置回调函数*/
        enhancer.setCallback(this);
        /*创建代理对象*/
        return (TrainStation) enhancer.create();
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("代理收费(CGLIB动态版本).");
        /*要调用目标对象的方法*/
       return method.invoke(trainStation,objects);
    }
}


package com.syn.proxy.cglib_proxy;

public class Client {
    public static void main(String[] args) {
        /*创建代理工厂对象*/
        ProxyFactory proxyFactory = new ProxyFactory();
        /*获取代理对象*/
        TrainStation proxyObject = proxyFactory.getProxyObject();
        /*调用代理对象的sell方法卖票*/
        proxyObject.sell();
    }
}

在这里插入图片描述

三种代理对比

  • jdk代理和CGLIB代理

使用CGLib实现动态代理，CGLib底层采用ASM字节码生成框架，使用字节码技术生成代理类，在JDK1.6之前比使用Java反射效率要高。唯一需要注意的是，CGLib不能对声明为final的类或者方法进行代理，因为CGLib原理是动态生成被代理类的子类。
在JDK1.6、JDK1.7、JDK1.8逐步对JDK动态代理优化之后，在调用次数较少的情况下，JDK代理效率高于CGLib代理效率，只有当进行大量调用的时候，JDK1.6和JDK1.7比CGLib代理效率低一点，但是到JDK1.8的时候，JDK代理效率高于CGLib代理。所以如果有接口使用JDK动态代理，如果没有接口使用CGLIB代理。

  • 动态代理和静态代理

动态代理与静态代理相比较，最大的好处是接口中声明的所有方法都被转移到调用处理器一个集中的方法中处理(InvocationHandler.invoke)。这样，在接口方法数量比较多的时候，我们可以进行灵活处理，而不需要像静态代理那样每一个方法进行中转。
如果接口增加一个方法，静态代理模式除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。增加了代码维护的复杂度。而动态代理不会出现该问题。

优缺点

优点:

  • 代理模式在客户端与目标对象之间起到一个中介作用和保护目标对象的作用;
  • 代理对象可以扩展目标对象的功能;
  • 代理模式能将客户端与目标对象分离，在一定程度上降低了系统的耦合度。

缺点:

  • 增加了系统的复杂度。

相关文章