代理模式（Proxy）

代理模式

解释

代理模式:为一个对象提供一个替身，以控制对这个对象的访问。即通过代理对象访问目标对象

优点

可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能。

可被代理的对象

• 远程对象
• 创建开销大的对象
• 需要安全控制的对象

形式

• 静态代理
• 动态代理（JDK代理，接口代理）
• Cglib代理（可以在内存动态的创建对象，而不需要实现接口，他是属于动态代理的范畴）

---

代理模式示意图

---

静态代理

静态代理在使用时,需要定义接口或者父类,被代理对象(即目标对象)与代理对象一起实现相同的接口或者是继承相同父类

接口

package proxy.staticproxy;

/**
 * @author pangjian
 * @ClassName ITeacherDao
 * @Description 聚合接口
 * @date 2021/6/30 20:38
 */

public interface ITeacherDao {
    void teach();
}

被代理对象（目标对象）

package proxy.staticproxy;

/**
 * @author pangjian
 * @ClassName TeacherDao
 * @Description 被代理对象
 * @date 2021/6/30 20:40
 */

public class TeacherDao implements ITeacherDao{
    @Override
    public void teach() {
        System.out.println("你好！世界");
    }
}

代理对象

package proxy.staticproxy;

/**
 * @author pangjian
 * @ClassName TeacherDaoProxy
 * @Description 静态代理对象
 * @date 2021/6/30 20:41
 */

public class TeacherDaoProxy implements ITeacherDao{

    private ITeacherDao targetObject; // 目标对象，通过接口来聚合

    public TeacherDaoProxy(ITeacherDao targetObject) {
        this.targetObject = targetObject;
    }

    @Override
    public void teach() {
        System.out.println("静态代理开始");
        targetObject.teach();
        System.out.println("静态代理结束");
    }
}

测试客户类

package proxy.staticproxy;

/**
 * @author pangjian
 * @ClassName Client
 * @Description 客户端
 * @date 2021/6/30 20:46
 */

public class Client {

    public static void main(String[] args) {
        // 创建目标对象
        TeacherDao teacherDao = new TeacherDao();
        // 创建目标对象，同时将被代理对象传递给代理对象
        TeacherDaoProxy teacherDaoProxy = new TeacherDaoProxy(teacherDao);
        // 通过代理对象，调用到被代理对象的方法
        teacherDaoProxy.teach();
    }

}

结果

优缺点

优点:在不修改目标对象的功能前提下，能通过代理对象对目标功能扩展

缺点:因为代理对象需要与目标对象实现一样的接口,所以会有很多代理类一旦接口增加方法,目标对象与代理对象都要维护

---

JDK动态代理

动态生成的代理对象其实也实现了接口（就是目标类实现的接口），目标对象也要实现接口（后面说原因），否则动态代理失败，代理对象的生成，是利用JDK的APl，动态的在内存中构建代理对象

应用案例

动态代理实现类似AOP事务处理，一份事务处理的代码即可，可以应用到所有的模块中的增删改。比如添加一个用户记录，如果出现异常要回滚，添加用户记录功能具有事务特性。而业务遍布系统各处，我们每个业务都去写相同的代码就是垃圾代码，我们要应用动态代理去处理事务开启、提交或回滚。

控制器

package design.patterns.proxy.dynamic.jdk;

import design.patterns.util.AopTargetUtils;
import design.patterns.util.SpringUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class AccountController {

    @Autowired
    private TransactionUtil transactionUtil;

    @RequestMapping("user/insertUser")
    public String insertUser() throws Exception {
        // 获取真实对象，并通过真实对象获取我们自定义的代理对象
        IAccountService iAccountService = (AccountServiceImpl) AopTargetUtils.getTarget(SpringUtil.getBean("accountServiceImpl"));
        IAccountService accountService = (IAccountService)
                new TransactionHandler(transactionUtil, iAccountService).creatProxyObject();
        User user = new User(1, "小明", "123");
        try {
            // 代理对象执行代理方法
            accountService.insertUser(user);
            return "成功";
        } catch (Exception e) {
            // 可返回错误信息
            e.printStackTrace();
            return "失败";
        }
    }
}

业务

插入一个对象，模拟出现异常，会回滚，数据库并没有该数据

package design.patterns.proxy.dynamic.jdk;

import com.baomidou.mybatisplus.extension.service.IService;

public interface IAccountService extends IService<User> {

    void insertUser(User user);

}

package design.patterns.proxy.dynamic.jdk;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class AccountServiceImpl extends ServiceImpl<UserMapper, User> implements IAccountService {

    @Autowired
    private UserMapper userMapper;

    @Override
    public void insertUser(User user) {
        try {
            userMapper.insert(user);
            // int a = 1/0;
        } catch (Exception e) {
            e.printStackTrace();
            throw e; // 我们捕获从数据库访问层抛出的异常后还要继续抛出给代理对象去进行捕获进行回滚操作，和控制层进行错误信息的前端返回操作
        }
    }
}

代理实例工厂

package design.patterns.proxy.dynamic.jdk;

import org.springframework.transaction.TransactionStatus;

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

public class TransactionHandler implements InvocationHandler {

    private Object targetObject;

    private TransactionUtil transaction;

    public TransactionHandler(TransactionUtil transaction, Object o) {
        this.transaction = transaction;
        this.targetObject = o;
    }

    /**
     * @Description: 执行目标对象方法时，实际上是调用了invoke方法，invoke方法再调用目标对象方法，你可以在这里对要执行的方法进行增强，而不需要改目标对象的代码，专注于编写增强逻辑
     * @Param proxy:
     * @Param method:
     * @Param args:
     * @return java.lang.Object
     * @date 2021/7/1 17:05
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) {
        TransactionStatus begin = transaction.begin();
        Object retVal = null;
        try {
            if( !(method.getName().startsWith("select")
                    || method.getName().startsWith("get"))){ // 不对查找进行事务控制
                retVal = method.invoke(targetObject, args);
                transaction.commit(begin);
            }else {
                retVal = method.invoke(targetObject, args);
            }
        } catch (Exception e) {
            transaction.rollback(begin);
        }
        return retVal;
    }

    /**
     * @Description: 给目标对象生成一个代理对象，专注于生成代理对象
     * @Param targetObject: 目标对象
     * @return java.lang.Object
     * @date 2021/7/1 16:43
     */
    public Object creatProxyObject(){
        /*
            public static Object newProxyInstance(ClassLoader loader,
                                                  Class<?>[] interfaces,
                                                  InvocationHandler h)
         * @Param ClassLoader loader:指定当前目标对象使用的类加载器，获取加载器的方法
         * @Param Class<?>[] interfaces:目标对象实现的接口类型，使用泛型方法确认类型
         * @Param InvocationHandler h:事件处理，执行目标对象的方法时，会把当前执行的目标对象方法作为参数传入
        */
        return Proxy.newProxyInstance(
                targetObject.getClass().getClassLoader(),
                targetObject.getClass().getInterfaces(),
                this // 代表当前InvocationHandler实例
        );
    }

}

问题

为什么目标类要实现一个接口

package design.patterns.proxy.dynamic.jdk;

public class Test implements ITest {

    @Override
    public void select(){
        System.out.println("sfdsf");
    }

}

// 测试如果目标类没有继承接口的状况，虽然也会生成代理类，但没有代理方法，无法对目标类的方法进行增强，这样就算失败代理了
public static void main(String[] args) {
    System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
    ITest testProxy = new TransactionHandler(new TransactionUtil(), new Test()).creatProxyObject();
    testProxy.select();
}

1.先看#creatProxyObject()中的#newProxyInstance()，本质就是调用了代理类的构造方法

public Object creatProxyObject(){
    return Proxy.newProxyInstance(
            targetObject.getClass().getClassLoader(),
            targetObject.getClass().getInterfaces(),
            this // 代表当前InvocationHandler实例
    );
}

@CallerSensitive
public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces,
                                      InvocationHandler h)
    throws IllegalArgumentException
{
		.....
        final Constructor<?> cons = cl.getConstructor(constructorParams);
        final InvocationHandler ih = h;
        .....
        // 调用了代理对象的构造方法
        return cons.newInstance(new Object[]{h});
        .....
}

2.看代理类$Proxy0代码，对象上面创建的testProxy实例源码

package com.sun.proxy;

import design.patterns.proxy.dynamic.jdk.ITest;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public final class $Proxy0 extends Proxy implements ITest {
	.....
	// 实例创建靠执行该方法，该方法又调用了父类构造方法
    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }
    .....
}

3.父类把刚开始创建的InvocationHandler实例赋值给了自身成员属性

public class Proxy implements java.io.Serializable {
	protected InvocationHandler h;
	
	protected Proxy(InvocationHandler h) {
	    Objects.requireNonNull(h);
	    this.h = h;
	}
}

当testProxy.select()，第一先进去代理类的代理方法#select()

public final class $Proxy0 extends Proxy implements ITest {

    private static Method m3;

    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }

	// 执行该代理方法，其实执行了父类的h属性，也就是我们刚创建对象由构造方法传入的InvocationHandler实例的invoke方法（如下方所示）
    public final void select() throws  {
        try {
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m3 = Class.forName("design.patterns.proxy.dynamic.jdk.ITest").getMethod("select");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

我们的自定义代理方法逻辑增强类有目标类的引用配合传递过来的目标方法的引用，最后完成目标方法的增强

public class TransactionHandler implements InvocationHandler {

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) {
    	....增强逻辑
    	retVal = method.invoke(targetObject, args);
    	....增强逻辑
    }

}

java单继承多实现，java动态代理要在内存动态生成代理类，所以该代理类要默认继承 Proxy类，如果java动态代理的目标对象没有实现一个接口，当代理类要和目标对象要产生关联时，不能是继承关联了（因为要动态生成代理对象，已经继承Proxy类了），那只能是实现，所以目标对象必须要实现一个接口，给动态生成的代理类对象去实现，这样才能使代理类和目标类产生关联（关联后才有相关代理方法，否则$Proxy中是没有select()的）

为什么在Spring事务中，在类中用this调用同类的事务方法会失效

@Service
public class TestServiceImpl implements TestService{
    
    public void a() {
        this.b();
    }
    
    @Transactional
    public void b() {
        System.out.println("事务失效");
    }
    
}

通过上面分析，controller调用a方法，但a方法没有开启事务，b开启了事务，b就应该由sevice代理类的代理方法b中去控制事务，但由于a方法中调用b方法用的是this，controller虽然调用了service代理类，但最终a方法的执行是由a实例引用去执行（代理模式中，基于以上分析），所以a方法调用b方法时的this是a实例，this.b()就是调用了实例中的b方法，此时的b方法不是代理方法，没有开启事务控制，导致事务失效（虽然已经有相关的代理方法b了，但没调用）

---

Cglib代理

Cglib代理也叫作子类代理,它是在内存中构建一个子类对象从而实现对目标对象功能扩展，他不需要目标对象实现接口。

实现步骤

• 引入cglib的jar文件
• 在内存中动态构建子类，代理的类不能为final
• 目标对象方法如果为final/static，那么就不会执行目标对象额外的业务方法

<!-- cglib包 -->
<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.3.0</version>
</dependency>

目标对象（被代理的对象）

package proxy.cglib;

/**
 * @author pangjian
 * @ClassName TargetObject
 * @Description 目标对象
 * @date 2021/7/1 18:09
 */

public class TargetObject {

    public void targetMethod(){
        System.out.println("你好");
    }

}

代理对象工厂类

package proxy.cglib;

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

import java.lang.reflect.Method;

/**
 * @author pangjian
 * @ClassName proxyFactory
 * @Description 代理对象工厂类
 * @date 2021/7/1 18:12
 */

public class ProxyFactory implements MethodInterceptor {

    private Object targetObject;

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

    /**
     * @Description: 实现目标对象方法的调用
     * @Param o:
     * @Param method:
     * @Param objects:
     * @Param methodProxy:
     * @return java.lang.Object
     * @date 2021/7/1 18:27
    */
    @Override
    public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        System.out.println("方法之前");
        Object returnValue = method.invoke(targetObject,args);
        System.out.println("方法之后");
        return returnValue;
    }

    /**
     * @Description:返回一个代理对象
     * @return java.lang.Object
     * @date 2021/7/1 18:29
    */
    public Object getProxyInstance(){
        // 创建一个工具类
        Enhancer enhancer = new Enhancer();
        // 设置目标对象为父类
        enhancer.setSuperclass(targetObject.getClass());
        // 设置回调函数
        enhancer.setCallback(this);
        // 创建子类对象，即代理对象
        return enhancer.create();
    }

}

测试

package proxy.cglib;

/**
 * @author pangjian
 * @ClassName Client
 * @Description 测试
 * @date 2021/7/1 18:40
 */

public class Client {

    public static void main(String[] args) {
        TargetObject targetObject = new TargetObject();
        TargetObject targetObjectProxy = (TargetObject) new ProxyFactory(targetObject).getProxyInstance();
        targetObjectProxy.targetMethod();
    }
}