看了我写的设计模式,全公司同事都开始悄悄模仿了。。。

LLM驱动开发:规格说明书与提示工程成为新核心 在AI深度融入软件开发的今天,'LLM驱动开发'已从概念走向工程现实。其本质是将传统SDLC中分散的知识表达(UML、API文档、ER图)统一收束为自然语言驱动的‘规格说明书’,再通过‘提示工程’将其转化为可执行代码。这一转变的核心在于:人类不再直接编码,而是精确定义意图、边界与质量契约;AI则承担模式识别与细节生成。技术价值体现在交付效率跃升与工程师角色升维——从写代码者变为系统意图架构师。典型应用场景包括微服务快速原型、合规敏感型系统(如金融、医疗)的自动化代码生成,以及跨职能需求对齐。本文聚焦于如何构 阅读详情

点击上方“芋道源码”,选择“设为星标”

管她前浪,还是后浪?

能浪的浪,才是好浪!

每天 10:33 更新文章,每天掉亿点点头发...

源码精品专栏

 

来源:楼仔

70d12b41a9c6c15bfcc777a8740fee69.jpeg


无论大家工作还是面试,都会用到设计模式,如果不结合具体的场景,通过书本学到的设计模式非常容易忘。

本文通过具体的示例,教大家如何学习设计模式,保证你看完这篇文章后,这 3 种常用的设计模式,能妥妥掌握!

不 BB,上文章目录。

02e9bee94c6b9721db3f26dd4531eb05.png

1. 一起打豆豆

有个记者去南极采访一群企鹅,他问第一只企鹅:“你每天都干什么?”

企鹅说:“吃饭,睡觉,打豆豆!”

接着又问第 2 只企鹅,那只企鹅还是说:“吃饭,睡觉,打豆豆!”

记者带着困惑问其他的企鹅,答案都一样,就这样一直问了 99 只企鹅。

当走到第 100 只小企鹅旁边时,记者走过去问它:每天都做些什么啊?

那只小企鹅回答:"吃饭,睡觉."

记者惊奇的又问:"你怎么不打豆豆?"

小企鹅撇着嘴巴,瞪了记者一眼说:"我就是豆豆!"

楼哥,你搞错了吧,这是篇技术文,你咋讲笑话了?甭着急,继续往后面看哈~~

基于 Spring Boot + MyBatis Plus + Vue & Element 实现的后台管理系统 + 用户小程序,支持 RBAC 动态权限、多租户、数据权限、工作流、三方登录、支付、短信、商城等功能

  • 项目地址:https://github.com/YunaiV/ruoyi-vue-pro

  • 视频教程:https://doc.iocoder.cn/video/

2. 模板&策略模式

2.1 实现姿势

我们会从简单到复杂,讲解代码正确的实现姿势,分别为最 Low 方式、常规方式、模板模式和策略模式。

2.1.1 最 Low 方式

假如现在有 3 只企鹅,都喜欢 “吃饭,睡觉,打豆豆”:

public class littlePenguin {
    public void everyDay() {
        System.out.println("吃饭");
        System.out.println("睡觉");
        System.out.println("用小翅膀打豆豆");
    }
}
public class middlePenguin {
    public void everyDay() {
        System.out.println("吃饭");
        System.out.println("睡觉");
        System.out.println("用圆圆的肚子打豆豆");
    }
}
public class bigPenguin {
    public void everyDay() {
        System.out.println("吃饭");
        System.out.println("睡觉");
        System.out.println("拿鸡毛掸子打豆豆");
    }
}
public class test {
    public static void main(String[] args) {
        System.out.println("littlePenguin:");
        littlePenguin penguin_1 = new littlePenguin();
        penguin_1.everyDay();
        
        System.out.println("middlePenguin:");
        middlePenguin penguin_2 = new middlePenguin();
        penguin_2.everyDay();
        
        System.out.println("bigPenguin:");
        bigPenguin penguin_3 = new bigPenguin();
        penguin_3.everyDay();
    }
}

看一下执行结果:

littlePenguin:
吃饭
睡觉
用小翅膀打豆豆
middlePenguin:
吃饭
睡觉
用圆圆的肚子打豆豆
bigPenguin:
吃饭
睡觉
拿鸡毛掸子打豆豆

这种方式是大家写代码时,最容易使用的方式,上手简单,也容易理解,目前看项目中陈旧的代码,经常能找到它们的影子,下面我们看怎么一步步将其进行重构。

2.1.2 常规方式

“吃饭,睡觉,打豆豆” 其实都是独立的行为,为了不相互影响,我们可以通过函数简单进行封装:

public class littlePenguin {
    public void eating() {
        System.out.println("吃饭");
    }
    public void sleeping() {
        System.out.println("睡觉");
    }
    public void beating() {
        System.out.println("用小翅膀打豆豆");
    }
}
public class middlePenguin {
    public void eating() {
        System.out.println("吃饭");
    }
    public void sleeping() {
        System.out.println("睡觉");
    }
    public void beating() {
        System.out.println("用圆圆的肚子打豆豆");
    }
}
// bigPenguin相同,省略...
public class test {
    public static void main(String[] args) {
        System.out.println("littlePenguin:");
        littlePenguin penguin_1 = new littlePenguin();
        penguin_1.eating();
        penguin_1.sleeping();
        penguin_1.beating();
        // 下同,省略...
    }
}

工作过一段时间的同学,可能会采用这种实现方式,我们有没有更优雅的实现方式呢?

2.1.3 模板模式

定义 :一个抽象类公开定义了执行它的方法的方式/模板,它的子类可以按需要重写方法实现,但调用将以抽象类中定义的方式进行,属于行为型模式。

这 3 只企鹅,因为 “吃饭,睡觉” 都一样,所以我们可以直接实现出来,但是他们 “打豆豆” 的方式不同,所以封装成抽象方法,需要每个企鹅单独去实现 “打豆豆” 的方式。

最后再新增一个方法 everyDay(),固定每天的执行流程:

public abstract class penguin {
    public void eating() {
        System.out.println("吃饭");
    }
    public void sleeping() {
        System.out.println("睡觉");
    }
    public abstract void beating();
    public void everyDay() {
        this.eating();
        this.sleeping();
        this.beating();
    }
}

每只企鹅单独实现自己 “打豆豆” 的方式:

public class littlePenguin extends penguin {
    @Override
    public void beating() {
        System.out.println("用小翅膀打豆豆");
    }
}
public class middlePenguin extends penguin {
    @Override
    public void beating() {
        System.out.println("用圆圆的肚子打豆豆");
    }
}
public class bigPenguin extends penguin {
    @Override
    public void beating() {
        System.out.println("拿鸡毛掸子打豆豆");
    }
}

最后看调用方式:

public class test {
    public static void main(String[] args) {
        System.out.println("littlePenguin:");
        littlePenguin penguin1 = new littlePenguin();
        penguin1.everyDay();
        System.out.println("middlePenguin:");
        middlePenguin penguin2 = new middlePenguin();
        penguin2.everyDay();
        System.out.println("bigPenguin:");
        bigPenguin penguin3 = new bigPenguin();
        penguin3.everyDay();
    }
}

楼哥,你这代码看的费劲,能给我画一个 UML 图么?来,安排!

d5d0e72f265dd68b4dffcf5a7d587133.png
2.1.4 策略模式

定义 :一个类的行为或其算法可以在运行时更改,即我们创建表示各种策略的对象和一个行为随着策略对象改变而改变的 context 对象,策略对象改变 context 对象的执行算法,属于行为型模式。

我们还是先抽象出 3 个企鹅的行为:

public abstract class penguin {
    public void eating() {
        System.out.println("吃饭");
    }
    public void sleeping() {
        System.out.println("睡觉");
    }
    public abstract void beating();
}

每只企鹅单独实现自己 “打豆豆” 的方式:

public class littlePenguin extends penguin {
    @Override
    public void beating() {
        System.out.println("用小翅膀打豆豆");
    }
}
public class middlePenguin extends penguin {
    @Override
    public void beating() {
        System.out.println("用圆圆的肚子打豆豆");
    }
}
public class bigPenguin extends penguin {
    @Override
    public void beating() {
        System.out.println("拿鸡毛掸子打豆豆");
    }
}

这里就是策略模式的重点 ,我们再看一下策略模式的定义 “我们创建表示各种策略的对象和一个行为随着策略对象改变而改变的 context 对象”,那么该 contex 对象如下:

public class behaviorContext {
    private penguin _penguin;

    public behaviorContext(penguin newPenguin) {
        _penguin = newPenguin;
    }
    public void setPenguin(penguin newPenguin) {
        _penguin = newPenguin;
    }
    public void everyDay() {
        _penguin.eating();
        _penguin.sleeping();
        _penguin.beating();
    }
}

最后看调用方式:

public class test {
    public static void main(String[] args) {
        behaviorContext behavior = new behaviorContext(new littlePenguin());
        behavior.everyDay();

        behavior.setPenguin(new middlePenguin());
        behavior.everyDay();

        behavior.setPenguin(new bigPenguin());
        behavior.everyDay();
    }
}

我们可以通过给 behaviorContext 传递不同的对象,然后来约定 everyDay() 的调用方式。

其实我这个示例,有点把策略模式讲复杂了,因为纯粹的策略模式,3 个企鹅只有 beating() 方法不同,所以可以把 beating() 理解为不同的算法即可。

之所以引入 everyDay(),是因为实际的项目场景中,会经常这么使用,也就是把这个变化的算法 beating(),包装到具体的执行流程里面 ,所以策略模式就看起来没有那么直观,但是核心思想是一样的。

f393a85f776061b25132b41ad84c5a62.png

2.2 模板 vs 策略

我在选择模板模式和策略模式时,发现两者都可以完全满足我的需求,然后我到网上查阅了很多资料,希望能找到两种模式在技术选择时,能确定告诉我哪些情况需要选择哪种模式。

说来惭愧,到现在我都没有找到 ,因为网上只告诉我两种实现姿势的区别,但是没有说明如何具体选型。

2.2.1 网上观点

据我可以告诉他们是 99% 相同,唯一的区别是模板方法模式具有抽象类作为基类,而战略类使用由每个具体战略类实现的接口,两者的主要区别在于具体 algorithm 的 select。

使用 Template 方法模式时,通过子类化模板在编译时发生,每个子类通过实现模板的抽象方法提供了一个不同的具体 algorithm。

当客户端调用模板的外部接口的方法时,模板根据需要调用其抽象方法(其内部接口)来调用 algorithm。

相比之下,策略模式允许在运行时通过遏制来 select algorithm,具体 algorithm 是通过单独的类或函数实现的,这些类或函数作为 parameter passing 给构造函数或构造方法。

上面讲的有点抽象,下面直接看具体对比。

0020aa9b773bdb8c6d3bd0a5f7ce14ce.jpeg

相似:

  • 策略和模板方法模式都可以用来满足开闭原则,使得软件模块在不改变代码的情况下易于扩展;

  • 两种模式都表示通用 function 与该 function 的详细实现的分离,不过它们所提供的粒度有一些差异。

差异:

  • 策略模式:

    • 它基于接口 ;

    • 客户和策略之间的耦合更加松散;

    • 定义不能被子类改变的 algorithm 的骨架,只有某些操作可以在子类中重写;

    • 父类完全控制 algorithm ,仅将具体的步骤与具体的类进行区分;

    • 绑定是在编译时完成的。

  • 模板模式:

    • 它基于框架或抽象类 ,甚至可以有一个具有默认实现的具体类。

    • 模块耦合得更紧密; 它通过修改方法的行为来改变对象的内容;

    • 它用于在 algorithm 族之间切换;

    • 它在运行时通过其他 algorithm 完全 replace 一个algorithm 来改变对象的行为;

    • 绑定在运行时完成。

2.2.2 个人理解

对于有强迫症的我,没有找到问题的根源,总感觉哪里不对劲,我就说一下我对于两者区别的理解吧。

说实话,两种设计模式,我也就看到在实现姿势上有所区别,至于说的策略模式要定义统一接口,模板模式不这样做等,我不太赞同,因为我有时也会给模板模式定义一个通用接口。

然后也有人说,策略模式需要定义一堆对象,模板模式就不需要,如果有 10 个不同的企鹅,模板模式不也是需要定义 10 个不同的企鹅类,然后再专门针对特定的方法去实现么?

这两种设计模式,我感觉还没有到非此即彼的划分。

如果我没有固定的执行流程,比如只去打豆豆,只需要对一个方法做具体抽象,我愿意选择策略模式,因为这个我感觉会让我需要使用的对象,更清晰一些。

如果我有固定的执行流程,比如 “吃饭、睡觉、打豆豆”,我更愿意使用模板方法,可能是代码看多了,也看习惯了,更愿意用模板方法去规范代码固定的执行流程。

当然,我也可以将两者结合起来使用 ,比如我们可以用模板方法,去实现这 3 只企鹅,但是对于 middlePenguin,可能有分为企鹅少年 A、企鹅少年 B、企鹅少年 C,他们都喜欢隔壁的企鹅妹妹,但是喜欢的方式不同,有暗恋的,有直接表白的,还有霸道总裁的,我可以用策略模式,去指定他们对企鹅妹妹的表达方式。

2.3 实际场景

任何模式,都需要结合实际的场景来讲,才能更清晰。

这两个模式,可以在你之前做过的项目中,只要稍微留意一下,应该会发现它们其实是大量存在的。

比如很多框架代码,里面有很多固定的执行流程,有些逻辑是可以采用默认处理的方式,有些逻辑需要下游自己去实现,然后有些逻辑还需要提前预留钩子。

比如在执行 process() 流程时,可能需要进行 preProcess() 的操作,那么这个 preProcess() 就是你预留的钩子,下游可以实现,也可以不实现。

基于 Spring Cloud Alibaba + Gateway + Nacos + RocketMQ + Vue & Element 实现的后台管理系统 + 用户小程序,支持 RBAC 动态权限、多租户、数据权限、工作流、三方登录、支付、短信、商城等功能

  • 项目地址:https://github.com/YunaiV/yudao-cloud

  • 视频教程:https://doc.iocoder.cn/video/

3. 工厂模式

后面会结合模板模式,来讲解工厂模式,实战场景非常强。

3.1 问题引入

对于工厂模式,大家可能觉得会很 Low,不就是搞个类,然后专门生成一个具体的对象嘛,这有什么难的?

是的,工厂模式确实不难,但是问你一下,如果你的代码中有很多 if...else,你知道怎么通过工厂模式,把这些 if...else 去掉么?

嗯,工厂模式我会,但是和去掉 if...else 好像没有关系吧?

我举个例子,假如你遇到如下代码:

switch($taskInfo['type_id']) {
    //批量冻结订单
    case 1:
        $result = self::batchFrozen($row_key,1);
        break;
    //批量解冻订单
    case 2:
        $result = self::batchFrozen($row_key,0);
        break;
    //批量允许发货
    case 3:
        $result =self::batchReshipment($row_key);
        break;
    //批量取消发货
    case 4:
        $result = self::batchCancel($row_key);
        break;
    // 后面还有几十个case,省略...

既然你懂工厂模式,可以把 if...else 简单重构一下,那就开始你的表演吧。

什么?不会?!你刚才还是自己是会工厂模式,怎么突然就怂了呢?

既然不会,那就静下心来,虚心学习一下。

3.2 工厂模式

定义 :它提供了一种创建对象的最佳方式,我们在创建对象时不会对客户端暴露创建逻辑,并且是通过使用一个共同的接口来指向新创建的对象,属于创建型模式。

先直接上图,后面的示例主要通过该图展开:

5accd37f73076ec7681efaddaf1abdd2.png

其实设计模式一般不会单一使用,通常会和其它模式结合起来使用,这里我们就将上一篇文章讲到的模板模式和工厂模式结合起来。

因为工厂模式,通常会给这些新创建的对象制定一个公共的接口,我们可以通过抽象类定义:

public abstract class penguin {
    public void eating() {
        System.out.println("吃饭");
    }

    public void sleeping() {
        System.out.println("睡觉");
    }

    public abstract void beating();

    public void everyDay() {
        this.eating();
        this.sleeping();
        this.beating();
    }
}

因为我们是结合了模板模式,所以这个抽象类中,可以看到模板模式的影子。

如果你只关注抽象的接口,比如 beating,那么这个就是一个抽象方法,也可以理解为下游需要实现的方法,其它的接口其实可以忽略。

看看每个企鹅具体的实现:

public class littlePenguin extends penguin {
    @Override
    public void beating() {
        System.out.println("用小翅膀打豆豆");
    }
}
public class middlePenguin extends penguin {
    @Override
    public void beating() {
        System.out.println("用圆圆的肚子打豆豆");
    }
}
public class bigPenguin extends penguin {
    @Override
    public void beating() {
        System.out.println("拿鸡毛掸子打豆豆");
    }
}

这里是工厂方法的重点 ,需要构建一个工厂,专门用来拿企鹅:

public class penguinFactory {
    private static final Map<String, penguin> map = new HashMap<>();
    static {
        map.put("littlePenguin", new littlePenguin());
        map.put("middlePenguin", new middlePenguin());
        map.put("bigPenguin", new bigPenguin());
    }
    // 获取企鹅
    public static penguin getPenguin(String name) {
        return map.get(name);
    }
}

上面的逻辑很简单,就是通过一个 map 对象,放入所有的企鹅,这个工厂就可以通过企鹅的名字,拿到对应的企鹅对象,最后我们看使用方式:

public class test {
    public static void main(String[] args) {
        penguin penguin_1 = penguinFactory.getPenguin("littlePenguin");
        penguin_1.everyDay();
        penguin penguin_2 = penguinFactory.getPenguin("middlePenguin");
        penguin_2.everyDay();
        penguin penguin_3 = penguinFactory.getPenguin("bigPenguin");
        penguin_3.everyDay();
    }
}

输出如下:

吃饭
睡觉
用小翅膀打豆豆
吃饭
睡觉
用圆圆的肚子打豆豆
吃饭
睡觉
拿鸡毛掸子打豆豆

楼哥,你这个例子我看懂了,但是你最开始抛的那个问题,能给出答案么?

3.3 问题解答

文章开头的这个示例,其实也是我最近需要重构项目中的一段代码,我就是用 “工厂模式 + 模板模式” 来重构的。

我首先会对每个方法中的内容通过模板模式进行抽象(因为本章主要讲工厂模式,模板模式的代码,我就不贴了),然后通过工厂模式获取不同的对象,直接看重构后的代码:

public class TaskFactory {
    @Autowired
    public static List<AbstractTask> taskList;
    private static final Map<String, AbstractTask> map = new HashMap<>();
    static {
        // 存放任务映射关系
        map.put(AbstractTask.OPERATOR_TYPE_FROZEN, new BatchFrozenTask());
        map.put(AbstractTask.OPERATOR_TYPE_REJECT, new BatchRejectTask());
        map.put(AbstractTask.OPERATOR_TYPE_CANCEL, new BatchCancelTask());
    }

    public static void main(String[] args) {
        String operatorType = AbstractTask.OPERATOR_TYPE_REJECT;
        AbstractTask task = TaskFactory.map.get(operatorType);
        ParamWrapper<CancelParams> params = new ParamWrapper<CancelParams>();
        params.rowKey = 11111111;
        params.data = new CancelParams();
        OcApiServerResponse res =  task.execute(params);
        System.out.println(res.toString());
        return;
    }
}

3.4 实际场景

这个场景就太多了,刚才给大家讲解的是去掉 if...else 的场景,然后在小米商城的支付系统中,因为海外有几十种支付方式,也是通过这种方式去掉 if...else 的,不过支付类的封装不是用的模板方法,用的的策略模式 ,虽然感觉两者差不多。

如果你直接 new 一个对象就能解决的问题,就用不到工厂模式了。

4. 结语

看完这篇文章,相信这 3 种设计模式,已经深深刻在你骨子里面了。

大家可以静下心来想想,自己之前做过的项目中,有哪些用到上面这 3 种设计模式,然后自己再结合具体的场景总结一下,我想你应该会有更深入的理解。



欢迎加入我的知识星球,一起探讨架构,交流源码。加入方式,长按下方二维码噢:

12119c7228f82e4dd66bc9f288efc19a.png

已在知识星球更新源码解析如下:

188cbe979b980a6bbe8363c7ee4de21a.jpeg

b88ddcc4416ea341012622f795c8fd94.jpeg

21891a3270f60e2a4480e276c72cf722.jpeg

faf2b4921a0e7333385e6ca93d1fee6a.jpeg

最近更新《芋道 SpringBoot 2.X 入门》系列,已经 101 余篇,覆盖了 MyBatis、Redis、MongoDB、ES、分库分表、读写分离、SpringMVC、Webflux、权限、WebSocket、Dubbo、RabbitMQ、RocketMQ、Kafka、性能测试等等内容。

提供近 3W 行代码的 SpringBoot 示例,以及超 4W 行代码的电商微服务项目。

获取方式:点“在看”,关注公众号并回复 666 领取,更多内容陆续奉上。

文章有帮助的话,在看,转发吧。
谢谢支持哟 (*^__^*)
代码熵减:用热力学原理降低软件系统混乱度 在软件工程中,‘熵’并非抽象比喻,而是可量化、可干预的系统混乱度指标——它体现为耦合加剧、认知负荷上升、变更成本攀升等典型现象。基于热力学第二定律,未加约束的代码系统天然趋向熵增,导致维护困难、故障频发、新人上手慢。通过将‘熵减’定义为降低未来行为不确定性,结合领域建模、契约测试、结构化日志、不可变基础设施等七类工程实践,开发者可将模糊的质量诉求转化为可测量、可执行、可传承的技术动作。本文聚焦中阶工程师日常所困的‘改一处崩三处’‘逻辑magic难追溯’等高熵场景,提供从诊断、声明、审查到冲刺的闭环落地路径。 阅读详情

相关推荐

【CUT&TAG分析-加了spike in的样品】

使用 Bowtie2 或 Subread (subjunc) 来构建大肠杆菌的索引。bowtie2比对时设置参数–local, 局部比对。

weixin_57975238的博客 1402

Spring Boot中如何干掉if else

点击上方“Java之间”,选择“置顶或者星标”你关注的就是我关心的!作者:Java高级架构狮需求这里虚拟一个业务需求,让大家容易理解。假设有一个订单系统,里面的一个功能是...

Java之间 2622

手机拍照也能玩高光谱?教你用TensorFlow Lite在Android上实现实时RGB转高光谱

本文介绍了如何利用TensorFlow Lite在Android设备上实现实时RGB到高光谱的图像重构技术。通过深度学习模型优化和移动端部署策略,使智能手机具备专业级光谱分析能力,适用于农业检测、化妆品分析等多个领域。

weixin_29091105的博客 247

全公司同事都开始悄悄模仿我写的设计模式

看完这篇文章,我相信你对这 3 种设计模式有了更好的理解。,比如我们可以用模板方法,去实现这 3 只企鹅,但是对于 middlePenguin,可能有分为企鹅少年 A、企鹅少年 B、企鹅少年 C,他们都喜欢隔壁的企鹅妹妹,但是喜欢的方式不同,有暗恋的,有直接表白的,还有霸道总裁的,我可以用策略模式,去指定他们对企鹅妹妹的表达方式。然后也有人说,策略模式需要定义一堆对象,模板模式就不需要,如果有 10 个不同的企鹅,模板模式不也是需要定义 10 个不同的企鹅类,然后再专门针对特定的方法去实现么?

2301_76936922的博客 128

关于光耦隔离与SP3485E芯片一起使用无法拉高485使能引脚问题

最近在做的一个项目,定制了一块STM32F407ZG的工控板,工控板载4个485接口全部都是只能接收数据,不能对外发送数据。1.接线不正确:接线不正确导致485收发出现问题。 2.程序端口初始化问题:控制光耦隔离的输入脚IO的初始化和置位状态有问题。 3.GPIO复用问题:控制对应串口的GPIO不是正点原子默认的GPIO,而是经过复用的其他IO,复用问题。 4.程序设置与485E芯片收发模式不对应:对于使能引脚的电平要根据光耦的输出情况确定输入IO与RE的关系,可能模式没有对应。 5.光耦隔离或者SP485

weixin_45862642的博客 2979

FME入门系列教程3-带你玩转GIS数据搬运与处理

FME(Feature Manipulation Engine)就像GIS界的"瑞士军刀",它能轻松解决90%的数据处理难题。我最初接触FME是因为要处理200多个不同格式的CAD地形图,传统方法需要1周时间,用FME只花了2小时!:支持300+数据格式(Shapefile、GeoJSON、CAD、Excel等)添加Reader(数据源):选择示例数据roads.shp。添加Writer(输出):设置输出为GeoJSON格式。:将常用流程保存为Template(.fmwt)

weixin_41234946的博客 1245

看了我写的设计模式,全公司同事都开始悄悄模仿了

一个抽象类公开定义了执行它的方法的方式/模板,它的子类可以按需要重写方法实现,但调用将以抽象类中定义的方式进行,属于行为型模式。这 3 只企鹅,因为 “吃饭,睡觉” 都一样,所以我们可以直接实现出来,

z_ssyy的博客 147

uni-app - 最详细 H5 网页接入微信登录功能,提供公众号配置与详细注释示例代码(移动端网页实现点击登录按钮后 调用微信公众号授权登录功能 详细讲解接入流程与详细示例代码)官方最新超级详细教程

uniapp中H5微信登录,uniapp H5微信授权登录,微信公众号第三方网页(H5)授权登录(OAuth2.0)流程及逻辑详细教程,UNIAPP 开发H5 怎么实现微信公众号登录功能,uniapp如何实现H5网页的公众号微信登录,怎么做uniapp微信登录,uniapp h5项目怎么实现微信登录的功能,uniapp微信浏览器H5授权微信登录,UniApp开发H5接入微信登录的全过程,uniapp的H5页面使用微信登录,uniapp H5微信授权登录,H5之微信授权登陆 (uniapp网页版微信授权登录)

🏆 前端领域优质创作者 7410

使用工厂模式 + 模板模式 策略模式 消除 if…else 和重复代码

看了我写的设计模式,全公司同事都开始悄悄模仿了。干掉 “重复代码”,这三种方式绝了!

chezabo6116的博客 292

基于STM32设计的数字电子秤

当前项目是采用采用STM32+称重模块+OLED实现了简单的电子秤项目,称重模块上采用24位的ADC芯片,精度较高。实现了称重,校准、去皮等功能。

1万+

配置某VLAN下ONU的二层互访(隔离)问题(解决OLT二层隔离问题)

问题:OLT的ONU节点之间在同一VLAN下的终端默认隔离,在确实需要互通的场景下如何解决。

symstandsun的博客 4569

项目中经常使用的设计模式之“模板模式”、“策略模式”、“代理模式”、“组合模式”.....

看了我写的设计模式,全公司同事都开始悄悄模仿了.....

lqs_user的博客 788

用 AI 设计力打造专业 UI_UX:在 Trea、Qoder 等 AI IDE 中集成 ui-ux-pro-max-skill

的核心是知识库Trea 和 Qoder 虽未被--ai all原生支持,但完全可通过@folder手动集成使用后,你的 AI 生成代码将从“功能可用”跃升至“设计专业”这是零成本提升产品质感的最佳实践之一🎨好的 UI 不应是设计师的专利,而是每个开发者的默认能力。然后在 Trea 或 Qoder 中输入—— 让 AI 成为你最懂设计的结对编程伙伴。

lpfasd123的博客 7110

一些文章资讯汇总(框架篇)

各类资讯汇总写在前面(声明)常用框架/组件NettySpringSpringBoot缓存ORM框架MybatisHibernate数据库连接池微服务DubboSpringCloudDubbo Spring Cloud 写在前面(声明) 声明:这里的各个内容基本都是平时看到的一些觉得有用的文章资讯的链接汇总,里面的内容都不是我的创作! 做个快乐的搬运工! 常用框架/组件 高效 Java 人必须知道的十大框架 Spring MVC & Boot & Cloud 技术教程汇总 Netty 看完这篇

老苏的一日三浪 398

VB摄像头监控

该VB模块可对摄像头捕获的画面进行录像等,可在创建的窗口进行控制

老版QQ原生表情gif动态

这是老版的QQ表情,不过全是动态的的,Windows照片查看器是不会动的,可以右击用浏览器打开查看,再说一遍是老版的,只是分享给宁愿用老版也要动态的人。

代码中的温度:从变量命名到注释,看见理科生藏在逻辑里的浪漫

编程不仅是逻辑与语法的堆砌,更是程序员思维与情感的表达。从基础的变量命名、函数注释,到异常处理与日志输出,每一行代码都可能承载着设计者的意图与关怀。理解这些隐性信息,能显著提升代码的可读性与维护性,让团队协作更顺畅。在实际项目中,无论是用Python绘制爱心图案、用C语言实现樱花动画,还是开发八卦罗盘时钟,技术本身并无温度,温度来自使用技术的人。学会在工程实践中注入同理心,通过清晰的注释和人性化的报错提示,可以让冰冷的机器逻辑散发出人文气息。本文以多个典型代码场景为例,探讨如何从视角转换中发现编程的深层价值

weixin_34198762的博客 327

数学建模模型总结

这是本人在两年内准备参加数学建模竞赛搜集到的模型资料,已经经过了本人的筛选和整理,希望能够对准备参加数学建模竞赛的学弟学妹们提供一些帮助!

AI代码生成可维护性危机:从理解断层到驾驭策略

在软件工程实践中,代码可维护性是衡量项目长期健康度的核心指标,它直接影响团队协作效率和系统演化能力。其原理在于通过清晰的架构设计、一致的编码规范和完善的文档体系,降低代码的认知负荷与修改成本。随着AI辅助编程工具的普及,开发者面临从“代码编写者”向“代码架构师与审查官”的角色转变,技术价值体现在如何将AI的高效生成能力,与人类对业务上下文、设计意图和系统一致性的把控能力相结合。应用场景涵盖日常功能开发、遗留系统维护、团队协作规范制定等环节。本文聚焦于AI生成代码导致的“理解断层”问题,探讨逻辑黑箱化、风格混

weixin_33896726的博客 365

ssm框架搭建

这个是一个在idea上成功跑起来的ssm框架项目,保存在这里方便以后使用直接下载

访问者模式详解

汇总目录请点击访问:《设计模式目录汇总》 喜欢内容的话欢迎关注、点赞、收藏!感谢支持,祝大家祉猷并茂,顺遂无虞!

2601_96797912的博客 34

设计模式之状态模式

状态模式是一种行为型设计模式,通过将对象的不同状态行为封装到独立的状态类中,使上下文对象在状态变化时自动切换行为。以外卖订单为例,不同状态(如待支付、配送中)对同一操作(如取消)有不同响应。状态模式避免了复杂的if/else判断,提升代码可维护性与扩展性。其核心由上下文(Order)、状态接口(OrderState)和具体状态类组成,通过委托机制实现状态间的平滑切换。

FallingGod的博客 316

Agent Skill 五大设计模式:从工程实践到落地指南

Skill 不是一段临时 Prompt,而是一个可复用、可测试、可迭代的任务流程模板。通常通过SKILL.mdWhen:什么情况下触发How:按什么步骤执行What:最终输出什么:哪些行为必须遵守、哪些行为禁止fill:#333;important;important;fill:none;color:#333;color:#333;important;fill:none;fill:#333;height:1em;用户意图Skill 路由工具调用 / MCP / API结构化输出检查与交付。

m0_62458145的博客 235

设计模式(unity游戏研发版)

当你使用图形用户界面类时通常会遇到一个问题。比如,你创建了自定义按钮类并允许客户端在按钮中注入自定义代码,这样当用户按下按钮时就会触发这些代码。观察者模式允许任何实现了订阅者接口的对象订阅发布者对象的事件通知。你可在按钮中添加订阅机制,允许客户端通过自定义订阅类注入自定义代码。在Unity中,这就像UnityEvent在Inspector中绑定多个回调。

m0_63330263的博客 135

设计模式之策略模式

策略模式是一种行为型设计模式,将可互换的算法封装为独立策略,使客户端可在运行时动态选择并切换算法。核心由策略接口、具体策略和上下文三部分组成。通过将算法与使用分离,实现解耦与灵活扩展。适用于多算法场景,如支付方式、排序策略等,避免冗长的if/else。

FallingGod的博客 421

设计模式指南 (Java 版)

设计模式是解决软件设计中常见问题的可复用方案,而非直接代码。本文以最简方式梳理三大类设计模式:创建型(如单例、工厂方法)、结构型(如适配器、装饰器)和行为型(如观察者、策略)。通过生活化类比与Java示例,强调“按需使用、避免过度设计”的原则,帮助理解其核心思想与实际应用。

sync_with_U 258

Vue3 组合式函数(Composables)设计模式:从封装到复用

本文以一次因复制粘贴导致的全局状态污染事故为引,深入剖析 Vue 3 Composable 的三大陷阱:单例状态误用、生命周期钩子注册失效与异步请求竞态。作者通过重构实践,强调 Composable 复用的核心是“带生命周期的响应式上下文”,而非简单代码复用。提出关键规范:状态归属决定 ref 位置、钩子必须在 setup 同步执行、用序号或 AbortController 解决竞态,并倡导基于“状态与生命周期”判断抽取时机,最终提升代码健壮性与团队协作效率。

滴水成河,汇流成海 196

【第四部分:Agentic 智能体设计模式】18.Agent 并行化实战:任务拆分、并发执行与结果汇总

本文介绍 Parallelization(并行化模式)的原理与工程实现,重点分析 Fan-out / Fan-in、Sectioning、Voting、任务依赖、上下文隔离、并发控制及部分失败处理。结合采购合同并行分析案例与 Java CompletableFuture 代码,说明如何实现独立任务的并发执行、结构化结果汇总和证据校验。同时介绍 LangGraph 动态任务分发、OpenAI 并行 Subagent、LangChain 异步 Subagent 及 DeepSeek Super-agent 等近

weixin_42258782的博客 267

设计模式之访问者模式

访问者模式是一种行为型设计模式,核心思想是将操作从元素类中分离,通过“访问者”统一管理对对象结构的多种操作。适用于元素类型稳定但操作频繁变化的场景。其精髓在于双重分派:元素通过accept方法触发访问者visit,最终由元素和访问者的运行时类型共同决定具体执行逻辑。该模式避免了在元素类中添加大量方法,提升扩展性,但会增加类数量与复杂度。典型应用如编译器语法树遍历、报表统计等。

FallingGod的博客 139
上一篇: 接了个变态需求:给定一个接口,要用户自定义动态实现并上传热部署,怎么搞?...
下一篇: SpringCloud Gateway网关为认证中心和用户微服务构建统一的认证授权入口
公众号-芋道源码
博客等级 码龄10年 1639粉丝 377原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值