设计模式之代理模式

最新推荐文章于 2024-07-06 19:10:28 发布
最新推荐文章于 2024-07-06 19:10:28 发布
阅读量518 收藏
点赞数
分类专栏： java设计模式 文章标签： 代理模式 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_50319351/article/details/125815609
版权

我的理解：
代理模式，重要的是代理，怎么代理呢，在生活中比较显著的例子，就是律师给委托人，打官司，委托人提供事件的经过（起因，发展，结果），律师负责二次称述，在案件的基础上发表自己的建议
在这里插入图片描述
举个好玩的例子
我们想玩游戏，但又不想碰触到游戏中的烦恼，如何解决呢？有办法，现在游戏代练的公司非常多，我把自己的账号交给代练人员，由他们去帮我升级，去打怪，非常好的想法，我们看一下下类图
在这里插入图片描述
定义一个接口IGamePlayer，是所有喜爱网络游戏的玩家，然后定义一个具体
的实现类GamePlayer，实现每个游戏爱好者为了玩游戏要执行的功能，在类图中增加了一个GamePlayerProxy类来代表游戏代练者，它也不能有作弊的方法呀，游戏代练者也是手动打怪呀，因此同样继承IGamePlayer接口，
游戏者：代码

public class GamePlayer implements IGamePlayer {
private String name = "";
//通过构造函数传递名称
public GamePlayer(String _name){
this.name = _name;
}
//打怪，最期望的就是杀老怪
public void killBoss() {
System.out.println(this.name + "在打怪！");
}
//进游戏之前你肯定要登录吧，这是一个必要条件
public void login(String user, String password) {
System.out.println("登录名为"+user+"的用户"+this.name+"登录成功！");
}
//升级，升级有很多方法，花钱买是一种，做任务也是一种
public void upgrade() {
System.out.println(this.name + " 又升了一级！");
}
}

代练者 代码：

public class GamePlayerProxy implements IGamePlayer {
private IGamePlayer gamePlayer = null;
//通过构造函数传递要对谁进行代练
public GamePlayerProxy(IGamePlayer _gamePlayer){
this.gamePlayer = _gamePlayer;
}
//代练杀怪
public void killBoss() {
this.gamePlayer.killBoss();
}
//代练登录
public void login(String user, String password) {
this.gamePlayer.login(user, password);
}
//代练升级
public void upgrade() {
this.gamePlayer.upgrade();
}
}

通过构造方法去传递被代理的游戏玩家，让带练的玩家，打怪升级。
场景类：

public class Client {
public static void main(String[] args) {
//定义一个痴迷的玩家
IGamePlayer player = new GamePlayer("张三");
//然后再定义一个代练者
IGamePlayer proxy = new GamePlayerProxy(player);
//开始打游戏，记下时间戳
System.out.println("开始时间是：2009-8-25 10:45");
proxy.login("zhangSan", "password");
//开始杀怪
proxy.killBoss();
//升级
proxy.upgrade();
//记录结束游戏时间
System.out.println("结束时间是：2009-8-26 03:40");
}
}

结果是：
在这里插入图片描述
结果并没有改变，但是还是能打怪升级，你的游戏已经在升级，有人在帮你干活了！终于升级到120级，这就是代理模式
看一下通用的代理模式定义：为其他对象提供一种代理以控制对这个对象的访问
怎么理解呢，代理类，可以调用被代理类的方法，完成一系列的业务逻辑，控制被代理类

在这里插入图片描述
Subject抽象主题角色（游戏的接口）
抽象主题类可以是抽象类也可以是接口，是一个最普通的业务类型定义，无特殊要求。
RealSubject具体主题角色（具体的玩家）
也叫做被委托角色、被代理角色。它才是冤大头，是业务逻辑的具体执行者。
Proxy代理主题角色（代练玩家）
也叫做委托类、代理类。它负责对真实角色的应用，把所有抽象主题类定义的方法限制
委托给真实主题角色实现，并且在真实主题角色处理完毕前后做预处理和善后处理工作。

代理模式的优点

● 职责清晰
真实的角色就是实现实际的业务逻辑，不用关心其他非本职责的事务，通过后期的代理
完成一件事务，附带的结果就是编程简洁清晰。
● 高扩展性
具体主题角色是随时都会发生变化的，只要它实现了接口，甭管它如何变化，都逃不脱
如来佛的手掌（接口），那我们的代理类完全就可以在不做任何修改的情况下使用。

代理模式的使用场景
我们为啥要使用代理呢，
想想现实世界吧，打官司为什么要找个律师？因为你不想参与中间过程的是是非非，只要完成自己的答辩
就成，其他的比如事前调查、事后追查都由律师来搞定。
大家可以看看Spring AOP，这是一个非常典型的动态代理
接下来 代理模式的扩展，才是重点
代理模式的扩展
一类：普通代理（别代理者，必须知道谁代理它才可以完成代理）

		首先说普通代理，它的要求就是客户端只能访问代理角色，而不能访问真实角色，这是

比较简单的。我们以上面的例子作为扩展，我自己作为一个游戏玩家，我肯定自己不练级
了，也就是场景类不能再直接new一个GamePlayer对象了，它必须由GamePlayerProxy来进行
模拟场景。
在这里插入图片描述
改动很小，仅仅修改了两个实现类的构造函数，GamePlayer的构造函数增加了
_gamePlayer参数，代理角色则只要传入代理者名字即可，而不需要说是替哪个对象做代
理。
普通代理的游戏者
普通代理的游戏者

public class GamePlayer implements IGamePlayer {
private String name = "";
//构造函数限制谁能创建对象，并同时传递姓名
public GamePlayer(IGamePlayer _gamePlayer,String _name) throws Exception{
if(_gamePlayer == null ){
throw new Exception("不能创建真实角色！");
}else{
this.name = _name;
}
}
//打怪，最期望的就是杀老怪
public void killBoss() {
System.out.println(this.name + "在打怪！");
}
//进游戏之前你肯定要登录吧，这是一个必要条件
public void login(String user, String password) {
System.out.println("登录名为"+user + "的用户" + this.name + "登录成功！");
}
//升级，升级有很多方法，花钱买是一种，做任务也是一种
public void upgrade() {
System.out.println(this.name + " 又升了一级！");
}
}

在构造函数中，传递进来一个IGamePlayer对象，检查谁能创建真实的角色，当然还可以
有其他的限制，比如类名必须为Proxy类等.
普通代理的代理者 GamePlayerProxy

public class GamePlayerProxy implements IGamePlayer {
private IGamePlayer gamePlayer = null;
//通过构造函数传递要对谁进行代练
public GamePlayerProxy(String name){
try {
gamePlayer = new GamePlayer(this,name);
} catch (Exception e) {
// TODO 异常处理
}
}
//代练杀怪
public void killBoss() {
this.gamePlayer.killBoss();
}
//代练登录
public void login(String user, String password) {
this.gamePlayer.login(user, password);
}
//代练升级
public void upgrade() {
this.gamePlayer.upgrade();
}
}

仅仅修改了构造函数，传递进来一个代理者名称，即可进行代理，在这种改造下，系统
更加简洁了，调用者只知道代理存在就可以，不用知道代理了谁
普通代理的场景类

public class Client {
public static void main(String[] args) {
//然后再定义一个代练者
IGamePlayer proxy = new GamePlayerProxy("张三");
//开始打游戏，记下时间戳
System.out.println("开始时间是：2009-8-25 10:45");
proxy.login("zhangSan", "password");
//开始杀怪
proxy.killBoss();
//升级
proxy.upgrade();
//记录结束游戏时间
System.out.println("结束时间是：2009-8-26 03:40");
}
}

运行结果完全相同。在该模式下，调用者只知代理而不用知道真实的角色是谁，屏蔽了
真实角色的变更对高层模块的影响，真实的主题角色想怎么修改就怎么修改，对高层次的模
块没有任何的影响，只要你实现了接口所对应的方法.
强制代理
一般的思维都是通过代理找到真实
的角色，但是强制代理却是要“强制”，你必须通过真实角色查找到代理角色，否则你不能访
问。甭管你是通过代理类还是通过直接new一个主题角色类，都不能访问，只有通过真实角
色指定的代理类才可以访问。
举个生活中的例子
这就好比是你和一个明星比较熟，相互认
识，有件事情你需要向她确认一下，于是你就直接拨通了明星的电话：
“喂，沙比呀，我要见一下×××导演，你帮下忙了！”
“不行呀衰哥，我这几天很忙呀，你找我的经纪人吧……”
郁闷了吧，你是想直接绕过她的代理，谁知道返回的还是她的代理，这就是强制代理，
你可以不用知道代理存在，但是你必须通过代理类提供，实例化对象，自己new都不行
在这里插入图片描述
在这里插入图片描述
强制代理的真实角色

public class GamePlayer implements IGamePlayer {
private String name = "";
//我的代理是谁
private IGamePlayer proxy = null;
public GamePlayer(String _name){
this.name = _name;
}
//找到自己的代理
public IGamePlayer getProxy(){
this.proxy = new GamePlayerProxy(this);
return this.proxy;
}
//打怪，最期望的就是杀老怪
public void killBoss() {
if(this.isProxy()){
System.out.println(this.name + "在打怪！");
}else{
System.out.println("请使用指定的代理访问");
}
}
//进游戏之前你肯定要登录吧，这是一个必要条件
public void login(String user, String password) {
if(this.isProxy()){
System.out.println("登录名为"+user+"的用户"+this.name+"登录成功！");
}else{
System.out.println("请使用指定的代理访问");;
}
}
//升级，升级有很多方法，花钱买是一种，做任务也是一种
public void upgrade() {
if(this.isProxy()){
System.out.println(this.name + " 又升了一级！");
}else{
System.out.println("请使用指定的代理访问");
}
}
//校验是否是代理访问
private boolean isProxy(){
if(this.proxy == null){
return false;
}else{
return true;
}
}
}

增加了一个私有方法，检查是否是自己指定的代理，是指定的代理则允许访问，否则不
允许访问。我们再来看代理角色，

public class GamePlayerProxy implements IGamePlayer {
private IGamePlayer gamePlayer = null;
//构造函数传递用户名
public GamePlayerProxy(IGamePlayer _gamePlayer){
this.gamePlayer = _gamePlayer;
}
//代练杀怪
public void killBoss() {
this.gamePlayer.killBoss();
}
//代练登录
public void login(String user, String password) {
this.gamePlayer.login(user, password);
}
//代练升级
public void upgrade() {
this.gamePlayer.upgrade();
}
//代理的代理暂时还没有，就是自己
public IGamePlayer getProxy(){
return this;
}
}

我们先按照常规的思路来运行一下，直接new一个真实角
色，如代码清单12-16所示。

public class Client {
public static void main(String[] args) {
//定义一个游戏的角色
IGamePlayer player = new GamePlayer("张三");
//开始打游戏，记下时间戳
System.out.println("开始时间是：2009-8-25 10:45");
player.login("zhangSan", "password");
//开始杀怪
player.killBoss();
//升级
player.upgrade();
//记录结束游戏时间
System.out.println("结束时间是：2009-8-26 03:40");
}
}

在这里插入图片描述

运行结果是，自己创建的都不行，必须是由代理者创建的
强制代理

public class Client {
public static void main(String[] args) {
//定义一个游戏的角色
IGamePlayer player = new GamePlayer("张三");
//获得指定的代理
IGamePlayer proxy = player.getProxy();
//开始打游戏，记下时间戳
System.out.println("开始时间是：2009-8-25 10:45");
proxy.login("zhangSan", "password");
//开始杀怪
proxy.killBoss();
//升级
proxy.upgrade();
//记录结束游戏时间
System.out.println("结束时间是：2009-8-26 03:40");
}
}

在这里插入图片描述
增加了一个IProxy接口，其作用是计算代理的费用。我们先来看IProxy接口，如代码清
单12-19所示。

代码清单12-19 代理类的接口
public interface IProxy {
//计算费用
public void count();
}

非常简单，看GamePlayerProxy带来的变化，如代码清单12-20所示。

public class GamePlayerProxy implements IGamePlayer,IProxy {
private IGamePlayer gamePlayer = null;
//通过构造函数传递要对谁进行代练
public GamePlayerProxy(IGamePlayer _gamePlayer){
this.gamePlayer = _gamePlayer;
}
//代练杀怪
public void killBoss() {
this.gamePlayer.killBoss();
}
//代练登录
public void login(String user, String password) {
this.gamePlayer.login(user, password);
}
//代练升级
public void upgrade() {
this.gamePlayer.upgrade();
this.count();
}
//计算费用
public void count(){
System.out.println("升级总费用是：150元");
}
}

实现了IProxy接口，同时在upgrade方法中调用该方法，完成费用结算，其他的类都没有
任何改动。
在这里插入图片描述

标题代理是有个性的

一个类可以实现多个接口，完成不同任务的整合。也就是说代理类不仅仅可以实现主题
接口，也可以实现其他接口完成不同的任务，而且代理的目的是在目标对象方法的基础上作
增强，这种增强的本质通常就是对目标对象的方法进行拦截和过滤。
代理类，只需要添加合适的接口，就可以给被代理的对象添加功能了

在这里插入图片描述
在这里插入图片描述

**

动态代理

**
动态代理是在实现阶段不用关心代理谁，而在运行阶段才指定代理哪一个对象。
现在有一个非常流行的名称叫做面向横切面编程，也就是AOP（AspectOriented Programming），其核心就是采用了动态代理机制，既然这么重要，我们来看一看怎么实现的
在这里插入图片描述
在类图中增加了一个InvocationHandler接口和GamePlayIH类，作用就是产生一个对象的
代理对象，其中InvocationHandler是JDK提供的动态代理接口，对被代理类的方法进行代理。
我们来看程序，接口保持不变，实现类也没有变化，

代码清单12-21 动态代理类
public class GamePlayIH implements InvocationHandler {
//被代理者
Class cls =null;
//被代理的实例
Object obj = null;
//我要代理谁
public GamePlayIH(Object _obj){
this.obj = _obj;
}
//调用被代理的方法
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
Object result = method.invoke(this.obj, args);
return result;
}
}

其中invoke方法是接口InvocationHandler定义必须实现的，它完成对真实方法的调用。我
们来详细讲解一下InvocationHandler接口，动态代理是根据被代理的接口生成所有的方法，
也就是说给定一个接口。
动态代理会宣称“我已经实现该接口下的所有方法了”，那各位读者
想想看，动态代理怎么才能实现被代理接口中的方法呢？默认情况下所有的方法返回值都是
空的，是的，代理已经实现它了，但是没有任何的逻辑含义，那怎么办？好办，通过
InvocationHandler接口，所有方法都由该Handler来进行处理，即所有被代理的方法都由
InvocationHandler接管实际的处理任务。
我们接下来看看场景类，

public class Client {
public static void main(String[] args) throws Throwable {
//定义一个痴迷的玩家
IGamePlayer player = new GamePlayer("张三");
//定义一个handler
InvocationHandler handler = new GamePlayIH(player);
//开始打游戏，记下时间戳
System.out.println("开始时间是：2009-8-25 10:45");
//获得类的class loader
ClassLoader cl = player.getClass().getClassLoader();
//动态产生一个代理者
IGamePlayer proxy = (IGamePlayer)Proxy.newProxyInstance(cl,new Class[]{IGamePlayer.class},handler);
//登录
proxy.login("zhangSan", "password");
//开始杀怪
proxy.killBoss();
//升级
proxy.upgrade();
//记录结束游戏时间
System.out.println("结束时间是：2009-8-26 03:40");
}
}

在这里插入图片描述
我们还是让代练者帮我们打游戏，但是我们既没有创建代理类，也没有实现IGamePlayer
接口，这就是动态代理。
，还有更重要的，如果想让
游戏登录后发一个信息给我们，防止账号被人盗用嘛，该怎么处理？直接修改被代理类
GamePlayer？这不是一个好办法，好办法如代码

public class GamePlayIH implements InvocationHandler {
//被代理者
Class cls =null;
//被代理的实例
Object obj = null;
//我要代理谁
public GamePlayIH(Object _obj){
this.obj = _obj;
}
//调用被代理的方法
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
Object result = method.invoke(this.obj, args);
//如果是登录方法，则发送信息
if(method.getName().equalsIgnoreCase("login")){
System.out.println("有人在用我的账号登录！");
}
return result;
}
}

只要在代理中增加一个判断就可以决定是否要发送信息，

在这里插入图片描述
有人用我的账号就发送一个信息，然后看看自己的账号是不是被人盗了，非常
好的方法，这就是AOP编程。AOP编程没有使用什么新的技术，但是它对我们的设计、编码
有非常大的影响，对于日志、事务、权限等都可以在系统设计阶段不用考虑，而在设计后通
过AOP的方式切过去。
类图如图
在这里插入图片描述
很简单，两条独立发展的线路。动态代理实现代理的职责，业务逻辑Subject实现相关的
逻辑功能，两者之间没有必然的相互耦合的关系。通知Advice从另一个切面切入，最终在高
层模块也就是Client进行耦合，完成逻辑的封装任务。我们先来看Subject接口，如代码清单

代码清单12-24 抽象主题
public interface Subject {
//业务操作
public void doSomething(String str);
}

其中的doSomething是一种标识方法，可以有多个逻辑处理方法，实现类如代码清单

public class RealSubject implements Subject {
//业务操作
public void doSomething(String str) {
System.out.println("do something!---->" + str);
}
}

重点是我们的MyInvocationHandler，如代码清单12-26所示

public class MyInvocationHandler implements InvocationHandler {
//被代理的对象
private Object target = null;
//通过构造函数传递一个对象
public MyInvocationHandler(Object _obj){
this.target = _obj;
}
//代理方法
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
//执行被代理的方法
return method.invoke(this.target, args);
}
}

非常简单，所有通过动态代理实现的方法全部通过invoke方法调用。DynamicProxy代码
如代码清单12-27所示
7 动态代理类

public class DynamicProxy<T> {
public static <T> T newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h){
//寻找JoinPoint连接点，AOP框架使用元数据定义
if(true){
//执行一个前置通知
(new BeforeAdvice()).exec();
}
//执行目标，并返回结果
return (T)Proxy.newProxyInstance(loader,interfaces, h);
}
}

在这里插入了较多的AOP术语，如在什么地方（连接点）执行什么行为（通知）。我们
在这里实现了一个简单的横切面编程，有经验的读者可以看看AOP的配置文件就会明白这段
代码的意义了。我们来看通知Advice，也就是我们要切入的类，接口和实现如代码清单12

public interface IAdvice {
//通知只有一个方法，执行即可
public void exec();
}
public class BeforeAdvice implements IAdvice{
public void exec(){
System.out.println("我是前置通知，我被执行了！");
}
}

动态代理的场景类

public class Client {
public static void main(String[] args) {
//定义一个主题
Subject subject = new RealSubject();
//定义一个Handler
InvocationHandler handler = new MyInvocationHandler(subject);
//定义主题的代理
Subject proxy = DynamicProxy.newProxyInstance(subject.getClass().
getClassLoader(), subject.getClass().getInterfaces(),handler);
//代理的行为
proxy.doSomething("Finish");
}
}

好，所有的程序都看完了，我们回过头来看看程序是怎么实现的。在DynamicProxy类
中，我们有这样的方法：
this.obj=Proxy.newProxyInstance(c.getClassLoader(),c.getInterfaces(),new MyInvocationHandler(_obj));
该方法是重新生成了一个对象，为什么要重新生成？你要使用代理呀，注意
c.getInterfaces()这句话，这是非常有意思的一句话，是说查找到该类的所有接口，然后实现
接口的所有方法。当然了，方法都是空的，由谁具体负责接管呢？是new
MyInvocationHandler(_Obj)这个对象。于是我们知道一个类的动态代理类是这样的一个类，
由InvocationHandler的实现类实现所有的方法，由其invoke方法接管所有方法的实现，其动态
调用过程如图12-9所示。
在这里插入图片描述
读者可能注意到我们以上的代码还有更进一步的扩展余地，注意看DynamicProxy类，它
是一个通用类，不具有业务意义，如果我们再产生一个实现类是不是就很有意义了呢？

public class SubjectDynamicProxy extends DynamicProxy{
public static <T> T newProxyInstance(Subject subject){
//获得ClassLoader
ClassLoader loader = subject.getClass().getClassLoader();
//获得接口数组
Class<?>[] classes = subject.getClass().getInterfaces();
//获得handler
InvocationHandler handler = new MyInvocationHandler(subject);
return newProxyInstance(loader, classes, handler);
}
}

场景类

public class Client {
public static void main(String[] args) {
//定义一个主题
Subject subject = new RealSubject();
//定义主题的代理
Subject proxy = SubjectDynamicProxy.newProxyInstance(subject);
//代理的行为
proxy.doSomething("Finish");
}
}

友情提醒，在学习AOP框架时，弄清楚几个名词就成：切面（Aspect）、切入点
（JoinPoint）、通知（Advice）、织入（Weave）就足够了，理解了这几个名词，应用时你
就可以游刃有余了

奋斗中的代码猿--刘同学
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Unity游戏开发设计模式——代理模式
问渠哪得清如许，为有源头活水来
02-13 547
代理模式是一种结构型设计模式， 让你能够提供对象的替代品或其占位符。代理控制着对于原对象的访问， 并允许在将请求提交给对象前后进行一些处理。
设计模式之禅-代理模式
gclhaha的博客
02-05 122
目录代理模式例子定义优点使用场景扩展普通代理强制代理代理的个性-增强动态代理 代理模式 例子 public interface IGamePlayer { /** * 登录游戏 */ void login(String user, String password); /** * 杀怪，网络游戏的主要特色 */ void killBoss(); /** * 升级 */ void upgrade();
JavaScript设计模式之代理模式
01-31
代理，顾名思义就是帮助别人做事，GoF对代理模式的定义如下：代理模式(Proxy)，为其他对象提供一种代理以控制对这个对象的访问。代理模式使得代理对象控制具体对象的引用。代理几乎可以是任何对象：文件，资源，内存...
C++设计模式之代理模式
01-20
前言 青春总是那样，逝去了才开始回味...今天，我并不会去总结游戏代理是如何实现的，重点是通过游戏代理这个例子来总结设计模式中的代理模式。 什么是代理模式？ 在GOF的《设计模式:可复用面向对象软件的基础》一书中
详解JAVA设计模式之代理模式
08-19
JAVA 设计模式之代理模式 代理模式是 JAVA 设计模式之一，主要用于为其他对象提供一种代理，以控制对这个对象的访问。代理对象起到中介作用，可去掉功能服务或增加额外的服务。 代理模式的定义：代理模式就是为...
7 动态规划
qq_28611929的博客
07-03 1043
动态规划解决问题
刷题之买股票的最佳时机（leetcode）
qq_42538417的博客
07-06 253
【代码】刷题之买股票的最佳时机（leetcode）
力扣hot100-普通数组
hac1322的博客
07-02 591
的起始值大于 merged 列表中最后一个区间的结束值，则直接将新的区间添加到 merged 列表中；否则，更新 merged 列表中最后一个区间的结束值。方法1是自己写出来的。方法2参考的别人的，方法2太👍了，不易发现这个规律。当时没看题目中不让用除法，当时一下就想到这个思路了，哈哈哈。方法2使用两次遍历分别计算数组元素。的乘积，从而构建出结果数组。方法二可能不容易想到。
动态规划 剪绳子问题
m0_61862494的博客
07-02 492
当然可以使用更有效的解法，但是需要一点数学知识这个优化的算法基于一个数学发现：当绳子长度大于3时，尽可能多地切出长度为3的片段会得到最大乘积。如果最后剩下的长度为1，我们应该将其与一个3合并，形成一个长度为4的片段。给一段长度为n的绳子，请把绳子剪成m段，每段绳子的长度为k[0],k[1],k[2],k[3]....k[m].请问k[0]这个实现使用了动态规划的方法来解决问题。这个算法的时间复杂度为O(n^2)，空间复杂度为O(n)。k[2].....*k[m]的最大乘积为多少。
设计模式-代理模式和装饰者模式
u013398960的博客
07-01 660
代理模式和装饰者模式
深入解析代理模式：静态代理与动态代理的比较及JDK与CGLIB动态代理技术
搬砖的小熊猫的博客
07-06 761
静态代理适用于代理对象类型固定、接口较少、性能要求较高的情况。动态代理适用于代理对象类型不固定、接口较多、灵活性要求较高的情况。通过动态代理，可以根据接口或目标对象，计算出代理类的字节码，然后再加载到JVM中使用，使得代理对象的生成和方法调用更加灵活和动态。JDK动态代理和CGLIB动态代理是Java语言中实现动态代理的两种方式。JDK动态代理：适用于代理接口方法，性能稍低，使用反射机制。CGLIB动态代理：适用于代理普通类方法，性能较高，使用字节码生成技术。
设计模式-责任链模式
明戈戈的博客
07-04 918
在该函数中为了实现对下家的引用，必须继承自 AbstractHandler，以实现对下家的引用，并提供getter/setter函数实现对该引用的取得和修改操作，这就是责任链的核心。由流管道的责任链模式也可以得出，凡是具有过滤和管道特征的应用都属于责任链器模式，例如 Java EE 中的 Filter 过滤器、UNIX中的管道符等，都属于责任链模式。因此，Java I/O 库中的所有输入流、输出流的类都采用了责任链模式，它们可以无限次地进行装饰转换，转换的目标就是得到自己想要的数据类型的流对象。
Java中的设计模式在实际项目中的应用
微赚淘客开发者博客
07-05 378
设计模式是解决软件设计中常见问题的经验总结，它们提供了一种标准的解决方案，能够帮助开发人员设计出灵活、可扩展和易于维护的代码。在Java中，设计模式尤为重要，因为Java是一种面向对象的语言，设计模式可以帮助开发人员更好地利用面向对象编程的特性。通过合理应用设计模式，可以提高代码的复用性、灵活性和可维护性，降低项目的开发和维护成本，同时提升系统的可靠性和性能。观察者模式定义了对象之间的一对多依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。对象，隐藏了对象的创建细节。
设计模式之单例模式
07-03 442
单例模式（Singleton Pattern）是一种常用的软件设计模式，它确保一个类仅有一个实例，并提供一个全局访问点来获取该实例。这个模式在多种场景下都非常有用，比如配置文件的读取、数据库连接、线程池等，这些资源通常只需要一个实例来管理，以避免资源浪费或数据不一致。
设计模式-模板方法模式
明戈戈的博客
07-02 1146
因为 HtpServlet.service()方法会检查请求方法是否调用了适当的处理方法，不必要覆盖 service()方法，只需覆盖相应的 do 方法就可以了。模板方法模式的使用方法：定义一个abstract的Class，在这个抽象类中，至少包括一个实现模板方法的不可被子类改写的public方法(需声明为final)，在这个公共方法中，实现模板方法的业务处理逻辑，同时，在这个方法中，还包括一些对本类中的抽象方法的调用：再根据业务的需要，定义各种不同的子类，并实现模板方法类的所有抽象方法。
Go 依赖注入设计模式
最新发布
专注于全栈开发领域
07-06 945
依赖注入是一种强大的设计模式，可以帮助开发者编写更干净、更模块化的代码。虽然 Go 语言没有原生支持依赖注入，但通过手动实现、使用反射或利用第三方库，我们仍然可以在 Go 中有效地使用这一模式。选择哪种方法取决于你的具体需求和偏好，但无论如何，依赖注入都是提升 Go 开发效率的一个有力工具。
【设计模式之美】策略模式实践：不同大小（采用不同的策略）文件进行排序
hiliang521的博客
07-06 212
【设计模式之美】策略模式实践：不同大小（采用不同的策略）文件进行排序
设计模式 代理模式
06-09
代理模式是一种软件设计模式，它允许你创建一个对象的“代理”来控制对原对象的访问。这个代理对象可以在不影响原对象的情况下，增加额外的功能、延迟操作执行、修改行为或者控制对原对象的访问权限。在许多场景中，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

奋斗中的代码猿--刘同学

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值