Java设计模式之代理模式

        代理模式是Java设计模式中的一个很重要的设计模式，代理模式也都是可以通过现实生活中的例子来说明的，例如我是一家手机生产商，我生产了一款比现在市面上都厉害的手机。我就想让更多人来购买我的这款手机，但是需要在市场上出售的话，我得有销售渠道。但是短期内又不能一下子开那么多点，公司的资金也不支持一下子的迅速扩张，风险太大。于是我就找到了现在有全国完整的销售渠道的公司，例如苏宁，国美等这些。我通过他们的销售渠道来售卖我的手机。客户在苏宁等商店里可以买到我的手机，这种就是一种代理模式的体现。我方是被代理方，苏宁、国美是代理方，用户是购买方也可以说是客户端。那么这种代理思想体现在代码上，怎么处理呢？

        我们需要知道的是，代理模式有常见的三种实现方式，静态代理模式、JDK动态代理模式、Cglib动态代理模式。Cglib是使用Cglib框架来实现，下面我们使用代码来实现这三种代理方式。

1. 静态代理模式

        静态代理模式在代码上和装饰模式不能说风格相近，可以说一模一样。那么我们就来通过代码案例中体验一下。

接口类

public interface ITeacherService {

    void teach();
}

接口实现类，也是被代理类

public class TeacherServiceImpl implements ITeacherService {


    @Override
    public void teach() {
        System.out.println("这里是被代理对象里面的逻辑，老师上课教知识。。。");
    }
    
}

代理类

public class TeacherServiceProxy implements ITeacherService {

    ITeacherService teacherService;

    public TeacherServiceProxy(ITeacherService teacherService) {
        this.teacherService = teacherService;
    }

    @Override
    public void teach() {
        System.out.println("代理对象开始代理。。。");
        teacherService.teach();
        System.out.println("代理对象执行结束。。。");
    }
}

从代码结构上来说看，确实和装饰器模式几乎一样，虽然两者的代码风格相近，但两种设计模式的定位确是不一样的，装饰器模式定位是对原有功能的增加。代理模式是对被代理对象功能的展示或者说提供被代理对象的功能，对其功能是不做修改的。我们来测试一下，测试和效果如下

public class Main {

    public static void main(String[] args) {
        TeacherServiceProxy proxy = new TeacherServiceProxy(new TeacherServiceImpl());
        proxy.teach();
    }
}

2. JDK动态代理模式

        JDK动态代理是JDK提供的一种动态代理实现方式，JDK动态代理是需要基于接口来实现，就是说，被代理的对象得是接口的实现类，我们通过代码来体验一下，接口和实现类我们还是使用静态代理中创建的ITeacherService和TeacherServiceImpl，我们新建一个JDK代理类，代理类详情如下

public class JDKProxyFactory {

    //目标对象，被代理对象
    Object target;

    public JDKProxyFactory(Object target) {
        this.target = target;
    }

    public Object proxyInstance() {
        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("JDK代理开始。。。");
                        //method.invoke：执行的方法，需要告知那个类和该方法的参数有哪些
                        Object result = method.invoke(target, args);
                        System.out.println("JDK代理结束。。。");
                        return result;
                    }
                });
    }
}

测试代码合测试效果如下

public class Main {

    public static void main(String[] args) {
        //被代理类
        ITeacherService teacherService = new TeacherServiceImpl();
        //产生代理对象
        JDKProxyFactory jdkProxyFactory = new JDKProxyFactory(teacherService);
        ITeacherService proxy = (ITeacherService) jdkProxyFactory.proxyInstance();
        System.out.println("代理对象：" + proxy.getClass());
        proxy.teach();
    }
}

 3. Cglib动态代理模式

        Cglib代理是使用Cglib框架来实现动态代理的，JDK动态代理和静态代理都是需要创建接口，然后实现接口方法，然后进行代理，Cglib可以做到在没有任何接口的情况下进行代理，代码实现细节如下。

3.1 引入jar包

需要引入cglib的maven的依赖，详情如下

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

3.2 代理实现过程

先创建一个业务类，然后对这个业务类进行代理，业务类详情如下

public class StudentService {

    public void study() {
        System.out.println("学生正在学习。。。");
    }
}

Cglib代理类的实现细节如下

package com.study.rabbitmq.designPattern.proxy;

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

import java.lang.reflect.Method;

/**
 * @Author alen
 * @DATE 2022/7/9 17:24
 */
public class CglibProxyFactory implements MethodInterceptor {
    //目标对象，被代理对象
    Object target;

    public CglibProxyFactory(Object object) {
        this.target = object;
    }

    /**
     * 获取代理对象
     * @return
     */
    public Object cglibProxyInstance() {
        //1. 创建工具类
        Enhancer enhancer = new Enhancer();
        //2. 设置父类，将被代理类设置为父类
        enhancer.setSuperclass(target.getClass());
        //3. 设置回调函数
        enhancer.setCallback(this);
        //4. 创建子类对象，即代理对象，cglib的是使用继承类实现代理逻辑
        return enhancer.create();
    }

    @Override
    public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        System.out.println("Cglib代理模式开始代理。。。");
        Object result = method.invoke(target, args);
        System.out.println("Cglib代理模式代理结束。。。");
        return result;
    }
}

代理类中导包需要注意别导错了，测试代码合效果如下

public class Main {

    public static void main(String[] args) {
        //被代理对象
        StudentService studentService = new StudentService();
        //创建代理工厂，设置被代理类target
        CglibProxyFactory cglibProxyFactory = new CglibProxyFactory(studentService);
        StudentService proxy = (StudentService) cglibProxyFactory.cglibProxyInstance();
        System.out.println("代理对象：" + proxy.getClass());
        proxy.study();
    }
}

到这里，Java的代理模式已经实现完了。现在进行一个小总结。Java设计模式的代理模式有三种实现，分别是静态代理模式，JDK动态代理模式，Cglib动态代理模式。其中静态代理模式和JDK动态代理模式需要依赖接口，Cglib动态代理模式可以不需要接口也可以实现代理逻辑。JDK运用的是接口实现，Cglib运用的是类继承，Cglib会将被代理类作为父类设置，创建出来的代理类是其子类的关系。

代理模式就这么多东西的分享了，欢迎讨论。