设计原则和设计模式

设计模式和设计原则的关系

软件唯一不变的就是变化。设计原则的核心目的就一个:当需求变了,你的代码改动范围尽可能小、尽可能安全。设计原则就是开啊过程中,针对这些变化我们编码所遵循的准则。如果将设计原则比作交通规则(不酒驾、不超速),那么设计模式就是驾驶的技巧(并线打灯、坡道起步等等)。设计模式是这些思想在具体场景下的 “标准答案”。原则告诉你 “往哪个方向走”,模式告诉你 “具体怎么走”。模式告诉你具体场景下怎么做(方法论)。


常见的设计原则

SOLID

S:单一职责,一个类只干一件事,一个类只为一个理由而修改。
O:开闭原则,对扩展开放,对修改关闭(面向抽象进行构建,使用实现扩展细节)。
L:里氏替换,子类能替换父类而不出问题,子类不能让调用方的假设失效。

1
2
3
4
# 子类不能比父类"更严格"或"更弱",否则替换会炸。
## 比如 abstract class Bird 有 fly 的抽象方法,鸵鸟 Ostrich 不会飞,直接 extends Bird 是不合适的。
## 合理的设计就应该是把 fly 定义在 abstract class FlyingBird extends Bird 中,
## 然后不会飞的鸵鸟 Ostrich extends Bird,而会飞的麻雀 Sparrow extends FlyingBird。

I:接口细分和隔离,别逼别人依赖用不到的接口。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// ❎ 违反:一个巨型接口
interface Worker {
void code();
void test();
void deploy();
}
class Developer implements Worker {
public void code() { ... }
public void test() { ... }
public void deploy() { throw new UnsupportedOperationException(); }
// Developer 被迫实现 deploy,但它不负责部署
}

// ✅ 拆小
interface Coder { void code(); }
interface Tester { void test(); }
interface Deployer { void deploy(); }
class Developer implements Coder, Tester { ... }

D:依赖倒置,针对接口进行编程,具体类怎么变都伤不到你。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// ❎ 违反:高层直接依赖低层具体类
class OrderService {
MySQLRepository repo = new MySQLRepository(); // 写死了
// 换 Oracle?改这行代码 → 高层被低层绑架
}

// ✅ 依赖抽象
interface Repository { void save(Order o); }
class MySQLRepository implements Repository { ... }
class OracleRepository implements Repository { ... }

class OrderService {
Repository repo; // 构造时注入
OrderService(Repository repo) { this.repo = repo; }
// 换数据库?传不同的实现进来,OrderService 一行不改
}


DRY、KISS、LoD

还有其他常用的:

DRY(Don’t Repeat Yourself):别写重复代码。一句话说清就是系统中每一块知识,都应该有唯一、明确、权威的表示(注意关键词是知识,不是代码行)。很多人以为 DRY 就是”别复制粘贴代码”,这只是最表面的理解,DRY 的深层含义是 ”知识只存一份”,对于需求修改只需要修改唯一的知识即可。DRY 的核心目的就一个:改一处就能生效,不用到处找。

1
2
3
4
5
6
7
8
9
// 订单模块
if (user.getVipLevel() >= 3 && user.getPoints() > 1000) {
// 发优惠券
}

// 推荐模块
if (customer.getLevel() >= 3 && customer.getScore() > 1000) {
// 推荐高价商品
}

代码不一样,但什么是高价值用户这个知识重复了。哪天规则变成”等级≥2 且积分>500”,你要改两个地方。

1
2
3
4
5
// 正确做法:
// 两处都调这个方法。知识只有一份。
boolean isHighValueUser(User user) {
return user.getVipLevel() >= 3 && user.getPoints() > 1000;
}

KISS(Keep It Simple, Stupid):简单直接好过复杂精巧。Stupid 不是骂人,而是在提醒你别自作聪明。程序员有个通病——尤其是有几年经验之后——喜欢炫技:明明一个 for 循环能解决,非要写个 Stream + Lambda + 自定义 Collector;明明直接查数据库就行,非要上缓存、消息队列、分布式锁;明明 if-else 清清楚楚,非要抽象出三层工厂+策略+注解驱动。
KISS 在说:你的聪明应该用在 “把复杂问题想清楚”,而不是 “把简单问题搞复杂”。在实际中 KISS 和 DRY 经常打架。DRY 说抽成公共方法,别重复;KISS 说别为了省两行代码搞出三层抽象。那怎么权衡呢?——先 KISS,等重复真的痛了再 DRY。不要一开始就抽象。等你发现同一段逻辑真的在三个地方出现了,再抽。这就是三次法则(Rule of Three):第一次写不管,第二次复制粘贴,第三次才抽公共方法。

LoD(Law of Demeter):迪米特法则,对象只和直接朋友说话,不和陌生人说话(朋友指的是输入输出参数、方法内参数、以及成员变量)。他还有一个更通俗的名字——最小知识原则,通俗讲就是别扒别人内裤看口袋,告诉他你要啥,让他自己去办。落地时用的模式往往是:门面(Facade)、中介(Mediator)、委托方法、封装 getter —— 这些是模式,LoD 是它们背后的理由。

1
2
// 经典反例(火车事故 train wreck)
String zip = order.getCustomer().getAddress().getZipCode();

OrderProcessor 本来只该认识 Order,结果它顺藤摸瓜知道了:Order 里有 Customer,Customer 里有 Address,Address 里有 zipCode,哪天 Customer 改成支持多个地址(getAddresses()),这行直接崩。正确的调用方式:

1
2
3
// Order 内部自己去找 customer / address
// 调用方只和 Order 说话,Order 内部结构怎么变它都不关心。
String zip = order.getShippingZipCode();


常见的设计模式

设计模式是前人总结的、在特定场景下解决特定问题的可复用方案(套路)。GoF(Gang of Four)的 23 种模式通常分三类:

  • 创建型(5 种):解决对象怎么创建的问题,把创建过程和使用过程解耦。
    • 单例(Singleton):一个类全局只有一个实例
    • 工厂方法(Factory Method):子类决定创建哪种具体对象
    • 抽象工厂(Abstract Factory):创建一组相关或依赖的对象家族
    • 建造者(Builder):一步步构建复杂对象,分离构建和表示
    • 原型(Prototype):通过复制已有对象来创建新对象
  • 结构型(7 种):解决类和对象怎么组合成更大的结构的问题,让结构更灵活、更易扩展。
    • 适配器(Adapter):把一个接口转成另一个接口,让不兼容的类能一起工作
    • 桥接(Bridge):把抽象和实现分离,让它们可以独立变化
    • 组合(Composite):用树形结构表示”部分-整体”层次,统一对待单个对象和组合对象
    • 装饰器(Decorator):动态给对象加功能,比继承更灵活
    • 外观(Facade):给复杂子系统提供一个统一入口(门面)
    • 享元(Flyweight):共享大量细粒度对象,减少内存占用
    • 代理(Proxy):给对象加一个代理层,控制对它的访问
  • 行为型(11 种):解决对象之间怎么通信、怎么协作、怎么分配职责的问题。
    • 责任链(Chain of Responsibility):请求沿着链条传递,直到有人处理它
    • 命令(Command):把请求封装成对象,支持撤销、队列、日志
    • 解释器(Interpreter):定义语言的文法,并解释执行
    • 迭代器(Iterator):提供统一的方式遍历集合,不暴露内部结构
    • 中介者(Mediator):用一个中介对象封装一组对象的交互,减少耦合
    • 备忘录(Memento):在不暴露内部状态的前提下,保存和恢复对象之前的状态
    • 观察者(Observer):一个对象状态变了,所有依赖它的对象自动收到通知
    • 状态机(State):对象内部状态改变时,行为跟着改变
    • 策略(Strategy):封装一组算法,让它们可以互相替换
    • 模板方法(Template Method):父类定义算法骨架,子类实现某些步骤
    • 访问者(Visitor):在不改类的前提下,给一组对象加新操作

模式不是代码,是思想的模板。它通常包含:

  • 场景:什么时候用
  • 结构:类之间怎么组织
  • 效果:好处和代价

举个例子:如策略模式

1
2
3
4
5
// 不用模式:if-else 堆在一起
if (type == "支付宝") { ... }
else if (type == "微信") { ... }
else if (type == "银行卡") { ... }
// 加一种支付方式?改这个类 → 违反开闭原则
1
2
3
4
5
6
7
8
9
10
11
// 策略模式:每种支付方式是一个类,实现统一接口
interface PaymentStrategy {
void pay(int amount);
}
class AliPay implements PaymentStrategy { ... }
class WeChatPay implements PaymentStrategy { ... }
class CardPay implements PaymentStrategy { ... }

// 使用时
PaymentStrategy strategy = strategyMap.get(type);
strategy.pay(amount);

这里的策略模式为什么好?因为它体现了:

  • 单一职责:每种支付方式自己管自己的逻辑
  • 开闭原则:加新支付方式只需加一个新类,不改旧代码
  • 依赖倒置:高层代码依赖 PaymentStrategy 接口,不依赖具体实现

很多程序员,写了多年的代码,还是对写代码没有感觉,关键就是没有吃透设计原则和模式。对编程有感觉或者说 ”开窍“。我觉得设计原则和模式就是开窍的关键转折点:写代码的前几年,你在学 “怎么让代码跑起来”,开窍之后,你会想 “怎么让代码在半年后、别人改需求时,还能活下来”。


Spring Boot 日志管理

说说日志框架的起源及现状

比如说,公司中张三要开发一个大型系统,需要打印日志的功能,他的日志完善的过程如下:

  1. System.out.println(“xxx”), 将关键数据打印在控制台;新增和去除一行日志的打印很麻烦;
  2. 使用自己写的日志框架来记录系统的一些关键信息,zhangsan-logging.jar;
  3. 接着他又把之前写的日志jar包加了几个高大上的功能,如异步模式、自动归档等,zhangsan-logging-good.jar;
  4. 公司又需要搭建新的系统,跟之前用的API不一样,张三需要给新的系统重新换上新的日志功能的实现包,zhangsan-logging-better.jar;
  5. 张三突然想到了jdbc与数据库驱动的设计方式,他写了一个统一的接口层(日志功能的一个抽象层logging-abstract.jar),然后他要做的就是给项目中导入具体的日志实现就可以了,张三之前写的日志框架都是实现的日志抽象接口;

Java 并发基础(五)

LockSupport 工具类

LockSupport 是个基础工具类,它的主要作用是挂起和唤醒线程, 该工具类是创建锁和其他同步类的实现基础。

LockSupport 类与每个使用它的线程都会关联一个许可证,在默认情况下调用 LockSupport 类的方法的线程是不持有许可证的。LockSupport 是使用 Unsafe 类实现的, 下面介绍 LockSupport 中的几个主要函数。