链式调用 | 我的代码没有else

std::optional新增transform and_then or_else and_then` 函数用于对 `std::optional` 中的值应用一个返回 `std::optional` 的函数,并返回这个新的 `std::optional`。- `and_then` 用于对 `std::optional` 中的值应用一个返回 `std::optional` 的函数,并返回这个新的 `std::optional`。- `and_then`:应用的函数返回一个 `std::optional`,`and_then` 返回这个新的 `std::optional`。 阅读详情

嗯,我的代码没有else系列,一个设计模式业务真实使用的golang系列。

前言

本系列主要分享,如何在我们的真实业务场景中使用设计模式。

本系列文章主要采用如下结构:

  • 什么是「XX设计模式」?

  • 什么真实业务场景可以使用「XX设计模式」?

  • 怎么用「XX设计模式」?

本文主要介绍「责任链模式」如何在真实业务场景中使用。

什么是「责任链模式」?

首先把一系列业务按职责划分成不同的对象,接着把这一系列对象构成一个链,然后在这一系列对象中传递请求对象,直到被处理为止。

我们从概念中可以看出责任链模式有如下明显的优势:

  • 按职责划分:解耦

  • 对象链:逻辑清晰

但是有一点直到被处理为止,代表最终只会被一个实际的业务对象执行了实际的业务逻辑,明显适用的场景并不多。但是除此之外,上面的那两点优势还是让人很心动,所以,为了适用于目前所接触的绝大多数业务场景,把概念进行了简单的调整,如下:

首先把一系列业务按职责划分成不同的对象,接着把这一系列对象构成一个链,直到“链路结束”为止。(结束:异常结束,或链路执行完毕结束)

简单的直到“链路结束”为止转换可以让我们把责任链模式适用于任何复杂的业务场景。

以下是责任链模式(改)的具体优势:

  • 直观:一眼可观的业务调用过程

  • 无限扩展:可无限扩展的业务逻辑

  • 高度封装:复杂业务代码依然高度封装

  • 极易被修改:复杂业务代码下修改代码只需要专注对应的业务类(结构体)文件即可,以及极易被调整的业务执行顺序

什么真实业务场景可以用「责任链模式(改)」?

满足如下要求的场景:

业务极度复杂的所有场景

任何杂乱无章的业务代码,都可以使用责任链模式(改)去重构、设计。

我们有哪些真实业务场景可以用「责任链模式(改)」呢?

比如电商系统的下单接口,随着业务发展不断的发展,该接口会充斥着各种各样的业务逻辑。

怎么用「责任链模式(改)」?

关于怎么用,完全可以生搬硬套我总结的使用设计模式的四个步骤:

  • 业务梳理

  • 业务流程图

  • 代码建模

  • 代码demo

业务梳理
步骤逻辑
1
参数校验
2获取地址信息
3地址信息校验
4获取购物车数据
5获取商品库存信息
6商品库存校验
7获取优惠信息
8获取运费信息
9使用优惠信息
10扣库存
11清理购物车
12写订单表
13写订单商品表
14写订单优惠信息表
XX以及未来会增加的逻辑...

业务的不断发展变化的:

  • 新的业务被增加

  • 旧的业务被修改

比如增加的新的业务,订金预售:

  • 在4|获取购物车数据后,需要校验商品参见订金预售活动的有效性等逻辑。

  • 等等逻辑

注:流程不一定完全准确

业务流程图

我们通过梳理的文本业务流程得到了如下的业务流程图:

代码建模

责任链模式主要类主要包含如下特性:

  • 成员属性

    • nextHandler: 下一个等待被调用的对象实例 -> 稳定不变的

  • 成员方法

    • SetNext: 把下一个对象的实例绑定到当前对象的nextHandler属性上 -> 稳定不变的

    • Do: 当前对象业务逻辑入口 -> 变化的

    • Run: 调用当前对象的Do,nextHandler不为空则调用nextHandler.Do -> 稳定不变的

套用到下单接口伪代码实现如下:

一个父类(抽象类):

- 成员属性
	+ `nextHandler`: 下一个等待被调用的对象实例
- 成员方法
	+ 实体方法`SetNext`: 实现把下一个对象的实例绑定到当前对象的`nextHandler`属性上
	+ 抽象方法`Do`: 当前对象业务逻辑入口
	+ 实体方法`Run`: 实现调用当前对象的`Do`,`nextHandler`不为空则调用`nextHandler.Do`

子类一(参数校验)
- 继承抽象类父类
- 实现抽象方法`Do`:具体的参数校验逻辑

子类二(获取地址信息)
- 继承抽象类父类
- 实现抽象方法`Do`:具体获取地址信息的逻辑

子类三(获取购物车数据)
- 继承抽象类父类
- 实现抽象方法`Do`:具体获取购物车数据的逻辑

......略

子类X(以及未来会增加的逻辑)
- 继承抽象类父类
- 实现抽象方法`Do`:以及未来会增加的逻辑

但是,golang里没有的继承的概念,要复用成员属性nextHandler、成员方法SetNext、成员方法Run怎么办呢?我们使用合成复用的特性变相达到“继承复用”的目的,如下:

一个接口(interface):

- 抽象方法`SetNext`: 待实现把下一个对象的实例绑定到当前对象的`nextHandler`属性上
- 抽象方法`Do`: 待实现当前对象业务逻辑入口
- 抽象方法`Run`: 待实现调用当前对象的`Do`,`nextHandler`不为空则调用`nextHandler.Do`

一个基础结构体:

- 成员属性
	+ `nextHandler`: 下一个等待被调用的对象实例
- 成员方法
	+ 实体方法`SetNext`: 实现把下一个对象的实例绑定到当前对象的`nextHandler`属性上
	+ 实体方法`Run`: 实现调用当前对象的`Do`,`nextHandler`不为空则调用`nextHandler.Do`

子类一(参数校验)
- 合成复用基础结构体
- 实现抽象方法`Do`:具体的参数校验逻辑

子类二(获取地址信息)
- 合成复用基础结构体
- 实现抽象方法`Do`:具体获取地址信息的逻辑

子类三(获取购物车数据)
- 合成复用基础结构体
- 实现抽象方法`Do`:具体获取购物车数据的逻辑

......略

子类X(以及未来会增加的逻辑)
- 合成复用基础结构体
- 实现抽象方法`Do`:以及未来会增加的逻辑

同时得到了我们的UML图:

代码demo
package main

//---------------
//我的代码没有`else`系列
//责任链模式
//@auhtor TIGERB<https://github.com/TIGERB>
//---------------

import (
	"fmt"
	"runtime"
)

// Context Context
type Context struct {
}

// Handler 处理
type Handler interface {
	// 自身的业务
	Do(c *Context) error
	// 设置下一个对象
	SetNext(h Handler) Handler
	// 执行
	Run(c *Context) error
}

// Next 抽象出来的 可被合成复用的结构体
type Next struct {
	// 下一个对象
	nextHandler Handler
}

// SetNext 实现好的 可被复用的SetNext方法
// 返回值是下一个对象 方便写成链式代码优雅
// 例如 nullHandler.SetNext(argumentsHandler).SetNext(signHandler).SetNext(frequentHandler)
func (n *Next) SetNext(h Handler) Handler {
	n.nextHandler = h
	return h
}

// Run 执行
func (n *Next) Run(c *Context) (err error) {
	// 由于go无继承的概念 这里无法执行当前handler的Do
	// n.Do(c)
	if n.nextHandler != nil {
		// 合成复用下的变种
		// 执行下一个handler的Do
		if err = (n.nextHandler).Do(c); err != nil {
			return
		}
		// 执行下一个handler的Run
		return (n.nextHandler).Run(c)
	}
	return
}

// NullHandler 空Handler
// 由于go无继承的概念 作为链式调用的第一个载体 设置实际的下一个对象
type NullHandler struct {
	// 合成复用Next的`nextHandler`成员属性、`SetNext`成员方法、`Run`成员方法
	Next
}

// Do 空Handler的Do
func (h *NullHandler) Do(c *Context) (err error) {
	// 空Handler 这里什么也不做 只是载体 do nothing...
	return
}

// ArgumentsHandler 校验参数的handler
type ArgumentsHandler struct {
	// 合成复用Next
	Next
}

// Do 校验参数的逻辑
func (h *ArgumentsHandler) Do(c *Context) (err error) {
	fmt.Println(runFuncName(), "校验参数成功...")
	return
}

// AddressInfoHandler 地址信息handler
type AddressInfoHandler struct {
	// 合成复用Next
	Next
}

// Do 校验参数的逻辑
func (h *AddressInfoHandler) Do(c *Context) (err error) {
	fmt.Println(runFuncName(), "获取地址信息...")
	fmt.Println(runFuncName(), "地址信息校验...")
	return
}

// CartInfoHandler 获取购物车数据handler
type CartInfoHandler struct {
	// 合成复用Next
	Next
}

// Do 校验参数的逻辑
func (h *CartInfoHandler) Do(c *Context) (err error) {
	fmt.Println(runFuncName(), "获取购物车数据...")
	return
}

// StockInfoHandler 商品库存handler
type StockInfoHandler struct {
	// 合成复用Next
	Next
}

// Do 校验参数的逻辑
func (h *StockInfoHandler) Do(c *Context) (err error) {
	fmt.Println(runFuncName(), "获取商品库存信息...")
	fmt.Println(runFuncName(), "商品库存校验...")
	return
}

// PromotionInfoHandler 获取优惠信息handler
type PromotionInfoHandler struct {
	// 合成复用Next
	Next
}

// Do 校验参数的逻辑
func (h *PromotionInfoHandler) Do(c *Context) (err error) {
	fmt.Println(runFuncName(), "获取优惠信息...")
	return
}

// ShipmentInfoHandler 获取运费信息handler
type ShipmentInfoHandler struct {
	// 合成复用Next
	Next
}

// Do 校验参数的逻辑
func (h *ShipmentInfoHandler) Do(c *Context) (err error) {
	fmt.Println(runFuncName(), "获取运费信息...")
	return
}

// PromotionUseHandler 使用优惠信息handler
type PromotionUseHandler struct {
	// 合成复用Next
	Next
}

// Do 校验参数的逻辑
func (h *PromotionUseHandler) Do(c *Context) (err error) {
	fmt.Println(runFuncName(), "使用优惠信息...")
	return
}

// StockSubtractHandler 库存操作handler
type StockSubtractHandler struct {
	// 合成复用Next
	Next
}

// Do 校验参数的逻辑
func (h *StockSubtractHandler) Do(c *Context) (err error) {
	fmt.Println(runFuncName(), "扣库存...")
	return
}

// CartDelHandler 清理购物车handler
type CartDelHandler struct {
	// 合成复用Next
	Next
}

// Do 校验参数的逻辑
func (h *CartDelHandler) Do(c *Context) (err error) {
	fmt.Println(runFuncName(), "清理购物车...")
	// err = fmt.Errorf("CartDelHandler.Do fail")
	return
}

// DBTableOrderHandler 写订单表handler
type DBTableOrderHandler struct {
	// 合成复用Next
	Next
}

// Do 校验参数的逻辑
func (h *DBTableOrderHandler) Do(c *Context) (err error) {
	fmt.Println(runFuncName(), "写订单表...")
	return
}

// DBTableOrderSkusHandler 写订单商品表handler
type DBTableOrderSkusHandler struct {
	// 合成复用Next
	Next
}

// Do 校验参数的逻辑
func (h *DBTableOrderSkusHandler) Do(c *Context) (err error) {
	fmt.Println(runFuncName(), "写订单商品表...")
	return
}

// DBTableOrderPromotionsHandler 写订单优惠信息表handler
type DBTableOrderPromotionsHandler struct {
	// 合成复用Next
	Next
}

// Do 校验参数的逻辑
func (h *DBTableOrderPromotionsHandler) Do(c *Context) (err error) {
	fmt.Println(runFuncName(), "写订单优惠信息表...")
	return
}

// 获取正在运行的函数名
func runFuncName() string {
	pc := make([]uintptr, 1)
	runtime.Callers(2, pc)
	f := runtime.FuncForPC(pc[0])
	return f.Name()
}

func main() {
	// 初始化空handler
	nullHandler := &NullHandler{}

	// 链式调用 代码是不是很优雅
	// 很明显的链 逻辑关系一览无余
	nullHandler.SetNext(&ArgumentsHandler{}).
		SetNext(&AddressInfoHandler{}).
		SetNext(&CartInfoHandler{}).
		SetNext(&StockInfoHandler{}).
		SetNext(&PromotionInfoHandler{}).
		SetNext(&ShipmentInfoHandler{}).
		SetNext(&PromotionUseHandler{}).
		SetNext(&StockSubtractHandler{}).
		SetNext(&CartDelHandler{}).
		SetNext(&DBTableOrderHandler{}).
		SetNext(&DBTableOrderSkusHandler{}).
		SetNext(&DBTableOrderPromotionsHandler{})
		//无限扩展代码...

	// 开始执行业务
	if err := nullHandler.Run(&Context{}); err != nil {
		// 异常
		fmt.Println("Fail | Error:" + err.Error())
		return
	}
	// 成功
	fmt.Println("Success")
	return
}

代码运行结果:

[Running] go run "../easy-tips/go/src/patterns/responsibility/responsibility-order-submit.go"
main.(*ArgumentsHandler).Do 校验参数成功...
main.(*AddressInfoHandler).Do 获取地址信息...
main.(*AddressInfoHandler).Do 地址信息校验...
main.(*CartInfoHandler).Do 获取购物车数据...
main.(*StockInfoHandler).Do 获取商品库存信息...
main.(*StockInfoHandler).Do 商品库存校验...
main.(*PromotionInfoHandler).Do 获取优惠信息...
main.(*ShipmentInfoHandler).Do 获取运费信息...
main.(*PromotionUseHandler).Do 使用优惠信息...
main.(*StockSubtractHandler).Do 扣库存...
main.(*CartDelHandler).Do 清理购物车...
main.(*DBTableOrderHandler).Do 写订单表...
main.(*DBTableOrderSkusHandler).Do 写订单商品表...
main.(*DBTableOrderPromotionsHandler).Do 写订单优惠信息表...
Success

结语

最后总结下,「责任链模式(改)」抽象过程的核心是:

  • 按职责划分:业务逻辑归类,收敛的过程。

  • 对象链:把收敛之后的业务对象构成对象链,依次被执行。

特别说明:
1. 我的代码没有`else`,只是一个在代码合理设计的情况下自然而然无限接近或者达到的结果,并不是一个硬性的目标,务必较真。
2. 本系列的一些设计模式的概念可能和原概念存在差异,因为会结合实际使用,取其精华,适当改变,灵活使用。

我的代码没有else系列 更多文章

 

点击阅读原文,查看源代码

焊缝缺陷智能检测:基于 YOLO 的工业质检系统实战 从焊缝缺陷数据集的构建到模型训练,从桌面检测界面到缺陷统计输出,本文覆盖了一套工业焊缝质检系统的完整路线。这个场景的核心难点在数据层面——气孔和裂纹这类小目标的标注质量直接决定了模型的最终表现。建议先在开源数据集上跑通全链路,确认 mAP 达到可接受的水平后,再通过补充特定类型的小目标数据和提升输入分辨率来做精度优化。工业场景中,漏检一个气孔的成本和误报一个假阳性的成本不一样——根据对两类成本的承受力,调整置信度阈值来找到业务上的最佳平衡点。 阅读详情

相关推荐

【深度学习】基于BERT模型的情感分析(附实战完整代码+数据集)

情感分类是一个快速发展的研究领域,尽管众多模型和数据集在二分类任务中显示出很高的准确性,但细粒度的情感分类任务仍然是一个很大改进空间的领域。分析SST-5数据集,Munikar等人的先前工作表明,嵌入工具BERT允许使用简单的模型来实现最新的准确性。

aaaa_hsjsueu的博客 2万+

关于链式调用

使用链式调用

2201_75837601的博客 2617

荔枝派Lichee Nano全志F1C100s烧录避坑指南:从Fel模式到SPI Flash完整流程

本文详细介绍了荔枝派Lichee Nano基于全志F1C100s芯片的SPI Flash烧录完整流程,从FEL模式进入技巧到定制化sunxi-tools编译,再到分区策略与实战烧录步骤。针对开发者常见的烧录程序问题提供了专业解决方案,帮助用户高效完成嵌入式系统部署。

tea88的博客 790

5 分钟解读 Python 中的链式调用

如果你是有打算从事有关数据分析或者数据挖掘的等数据科学领域的工作,或者和我一样目前就是从事相关领域的工作,那么「链式调用」对我们而言是一门必修课。为什么是链式调用?链式调用,或者也可以称...

Python中文社区 7649

攻防世界:Crypto习题之easy_RSA

在非对称加密算法中,单向函数被广泛应用,用于确保从公钥加密后的密文无法轻易推导出私钥,从而保证数据的安全性。而其中最著名的算法便是 RSA 加密算法。首先设φm:=∣1≤k≤mgcdkm1∣为欧拉函数(Euler’sche Phi-function)。pqn:=pqpqφnnpqpqφnp−1q−1e∈12...φn−1gcdφne1ended≡1φn假设我们现在有明文x以及公钥en。

qq_52789488的博客 1574

Freemarker整合poi导出带有图片的Excel教程

Freemarker整合poi导出带有图片的Excel教程 https://blog.youkuaiyun.com/x541211190/article/details/105675771根据此人博客可完成此功能,但原文中有一处错误需要纠正,当单元格合并时,计算起始单元格有错误。 源代码: /** * 构造合并单元格集合 * * @param createRowIndex: * @param cellRangeAddresses: * @param startIndex: * @param c

weixin_39403349的博客 1004

Python链式调用:优雅的编程风格

链式调用是一种通过连续调用对象的方法,使得代码可读性更强、结构更清晰的编程风格。在链式调用中,每个方法的返回值通常是一个包含了其他方法的对象,这样就可以在单一的表达式中完成多个操作。Python链式调用是一种优雅的编程风格,通过连续调用对象的方法,使得代码结构更清晰、可读性更强。本文通过构建链式调用的类、实际应用场景和数据处理示例,详细介绍了链式调用的基本概念、原理以及在实际项目中的应用。链式调用可以用于构建流畅的API、优雅的配置对象以及简化数据处理操作,是Python中一个强大且常用的编程技巧。

涛哥聊Python 1661

Unity Hololens2开发|(三)工程发布及真机部署(3种方法)

选择项目->属性,进入项目属性页,选择调试,将HoloLens2的IP地址填写至页面,如下图。确保HoloLens2与计算机在同一网络下,并保持开启状态,点击运行,即开始生成部署.注意:该方式不支持覆盖安装,如果重复安装同一个App,需要先卸载再安装!选择Release下的ARM64,选择远程计算机,如下图。

游戏开发小Y的博客 14万+

JavaScript链式调用

1、什么是链式调用? 这个很容易理解,例如 $('text’).setStyle('color', 'red').show(); 一般的函数调用和链式调用的区别:链式调用完方法后,return this返回当前调用方法的对象。 首先,我们先来看看一般函数的调用方式 (1)先创建一个简单的类 //创建一个bird类 function Bird(name) { ...

hsany330的专栏 6749

ABAP SQL Hierarchy 全景参考,组织树、分类树与递归查询在数据库层的优雅落地

ABAP SQL中的hierarchy语法为树形数据结构处理提供了高效方案。S/4HANA系统中常见的成本中心、利润中心、物料分类等树形结构,传统开发需通过递归和嵌套循环处理,而ABAP SQL hierarchies通过将层级遍历能力下沉到SQL层,借助SAP HANA的层级函数支持,实现了更高效的查询。 该功能要求ABAP 7.51+版本,支持两种实现方式:CDS hierarchy用于创建可复用的稳定层级模型,适合业务核心数据;ABAP SQL HIERARCHY generator则适用于临时性层级

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 315

ABAP 7.40 FOR 表达式与 REDUCE 构造运算符深度解析:从语法新特性到真实项目实践

ABAP 7.40引入了FOR和REDUCE表达式语法,使代码更简洁和函数式。FOR支持内表迭代和条件迭代,可配合VALUE构造新内表,替代传统LOOP。REDUCE用于归约运算,将多值折叠为单一结果,如求和、拼接等。这些新特性让ABAP更现代化,与SAP新架构协同更好,提升了开发效率和代码可读性。

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 321

链式调用的方式

链式调用是指在一个对象上连续调用多个方法,每个方法调用后返回的都是该对象本身,以便继续调用下一个方法。在实际开发中,如果我们需要对一个对象进行多个操作,使用链式调用可以让我们在一个语句中完成多个操作,从而提高代码的效率。在实际开发中,如果我们需要对一个对象进行多个操作,使用链式调用可以让我们根据需求选择需要调用的方法,从而增强代码的灵活性。在使用链式调用时,每个方法的返回值需要是该对象本身,以便下一个方法可以继续调用它。而在链式调用中,每个方法都需要返回该对象本身,以便下一个方法可以继续调用它。

gxdzi的博客 791

人工蜂群优化算法(ABC)详解:原理、实现与应用

人工蜂群算法(Artificial Bee Colony, ABC)是Karaboga于2005年提出的一种群体智能优化算法,其灵感来源于蜜蜂群体在自然界中高效的采蜜行为。该算法通过模拟雇佣蜂、观察蜂和侦察蜂三种角色的分工协作来寻找最优解。在ABC算法中,每个潜在的解决方案被视为一个“食物源”,其质量由适应度函数评估。雇佣蜂负责在已知优质食物源附近进行局部开采;观察蜂根据雇佣蜂分享的信息,以一定概率选择并跟进优质食物源;侦察蜂则随机探索新区域,防止种群陷入局部最优。

qq_42212808的博客 394

高级版的if-else语句----options链式调用

场景的难点在于,用户对象可能为空,用户的地址对象也可能为空。我们需要小心翼翼地检查每一层,否则就会遇到。

TaurusRui的博客 433

廖雪峰Python教程[完整版]

廖雪峰的python教程整理的,已经排好版了,而且还是完整的,适合小白

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox(带书签),MATLAB统计学习工具

链式调用和Lambda表达式在C语言中的应用

在编程世界中,我们经常会遇到需要执行一系列操作的情况。这些操作可能包括调用多个函数,或者根据不同的条件执行不同的代码块。在这种情况下,我们通常会使用if-else语句或者switch语句来实现。然而,当我们需要处理的条件和操作变得越来越复杂时,这种方式可能会导致代码变得难以理解和维护。为了解决这个问题,一些高级语言引入了链式调用(Method Chaining)和Lambda表达式(Lambda Expressions)这两种强大的编程技术。

m0_46359684的博客 415

android 蓝牙通讯demo

android 下蓝牙通讯demo,实现了发现蓝牙,使能蓝牙,通过蓝牙发送消息。

使用链式调用风格来增加C++代码的可阅读性

使用链式调用风格来增加C++代码的可阅读性

Leo的专栏 446

IEM模型,地表粗糙度模拟

利用微波反演土壤水分时候,利用IEM模型可以实现对随机地表的模拟

JavaScript链式调用实例浅析

本文实例分析了JavaScript链式调用。分享给大家供大家参考,具体如下: 对$函数你已经很熟悉了。它通常返回一个html元素或一个html元素的集合,如下: function$(){ var elements = []; for(vari=0,len=arguments.length;i&lt;len;++i){ v...

weixin_33675507的博客 90

ErrorOr高级用法:掌握Then、FailIf、Else等核心方法的实战应用

ErrorOr是一个简单而流畅的错误处理库,它通过区分联合类型(discriminated union)优雅地处理成功结果和错误信息。本文将深入探讨ErrorOr中Then、FailIf、Else等核心方法的高级用法,帮助开发者构建更健壮、更易维护的错误处理逻辑。 [![ErrorOr库Logo](https://raw.gitcode.com/gh_mirrors/er/error-or/ra

gitblog_00026的博客 858

Fn 函数环境变量配置实战:用 func.yaml 声明必选与可选变量(Go 示例)

本教程围绕 Fn 开源无服务器平台中 `func.yaml` 的 `expects.config` 配置机制展开,通过 `examples/inputs` 目录下的 Go 函数示例,完整演示如何在本地与云端声明、注入必选(required)与可选环境变量,以及缺失时 Fn 的校验行为。读完本文,你将掌握 `fn run` 的本地调试流程、`-e` 传参方式、`expects` 配置写法,并能在自己

gitblog_00376的博客 992

链式调用,当一个逻辑执行完成后,继续向下执行另一个逻辑

链式调用,当一个逻辑执行完成后,继续向下执行另一个逻辑 使用场景: 如跳转第三方App,优先使用A方式,当A方式失败后,则使用B方式;若B方式也失败则使用C方式,等等… 实现步骤: 构造公共抽象父类 Jump.java Jump是父类,提供成功、失败回调设置;启动跳转start方法,都为final,子类不可覆盖。 jump为抽象方法,子类必须实现。 父类提供方法框架,跳转失败后,尝试使用下一种方式跳转(next),具体逻辑子类各自实现。 public abstract class Jump {

a day a better 605

如何消除if...else代码块

前言最近在做代码重构,发现了很多代码的烂味道。其他的不多说,今天主要说说那些又臭又长的if...else要如何重构。在介绍更更优雅的编程之前,让我们一起回顾一下,不好的if...else代...

IT技术精选文摘 446

如何解决代码中if…else 过多的问题,含BATJM大厂

介绍 通过 Java 注解(或其它语言的类似机制)定义执行某个方法的条件。在程序执行时,通过对比入参与注解中定义的条件是否匹配,再决定是否调用此方法。具体实现时,可以采用表驱动或职责链的方式实现。 适用场景 适合条件分支很多多,对程序扩展性和易用性均有较高要求的场景。通常是某个系统中经常遇到新需求的核心功能。 实现与示例 很多框架中都能看到这种模式的使用,比如常见的 Spring MVC。因为这些框架很常用,demo 随处可见,所以这里不再上具体的演示代码了。 这个模式的重点在于实现。现有的框架都是用于实现

m0_65322636的博客 650

如何解决代码中if…else 过多的问题,kotlin常量

适用场景 适合条件分支很多多,对程序扩展性和易用性均有较高要求的场景。通常是某个系统中经常遇到新需求的核心功能。 实现与示例 很多框架中都能看到这种模式的使用,比如常见的 Spring MVC。因为这些框架很常用,demo 随处可见,所以这里不再上具体的演示代码了。 这个模式的重点在于实现。现有的框架都是用于实现某一特定领域的功能,例如 MVC。故业务系统如采用此模式需自行实现相关核心功能。主要会涉及反射、职责链等技术。具体的实现这里就不做演示了。 方法四:事件驱动 介绍 通过关联不同的事件类型和对应的处理

m0_65322636的博客 525

如何优雅规范编写Java代码

else并不会降低代码的复杂度,相反比较少见的写法可能会增加认知负荷,从而进一步增加了复杂度。else是为了对代码进行解耦合,方便扩展代码,最终方便对代码的维护。思路:定义一个注解,将需要校验的参数对象都标注该注解,利用SpringAOP,拦截该注解,将其中标注的参数取出,最后通过BeanValidator进行校验。是因为通常在编码过程中我们不只自己进行开发,通常需要一个团队来进行,开发好之后还需要维护,所以编码规范就显的尤为重要。代码维护时间比较长,那么保证代码可读性就显得很重要。

努力分享一些干货 1401

JDK8简化if-else

简化if-else 1234567891011 User user = ...if (user != null) { String userName = user.getUserName(); if (userName != null) { return userName.toUpperCase(); } else { return nul...

weixin_34417814的博客 3325

Python if-else 工程化实践:从语法糖到健壮代码设计

if-else 是编程中最基础的控制结构,其本质是基于布尔表达式的分支决策机制。理解其执行原理(短路求值、条件顺序匹配、Falsy值隐式转换)是写出可靠代码的前提。在工程实践中,if-else 的技术价值远超流程控制——它承担着错误隔离、关注点分离、状态路由与防御性编程等关键职责。典型应用场景包括API请求校验(卫语句)、多源配置加载(优先级链)、业务状态流转(字典驱动状态机)和数据验证管道(可插拔校验链)。本文聚焦Python开发者真实高频痛点,如None与Falsy混淆、elif顺序陷阱、嵌套可读性崩塌

culh2177的博客 688
上一篇: 代码模板 | 我的代码没有else
下一篇: 代码组件 | 我的代码没有else
TIGERB_Blog
博客等级 码龄10年 109粉丝 65原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值