【Spring】GoF 之代理模式

一、代理模式

在 Java 程序中的代理模式的作用：

  • 当一个对象需要受到保护的时候，可以考虑使用代理对象去完成某个行为

  • 需要给某个对象的功能进行功能增强的时候，可以考虑找一个代理进行增强

  • A 对象无法和 B 对象直接交互时，也可以使用代理模式来解决

代理模式中的三大角色：

  • 目标对象（演员）

  • 代理对象（替身演员）

  • 目标对象和代理对象的公共接口（演员与替身演员相同的行为，可以让观众不知道是替身演员）

如果使用代理模式，对于客户端程序来说，客户端是无法察觉的，客户端在使用代理对象的时候就像在使用目标对象

代理模式在代码实现上，包括两种形式：

  • 静态代理

  • 动态代理

 

二、静态代理

package org.qiu.proxy.service;/*** 订单业务接口* @author 秋玄* @version 1.0* @email qiu_2022@aliyun.com* @project Spring* @package org.qiu.proxy.service* @date 2022-11-16-13:09* @since 1.0*/
public interface OrderService {/*** 生成订单*/void generate();/*** 修改订单信息*/void modify();/*** 查看订单详情*/void detail();
}
package org.qiu.proxy.service;/*** @author 秋玄* @version 1.0* @email qiu_2022@aliyun.com* @project Spring* @package org.qiu.proxy.service* @date 2022-11-16-13:10* @since 1.0*/
public class OrderServiceImpl implements OrderService{@Overridepublic void generate() {// 模拟网络延迟try {Thread.sleep(1024);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("订单已生成！");}@Overridepublic void modify() {// 模拟网络延迟try {Thread.sleep(512);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("订单已修改！");}@Overridepublic void detail() {// 模拟网络延迟try {Thread.sleep(800);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("订单详情......");}
}
public class Test {public static void main(String[] args) {OrderService orderService = new OrderServiceImpl();orderService.generate();orderService.detail();orderService.modify();}
}

运行结果：  

项目已上线，并且运行正常，只是客户反馈系统有一些地方运行较慢，要求项目组对系统进行优化。于是项目负责人就下达了这个需求。首先需要搞清楚是哪些业务方法耗时较长，于是让我们统计每个业务方法所耗费的时长。如果是你，你该怎么做呢？

 

第一种方案

直接修改Java源代码，在每个业务方法中添加统计逻辑，如下：

package org.qiu.proxy.service;/*** @author 秋玄* @version 1.0* @email qiu_2022@aliyun.com* @project Spring* @package org.qiu.proxy.service* @date 2022-11-16-13:10* @since 1.0*/
public class OrderServiceImpl implements OrderService{@Overridepublic void generate() {long begin = System.currentTimeMillis();// 模拟网络延迟try {Thread.sleep(1024);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("订单已生成！");long end = System.currentTimeMillis();System.out.println("耗时（毫秒）：" + (end - begin));}@Overridepublic void modify() {long begin = System.currentTimeMillis();// 模拟网络延迟try {Thread.sleep(512);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("订单已修改！");long end = System.currentTimeMillis();System.out.println("耗时（毫秒）：" + (end - begin));}@Overridepublic void detail() {long begin = System.currentTimeMillis();// 模拟网络延迟try {Thread.sleep(800);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("订单详情......");long end = System.currentTimeMillis();System.out.println("耗时（毫秒）：" + (end - begin));}
}

运行效果：  

需求可以满足，但显然是违背了OCP开闭原则，这种方案不可取

第二种方案

编写一个子类继承OrderServiceImpl，在子类中重写每个方法，代码如下：

package org.qiu.proxy.service;/*** @author 秋玄* @version 1.0* @email qiu_2022@aliyun.com* @project Spring* @package org.qiu.proxy.service* @date 2022-11-16-13:24* @since 1.0*/
public class OrderServiceImplSub extends OrderServiceImpl{@Overridepublic void generate() {long begin = System.currentTimeMillis();super.generate();long end = System.currentTimeMillis();System.out.println("耗时（毫秒）：" + (end - begin));}@Overridepublic void modify() {long begin = System.currentTimeMillis();super.modify();long end = System.currentTimeMillis();System.out.println("耗时（毫秒）：" + (end - begin));}@Overridepublic void detail() {long begin = System.currentTimeMillis();super.detail();long end = System.currentTimeMillis();System.out.println("耗时（毫秒）：" + (end - begin));}
}
public class Test {public static void main(String[] args) {OrderService orderService = new OrderServiceImplSub();orderService.generate();orderService.detail();orderService.modify();}
}

运行效果：  

这种方式可以解决，但是存在两个问题：

  • 第一个问题：假设系统中有100个这样的业务类，需要提供100个子类，并且之前写好的创建Service对象的代码，都要修改为创建子类对象

  • 第二个问题：由于采用了继承的方式，导致代码之间的耦合度较高。

这种方案也不可取

第三种方案

使用代理模式（这里采用静态代理）

可以为 OrderService 接口提供一个代理类

package org.qiu.proxy.service;/*** 代理对象* @author 秋玄* @version 1.0* @email qiu_2022@aliyun.com* @project Spring* @package org.qiu.proxy.service* @date 2022-11-16-13:32* @since 1.0*/
public class OrderServiceProxy implements OrderService {// 目标对象// 这里要使用“公共接口”类型，因为公共接口耦合度低private OrderService orderService;// 通过构造方法将目标对象传递给代理对象public OrderServiceProxy(OrderService orderService){this.orderService = orderService;}@Overridepublic void generate() {long begin = System.currentTimeMillis();// 执行目标对象的目标方法orderService.generate();long end = System.currentTimeMillis();System.out.println("耗时（毫秒）：" + (end - begin));}@Overridepublic void modify() {long begin = System.currentTimeMillis();orderService.modify();long end = System.currentTimeMillis();System.out.println("耗时（毫秒）：" + (end - begin));}@Overridepublic void detail() {long begin = System.currentTimeMillis();orderService.detail();long end = System.currentTimeMillis();System.out.println("耗时（毫秒）：" + (end - begin));}
}

这种方式的优点：

符合OCP开闭原则，同时采用的是关联关系，所以程序的耦合度较低。所以这种方案是被推荐的 

package org.qiu.proxy.client;import org.qiu.proxy.service.OrderService;
import org.qiu.proxy.service.OrderServiceImpl;
import org.qiu.proxy.service.OrderServiceImplSub;
import org.qiu.proxy.service.OrderServiceProxy;/*** @author 秋玄* @version 1.0* @email qiu_2022@aliyun.com* @project Spring* @package org.qiu.proxy.client* @date 2022-11-16-13:13* @since 1.0*/
public class Test {public static void main(String[] args) {// 创建目标对象OrderService target = new OrderServiceImpl();// 创建代理对象OrderService proxy = new OrderServiceProxy(target);// 调用代理对象的代理方法proxy.generate();proxy.modify();proxy.detail();}
}

运行效果：  

以上就是代理模式中的静态代理，其中：

OrderService 接口是代理类和目标类的共同接口

OrderServiceImpl 是目标类

OrderServiceProxy 是代理类

思考一下：如果系统中业务接口很多，一个接口对应一个代理类，显然也是不合理的，会导致类爆炸。怎么解决这个问题？动态代理可以解决。因为在动态代理中可以在内存中动态的为我们生成代理类的字节码。代理类不需要我们写了。类爆炸解决了，而且代码只需要写一次，代码也会得到复用

 

三、动态代理 

在程序运行阶段，在内存中动态生成代理类，被称为动态代理，目的是为了减少代理类的数量，解决代码复用的问题

在内存当中动态生成类的技术常见的包括：

  • JDK 动态代理技术：只能代理接口

  • CGLIB 动态代理技术：CGLIB(Code Generation Library)是一个开源项目。是一个强大的，高性能，高质量的Code生成类库，它可以在运行期扩展 Java 类与实现 Java 接口。它既可以代理接口，又可以代理类，底层是通过继承的方式实现的。性能比 JDK 动态代理要好（底层有一个小而快的字节码处理框架ASM）

  • Javassist 动态代理技术：Javassist 是一个开源的分析、编辑和创建 Java 字节码的类库。是由东京工业大学的数学和计算机科学系的 Shigeru Chiba （千叶 滋）所创建的。它已加入了开放源代码 JBoss 应用服务器项目，通过使用 Javassist 对字节码操作为 JBoss 实现动态"AOP"框架。

JDK 动态代理 

package org.qiu.proxy.service;/*** 订单业务接口* @author 秋玄* @version 1.0* @email qiu_2022@aliyun.com* @project Spring* @package org.qiu.proxy.service* @date 2022-11-20-08:23* @since 1.0*/
public interface OrderService {/*** 生成订单*/void generate();/*** 修改订单信息*/void modify();/*** 查看订单详情*/void detail();
}
package org.qiu.proxy.service;/*** @author 秋玄* @version 1.0* @email qiu_2022@aliyun.com* @project Spring* @package org.qiu.proxy.service* @date 2022-11-20-08:23* @since 1.0*/
public class OrderServiceImpl implements OrderService{@Overridepublic void generate() {// 模拟网络延迟try {Thread.sleep(1024);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("订单已生成！");}@Overridepublic void modify() {// 模拟网络延迟try {Thread.sleep(512);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("订单已修改！");}@Overridepublic void detail() {// 模拟网络延迟try {Thread.sleep(800);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("订单详情......");}
}

使用静态代理的时候，除了以上一个接口和一个实现类之外，还需要写一个代理类 UserServiceProxy！在动态代理中UserServiceProxy 代理类是可以动态生成的，这个类不需要写。我们直接写客户端程序即可：  

package org.qiu.proxy.client;import org.qiu.proxy.service.OrderService;
import org.qiu.proxy.service.OrderServiceImpl;
import org.qiu.proxy.service.TimeInvocatioinHandler;
import org.qiu.proxy.util.ProxyUtil;import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;/*** @author 秋玄* @version 1.0* @email qiu_2022@aliyun.com* @project Spring* @package org.qiu.proxy.client* @date 2022-11-20-08:22* @since 1.0*/
public class Test {public static void main(String[] args) {OrderService target = new OrderServiceImpl();/*** 参数解析：* 参数一：Classloader loader 类加载器*      JDK要求，目标类的类加载器必须和代理类的类加载器使用同一个* 参数二：Class<?>[] interfaces 代理类要实现的接口*      代理类和目标类要实现同一个接口或同一些接口* 参数三：InvocationHandler h 调用处理器对象（是一个接口）*      在这里实现功能的增强（这里采用内部实现类，也可以将其独立出来）*/OrderService orderServiceProxy = (OrderService) Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new TimeInvocatioinHandler(target));orderServiceProxy.detail();orderServiceProxy.modify();orderServiceProxy.generate();}
}
package org.qiu.proxy.service;import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;/*** @author 秋玄* @version 1.0* @email qiu_2022@aliyun.com* @project Spring* @package org.qiu.proxy.service* @date 2022-11-20-09:01* @since 1.0*/
public class TimeInvocatioinHandler implements InvocationHandler {private Object target;public TimeInvocatioinHandler(Object target) {this.target = target;}/*** invoke 什么时候被调用？*  当代理对象调用代理方法的时候，注册在 InvocationHandler 调用处理器当中的 invoke 方法被调用** @param proxy     代理对象的引用* @param method    目标对象上的目标方法* @param args      目标方法上的实际参数* @return          若代理对象代用代理方法之后需要返回结果的话，invoke方法必须将目标对象目标方法执行结果继续返回*/@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {long begin = System.currentTimeMillis();// 调用目标对象上的目标方法Object resultValue = method.invoke(target, args);long end = System.currentTimeMillis();System.out.println("耗时（毫秒）：" + (end - begin));return null;}
}

上面调用 JDK 自带的方法比较繁琐，这里可以封装一个工具类，方便使用：  

package org.qiu.proxy.util;import org.qiu.proxy.service.OrderService;
import org.qiu.proxy.service.TimeInvocatioinHandler;import java.lang.reflect.Proxy;/*** @author 秋玄* @version 1.0* @email qiu_2022@aliyun.com* @project Spring* @package org.qiu.proxy.util* @date 2022-11-20-09:12* @since 1.0*/
public class ProxyUtil {/*** 获取代理对象（JDK动态代理）* @param target* @return*/public static Object newProxyInstance(Object target){return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new TimeInvocatioinHandler(target));}}
package org.qiu.proxy.client;import org.qiu.proxy.service.OrderService;
import org.qiu.proxy.service.OrderServiceImpl;
import org.qiu.proxy.service.TimeInvocatioinHandler;
import org.qiu.proxy.util.ProxyUtil;import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;/*** @author 秋玄* @version 1.0* @email qiu_2022@aliyun.com* @project Spring* @package org.qiu.proxy.client* @date 2022-11-20-08:22* @since 1.0*/
public class Test {public static void main(String[] args) {OrderService target = new OrderServiceImpl();/*** 参数解析：* 参数一：Classloader loader 类加载器*      JDK要求，目标类的类加载器必须和代理类的类加载器使用同一个* 参数二：Class<?>[] interfaces 代理类要实现的接口*      代理类和目标类要实现同一个接口或同一些接口* 参数三：InvocationHandler h 调用处理器对象（是一个接口）*      在这里实现功能的增强（这里采用内部实现类，也可以将其独立出来）*//*OrderService orderServiceProxy = (OrderService) Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new TimeInvocatioinHandler(target));*/// 工具类封装OrderService orderServiceProxy = (OrderService) ProxyUtil.newProxyInstance(target);orderServiceProxy.detail();orderServiceProxy.modify();orderServiceProxy.generate();}
}

 

CGLIB 动态代理

CGLIB 既可以代理接口，又可以代理类。底层采用继承的方式实现。所以被代理的目标类不能使用 final 修饰。

使用CGLIB，需要引入它的依赖：

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

准备一个没有实现接口的类，如下：  

package org.qiu.proxy.service;/*** @author 秋玄* @version 1.0* @email qiu_2022@aliyun.com* @project Spring* @package org.qiu.proxy.service* @date 2022-11-20-09:22* @since 1.0*/
public class UserService {public void login(){System.out.println("用户正在登录系统....");}public void logout(){System.out.println("用户正在退出系统....");}
}

使用 CGLIB 在内存中为 UserService 类生成代理类，并创建对象：  

package org.qiu.proxy.client;import net.sf.cglib.proxy.Enhancer;
import org.qiu.proxy.service.TimerMethodInterceptor;
import org.qiu.proxy.service.UserService;/*** @author 秋玄* @version 1.0* @email qiu_2022@aliyun.com* @project Spring* @package org.qiu.proxy.client* @date 2022-11-20-09:23* @since 1.0*/
public class Client {public static void main(String[] args) {// 创建字节码增强器Enhancer enhancer = new Enhancer();// 告诉cglib要继承哪个类enhancer.setSuperclass(UserService.class);// 设置回调接口enhancer.setCallback(方法拦截器对象);// 生成源码，编译class，加载到JVM，并创建代理对象UserService userServiceProxy = (UserService)enhancer.create();userServiceProxy.login();userServiceProxy.logout();}
}

和JDK动态代理原理差不多，在CGLIB中需要提供的不是InvocationHandler，而是：net.sf.cglib.proxy.MethodInterceptor

编写MethodInterceptor接口实现类：

package org.qiu.proxy.service;import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;import java.lang.reflect.Method;/*** @author 秋玄* @version 1.0* @email qiu_2022@aliyun.com* @project Spring* @package org.qiu.proxy.service* @date 2022-11-20-09:24* @since 1.0*/
public class TimerMethodInterceptor implements MethodInterceptor {@Overridepublic Object intercept(Object target, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {return null;}
}

 

MethodInterceptor接口中有一个方法intercept()，该方法有4个参数：

第一个参数：目标对象

第二个参数：目标方法

第三个参数：目标方法调用时的实参

第四个参数：代理方法

在MethodInterceptor的intercept()方法中调用目标以及添加增强：

package org.qiu.proxy.service;import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;import java.lang.reflect.Method;/*** @author 秋玄* @version 1.0* @email qiu_2022@aliyun.com* @project Spring* @package org.qiu.proxy.service* @date 2022-11-20-09:24* @since 1.0*/
public class TimerMethodInterceptor implements MethodInterceptor {@Overridepublic Object intercept(Object target, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {// 前增强long begin = System.currentTimeMillis();// 调用目标Object retValue = methodProxy.invokeSuper(target, objects);// 后增强long end = System.currentTimeMillis();System.out.println("耗时" + (end - begin) + "毫秒");// 一定要返回return retValue;}
}

回调已经写完了，可以修改客户端程序了：  

package org.qiu.proxy.client;import net.sf.cglib.proxy.Enhancer;
import org.qiu.proxy.service.TimerMethodInterceptor;
import org.qiu.proxy.service.UserService;/*** @author 秋玄* @version 1.0* @email qiu_2022@aliyun.com* @project Spring* @package org.qiu.proxy.client* @date 2022-11-20-09:23* @since 1.0*/
public class Client {public static void main(String[] args) {// 创建字节码增强器Enhancer enhancer = new Enhancer();// 告诉cglib要继承哪个类enhancer.setSuperclass(UserService.class);// 设置回调接口enhancer.setCallback(new TimerMethodInterceptor());// 生成源码，编译class，加载到JVM，并创建代理对象UserService userServiceProxy = (UserService)enhancer.create();userServiceProxy.login();userServiceProxy.logout();}
}

对于高版本的JDK，如果使用CGLIB，需要在启动项中添加两个启动参数：  

  • --add-opens java.base/java.lang=ALL-UNNAMED

  • --add-opens java.base/sun.net.util=ALL-UNNAMED

 

一  叶  知  秋，奥  妙  玄  心

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/681271.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

21_Scala集合_可变数组ArrayBuffer

21_Scala集合_可变数组ArrayBuffer

文章目录 ArrayBuffer1.创建可变数组ArrayBuffer2.增加数据3.删除数据4.修改数据5.查询数据Appendix ArrayBuffer ArrayBuffer可变数组–感觉优点类似于Java的ArrayList 1.创建可变数组ArrayBuffer –请注意下面的mutable import scala.collection.mutable.ArrayBuffer //m…
阅读更多...
Audition处理音频文件背景音（保留人声）

Audition处理音频文件背景音（保留人声）

音频文件背景音可以使用Adobe Audition进行处理&#xff0c;Adobe Audition的下载与安装见之前博客&#xff1a; Adobe Audition 2024 下载与安装-CSDN博客https://blog.csdn.net/xiaoxian666/article/details/138612837?spm1001.2014.3001.5502 一、选中一段不含人声的背景…
阅读更多...
ESD静电问题 | PCB布局布线对防护效果的影响

ESD静电问题 | PCB布局布线对防护效果的影响

【转自微信公众号&#xff1a;韬略科技EMC】
阅读更多...
C语言例题38、有n个人围成一圈，顺序排号。从第一个人开始报数（从1到3报数），凡报到3的人退出圈子，最后留下来的是原来第几号人员？

C语言例题38、有n个人围成一圈，顺序排号。从第一个人开始报数（从1到3报数），凡报到3的人退出圈子，最后留下来的是原来第几号人员？

#include <stdio.h> #define MAX_CALLER 3void main() {int j 0;int p_total;//人数int p_caller 0;//每3人循环计数&#xff1a;1,2,3int p_exit 0; //退出游戏的人数int people[255] {0};//参与游戏人员名单printf("请输入参与游戏人数&#xff1a;");s…
阅读更多...
通过编写dockerfile部署python项目

通过编写dockerfile部署python项目

docker命令总览 docker通过dockerfile构建镜像常用命令 # 创建镜像&#xff08;进入dockerfile所在的路径&#xff09; docker build -t my_image:1.0 .# 查看镜像 docker images# 创建容器 docker run -dit --restartalways -p 9700:9700 --name my_container my_image:1.0 #…
阅读更多...
一款开源的原神工具箱，专为现代化 Windows 平台设计，旨在改善桌面端玩家的游戏体验

一款开源的原神工具箱，专为现代化 Windows 平台设计，旨在改善桌面端玩家的游戏体验

Snap.Hutao 胡桃工具箱是一款以 MIT 协议开源的原神工具箱&#xff0c;专为现代化 Windows 平台设计&#xff0c;旨在改善桌面端玩家的游戏体验。通过将既有的官方资源与开发团队设计的全新功能相结合&#xff0c;提供了一套完整且实用的工具集&#xff0c;且无需依赖任何移动设…
阅读更多...
24 | MySQL是怎么保证主备一致的？

24 | MySQL是怎么保证主备一致的？

MySQL 主备的基本原理 内部流程 备库 B 跟主库 A 之间维持了一个长连接。主库 A 内部有一个线程，专门用于服务备库 B 的这个长连接。一个事务日志同步的完整过程是这样的： 在备库 B 上通过 change master 命令，设置主库 A 的 IP、端口、用户名、密码，以及要从哪个位置开始…
阅读更多...
VLM与基础分割模型的联合使用

VLM与基础分割模型的联合使用

最近做的项目里有涉及大模型&#xff0c;里面有一部分的功能是&#xff1a; 将图片输入VLM(视觉语言模型&#xff0c;我使用的是llava)&#xff0c;询问图中最显著的物体&#xff0c;将其给出的答案作为基础分割模型&#xff08;我使用的是Grounded-SAM&#xff09;的text prom…
阅读更多...
TMS320F280049 EQEP模块--Interrupt（6）

TMS320F280049 EQEP模块--Interrupt（6）

功能框图 12个中断源&#xff1a;PCE, PHE, QDC, WTO, PCU, PCO, PCR, PCM, SEL, IEL, UTO, QMAE 在QEINT中使能对应bit后&#xff0c;当发生该事件时会使QFLAG.INT置位且中断传递出去。 查看哪个事件触发的中断&#xff0c;可查看QFLAG寄存器。 清中断可使用QCLR寄存器。 …
阅读更多...
算法学习：递归

算法学习：递归

&#x1f525; 个人主页&#xff1a;空白诗 文章目录 一、引言二、什么是递归&#xff1f;三、两大基本要素&#x1f3c1; 基线条件&#xff08;Base Case&#xff09;&#x1f501; 递归条件&#xff08;Recursive Case&#xff09;&#x1f4c3; 代码示例&#xff1a;计算斐波…
阅读更多...
某票星球网图标点选验证码YOLOV8识别案例

某票星球网图标点选验证码YOLOV8识别案例

注意，本文只提供学习的思路，严禁违反法律以及破坏信息系统等行为，本文只提供思路 如有侵犯，请联系作者下架 图标点选验证码大家都不陌生了，我们来看下数据集 引言与个人想法 先说结论，本文采用的方法能够达到99的准确率，效果图如下 做图标点选其实方法有很多，有的…
阅读更多...
DuDuTalk：4G桌面拾音设备在银行网点服务场景的应用价值

DuDuTalk：4G桌面拾音设备在银行网点服务场景的应用价值

随着科技的飞速发展&#xff0c;银行业也在不断地寻求创新以提高服务质量和效率。在这个过程中&#xff0c;4G桌面拾音设备作为一种新型的智能设备&#xff0c;其在银行网点服务场景中的应用价值逐渐凸显出来。本文将从多个角度探讨4G桌面拾音设备在银行网点服务场景的应用价值…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023