创建型模式 - 标签 - 咔咔不太卡的博客https://ksmaple.github.io/tags/%E5%88%9B%E5%BB%BA%E5%9E%8B%E6%A8%A1%E5%BC%8F/创建型模式 - 标签 - 咔咔不太卡的博客Hugo -- gohugo.iozh-CNSun, 12 Apr 2026 12:30:00 +0800原型模式 (Prototype Pattern)https://ksmaple.github.io/posts/prototype-pattern/Sun, 12 Apr 2026 12:30:00 +0800咔咔https://ksmaple.github.io/posts/prototype-pattern/

概述

原型模式是一种创建型设计模式，它允许通过复制现有对象来创建新对象，而不是从头开始创建。

适用场景

  • 对象创建成本高（需要复杂计算或数据库操作）
  • 需要创建与现有对象相似的对象
  • 运行时动态决定创建哪种对象

基础实现

实现 Cloneable 接口

// 原型接口
public interface Prototype extends Cloneable {
    Prototype clone();
}

// 具体原型类
public class Document implements Cloneable {
    private String title;
    private String content;
    private List<String> tags;
    
    public Document(String title, String content, List<String> tags) {
        this.title = title;
        this.content = content;
        this.tags = tags;
    }
    
    // 浅拷贝
    @Override
    public Document clone() {
        try {
            return (Document) super.clone();
        } catch (CloneNotSupportedException e) {
            throw new RuntimeException(e);
        }
    }
    
    // Getters and Setters...
}

// 使用
Document template = new Document("模板", "内容", Arrays.asList("标签1"));
Document doc1 = template.clone();
doc1.setTitle("文档1");

深拷贝 vs 浅拷贝

浅拷贝问题

// 浅拷贝：引用类型共享
Document doc1 = template.clone();
doc1.getTags().add("新标签");
// template 的 tags 也会被修改！

深拷贝实现

public class Document implements Cloneable, Serializable {
    private String title;
    private String content;
    private List<String> tags;
    private Author author;
    
    // 深拷贝方式 1：手动复制
    @Override
    public Document clone() {
        try {
            Document cloned = (Document) super.clone();
            // 复制引用类型
            cloned.tags = new ArrayList<>(this.tags);
            cloned.author = this.author.clone();
            return cloned;
        } catch (CloneNotSupportedException e) {
            throw new RuntimeException(e);
        }
    }
    
    // 深拷贝方式 2：序列化
    public Document deepClone() {
        try {
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(baos);
            oos.writeObject(this);
            oos.close();
            
            ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bais);
            Document cloned = (Document) ois.readObject();
            ois.close();
            
            return cloned;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

// Author 类也需要实现 Cloneable
public class Author implements Cloneable, Serializable {
    private String name;
    private String email;
    
    @Override
    public Author clone() {
        try {
            return (Author) super.clone();
        } catch (CloneNotSupportedException e) {
            throw new RuntimeException(e);
        }
    }
}

使用拷贝构造函数

public class Document {
    private String title;
    private String content;
    private List<String> tags;
    
    // 普通构造
    public Document(String title, String content, List<String> tags) {
        this.title = title;
        this.content = content;
        this.tags = new ArrayList<>(tags);
    }
    
    // 拷贝构造（深拷贝）
    public Document(Document other) {
        this.title = other.title;
        this.content = other.content;
        this.tags = new ArrayList<>(other.tags);
    }
}

// 使用
Document doc1 = new Document("原文档", "内容", tags);
Document doc2 = new Document(doc1); // 深拷贝
doc2.setTitle("新文档");

原型注册表

// 原型管理器
public class PrototypeRegistry {
    private static final Map<String, Prototype> prototypes = new HashMap<>();
    
    static {
        // 注册默认原型
        prototypes.put("default", new Report("默认报告", "模板内容"));
        prototypes.put("monthly", new Report("月度报告", "月度数据..."));
        prototypes.put("annual", new Report("年度报告", "年度总结..."));
    }
    
    public static void register(String key, Prototype prototype) {
        prototypes.put(key, prototype);
    }
    
    public static Prototype create(String key) {
        Prototype prototype = prototypes.get(key);
        if (prototype == null) {
            throw new IllegalArgumentException("未知原型: " + key);
        }
        return prototype.clone();
    }
}

// 使用
Report report = (Report) PrototypeRegistry.create("monthly");
report.setTitle("2024年1月月报");

框架中的应用

Spring 原型作用域

@Component
@Scope("prototype")
public class PrototypeBean {
    private String data;
    
    public void setData(String data) {
        this.data = data;
    }
}

// 使用
@Configuration
public class AppConfig {
    @Autowired
    private ApplicationContext context;
    
    public void usePrototype() {
        // 每次获取都是新实例
        PrototypeBean bean1 = context.getBean(PrototypeBean.class);
        PrototypeBean bean2 = context.getBean(PrototypeBean.class);
        
        System.out.println(bean1 == bean2); // false
    }
}

JSON 对象的复制

import com.fasterxml.jackson.databind.ObjectMapper;

public class DeepCopyUtil {
    private static final ObjectMapper mapper = new ObjectMapper();
    
    public static <T> T copy(T object, Class<T> clazz) {
        try {
            String json = mapper.writeValueAsString(object);
            return mapper.readValue(json, clazz);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

// 使用
User user1 = new User("john", 25);
User user2 = DeepCopyUtil.copy(user1, User.class);

实际应用：报表生成

public abstract class ReportTemplate implements Cloneable {
    protected String title;
    protected String header;
    protected String footer;
    protected List<String> sections;
    
    public ReportTemplate(String title) {
        this.title = title;
        this.sections = new ArrayList<>();
    }
    
    // 添加内容
    public void addSection(String section) {
        sections.add(section);
    }
    
    // 生成报告
    public String generate() {
        StringBuilder report = new StringBuilder();
        report.append(header).append("\n");
        report.append("标题: ").append(title).append("\n");
        for (String section : sections) {
            report.append(section).append("\n");
        }
        report.append(footer);
        return report.toString();
    }
    
    @Override
    public ReportTemplate clone() {
        try {
            ReportTemplate cloned = (ReportTemplate) super.clone();
            cloned.sections = new ArrayList<>(this.sections);
            return cloned;
        } catch (CloneNotSupportedException e) {
            throw new RuntimeException(e);
        }
    }
}

// 月度报告
public class MonthlyReport extends ReportTemplate {
    public MonthlyReport() {
        super("月度报告");
        this.header = "===== 月度报告 =====";
        this.footer = "===== 报告结束 =====";
    }
}

// 使用
MonthlyReport template = new MonthlyReport();
template.addSection("销售额: 100万");
template.addSection("用户数: 5000");

// 克隆并定制
MonthlyReport janReport = template.clone();
janReport.addSection("月份: 1月");

MonthlyReport febReport = template.clone();
febReport.addSection("月份: 2月");

深拷贝方式对比

方式 优点 缺点
clone() 标准方法 需要实现 Cloneable
序列化 自动深拷贝 性能较差
拷贝构造 简单直观 需要手动复制每个字段
JSON 复制 通用性强 依赖库，性能一般
BeanUtils 方便 性能较差，部分字段可能无法复制

优缺点

优点 缺点
避免子类化 复杂对象的深拷贝实现困难
动态添加/删除产品 需要实现克隆方法
减少初始化代码 深拷贝可能有循环引用问题

最佳实践

  1. 优先使用拷贝构造：比 clone() 更清晰
  2. 注意深拷贝问题：特别是集合和对象引用
  3. 不可变对象：可以安全使用浅拷贝
  4. 原型注册表：管理常用原型对象
]]>建造者模式 (Builder Pattern)https://ksmaple.github.io/posts/builder-pattern/Sun, 12 Apr 2026 12:00:00 +0800咔咔https://ksmaple.github.io/posts/builder-pattern/

概述

建造者模式是一种创建型设计模式，它允许你分步骤创建复杂对象。该模式使你能够使用相同的创建代码生成不同类型和形式的对象。

适用场景

  • 对象构造复杂，参数众多
  • 需要创建不同表示的同类对象
  • 构造过程需要分步骤执行

基础实现

代码示例

// 产品类
public class Computer {
    private String cpu;
    private String ram;
    private String storage;
    private String gpu;
    private boolean hasWifi;
    private boolean hasBluetooth;
    
    // 私有构造方法
    private Computer(Builder builder) {
        this.cpu = builder.cpu;
        this.ram = builder.ram;
        this.storage = builder.storage;
        this.gpu = builder.gpu;
        this.hasWifi = builder.hasWifi;
        this.hasBluetooth = builder.hasBluetooth;
    }
    
    // Getters...
    
    // 建造者类
    public static class Builder {
        private String cpu;
        private String ram;
        private String storage;
        private String gpu;
        private boolean hasWifi;
        private boolean hasBluetooth;
        
        public Builder cpu(String cpu) {
            this.cpu = cpu;
            return this;
        }
        
        public Builder ram(String ram) {
            this.ram = ram;
            return this;
        }
        
        public Builder storage(String storage) {
            this.storage = storage;
            return this;
        }
        
        public Builder gpu(String gpu) {
            this.gpu = gpu;
            return this;
        }
        
        public Builder hasWifi(boolean hasWifi) {
            this.hasWifi = hasWifi;
            return this;
        }
        
        public Builder hasBluetooth(boolean hasBluetooth) {
            this.hasBluetooth = hasBluetooth;
            return this;
        }
        
        public Computer build() {
            return new Computer(this);
        }
    }
}

// 使用
Computer computer = new Computer.Builder()
    .cpu("Intel i9")
    .ram("32GB")
    .storage("1TB SSD")
    .gpu("RTX 4090")
    .hasWifi(true)
    .hasBluetooth(true)
    .build();

使用 Lombok 简化

import lombok.Builder;
import lombok.Data;

@Data
@Builder
public class User {
    private Long id;
    private String username;
    private String email;
    private String phone;
    private Integer age;
    private String address;
}

// 使用
User user = User.builder()
    .id(1L)
    .username("john")
    .email("john@example.com")
    .age(25)
    .build();

带校验的建造者

public class User {
    private final String username;
    private final String email;
    private final Integer age;
    
    private User(Builder builder) {
        this.username = builder.username;
        this.email = builder.email;
        this.age = builder.age;
    }
    
    public static class Builder {
        private String username;
        private String email;
        private Integer age;
        
        public Builder username(String username) {
            this.username = username;
            return this;
        }
        
        public Builder email(String email) {
            this.email = email;
            return this;
        }
        
        public Builder age(Integer age) {
            this.age = age;
            return this;
        }
        
        public User build() {
            validate();
            return new User(this);
        }
        
        private void validate() {
            if (username == null || username.isEmpty()) {
                throw new IllegalStateException("用户名不能为空");
            }
            if (email == null || !email.contains("@")) {
                throw new IllegalStateException("邮箱格式不正确");
            }
            if (age == null || age < 0 || age > 150) {
                throw new IllegalStateException("年龄不合法");
            }
        }
    }
}

框架中的应用

StringBuilder

// JDK 中的建造者模式
String result = new StringBuilder()
    .append("Hello")
    .append(" ")
    .append("World")
    .toString();

Stream.Builder

// Stream API 中的建造者
Stream<String> stream = Stream.<String>builder()
    .add("a")
    .add("b")
    .add("c")
    .build();

Spring ResponseEntity

// Spring 的 ResponseEntity 建造者
ResponseEntity<User> response = ResponseEntity
    .status(HttpStatus.OK)
    .header("X-Custom-Header", "value")
    .body(user);

Retrofit/OkHttp Request

// OkHttp 的请求建造者
Request request = new Request.Builder()
    .url("https://api.example.com/users")
    .header("Authorization", "Bearer token")
    .get()
    .build();

实际应用：SQL 查询构造器

public class SqlQuery {
    private String select;
    private String from;
    private String where;
    private String orderBy;
    private Integer limit;
    
    private SqlQuery(Builder builder) {
        this.select = builder.select;
        this.from = builder.from;
        this.where = builder.where;
        this.orderBy = builder.orderBy;
        this.limit = builder.limit;
    }
    
    public String toSql() {
        StringBuilder sql = new StringBuilder();
        sql.append("SELECT ").append(select)
           .append(" FROM ").append(from);
        if (where != null) {
            sql.append(" WHERE ").append(where);
        }
        if (orderBy != null) {
            sql.append(" ORDER BY ").append(orderBy);
        }
        if (limit != null) {
            sql.append(" LIMIT ").append(limit);
        }
        return sql.toString();
    }
    
    public static class Builder {
        private String select = "*";
        private String from;
        private String where;
        private String orderBy;
        private Integer limit;
        
        public Builder select(String... columns) {
            this.select = String.join(", ", columns);
            return this;
        }
        
        public Builder from(String table) {
            this.from = table;
            return this;
        }
        
        public Builder where(String condition) {
            this.where = condition;
            return this;
        }
        
        public Builder orderBy(String column) {
            this.orderBy = column;
            return this;
        }
        
        public Builder limit(int limit) {
            this.limit = limit;
            return this;
        }
        
        public SqlQuery build() {
            if (from == null) {
                throw new IllegalStateException("FROM 不能为空");
            }
            return new SqlQuery(this);
        }
    }
}

// 使用
SqlQuery query = new SqlQuery.Builder()
    .select("id", "username", "email")
    .from("users")
    .where("age > 18")
    .orderBy("created_at DESC")
    .limit(10)
    .build();

System.out.println(query.toSql());
// SELECT id, username, email FROM users WHERE age > 18 
// ORDER BY created_at DESC LIMIT 10

链式调用 vs 多参数构造

方式 代码示例 可读性
多参数构造 new User("john", "john@e.com", 25, ...) 差
Setter 多行 set 调用 一般
建造者 .username("john").email("...") 好

优缺点

优点 缺点
代码可读性强 需要额外创建 Builder 类
参数清晰明确 代码量增加
支持默认值 不适用于简单对象
可分步构造
线程安全（不可变对象）

最佳实践

  1. 参数较多时使用：通常超过 4-5 个参数建议使用
  2. 结合 Lombok：减少样板代码
  3. 添加参数校验：在 build() 方法中校验
  4. 创建不可变对象：适合建造者模式
]]>单例模式 (Singleton Pattern)https://ksmaple.github.io/posts/singleton-pattern/Sun, 12 Apr 2026 11:00:00 +0800咔咔https://ksmaple.github.io/posts/singleton-pattern/

概述

单例模式是最简单的设计模式之一，它确保一个类只有一个实例，并提供一个全局访问点来获取该实例。

类图结构

适用场景

  • 数据库连接池
  • 线程池
  • 缓存管理器
  • 配置管理器
  • 日志记录器

实现方式

1. 饿汉式（线程安全）

public class Singleton {
    // 类加载时就创建实例
    private static final Singleton INSTANCE = new Singleton();
    
    // 私有构造方法
    private Singleton() {}
    
    // 全局访问点
    public static Singleton getInstance() {
        return INSTANCE;
    }
}

优点：简单，线程安全 缺点：类加载时就创建，可能浪费资源

2. 懒汉式（线程不安全）

public class Singleton {
    private static Singleton instance;
    
    private Singleton() {}
    
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

注意：多线程环境下可能创建多个实例

]]>