文章目录

代理模式
- 解释
- 优点
- 可被代理的对象
- 形式
代理模式示意图
静态代理
- 接口
- 被代理对象（目标对象）
- 代理对象
- 测试客户类
- 结果
- 优缺点
JDK动态代理
- 应用案例
- - 控制器
  - 业务
  - 代理实例工厂
- 问题
- - `为什么目标类要实现一个接口`
  - `为什么在Spring事务中，在类中用this调用同类的事务方法会失效`
Cglib代理
- 实现步骤
- - 目标对象（被代理的对象）
  - 代理对象工厂类
  - 测试

代理模式

解释

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

优点

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

可被代理的对象

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

形式

静态代理
动态代理（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{@Overridepublic 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;}@Overridepublic 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 {@Autowiredprivate 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 {@Autowiredprivate UserMapper userMapper;@Overridepublic 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*/@Overridepublic 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 {@Overridepublic 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 {@Overridepublic 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();}@Transactionalpublic 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*/@Overridepublic 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();}
}

代理模式（Proxy）相关推荐

代理模式(Proxy)简介
代理模式相对来讲比较简单和容易理解. 一, 代理模式(Proxy)的定义教材里定义很简单: 所谓代理模式, 就是为其他对象提供一种代理控制对这个对象的访问. 上面出现了3个名词: 1.其他对象 2. ...
二十四种设计模式：代理模式(Proxy Pattern)
代理模式(Proxy Pattern) 介绍为其他对象提供一个代理以控制对这个对象的访问. 示例有一个Message实体类,某对象对它的操作有Insert()和Get()方法,用一个代理来控制对这 ...
Java24种设计模式(第二种)--代理模式(Proxy Pattern)
Java24种设计模式 (第二种) 一.代理模式(Proxy Pattern) 模式逻辑: 什么是代理模式呢?我很忙,忙的没空理你,那你要找我呢就先找我的代理人吧,那代理人总要知道被代理人能做哪些事 ...
二十三种设计模式(第十二种)-----代理模式(Proxy)
二十三种设计模式(第十二种)-----代理模式(Proxy) 尚硅谷视频连接https://www.bilibili.com/video/BV1G4411c7N4?from=search&se ...
[Java] 代理模式 Proxy Mode
[Java] 代理模式 Proxy Mode 文章目录 [Java] 代理模式 Proxy Mode 1. 代理思想 2.java.lang.reflect.Proxy类 2.1 利用反射创建prox ...
设计模式——代理模式(Proxy Pattern)之为别人做嫁衣
代理模式Proxy Pattern 代理模式 1.背景 2.定义 3.特征 4.应用场景 5.实验案例参考代理模式 1.背景假如说我现在想租一间房子,虽然我可以自己去找房源,做卫生检测等一系列的 ...
设计模式-代理模式(Proxy Pattern)
设计模式-代理模式(Proxy Pattern) 文章目录设计模式-代理模式(Proxy Pattern) 一.定义二.概念解释三.场景四.实现 1.类图 2.代码实现五.小结六.动态代理 ...
js设计模式——代理模式proxy
什么是代理模式代理模式是为一个对象提供一个代用品或占位符,以便控制对它的访问. (可以想象一下明星与经纪人的关系,明星是请求的本体,经纪人就是代理proxy) 如何实现代理模式代理对象内部含有对本 ...
设计模式之代理模式(Proxy)摘录
23种GOF设计模式一般分为三大类:创建型模式.结构型模式.行为模式. 创建型模式抽象了实例化过程,它们帮助一个系统独立于如何创建.组合和表示它的那些对象.一个类创建型模式使用继承改变被实例化的类,而 ...
PHP代理模式Proxy Mode
代理,指的就是一个角色代表另一个角色采取行动,就像现实生活中,微软或联想不会直接把自己的系统或者电脑卖给客户,而是通过代理来完成它的销售业务.而客户,也不用为了买个Office或笔记本而到处去找联想工 ...

代理模式（Proxy）