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

目录

一.概述

二.结构

三.静态代理

代码实现：

四.JDK动态代理 

代码实现

分析

执行流程

五.CJLib动态代理

代码实现

分析

六.三种代理方式对比

jdk代理与CJLib代理

动态代理与静态代理

七.优缺点

优点

缺点

八.使用场景

---

一.概述

有时，需要给对象一个代理以控制对该对象的访问。此时，访问对象不能直接引用目标对象，代理对象作为访问对象和目标对象之间的中介。

Java中代理按照代理类生成时机不同又分为静态代理和动态代理。静态代理在编译器生成，而动态代理在运行时动态生成。

二.结构

代理模式分为三种结构:

抽象主题类：作为接口或抽象类，提供真实主题类和代理类需要实现的方法。

真实主题类：实现抽象主题类中的方法，是目标对象，被代理类所代理。

代理类：实现抽象主题类中的方法，方法内部包含有真实主题的方法引用，可以进行扩展功能。

三.静态代理

下面以卖汽车来实现代理。卖汽车经常会在4s店进行售卖，我们只需要去4s店买就行。

以下是其UML类图：

代码实现：

/**
 * 抽象主题类
 */
public interface SellCars {
    void sell();
}

/**
 * 真实主题类
 */
public class CarFactory implements SellCars{
    @Override
    public void sell() {
        System.out.println("进行汽车售卖");
    }
}

/**
 * 代理类
 */
public class CarShops implements SellCars{
    private CarFactory carFactory=new CarFactory();
    @Override
    public void sell() {
        //todo 进行一些其他业务操作
        carFactory.sell();
    }
}

四.JDK动态代理 

Java为我们提供了动态代理Proxy，下面仍使用以上例子进行实现。

代码实现

/**
 * 抽象主体类
 */
public interface SellCar {
    void sell();
    void check();
}

/**
 * 真实主体类(目标对象)
 */
public class CarFactory implements SellCar{
    @Override
    public void sell() {
        System.out.println("进行汽车售卖");
    }

    @Override
    public void check() {
        System.out.println("进行汽车检测");
    }
}

/**
 * 代理工厂对象(创造代理类)
 */
public class ProxyFactory {
    //真实主题类
    private static CarFactory carFactory=new CarFactory();

    /*获取代理对象
    ClassLoader loader:类加载器，用于加载代理类,
    Class<?>[] interfaces：代理类实现的接口的字节码对象,
    InvocationHandler h：代理对象的调用处理程序
    */

    public static SellCar getProxyObject(){
        SellCar ProxyObject=(SellCar) Proxy.newProxyInstance(carFactory.getClass().getClassLoader(),
                carFactory.getClass().getInterfaces(),
                new InvocationHandler() {
                    /**
                     Object proxy:要代理的类的对象(真实主题类),
                     Method method：对接口中的方法进行封装的method对象,
                     Object[] args：接口中的方法的参数

                     返回的参数是接口中方法的返回值，若没有则为null
                     */
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("进行其他业务操作");
                        return method.invoke(carFactory,args);
                    }
                });
        return ProxyObject;
    }

}

测试：

public class Client {
    public static void main(String[] args) {
        SellCar proxyObject = ProxyFactory.getProxyObject();
        proxyObject.sell();
        System.out.println("---------");
        proxyObject.check();
    }
}

分析

我们创造了一个代理工厂类ProxyFactory，这个类不是代理类，而是创造代理类的工厂类，其提供了一个方法getProxyObject()用来获取代理类。这个方法中通过Java提供的Proxy类来创建一个代理类。

Proxy.newProxyInstance()方法可以创建一个代理类其返回值是代理类，实现了抽象主题类，其有三个参数：

ClassLoader loader:类加载器，用于加载代理类,
Class<?>[] interfaces：代理类实现的接口的字节码对象,
InvocationHandler h：代理对象的调用处理程序

前两个参数都可以通过要代理的类获得。最后一个参数是一个函数接口。在上面，我们定义了一个匿名子类对象来实现了其invoke()方法，这个方法又有三个参数和一个返回值：

Object proxy:要代理的类的对象(真实主题类),
Method method：对接口中的方法进行封装的method对象,
Object[] args：接口中的方法的参数

返回的值是接口中方法的返回值，若没有则为null

在这个方法中，我们需要进行方法的增强，通过method对象调用代理类中的原方法。

执行流程

1.通过代理工厂获取代理对象

2.底层jdk会根据Proxy.newProxyInstance()传入的三个参数通过反射创建一个代理类Proxy,使其实现抽象主体类(SellCar接口)，并实现其方法。

3.通过Proxy代理类调用方法，此时会调用我们传入的InvocationHandler的实现类对象，并调用其invoke()方法。

五.CGLIB动态代理

jdk动态代理是根据实现接口来进行代理，只适合有接口的被代理类。而CGLIB动态代理是通过继承被代理类来实现代理的，适用于没有接口的被代理类。

代码实现

pom文件引入依赖：

（如果不是maven工程，需要引入cglib和asm两个依赖，因为cglib需要靠asm解析）

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

/**
 * 真实主体类(目标对象)
 */
public class CarFactory{

    public void sell() {
        System.out.println("进行汽车售卖");
    }

    public void check() {
        System.out.println("进行汽车检测");
    }
}

/**
 * 代理工厂对象(创造代理类)
 */
public class ProxyFactory implements MethodInterceptor {
    //真实主题类
    private  CarFactory carFactory=new CarFactory();

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

    /**
     *
     * @param o 代理类对象
     * @param method 代理的方法
     * @param objects 代理方法参数
     * @param methodProxy 代理方法
     * @return 代理方法的返回值
     * @throws Throwable
     */
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("执行其他操作");
        method.invoke(carFactory,objects);
        return null;
    }
}

测试

public class Client {
    public static void main(String[] args) {
        ProxyFactory proxyFactory = new ProxyFactory();
        CarFactory proxyObject = proxyFactory.getProxyObject();
        System.out.println("父类是"+proxyObject.getClass().getSuperclass());
        proxyObject.sell();
        System.out.println("--------");
        proxyObject.check();
    }
}

分析

通过CGLIB实现动态代理需要创建Enhancer对象，其就相当于Proxy类。因为CGLIB代理是通过继承被代理类来实现代理的，所以要设置其父类字节码对象，也就是被代理类。此外，还需要设置一个回调函数，参数是一个函数式接口，要重写intercept()方法，就相当于JDK代理中InvocationHandler接口。这个方法有四个参数：

 @param o 代理类对象
* @param method 代理的方法
* @param objects 代理方法参数
* @param methodProxy 代理方法

在此方法中进行方法增强，当通过代理类调用代理方法时就会调用此方法。

注：method.invoke()方法的第一个参数不能写成o,否则会进入死循环。

关于CGLIB的具体解释可查看这篇文章

CGLIB动态代理之intercept函数刨析_cglib intercept_一个默默努力的人的博客-CSDN博客

六.三种代理方式对比

jdk代理与CGLIB代理

jdk动态代理只适合被代理类实现了接口，因为它是通过实现接口来实现的代理。

CGLIB动态代理无论是否实现了接口，其都可以使用，因为其是通过继承被代理类来实现的。但是需要注意的是CGLIB不能代理加了final关键字的类，因为加了final关键字的类不能被继承。

动态代理与静态代理

动态代理把所有的被代理的方法都集成在一个方法中处理，而静态代理需要一个一个的去实现。增加了代码的复杂度。并且，在新增一个方法后，静态代理需要修改代码，新增一个方法，而动态代理不用。符合开闭原则。

七.优缺点

优点

1.在客户端与目标对象之间起到了保护的作用。

2.可以对方法进行增强。

3.降低了客户端与目标对象的耦合度。

缺点

增加了系统的复杂度

八.使用场景

1.最常见的就spring框架的aop,面向切面编程。其底层实现就是代理模式。

2.在执sql语句前(某个方法)动态创建sql语句，比如数据权限的使用。

3.远程代理。

4.防护墙代理。

5.保护代理，执行方法前先判断用户是否有权限访问比如springSecurity中的鉴权。