代理模式详解

article/2025/10/2 9:22:01

1. 代理模式

代理模式是一种比较好理解的设计模式。简单来说就是 我们使用代理对象来代替对真实对象(real object)的访问，这样就可以在不修改原目标对象的前提下，提供额外的功能操作，扩展目标对象的功能。

代理模式一半包含三种角色：

抽象主题角色（Subject）：抽象主题类的主要职责是声明真实主题与代理的共同接口方法，该类可以是接口也可以是抽象类。；

真实主题角色（RealSubject）: 该类定义了代理所表示的真实对象，是负责执行系统真正的逻辑业务对象；

代理主题角色（Proxy）：代理类；其内部持有RealSubject的引用，因此具备完全的对RealSubject的代理权。客户端调用代理对象的方法，同时也调用被代理对象的方法，但是会在代理对象前后增加一些代码处理。

在代码中，一般代理会被理解为代码增强，实际上就是扩展目标对象的功能，比如说在目标对象的某个方法执行前后你可以增加一些自定义的操作。

代理模式属于结构性模式：分为静态代理和动态代理。

2. 静态代理

静态代理中，我们对目标对象的每个方法的增强都是手动完成的，非常不灵活（比如接口一旦新增加方法，目标对象和代理对象都要进行修改且麻烦需要对每个目标类都单独写一个代理类)。 实际应用场景非常非常少，日常开发几乎看不到使用静态代理的场景。

上面我们是从实现和应用角度来说的静态代理，从 JVM 层面来说， 静态代理在编译时就将接口、实现类、代理类这些都变成了一个个实际的 class 文件。

静态代理实现步骤:

  1. 定义一个接口及其实现类；
  2. 创建一个代理类同样实现这个接口
  3. 将目标对象注入进代理类，然后在代理类的对应方法调用目标类中的对应方法。这样的话，我们就可以通过代理类屏蔽对目标对象的访问，并且可以在目标方法执行前后做一些自己想做的事情。

下面通过代码展示！

2.1 简单示例

  • 定义一个接口

    public interface ISubject {void request();}

  • 实现类

    public class RealSubject implements ISubject {public void request() {System.out.println("real service is called.");}}

  • 创建代理类

    public class Proxy implements ISubject {private ISubject subject;public Proxy(ISubject subject) {this.subject = subject;}//代码增强public void request() {before();subject.request();after();}public void before() {System.out.println("called before request().");}public void after() {System.out.println("called after request().");}
}

  • 测试类

    public class Client {public static void main(String[] args) {Proxy proxy = new Proxy(new RealSubject());proxy.request();}}

  • 输出结果

    image-20211201122801220

2.2 业务应用

在分布式业务场景中，通常会对数据库进行分库分表，我们可以使用设置数据源路由来动态切换数据源。

注意：为了操作方便没有实际创建相关数据库；

  • 首先创建订单类

    public class Order {private Object orderInfo;//订单创建时间进行按年分库private Long createTime;private String id;public Object getOrderInfo() {return orderInfo;}public void setOrderInfo(Object orderInfo) {this.orderInfo = orderInfo;}public Long getCreateTime() {return createTime;}public void setCreateTime(Long createTime) {this.createTime = createTime;}public String getId() {return id;}public void setId(String id) {this.id = id;}
}

  • 持久层类

    public class OrderDao {public int insert(Order order) {System.out.println("OrderDao创建Order成功!");return 1;}}

  • 业务类

    public interface IOrderService {int createOrder(Order order);}

    public class OrderService implements IOrderService {private OrderDao orderDao;public OrderService() {//如果使用Spring应该是自动注入的//我们为了使用方便，在构造方法中将orderDao直接初始化了orderDao = new OrderDao();}public int createOrder(Order order) {System.out.println("OrderService调用orderDao创建订单");return orderDao.insert(order);}
}

接下来使用静态代理，主要完成的功能是:根据订单创建时间自动按年进行分库。

  • 创建数据源路由对象

    //动态切换数据源
public class DynamicDataSourceEntity {//默认数据源public final static String DEFAULE_SOURCE = null;private final static ThreadLocal<String> local = new ThreadLocal<String>();private DynamicDataSourceEntity() {}//获取正在使用的数据源名字public static String get() {return local.get();}//还原当前切换的数据源public static void restore() {local.set(DEFAULE_SOURCE);}//设置已知名字的数据源public static void set(String source) {local.set(source);}//根据年份动态设置数据源public static void set(int year) {local.set("DB_" + year);}//清空数据源public static void clear() {local.remove();}}

  • 创建代理类

    public class OrderServiceStaticProxy implements IOrderService {private SimpleDateFormat yearFormat = new SimpleDateFormat("yyyy");private IOrderService orderService;public OrderServiceStaticProxy(IOrderService orderService) {this.orderService = orderService;}public int createOrder(Order order) {before();Long time = order.getCreateTime();Integer dbRouter = Integer.valueOf(yearFormat.format(new Date(time)));System.out.println("静态代理类自动分配到【DB_" + dbRouter + "】数据源处理数据");DynamicDataSourceEntity.set(dbRouter);this.orderService.createOrder(order);DynamicDataSourceEntity.restore();after();return 0;}private void before() {System.out.println("Proxy before");}private void after() {System.out.println("Proxy after");}
}

  • 测试类

    public class DbRouteProxyTest {public static void main(String[] args) {try {Order order = new Order();SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");Date date = sdf.parse("2021/12/01");order.setCreateTime(date.getTime());IOrderService orderService = new OrderServiceStaticProxy(new OrderService());orderService.createOrder(order);} catch (Exception e) {e.printStackTrace();}}}

  • 输出结果

    image-20211201124535485

结果符合我们的预期，根据日期将数据存储到对应的数据库中。

3. 动态代理

相比于静态代理来说，动态代理更加灵活。我们不需要针对每个目标类都单独创建一个代理类，并且也不需要我们必须实现接口，我们可以直接代理实现类( CGLIB 动态代理机制)。

从 JVM 角度来说，动态代理是在运行时动态生成类字节码，并加载到 JVM 中的。

说到动态代理，Spring AOP、RPC 框架应该是两个不得不提的，它们的实现都依赖了动态代理。

动态代理在我们日常开发中使用的相对较少，但是在框架中的几乎是必用的一门技术。学会了动态代理之后，对于我们理解和学习各种框架的原理也非常有帮助。

就 Java 来说，动态代理的实现方式有很多种，比如 JDK 动态代理、CGLIB 动态代理等等。

3.1 优化静态代理

我们可以通过修改静态代理中的数据源路由来了解动态代理。

创建动态代理类：

public class OrderServiceDynamicProxy implements InvocationHandler {private SimpleDateFormat yearFormat = new SimpleDateFormat("yyyy");Object proxyObj;public Object getInstance(Object proxyObj) {this.proxyObj = proxyObj;Class<?> clazz = proxyObj.getClass();return Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), this);}public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {before(args[0]);Object object = method.invoke(proxyObj, args);after();return object;}private void after() {System.out.println("Proxy after method");//还原成默认的数据源DynamicDataSourceEntity.restore();}//target 应该是订单对象Orderprivate void before(Object target) {try {//进行数据源的切换System.out.println("Proxy before method");//约定优于配置Long time = (Long) target.getClass().getMethod("getCreateTime").invoke(target);Integer dbRouter = Integer.valueOf(yearFormat.format(new Date(time)));System.out.println("静态代理类自动分配到【DB_" + dbRouter + "】数据源处理数据");DynamicDataSourceEntity.set(dbRouter);} catch (Exception e) {e.printStackTrace();}}
}

测试代码如下：

public class DbRouteProxyTest {public static void main(String[] args) {try {Order order = new Order();SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");Date date = sdf.parse("2021/12/01");order.setCreateTime(date.getTime());IOrderService orderService = (IOrderService) new OrderServiceDynamicProxy().getInstance(new OrderService());orderService.createOrder(order);} catch (Exception e) {e.printStackTrace();}}}

我们可以看到依然实现了相关效果。但是，使用动态代理之后，我们不仅可以实现Order表的数据源动态切换，还可以实现其他表的路由。

3.2 JDK动态代理机制

3.2.1 介绍

在 Java 动态代理机制中 InvocationHandler 接口和 Proxy 类是核心。

Proxy 类中使用频率最高的方法是：newProxyInstance() ，这个方法主要用来生成一个代理对象。

public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)throws IllegalArgumentException
{......
}

这个方法一共有 3 个参数：

  1. loader :类加载器，用于加载代理对象。
  2. interfaces : 被代理类实现的一些接口；
  3. h : 实现了 InvocationHandler 接口的对象；

要实现动态代理的话，还必须需要实现InvocationHandler 来自定义处理逻辑。 当我们的动态代理对象调用一个方法时，这个方法的调用就会被转发到实现InvocationHandler 接口类的 invoke 方法来调用。

public interface InvocationHandler {/*** 当你使用代理对象调用方法的时候实际会调用到这个方法*/public Object invoke(Object proxy, Method method, Object[] args)throws Throwable;
}

invoke() 方法有下面三个参数：

  1. proxy :动态生成的代理类
  2. method : 与代理类对象调用的方法相对应
  3. args : 当前 method 方法的参数

也就是说：你通过Proxy 类的 newProxyInstance() 创建的代理对象在调用方法的时候，实际会调用到实现InvocationHandler 接口的类的 invoke()方法。 你可以在 invoke() 方法中自定义处理逻辑，比如在方法执行前后做什么事情。

3.2.2 使用步骤

  1. 定义一个接口及其实现类；

  2. 自定义 InvocationHandler 并重写invoke方法，在 invoke 方法中我们会调用原生方法（被代理类的方法）并自定义一些处理逻辑；

  3. 通过 Proxy.newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h) 方法创建代理对象；

3.2.3 简单示例

  • 定义接口

    public interface SmsService {String send(String message);
}

  • 实现类

    public class SmsServiceImpl implements SmsService {public String send(String message) {System.out.println("send message:" + message);return message;}
}

  • 代理类

    public class JDkInvocationHandler implements InvocationHandler {/*** 代理类中的真实对象*/private final Object target;public JDkInvocationHandler(Object target) {this.target = target;}public Object invoke(Object proxy, Method method, Object[] args) throws InvocationTargetException, IllegalAccessException {//调用方法之前，我们可以添加自己的操作System.out.println("before method " + method.getName());Object result = method.invoke(target, args);//调用方法之后，我们同样可以添加自己的操作System.out.println("after method " + method.getName());return result;}
}

    invoke() 方法: 当我们的动态代理对象调用原生方法的时候，最终实际上调用到的是 invoke() 方法，然后 invoke() 方法代替我们去调用了被代理对象的原生方法。

  • 获取代理对象的工厂类

    public class JdkProxyFactory {public static Object getProxy(Object target) {return Proxy.newProxyInstance(target.getClass().getClassLoader(), // 目标类的类加载target.getClass().getInterfaces(),  // 代理需要实现的接口，可指定多个new JDkInvocationHandler(target)   // 代理对象对应的自定义 InvocationHandler);}
}

    getProxy() ：主要通过Proxy.newProxyInstance（）方法获取某个类的代理对象

  • 测试

    public class JDKTest {public static void main(String[] args) {SmsService smsService = (SmsService) JdkProxyFactory.getProxy(new SmsServiceImpl());smsService.send("java");}
}

    image-20211201131031396

3.3 CGLIB 动态代理机制

3.3.1 介绍

JDK 动态代理有一个最致命的问题是其只能代理实现了接口的类。

为了解决这个问题，我们可以用 CGLIB 动态代理机制来避免。

CGLIB (opens new window)(Code Generation Library)是一个基于ASM (opens new window)的字节码生成库，它允许我们在运行时对字节码进行修改和动态生成。CGLIB 通过继承方式实现代理。很多知名的开源框架都使用到了CGLIB (opens new window)， 例如 Spring 中的 AOP 模块中：如果目标对象实现了接口，则默认采用 JDK 动态代理，否则采用 CGLIB 动态代理。

在 CGLIB 动态代理机制中 MethodInterceptor 接口和 Enhancer 类是核心。

你需要自定义 MethodInterceptor 并重写 intercept 方法，intercept 用于拦截增强被代理类的方法。

public interface MethodInterceptor
extends Callback{// 拦截被代理类中的方法public Object intercept(Object obj, java.lang.reflect.Method method, Object[] args,MethodProxy proxy) throws Throwable;
}
  1. obj :被代理的对象（需要增强的对象）
  2. method :被拦截的方法（需要增强的方法）
  3. args :方法入参
  4. proxy :用于调用原始方法

你可以通过 Enhancer类来动态获取被代理类，当代理类调用方法的时候，实际调用的是 MethodInterceptor 中的 intercept 方法。

3.3.2 使用步骤

  1. 定义一个类；
  2. 自定义 MethodInterceptor 并重写 intercept 方法，intercept 用于拦截增强被代理类的方法，和 JDK 动态代理中的 invoke 方法类似；
  3. 通过 Enhancer 类的 create()创建代理类；

3.3.3 简单示例

  • 引入依赖

    不同于 JDK 动态代理不需要额外的依赖。CGLIB (opens new window)(Code Generation Library) 实际是属于一个开源项目，如果你要使用它的话，需要手动添加相关依赖。

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

  • 定义类

    public class SmsService {public String send(String message) {System.out.println("send message:" + message);return message;}
}

  • 自定义MethodInterceptor

    public class CGMethodInterceptor implements MethodInterceptor {/*** @param o           代理对象（增强的对象）* @param method      被拦截的方法（需要增强的方法）* @param args        方法入参* @param methodProxy 用于调用原始方法*/@Overridepublic Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {//调用方法之前，我们可以添加自己的操作System.out.println("before method " + method.getName());Object object = methodProxy.invokeSuper(o, args);//调用方法之后，我们同样可以添加自己的操作System.out.println("after method " + method.getName());return object;}
}

  • 获取代理类

    public class CglibProxyFactory {public static Object getProxy(Class<?> clazz) {// 创建动态代理增强类Enhancer enhancer = new Enhancer();// 设置类加载器enhancer.setClassLoader(clazz.getClassLoader());// 设置被代理类enhancer.setSuperclass(clazz);// 设置方法拦截器enhancer.setCallback(new CGMethodInterceptor());// 创建代理类return enhancer.create();}
}

  • 测试

    public class CGTest {public static void main(String[] args) {SmsService aliSmsService = (SmsService) CglibProxyFactory.getProxy(SmsService.class);aliSmsService.send("java");}
}

    image-20211201131815626

3.4 JDK 动态代理和 CGLIB 动态代理对比

  • JDK 动态代理只能代理实现了接口的类或者直接代理接口，而 CGLIB 可以代理未实现任何接口的类。 另外， CGLIB 动态代理是通过生成一个被代理类的子类来拦截被代理类的方法调用，因此不能代理声明为 final 类型的类和方法。

  • JDK动态代理和CGLIB代理都在运行期间生成字节码，JDK动态代理直接写Class字节码，CGLIB代理使用ASM框架写Class字节码，随意相对复杂，生成代理类的效率比较低。

  • JDK调用代理方法是通过反射机制，CGLIB是通过FastClass机制直接调用方法，所有执行效率较高。

  • 就二者的效率来说，大部分情况都是 JDK 动态代理更优秀，随着 JDK 版本的升级，这个优势更加明显。

4. 静态代理和动态代理的对比

  • 灵活性 ：动态代理更加灵活，不需要必须实现接口，可以直接代理实现类，并且可以不需要针对每个目标类都创建一个代理类。另外，静态代理中，接口一旦新增加方法，目标对象和代理对象都要进行修改，这是非常麻烦的！

  • JVM 层面 ：静态代理在编译时就将接口、实现类、代理类这些都变成了一个个实际的 class 文件。而动态代理是在运行时动态生成类字节码，并加载到 JVM 中的。


http://chatgpt.dhexx.cn/article/HLXyurbZ.shtml

相关文章

代理模式详细讲解

代理模式详细讲解

文章目录 一、什么是代理模式&#xff1f;二、 为什么使用代理模式&#xff1f;三、 代理模式的实现1、静态代理1.1、 创建公共的接口1.2、 创建被代理角色1.3、 创建代理角色1.4、 创建测试类 2、动态代理的实现2.1、 使用 JDK 的 Proxy 类实现动态代理1、 创建业务接口2、 创…
阅读更多...
一文搞懂代理模式

一文搞懂代理模式

代理模式 前言一、代理模式是什么&#xff1f;二、静态代理三、动态代理1.jdk动态代理&#xff08;接口代理&#xff09;2.cglib动态代理 前言 一、代理模式是什么&#xff1f; 代理模式是常见的设计模式之一&#xff0c;顾名思义&#xff0c;代理模式就是代理对象具备真实对象…
阅读更多...
手机测试耳机音质的软件,耳机音质测试软件有哪些

手机测试耳机音质的软件,耳机音质测试软件有哪些

耳机音质测试软件并不存在&#xff0c;因为耳机的音质对于人来说是主观的&#xff0c;你认为音质好的耳机&#xff0c;有的人却并不认为也很正常&#xff0c;国内外都没有恒定的耳机音质评判标准&#xff0c;大多数人认为音质好的耳机&#xff0c;那么它十有八九实际就是好的。…
阅读更多...
软件测试的基本理论与方法

软件测试的基本理论与方法

文章目录 前言软件测试基础1. 软件测试的概念2. 软件测试的目的 测试用例1. 测试用例的概念2. 测试用例的分类3. 测试用例的治理4. 测试用例的编制及使用5. 测试需求 软件生命周期1. 问题的定义及规划2. 需求分析3. 软件设计4. 程序编码5. 软件测试6. 运行维护7. 生命周期模型 …
阅读更多...
固态硬盘测试软件有哪些,SSD测试软件有哪些？SSD测试软件盘点

固态硬盘测试软件有哪些,SSD测试软件有哪些？SSD测试软件盘点

在购买了固态硬盘(SSD)后&#xff0c;如果对商家或官方给出的诸如读写速度等关键性数据存在质疑的话&#xff0c;最好的解决方法莫过于通过SSD测试软件来找寻答案。那么&#xff0c;SSD测试软件有哪些&#xff1f;SSD测试软件哪个比较好用呢&#xff1f;针对上述问题&#xff0…
阅读更多...
软件工程-软件测试-测试方法

软件工程-软件测试-测试方法

软件工程-测试方法-白盒和黑盒测试 软件工程-软件测试 软件测试方法可以分为静态测试和动态测试。 静态测试 静态测试是指被测试程序不在程序上运行&#xff0c;而是采用人工检测和计算机辅助金泰分析的手段对程序进行检测。 静态测试方法 &#xff08;1&#xff09;人工检…
阅读更多...
软件测试方法和技术有哪些？

软件测试方法和技术有哪些？

软件测试方法和技术有哪些&#xff1f;包括软件测试基础、软件测试方法、软件测试流程和规范、单元测试与集成测试、系统测试、验收测试、软件本地化测试、测试自动化及其框架、白盒测试和黑盒测试等。 软件测试方法技术 　　软件测试方法&#xff1a; 一、等价类测试方法的…
阅读更多...
软件测试方法汇总 - 从不同角度分析软件测试方法有哪些

软件测试方法汇总 - 从不同角度分析软件测试方法有哪些

1、从是否关心内部结构来看 &#xff08;1&#xff09;白盒测试&#xff1a;又称为结构测试或逻辑驱动测试&#xff0c;是一种按照程序内部逻辑结构和编码结构&#xff0c;设计测试数据并完成测试的一种测试方法。 &#xff08;2&#xff09;黑盒测试&#xff1a;又称为数据驱…
阅读更多...
常见的软件测试方法有,常见的几种软件测试方法都有哪些

常见的软件测试方法有,常见的几种软件测试方法都有哪些

随着互联网的不断发展&#xff0c;越来越多的人也都开始学习软件测试的相关技术&#xff0c;而今天我们就一起来了解一下&#xff0c;常见的几种软件测试方法都有哪些。 1、单元测试 单元测试测试的是代码库的单元。 它们直接调用函数或单元&#xff0c;并确保返回正确的结果。…
阅读更多...
Dynatrace系列之- 标记常见问题

Dynatrace系列之- 标记常见问题

Dynatrace系列之- 标记常见问题 在大型环境中&#xff0c;系统的某些方面可能会持续触发不必要的警报。这些告警可能来自非关键组件或者是非关键情况下的资源不足的问题。通常这些问题不需要人员响应。 为了减少此类警报并避免发出垃圾告警邮件&#xff0c;Dynatrace AI根因分…
阅读更多...
什么是 Dynatrace 里的 Visually Complete 度量标准

什么是 Dynatrace 里的 Visually Complete 度量标准

Dynatrace 中的 Visually Complete 是一个度量标准&#xff0c;用于测量在加载过程中用户在页面上看到的内容。Visually Complete 指标是当一个用户看到页面上的所有重要元素并且它们正确地渲染时所测量的时间点。这意味着所有可见的文本、图像和视频都已加载并正确显示。该指标…
阅读更多...
DevSecOps 团队请避免陷入这些可观测性陷阱

DevSecOps 团队请避免陷入这些可观测性陷阱

如果您发现难以管理跨越多个云运行不断变化的容器化工作负载的庞大基础架构&#xff0c;那么您并不孤单。 根据 Dynatrace 近期发布的一项研究&#xff0c;超过一半的组织的 DevSecOps 团队在可观测性数据方面感到痛苦。 多云和混合计算设置的兴起&#xff0c;使大部分组织能够…
阅读更多...
前端性能分析工具Dyna Trace使用心得（转）

前端性能分析工具Dyna Trace使用心得（转）

什么是dynatrace ajax “dynatrace ajax 是一个详细的底层追踪工具&#xff0c;它不仅可以显示所有请求和文件在网络中传输的时间&#xff0c;还会记录浏览器render&#xff0c;CPU消耗、JS解析和运行情况等详细的信息&#xff0c;而这些也只是dynatrace ajax的冰山一角。” 为…
阅读更多...
使用dynatrace+showslow进行前端性能测试

使用dynatrace+showslow进行前端性能测试

原文&#xff1a;http://blog.csdn.net/zhangren07/article/details/6883617 1.背景 应用的性能测试与优化目前主要停留在服务器端的反馈&#xff0c;而对于前端性能标准的研究与测试相对比较空白&#xff0c;缺乏统一的标准与工具。众所周知&#xff0c;浏览器html组件的下载…
阅读更多...
什么是 Dynatrace 里的 User Action

什么是 Dynatrace 里的 User Action

用户操作是与最终用户界面的交互&#xff0c;涉及对 Web 服务器的调用&#xff0c;这可能有多个嵌套调用。 它是由用户输入&#xff08;例如页面加载、单击或触摸&#xff09;触发的从一个视图到另一个视图的转换。 Web 应用的 User Action 类型&#xff1a; Load actionsXHR …
阅读更多...
Ultra Fast Deep Lane Detection with HybridAnchor Driven Ordinal Classification

Ultra Fast Deep Lane Detection with HybridAnchor Driven Ordinal Classification

Abstract 我们将车道检测过程视为一个使用全局特征的锚定驱动的有序分类问题。 首先&#xff0c;我们在一系列混合&#xff08;行和列&#xff09;锚点上用稀疏坐标表示车道。在锚驱动表示的帮助下&#xff0c;我们将车道检测任务重新表述为一个有序分类问题&#xff0c;以得到…
阅读更多...
Dynatrace系列之-排除干扰请求

Dynatrace系列之-排除干扰请求

排除干扰请求 Dyatrace监控了所有服务端的请求。当特定请求的性能或者失败率高的时候&#xff0c;Dynatrace将触发告警。然尔不是所有的高并发的请求都是重要的请求&#xff0c;有些慢请求也不需要告警。比如心跳请求。这些不重要的请求可能会干扰整个服务(service)的响应时间…
阅读更多...
Web Performance工具 – Dynatrace AJAX Edition

Web Performance工具 – Dynatrace AJAX Edition

Dynatrace AJAX Edition是我认为最为强大的Web Performance Profile工具。废话不说了，直接上图介绍其主要功能。 先用IE访问你需要profile的网站，例如google，可以点击dynatrace工具栏来启动。这时候dynatrace就开始记录这个网站触发的一切事件。 我简单测试一下，点击googl…
阅读更多...
DynamicArray

DynamicArray

文章目录 1 DynamicArray设计要点2 继承关系图和接口实现3 代码实现4 代码优化 1 DynamicArray设计要点 类模板 动态确定内部数组空间的大小实现函数返回数组长度构造拷贝和赋值操作 2 继承关系图和接口实现 继承关系图 接口实现 template < typename T > class D…
阅读更多...
云途加油站 | 一文读懂 Dynatrace 与 Amazon Lambda 的“双剑合璧心法”

云途加油站 | 一文读懂 Dynatrace 与 Amazon Lambda 的“双剑合璧心法”

Amazon Lambda 正在掀起企业级云市场的一场小潮流。不少业内人士发现&#xff0c;越来越多的企业正在将 Lambda 函数加入其技术栈中。 这一潮流其实不难理解—— 一则&#xff0c;门槛低。Amazon Lambda为企业进入云计算提供了相对较低的门槛&#xff0c;无需立即全面推行转移…
阅读更多...
推荐文章

Copyright @ 2022~2023