山西建设公司网站做个外贸网站设计
23种设计模式说明
以下是常见的 23 种设计模式 分类及其核心思想、应用场景和简单代码示例，帮助你在实际开发中灵活运用：
一、创建型模式（5种）
解决对象创建问题，降低对象耦合。
1. 单例模式（Singleton）
-
核心思想：确保一个类只有一个实例，并提供全局访问点。
-
场景：数据库连接池、配置管理、日志对象。
-
示例：
public class Singleton {private static volatile Singleton instance;private Singleton() {}public static Singleton getInstance() {if (instance == null) {synchronized (Singleton.class) {if (instance == null) {instance = new Singleton();}}}return instance;} }
2. 工厂方法模式（Factory Method）
-
核心思想：定义创建对象的接口，由子类决定实例化哪个类。
-
场景：日志记录器、数据库连接工厂。
-
示例：
interface Product {void use(); }class ConcreteProductA implements Product {public void use() { System.out.println("Product A"); } }abstract class Creator {public abstract Product createProduct(); }class ConcreteCreatorA extends Creator {public Product createProduct() { return new ConcreteProductA(); } }
3. 抽象工厂模式（Abstract Factory）
-
核心思想：提供一个接口，创建一系列相关或依赖对象。
-
场景：跨平台的 UI 组件库（如按钮、文本框）。
-
示例：
interface Button { void render(); } interface TextField { void input(); }class WindowsButton implements Button { public void render() { /* Windows 风格按钮 */ } } class MacButton implements Button { public void render() { /* Mac 风格按钮 */ } }interface GUIFactory {Button createButton();TextField createTextField(); }class WindowsFactory implements GUIFactory {public Button createButton() { return new WindowsButton(); }public TextField createTextField() { return new WindowsTextField(); } }
4. 建造者模式（Builder）
-
核心思想：分步骤构建复杂对象，隔离构造细节。
-
场景：构造复杂对象（如 SQL 查询、HTTP 请求）。
-
示例：
java
复制
class Computer {private String cpu;private String ram;// 省略其他属性和构造方法static class Builder {private String cpu;private String ram;public Builder setCpu(String cpu) { this.cpu = cpu; return this; }public Builder setRam(String ram) { this.ram = ram; return this; }public Computer build() { return new Computer(this); }} }// 使用 Computer computer = new Computer.Builder().setCpu("Intel i7").setRam("16GB").build();
5. 原型模式（Prototype）
-
核心思想：通过复制现有对象来创建新对象。
-
场景：避免重复初始化开销（如游戏中的怪物生成）。
-
示例：
java
复制
interface Prototype extends Cloneable {Prototype clone(); }class ConcretePrototype implements Prototype {public Prototype clone() {return (ConcretePrototype) super.clone();} }
二、结构型模式（7种）
处理类或对象的组合，构建灵活结构。
6. 适配器模式（Adapter）
-
核心思想：将一个接口转换为另一个客户端期望的接口。
-
场景：整合不兼容的第三方库。
-
示例：
java
复制
class LegacyLibrary {public void specificRequest() { /* 旧接口 */ } }interface Target {void request(); }class Adapter implements Target {private LegacyLibrary legacy;public Adapter(LegacyLibrary legacy) { this.legacy = legacy; }public void request() { legacy.specificRequest(); } } - 备注实战经验：接口转换的中间层，比如标准品接口视作标准，分别对接不同的客户，为了减少标准品的改动，添加一层专门对接客户的接口适配层。
7. 装饰器模式（Decorator）
-
核心思想：动态地为对象添加额外职责。
-
场景：Java I/O 流（如
BufferedReader装饰FileReader）。 -
示例：
java
复制
interface Coffee {double getCost();String getDescription(); }class SimpleCoffee implements Coffee {public double getCost() { return 1.0; }public String getDescription() { return "Coffee"; } }abstract class CoffeeDecorator implements Coffee {protected Coffee decoratedCoffee;public CoffeeDecorator(Coffee coffee) { this.decoratedCoffee = coffee; } }class MilkDecorator extends CoffeeDecorator {public MilkDecorator(Coffee coffee) { super(coffee); }public double getCost() { return super.getCost() + 0.5; }public String getDescription() { return super.getDescription() + ", Milk"; } }
8. 代理模式（Proxy）
-
核心思想：为其他对象提供一种代理以控制访问。
-
场景：延迟加载（Lazy Initialization）、权限控制。
-
示例：
interface Image {void display(); }class RealImage implements Image {public RealImage(String filename) { loadFromDisk(filename); }private void loadFromDisk(String filename) { /* 加载图片 */ }public void display() { /* 显示图片 */ } }class ProxyImage implements Image {private RealImage realImage;private String filename;public ProxyImage(String filename) { this.filename = filename; }public void display() {if (realImage == null) {realImage = new RealImage(filename);}realImage.display();} }
9. 外观模式（Facade）
-
核心思想：为复杂子系统提供一个统一的高层接口。
-
场景：简化 API 调用（如订单支付流程封装）。
-
示例：
java
复制
class PaymentService {public void processPayment() { /* 处理支付 */ } } class InventoryService {public void updateInventory() { /* 更新库存 */ } }class OrderFacade {private PaymentService paymentService;private InventoryService inventoryService;public void placeOrder() {paymentService.processPayment();inventoryService.updateInventory();} } - 备注实战：入库场景下各种入库复杂场景，统一封装一个高阶入库接口，用于处理所有入库逻辑，函数内部通过查询sku对比订单信息来决定那种业务类型入库。
10. 桥接模式（Bridge）
-
核心思想：将抽象与实现分离，使它们可以独立变化。
-
场景：跨平台图形渲染（如不同操作系统下的绘图 API）。
-
示例：
java
复制
interface Renderer {void renderCircle(float radius); }class VectorRenderer implements Renderer {public void renderCircle(float radius) { /* 矢量渲染 */ } }abstract class Shape {protected Renderer renderer;public Shape(Renderer renderer) { this.renderer = renderer; }abstract void draw(); }class Circle extends Shape {private float radius;public Circle(Renderer renderer, float radius) {super(renderer);this.radius = radius;}public void draw() { renderer.renderCircle(radius); } }
三、行为型模式（11种）
关注对象之间的通信和职责分配。
11. 观察者模式（Observer）
-
核心思想：定义对象间的一对多依赖，当一个对象状态改变时，所有依赖者自动更新。
-
场景：事件驱动系统（如 GUI 按钮点击事件）。
-
示例：
java
复制
interface Observer {void update(String message); }class ConcreteObserver implements Observer {public void update(String message) { System.out.println("Received: " + message); } }class Subject {private List<Observer> observers = new ArrayList<>();public void addObserver(Observer observer) { observers.add(observer); }public void notifyObservers(String message) {for (Observer observer : observers) {observer.update(message);}} } - 备注实战：消息队列
12. 策略模式（Strategy）
-
核心思想：定义一系列算法，封装每个算法，并使它们可互换。
-
场景：支付方式选择（支付宝、微信、信用卡）。
-
示例：
java
复制
interface PaymentStrategy {void pay(int amount); }class AlipayStrategy implements PaymentStrategy {public void pay(int amount) { /* 支付宝支付 */ } }class Context {private PaymentStrategy strategy;public void setStrategy(PaymentStrategy strategy) { this.strategy = strategy; }public void executePayment(int amount) { strategy.pay(amount); } } - 备注实战：报表的统一路由，根据不同类型选择不同报表设计。
13. 模板方法模式（Template Method）
-
核心思想：定义一个算法的骨架，将某些步骤延迟到子类实现。
-
场景：框架中的流程控制（如 Spring 的 JdbcTemplate）。
-
示例：
java
复制
abstract class Game {abstract void initialize();abstract void startPlay();abstract void endPlay();public final void play() {initialize();startPlay();endPlay();} }class Cricket extends Game {void initialize() { /* 初始化板球游戏 */ }void startPlay() { /* 开始游戏 */ }void endPlay() { /* 结束游戏 */ } }
14. 责任链模式（Chain of Responsibility）
-
核心思想：将请求的发送者和接收者解耦，使多个对象都有机会处理请求。
-
场景：审批流程、异常处理链。
-
示例：
java
复制
abstract class Handler {protected Handler next;public void setNext(Handler next) { this.next = next; }public abstract void handleRequest(int request); }class ConcreteHandlerA extends Handler {public void handleRequest(int request) {if (request <= 10) { /* 处理请求 */ }else if (next != null) { next.handleRequest(request); }} } - 备注实战：事件监听，一个业务流程完成后，广播一条通知，监听端分别做对应收尾工作。
四、设计模式总结
-
优先理解问题场景：不要为了用模式而用模式。
-
关注开闭原则（OCP）：通过扩展而非修改现有代码来实现变化。
-
框架中的应用：如 Spring 的依赖注入（工厂模式）、AOP（代理模式）。
附：模式速查表
| 类型 | 模式名称 | 一句话核心思想 |
|---|---|---|
| 创建型 | 单例、工厂、建造者 | 灵活创建对象，解耦实例化过程 |
| 结构型 | 适配器、代理、装饰器 | 组合对象，构建灵活结构 |
| 行为型 | 观察者、策略、模板方法 | 定义对象交互方式，解耦行为逻辑 |
掌握这些模式能显著提升代码的可维护性和扩展性！
Spring boot中的设计模式
Spring Boot 作为 Spring 框架的扩展，在底层大量使用了设计模式来简化开发、提高扩展性和维护性。以下是 Spring Boot 中常见的 设计模式及其应用场景 的详细解析：
1. 单例模式（Singleton）
-
应用场景：Spring 容器管理的 Bean 默认是单例的，确保全局唯一实例。
-
源码示例：
java
复制
@Service public class UserService {// 默认单例，Spring 容器中只有一个 UserService 实例 } -
实现原理：通过
DefaultSingletonBeanRegistry的singletonObjects缓存管理单例 Bean。
2. 工厂方法模式（Factory Method）
-
应用场景：Bean 的创建通过工厂方法解耦。
-
源码示例：
java
复制
@Configuration public class AppConfig {@Bean // 工厂方法，由 Spring 调用此方法创建 DataSource 实例public DataSource dataSource() {return new HikariDataSource();} } -
扩展应用：
BeanFactory接口定义了 Bean 的工厂方法getBean()。
3. 抽象工厂模式（Abstract Factory）
-
应用场景：根据不同环境创建不同的 Bean（如多数据源）。
-
源码示例：
java
复制
@Configuration public class DataSourceConfig {@Bean@Profile("dev") // 根据 Profile 选择工厂实现public DataSource devDataSource() { /* 开发环境数据源 */ }@Bean@Profile("prod")public DataSource prodDataSource() { /* 生产环境数据源 */ } }
4. 模板方法模式（Template Method）
-
应用场景：定义算法骨架，子类实现具体步骤（如
JdbcTemplate）。 -
源码示例：
java
复制
public class JdbcTemplate extends JdbcAccessor {public <T> T query(String sql, ResultSetExtractor<T> rse) {// 定义执行流程：获取连接、创建语句、执行查询、处理结果Connection con = DataSourceUtils.getConnection(getDataSource());Statement stmt = con.createStatement();ResultSet rs = stmt.executeQuery(sql);return rse.extractData(rs); // 由回调处理结果} }
5. 代理模式（Proxy）
-
应用场景：AOP 切面编程、事务管理。
-
源码示例：
java
复制
@Service public class UserService {@Transactional // Spring 通过动态代理添加事务管理逻辑public void saveUser(User user) { /* ... */ } } -
实现原理：
-
使用 JDK 动态代理（基于接口）或 CGLIB（基于类）生成代理对象。
-
代理类在方法调用前后插入切面逻辑（如
@Around通知）。
-
6. 适配器模式（Adapter）
-
应用场景：Spring MVC 中的
HandlerAdapter处理不同类型的控制器。 -
源码示例：
java
复制
public class RequestMappingHandlerAdapter implements HandlerAdapter {public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) {// 将 HTTP 请求适配到 @RequestMapping 方法} }
7. 观察者模式（Observer）
-
应用场景：Spring 事件驱动模型（如
ApplicationEvent和ApplicationListener）。 -
源码示例：
java
复制
// 自定义事件 public class OrderCreatedEvent extends ApplicationEvent { /* ... */ }// 监听事件 @Component public class EmailListener implements ApplicationListener<OrderCreatedEvent> {public void onApplicationEvent(OrderCreatedEvent event) {// 发送邮件通知} }// 发布事件 @Autowired private ApplicationEventPublisher publisher; publisher.publishEvent(new OrderCreatedEvent(this, order));
8. 策略模式（Strategy）
-
应用场景：多数据源路由、缓存策略选择。
-
源码示例：
java
复制
public interface CacheStrategy {Object get(String key); }@Component("redisCache") public class RedisCacheStrategy implements CacheStrategy { /* ... */ }@Component("localCache") public class LocalCacheStrategy implements CacheStrategy { /* ... */ }// 根据条件动态选择策略 @Autowired private Map<String, CacheStrategy> strategies;public CacheStrategy getStrategy(String type) {return strategies.get(type + "Cache"); }
9. 装饰器模式（Decorator）
-
应用场景：增强请求/响应对象（如
HttpServletRequestWrapper）。 -
源码示例：
java
复制
public class CachingHttpServletRequest extends HttpServletRequestWrapper {private byte[] cachedBody;public CachingHttpServletRequest(HttpServletRequest request) {super(request);// 缓存请求体以便多次读取this.cachedBody = StreamUtils.copyToByteArray(request.getInputStream());}@Overridepublic ServletInputStream getInputStream() {return new CachedBodyServletInputStream(cachedBody);} }
10. 责任链模式（Chain of Responsibility）
-
应用场景：Spring Security 的过滤器链、拦截器链。
-
源码示例：
java
复制
public class SecurityFilterChain {private List<Filter> filters;public void doFilter(ServletRequest request, ServletResponse response) {for (Filter filter : filters) {filter.doFilter(request, response, chain);}} }
11. 建造者模式（Builder）
-
应用场景：构建复杂配置对象（如
SpringApplicationBuilder）。 -
源码示例：
java
复制
new SpringApplicationBuilder().sources(Parent.class).child(Application.class).bannerMode(Banner.Mode.OFF).run(args);
总结
Spring Boot 通过灵活运用设计模式，实现了以下目标：
-
解耦与扩展性：如工厂模式、策略模式。
-
代码复用：如模板方法模式、装饰器模式。
-
动态行为控制：如代理模式、观察者模式。
-
简化复杂逻辑：如建造者模式、责任链模式。
理解这些模式在 Spring Boot 中的应用，有助于更好地掌握框架设计思想，并在实际开发中编写高内聚、低耦合的代码。