一、Java开发模式有哪几种?——设计模式全景概览
在Java软件开发领域,设计模式是开发者应对复杂系统设计问题的成熟解决方案集合。设计模式并非具体代码实现,而是一种可复用的、经过实践验证的架构思想与组织方式。掌握设计模式有助于提升代码可读性、可维护性与扩展性,是区分初级与高级Java开发者的分水岭。
根据《设计模式:可复用面向对象软件的基础》(GoF)一书的经典分类,设计模式分为三大类共23种:
- 创建型模式(5种):关注对象创建机制,解决“如何创建对象”的问题,使系统独立于对象创建、组合和表示
- 结构型模式(7种):处理类与对象的组合,形成更大结构,简化设计
- 行为型模式(11种):关注对象之间的通信与职责分配,明确对象如何协作完成任务
随着Java生态持续演进,现代开发中还衍生出更多适应微服务、响应式编程、函数式编程的新模式与模式变体。本文将系统梳理主流设计模式,结合真实开发场景,提供可落地的实践指南。
值得注意的是,设计模式不是银弹。滥用模式反而会增加系统复杂度。正确的做法是:在明确问题背景、团队技术栈、系统生命周期阶段后,选择最匹配的模式。例如:单例模式适用于资源管理器、日志服务等全局唯一对象场景;而工厂模式则适合对象创建逻辑复杂、需解耦客户端与具体实现的场景。
二、创建型设计模式详解(5种核心模式)
创建型模式的核心目标是将对象的创建与使用分离,降低系统耦合度,提高灵活性。以下五种模式各具特色,适用于不同场景:
① 单例模式(Singleton)
确保某个类只有一个实例,并提供全局访问点。常用于配置管理、线程池、缓存、日志对象等场景。
典型实现方式:
- 饿汉式:类加载时即创建实例,线程安全但可能造成资源浪费
- 懒汉式:首次调用时创建,需解决线程安全问题(如双重检查锁定)
- 静态内部类:利用JVM类加载机制保证线程安全,延迟加载,推荐方式
- 枚举实现:最简洁安全的方式,防止反射与反序列化破坏单例
代码示例(静态内部类):
public class ConfigManager {
private ConfigManager() {}
private static class Holder {
private static final ConfigManager INSTANCE = new ConfigManager();
}
public static ConfigManager getInstance() {
return Holder.INSTANCE;
}
public String getProperty(String key) {
return properties.get(key);
}
}
适用场景:Spring容器中的Bean(默认单例)、数据库连接池、应用配置中心。但需警惕单例滥用导致状态污染与测试困难问题。
② 工厂方法模式(Factory Method)
定义一个创建对象的接口,但由子类决定实例化哪个类。将对象创建延迟到子类,实现创建与使用的解耦。
核心角色:
- Product:产品接口
- ConcreteProduct:具体产品实现
- Creator:抽象工厂
- ConcreteCreator:具体工厂
代码示例(日志系统):
interface Logger {
void log(String message);
}
class FileLogger implements Logger {
public void log(String msg) { }
}
class ConsoleLogger implements Logger {
public void log(String msg) { System.out.println(msg); }
}
interface LoggerFactory {
Logger createLogger();
}
class FileLoggerFactory implements LoggerFactory {
public Logger createLogger() { return new FileLogger(); }
}
class ConsoleLoggerFactory implements LoggerFactory {
public Logger createLogger() { return new ConsoleLogger(); }
}
// 客户端代码
LoggerFactory factory = new FileLoggerFactory();
Logger logger = factory.createLogger();
logger.log("系统启动");
优势:新增日志类型(如DatabaseLogger)时,只需新增实现类与工厂类,无需修改客户端代码,符合开闭原则。
③ 抽象工厂模式(Abstract Factory)
提供一个创建一系列相关或相互依赖对象的接口,而无需指定具体类。适用于多产品族的场景,如UI主题切换(Windows风格 vs macOS风格)。
与工厂方法区别:工厂方法针对单一产品等级结构;抽象工厂针对多个产品等级结构组成的产品族。
典型应用:Java Swing的UI委托机制、Spring Framework中BeanFactory的多种实现(如DefaultListableBeanFactory、XmlBeanFactory)。
④ 建造者模式(Builder)
将复杂对象的构建与其表示分离,使得同样的构建过程可以创建不同的表示。特别适用于具有多个可选参数的对象创建。
经典案例:StringBuilder、Guava的ImmutableList.Builder、MyBatis的SqlSessionFactoryBuilder。
代码示例(订单构建):
public class Order {
private String userId;
private String productId;
private int quantity;
private String deliveryAddress;
private String note;
private Order(Builder builder) {
this.userId = builder.userId;
this.productId = builder.productId;
this.quantity = builder.quantity;
this.deliveryAddress = builder.address;
this.note = builder.note;
}
public static class Builder {
private String userId;
private String productId;
private int quantity = 1;
private String address;
private String note;
public Builder userId(String uid) { this.userId = uid; return this; }
public Builder productId(String pid) { this.productId = pid; return this; }
public Builder quantity(int q) { this.quantity = q; return this; }
public Builder address(String addr) { this.address = addr; return this; }
public Builder note(String n) { this.note = n; return this; }
public Order build() {
if (userId == null || productId == null) throw new IllegalStateException("必需参数缺失");
return new Order(this);
}
}
}
// 使用
Order order = new Order.Builder()
.userId("U1001")
.productId("P2002")
.quantity(3)
.address("北京市朝阳区")
.note("请快递发货")
.build();
优势:避免构造函数参数爆炸;参数设置清晰可读;支持链式调用。
⑤ 原型模式(Prototype)
通过复制现有对象创建新对象,适用于对象创建成本高或结构复杂的情况。Java中通过实现Cloneable接口并重写clone()方法实现。
浅克隆 vs 深克隆:
- 浅克隆:只复制对象本身,引用类型字段仍共享
- 深克隆:递归复制所有层级对象,完全独立
代码示例(深克隆):
class Address implements Cloneable {
String city;
Address(String c) { city = c; }
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
class User implements Cloneable {
String name;
Address address;
User(String n, String c) { name = n; address = new Address(c); }
protected Object clone() throws CloneNotSupportedException {
User u = (User) super.clone();
u.address = (Address) address.clone();
return u;
}
}
// 使用
User u1 = new User("张三", "成都");
User u2 = (User) u1.clone();
u2.address.city = "北京";
System.out.println(u1.address.city); // 输出:成都(深克隆成功)
应用场景:游戏对象复制(如敌人生成)、配置模板克隆、复杂对象初始化优化。
三、结构型设计模式详解(7种组合策略)
结构型模式关注如何组合类和对象以形成更大结构,强调继承与组合的合理运用,提升系统灵活性。
① 适配器模式(Adapter)
将一个类的接口转换成客户期望的另一个接口,使原本不兼容的类可以协同工作。分为类适配器(继承)与对象适配器(组合)。
典型场景:
- Java IO流中的InputStreamReader(字节流→字符流)
- MyBatis中TypeHandler接口适配不同数据库类型
- Spring MVC中HandlerAdapter适配不同类型的Controller
代码示例(电源适配器):
interface EuropeanSocket {
void providePower220V();
}
class ChineseSocket {
public void providePower220V() { System.out.println("中国插座:220V交流电"); }
}
class SocketAdapter implements EuropeanSocket {
private ChineseSocket socket;
SocketAdapter(ChineseSocket s) { socket = s; }
public void providePower220V() {
System.out.println("适配器转换:");
socket.providePower220V();
}
}
// 使用
ChineseSocket cs = new ChineseSocket();
EuropeanSocket es = new SocketAdapter(cs);
es.providePower220V();
② 装饰者模式(Decorator)
动态地给对象添加额外职责,比生成子类更灵活。核心是“对象包装”,保持接口一致性。
经典案例:Java IO流(BufferedInputStream包装FileInputStream)、Servlet Filter链、Spring AOP代理链。
优势:避免类爆炸;支持运行时动态扩展;符合开闭原则。
代码示例(咖啡加料):
interface Coffee {
String getDescription();
double getCost();
}
class SimpleCoffee implements Coffee {
public String getDescription() { return "美式咖啡"; }
public double getCost() { return 15.0; }
}
abstract class CoffeeDecorator implements Coffee {
protected Coffee decoratedCoffee;
CoffeeDecorator(Coffee c) { decoratedCoffee = c; }
}
class MilkDecorator extends CoffeeDecorator {
MilkDecorator(Coffee c) { super(c); }
public String getDescription() { return decoratedCoffee.getDescription() + ", 加牛奶"; }
public double getCost() { return decoratedCoffee.getCost() + 3.0; }
}
// 使用
Coffee coffee = new MilkDecorator(new SimpleCoffee());
System.out.println(coffee.getDescription()); // 美式咖啡, 加牛奶
System.out.println(coffee.getCost()); // 18.0
③ 代理模式(Proxy)
为其他对象提供一种代理以控制对这个对象的访问。分为静态代理、JDK动态代理、CGLIB代理。
常见类型:
- 远程代理:RMI中的Stub/Skeleton
- 虚拟代理:延迟加载(如Hibernate的延迟关联)
- 保护代理:权限控制(如Spring Security)
- 智能代理:增强功能(如Spring AOP日志、事务)
JDK动态代理示例:
interface UserService {
void addUser(String name);
}
class UserServiceImpl implements UserService {
public void addUser(String name) { System.out.println("添加用户:" + name); }
}
class LoggingProxy implements InvocationHandler {
private Object target;
LoggingProxy(Object t) { target = t; }
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("【日志】调用方法:" + method.getName());
return method.invoke(target, args);
}
}
// 使用
UserService real = new UserServiceImpl();
UserService proxy = (UserService) Proxy.newProxyInstance(
real.getClass().getClassLoader(),
real.getClass().getInterfaces(),
new LoggingProxy(real)
);
proxy.addUser("李四");
④ 适配器模式(Adapter)
将一个类的接口转换成客户期望的另一个接口,使原本不兼容的类可以协同工作。分为类适配器(继承)与对象适配器(组合)。
典型场景:
- Java IO流中的InputStreamReader(字节流→字符流)
- MyBatis中TypeHandler接口适配不同数据库类型
- Spring MVC中HandlerAdapter适配不同类型的Controller
⑤ 桥接模式(Bridge)
将抽象部分与实现部分分离,使它们可以独立变化。通过组合替代继承,降低类的耦合度。
核心思想:抽象与实现解耦,支持独立扩展。
应用场景:JDBC驱动模型(Driver接口与各厂商实现)、图形渲染系统(形状与颜色分离)。
⑥ 组合模式(Composite)
将对象组合成树形结构以表示“部分-整体”的层次结构。客户端对单个对象和组合对象的使用具有一致性。
典型应用:文件系统(文件/文件夹)、GUI组件(容器与组件)、XML DOM树。
代码示例(菜单系统):
abstract class MenuComponent {
String name;
abstract void add(MenuComponent c);
abstract void remove(MenuComponent c);
abstract void display();
}
class MenuItem extends MenuComponent {
MenuItem(String n) { name = n; }
void add(MenuComponent c) { throw new UnsupportedOperationException(); }
void remove(MenuComponent c) { throw new UnsupportedOperationException(); }
void display() { System.out.println("菜单项:" + name); }
}
class Menu extends MenuComponent {
List children = new ArrayList<>();
Menu(String n) { name = n; }
void add(MenuComponent c) { children.add(c); }
void remove(MenuComponent c) { children.remove(c); }
void display() {
System.out.println("菜单:" + name);
for (MenuComponent child : children) child.display();
}
}
// 使用
Menu root = new Menu("主菜单");
Menu file = new Menu("文件");
file.add(new MenuItem("新建"));
file.add(new MenuItem("打开"));
root.add(file);
root.display();
⑦ 享元模式(Flyweight)
运用共享技术有效支持大量细粒度对象。通过缓存共享对象减少内存占用。
核心要素:内部状态(共享)与外部状态(非共享)分离。
Java典型应用:String常量池、Integer缓存(-128~127)、线程池中的线程复用。
代码示例(围棋棋子):
class ChessPiece {
private String color; // 内部状态
ChessPiece(String c) { color = c; }
public String getColor() { return color; }
}
class ChessPieceFactory {
private static Map pieces = new HashMap<>();
static ChessPiece getPiece(String color) {
if (!pieces.containsKey(color)) {
pieces.put(color, new ChessPiece(color));
}
return pieces.get(color);
}
}
// 使用
ChessPiece black1 = ChessPieceFactory.getPiece("黑");
ChessPiece black2 = ChessPieceFactory.getPiece("黑");
System.out.println(black1 == black2); // true(共享同一实例)
四、行为型设计模式详解(11种协作模式)
行为型模式关注对象之间的通信与职责分配,明确对象如何协作完成任务,提升系统灵活性与可维护性。
① 责任链模式(Chain of Responsibility)
将请求的发送者与接收者解耦,使多个对象都有机会处理请求。形成一条处理链,请求沿链传递直至被处理。
典型应用:Java Servlet Filter链、Spring Interceptor链、MyBatis Plugin机制、Tomcat Pipeline。
代码示例(请假审批):
abstract class Handler {
protected Handler next;
public void setNext(Handler h) { next = h; }
public abstract void handleRequest(int days);
}
class TeamLeader extends Handler {
public void handleRequest(int days) {
if (days <= 3) {
System.out.println("组长批准:" + days + "天请假");
} else if (next != null) {
next.handleRequest(days);
}
}
}
class Manager extends Handler {
public void handleRequest(int days) {
if (days <= 7) {
System.out.println("经理批准:" + days + "天请假");
} else if (next != null) {
next.handleRequest(days);
}
}
}
// 使用
TeamLeader tl = new TeamLeader();
Manager mgr = new Manager();
tl.setNext(mgr);
tl.handleRequest(5); // 经理批准:5天请假
② 命令模式(Command)
将请求封装为对象,从而可用不同请求对客户进行参数化、队列化或记录日志。
核心角色:Command接口、ConcreteCommand、Receiver(接收者)、Invoker(调用者)。
典型应用:GUI事件处理(ActionListener)、数据库事务、RPC调用封装。
代码示例(宏命令):
interface Command {
void execute();
}
class LightOnCommand implements Command {
private Light light;
LightOnCommand(Light l) { light = l; }
public void execute() { light.on(); }
}
class MacroCommand implements Command {
List commands = new ArrayList<>();
public void add(Command c) { commands.add(c); }
public void execute() {
for (Command cmd : commands) cmd.execute();
}
}
// 使用
Light light = new Light();
Command on = new LightOnCommand(light);
Command off = new LightOffCommand(light);
Command macro = new MacroCommand();
macro.add(on);
macro.add(off);
macro.execute(); // 先开灯再关灯
③ 解释器模式(Interpreter)
定义语言的文法表示,并定义一个解释器,该解释器使用该表示来解释语言中的句子。适用于简单语言解析场景。
典型应用:正则表达式引擎、SQL解析器(如Druid)、表达式求值(如SpEL)。
示例(布尔表达式):
interface Expression {
boolean interpret(String context);
}
class TerminalExpression implements Expression {
private String data;
TerminalExpression(String d) { data = d; }
public boolean interpret(String context) {
return context.contains(data);
}
}
class OrExpression implements Expression {
private Expression expr1, expr2;
OrExpression(Expression e1, Expression e2) { expr1 = e1; expr2 = e2; }
public boolean interpret(String context) {
return expr1.interpret(context) || expr2.interpret(context);
}
}
// 使用
Expression andExpr = new AndExpression(
new TerminalExpression("Java"),
new TerminalExpression("开发")
);
System.out.println(andExpr.interpret("Java开发模式")); // true
④ 迭代器模式(Iterator)
提供一种方法顺序访问聚合对象中的元素,而不暴露其底层表示。
Java内置支持:Iterable接口与Iterator接口,foreach循环底层实现。
自定义示例:
interface MyIterator {
boolean hasNext();
Object next();
}
class MyList {
private List
⑤ 中介者模式(Mediator)
用一个中介对象来封装一系列对象之间的交互,减少对象间的耦合。
典型应用:聊天室系统、MVC中的Controller、Spring事件机制。
⑥ 备忘录模式(Memento)
在不破坏封装性的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态。
应用场景:撤销操作(Undo/Redo)、数据库事务回滚、游戏存档。
⑦ 观察者模式(Observer)
定义对象间的一种一对多依赖关系,当一个对象状态改变时,所有依赖它的对象都得到通知并自动更新。
Java内置支持:java.util.Observer与Observable(已过时,建议用List替代)。
现代实现(Java 8 Lambda):
class Subject {
private List> observers = new ArrayList<>();
public void attach(Consumer obs) { observers.add(obs); }
public void notifyObservers(String msg) {
observers.forEach(obs -> obs.accept(msg));
}
}
// 使用
Subject sub = new Subject();
sub.attach(msg -> System.out.println("接收者1:" + msg));
sub.attach(msg -> System.out.println("接收者2:" + msg));
sub.notifyObservers("系统更新!");
Spring应用:ApplicationEvent与ApplicationListener、@EventListener注解。
⑧ 状态模式(State)
允许一个对象在其内部状态改变时改变其行为。对象看起来似乎修改了其类。
典型场景:订单状态流转(待支付→已支付→已发货→已完成)、工作流引擎。
代码示例(电梯状态):
interface LiftState {
void open();
void close();
void run();
void stop();
}
class OpeningState implements LiftState {
public void open() { System.out.println("门已打开"); }
public void close() { System.out.println("门正在关闭..."); }
public void run() { }
public void stop() { }
}
class RunningState implements LiftState {
public void open() { }
public void close() { }
public void run() { System.out.println("电梯运行中..."); }
public void stop() { System.out.println("电梯停止"); }
}
class LiftContext {
private LiftState state;
public void setState(LiftState s) { state = s; }
public void open() { state.open(); }
// ...
}
⑨ 策略模式(Strategy)
定义一系列算法,将每个算法封装起来,并使它们可以互换。策略模式让算法独立于使用它的客户而变化。
典型应用:Java Comparator接口(排序策略)、Spring Security认证策略、支付渠道选择。
代码示例(支付系统):
interface PaymentStrategy {
void pay(double amount);
}
class WechatPay implements PaymentStrategy {
public void pay(double amount) {
System.out.println("微信支付:" + amount + "元");
}
}
class Alipay implements PaymentStrategy {
public void pay(double amount) {
System.out.println("支付宝支付:" + amount + "元");
}
}
class ShoppingCart {
private PaymentStrategy strategy;
public void setStrategy(PaymentStrategy s) { strategy = s; }
public void checkout(double amount) {
strategy.pay(amount);
}
}
// 使用
ShoppingCart cart = new ShoppingCart();
cart.setStrategy(new Alipay());
cart.checkout(199.0); // 支付宝支付:199.0元
⑩ 模板方法模式(Template Method)
定义一个操作中的算法骨架,而将一些步骤延迟到子类中。模板方法使得子类可以不改变算法结构即可重定义该算法的某些特定步骤。
典型应用:JDBC连接管理、Spring JdbcTemplate、Servlet生命周期。
代码示例(泡茶 vs 泡咖啡):
abstract class Beverage {
final void prepareRecipe() {
boilWater();
brew();
pourInCup();
addCondiments();
}
abstract void brew();
abstract void addCondiments();
void boilWater() { System.out.println("烧水"); }
void pourInCup() { System.out.println("倒入杯中"); }
}
class Tea extends Beverage {
void brew() { System.out.println("冲泡茶叶"); }
void addCondiments() { System.out.println("加柠檬"); }
}
class Coffee extends Beverage {
void brew() { System.out.println("冲泡咖啡粉"); }
void addCondiments() { System.out.println("加牛奶"); }
}
⑪ 访问者模式(Visitor)
表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素类的前提下定义作用于这些元素的新操作。
典型场景:编译器AST遍历、报表生成(不同格式)、ORM框架元数据处理。
适用条件:对象结构稳定,但操作经常变化。