Java复习总结之代理模式及其实现

什么是代理？

代理(Proxy)是一种设计模式，提供了对目标对象另外的访问方式，即通过代理对象访问目标对象。

这样做的好处是：可以在目标对象实现的基础上，增强额外的功能操作，即扩展目标对象的功能。

代理模式的关键点是：代理对象与目标对象。代理对象是对目标对象的扩展，并会调用目标对象

这里使用到编程中的一个思想：不要随意去修改别人已经写好的代码或者方法，如果需要修改，可以通过代理的方式来扩展该方法。

代理模式分类

代理模式可分为：静态代理、动态代理（分为jdk代理和Cglib代理）

1、静态代理

以定制服装为例

代码：
服装接口

public interface Clothes {
    void clothes(Integer size);
}

服装工厂

/**
 * 服装工厂（目标对象）
 * @author 流星
 */
public class ClothesFactory implements Clothes {
    @Override
    public void clothes(Integer size) {
        System.out.println("已经为您制作好了一件尺码为"+size+"的衣服，价格为"+(size*0.5)+"元");
    }
}

中间代理商

/**
 * @author 流星
 * 中间代理商（代理对象）
 */
public class StaticProxy implements Clothes{
    private ClothesFactory clothesFactory = new ClothesFactory();

    @Override
    public void clothes(Integer size) {
        frontService();
        clothesFactory.clothes(size);
        endService();
    }

    /**
     * 前置服务
     **/
    public void frontService(){
        System.out.println("-----进行前置服务-----");
    }

    /**
     * 后置服务
     **/
    public void endService(){
        System.out.println("-----进行后置服务-----");
    }
}

静态代理测试类

/**
 * @author 流星
 * 顾客（用户）
 */
public class StaticProxyTest {
    public static void main(String[] args) {
        StaticProxy staticProxy = new StaticProxy();
        staticProxy.clothes(170);
    }
}

静态代理总结

优点：可以做到在不修改目标对象的功能前提下，对目标功能扩展。
缺点：因为代理对象需要与目标对象实现一样的接口，所以会有很多代理类。类太多，同时一旦接口增加方法，目标对象与代理对象都要维护.

那么，如何解决静态代理中的缺点呢？
答案：可以使用动态代理方式

动态代理

jdk代理

JDK中生成代理对象的API

代理类所在包：java.lang.reflect.Proxy
JDK实现代理只需要使用newProxyInstance方法。但是该方法需要接收三个参数，完整的写法是:

static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,InvocationHandler h )

ClassLoader loader：指定当前目标对象使用类加载器，获取加载器的方法是固定的
Class<?>[] interfaces：目标对象实现的接口的类型，使用泛型方式确认类型
InvocationHandler h：事件处理，执行目标对象的方法时，会触发事件处理器的方法，会把当前执行目标对象的方法作为参数传入

以代购公司为例，在原静态代理模式中新添加几个文件（公司的优势：可以代购很多种商品，不是定性的代购）

鞋子接口

public interface Shoes {
    void shoes(String size);
}

鞋子工厂

/**
 * description 鞋子工厂（目标对象）
 *
 * @author 流星
 * @date 2022/1/20 23:00
 */
public class ShoesFactory implements Shoes{
    @Override
    public void shoes(String size) {
        System.out.println("已经为您生产出了尺码为"+size+"的鞋子");
    }
}

代购公司

/**
 * description 代购公司（动态代理对象）
 *
 * @author 流星
 * @date 2022/1/20 23:02
 */
public class PurchasingCompany implements InvocationHandler {
    /**
     * 目标对象
     **/
    private Object factory ;

    public Object getFactory() {
        return factory;
    }

    public void setFactory(Object factory) {
        this.factory = factory;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        frontService();
        /**
         * 这里用了反射的思想，因为我们不知道调用的是那个工厂的那个方法
         **/
        Object retObject = method.invoke(factory, args);
        endService();
        return null;
    }

    public void frontService() {
        System.out.println("根据您的需求进行市场调研");
    }

    public void endService() {
        System.out.println("为您提供一条龙的包办服务");
    }

    /**
     * 调度员工
     *
     * 1 新建一名员工
     * 2.告诉员工工厂地址
     * this:绑定
     */
    public Object getProxyInstance() {
        return Proxy.newProxyInstance(factory.getClass().getClassLoader(), factory.getClass().getInterfaces(), this);
    }
}

动态代理测试类

/**
 * description 动态代理测试类
 *
 * @author 流星
 * @date 2022/1/20 23:10
 */
public class DynamicProxyTest {
    public static void main(String[] args) {
        ClothesFactory clothesFactory = new ClothesFactory();
        ShoesFactory shootFactory = new ShoesFactory();
        PurchasingCompany company = new PurchasingCompany();
        company.setFactory(shootFactory);
        Shoes employee1 = (Shoes) company.getProxyInstance();
        employee1.shoes("42");
        company.setFactory(clothesFactory);
        Clothes employee2 = (Clothes) company.getProxyInstance();
        employee2.clothes(180);
    }
}

动态代理总结

代理对象不需要实现接口，但是目标对象一定要实现接口，否则不能用动态代理

Cglib代理

什么是cglib代理

上面的静态代理和动态代理模式都是要求目标对象是实现一个接口的目标对象，但是有时候目标对象只是一个单独的对象，并没有实现任何的接口。这个时候就可以使用以目标对象子类的方式类实现代理，这种方法就叫做 Cglib 代理

Cglib代理，也叫作子类代理，它是在内存中构建一个子类对象从而实现对目标对象功能的扩展

代码：

前提是我们已经有一个完整的 Spring 框架，下载链接：Spring 框架初始化

项目结构

01、目标对象

public class Target {
    public void save() {
        System.out.println("----已经保存数据!----");
    }
}

02、代理对象

package com.cglib.proxy;

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 * description 代理工厂
 *
 * @author 流星
 * @date 2022/1/21 10:26
 */
public class ProxyFactory implements MethodInterceptor {

    /**
     * 维护目标对象
     **/
    private Object target;

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

    /**
     * 给目标对象创建一个代理对象
     **/
    public Object getProxyInstance() {
        //1.工具类
        Enhancer en = new Enhancer();
        //2.设置父类
        en.setSuperclass(target.getClass());
        //3.设置回调函数
        en.setCallback(this);
        //4.创建子类(代理对象)
        return en.create();
    }
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("开始事务...");
        //执行目标对象的方法
        Object returnValue = method.invoke(target, args);
        System.out.println("提交事务...");
        return returnValue;
    }
}

03、测试类

package com.cglib.test;
import com.cglib.proxy.ProxyFactory;
import com.cglib.target.Target;

/**
 * description cglib测试类
 *
 * @author 流星
 * @date 2022/1/21 10:29
 */
public class CglibTest {
    public static void main(String[] args) {
        //目标对象
        Target target = new Target();
        //代理对象
        Target proxy = (Target)new ProxyFactory(target).getProxyInstance();
        //执行代理对象的方法
        proxy.save();
    }
}

测试结果

有人会问：Spring 里边不是包含一些关于 cglib 的吗，这不会对测试结果有影响吗？

对于Spring cglib，我们在某些方法上加注解，然后通过网络访问或其他访问是，才会生效。不启动Spring，是不会影响程序的。

cglib代理总结

Cglib 代理经常被用于AOP中，具体实例如下：

1、spring的事务，事务的开启可以作为前置增强，事务的提交或回滚作为后置增强，数据库的操作处在两者之间（目标对象需要完成的事）；
2、日志记录，我们可以在不改变原有实现的基础上，对目标对象进行日志的输出，可以前置处理，记录参数情况，也可以后置处理，记录返回的结果；
3、web编程，传入参数的校验；
4、web编程，权限的控制也可以用aop来实现；

附：Spring AOP 参考

以下为博主有关于Spring Aop 的博文，有需要的可以参考一下，希望能对你有帮助

1、Spring boot 项目（五）——AOP切面
2、Spring boot 项目（六）——AOP操作日志
3、Spring boot 项目（七）——AOP权限校验