结构型模式 - 标签 - 咔咔不太卡的博客https://ksmaple.github.io/tags/%E7%BB%93%E6%9E%84%E5%9E%8B%E6%A8%A1%E5%BC%8F/结构型模式 - 标签 - 咔咔不太卡的博客Hugo -- gohugo.iozh-CNSun, 12 Apr 2026 14:30:00 +0800外观模式 (Facade Pattern)https://ksmaple.github.io/posts/facade-pattern/Sun, 12 Apr 2026 14:30:00 +0800咔咔https://ksmaple.github.io/posts/facade-pattern/

概述

外观模式是一种结构型设计模式，它为子系统中的一组接口提供一个统一的高层接口，使得子系统更容易使用。

适用场景

  • 简化复杂系统的使用
  • 解耦客户端与子系统
  • 分层架构中提供层间接口

基础实现

// 子系统 A
public class SubSystemA {
    public void operationA() {
        System.out.println("子系统 A 操作");
    }
}

// 子系统 B
public class SubSystemB {
    public void operationB() {
        System.out.println("子系统 B 操作");
    }
}

// 子系统 C
public class SubSystemC {
    public void operationC() {
        System.out.println("子系统 C 操作");
    }
}

// 外观类
public class Facade {
    private SubSystemA systemA;
    private SubSystemB systemB;
    private SubSystemC systemC;
    
    public Facade() {
        this.systemA = new SubSystemA();
        this.systemB = new SubSystemB();
        this.systemC = new SubSystemC();
    }
    
    // 简化操作 1
    public void simpleOperation1() {
        systemA.operationA();
        systemB.operationB();
    }
    
    // 简化操作 2
    public void simpleOperation2() {
        systemB.operationB();
        systemC.operationC();
    }
}

// 使用
Facade facade = new Facade();
facade.simpleOperation1(); // 无需了解子系统细节

实际应用：订单处理外观

// 库存服务
@Service
public class InventoryService {
    public boolean checkStock(String productId, int quantity) {
        System.out.println("检查库存: " + productId);
        return true;
    }
    
    public void reduceStock(String productId, int quantity) {
        System.out.println("扣减库存: " + productId);
    }
}

// 支付服务
@Service
public class PaymentService {
    public boolean processPayment(String orderId, BigDecimal amount) {
        System.out.println("处理支付: " + orderId);
        return true;
    }
}

// 物流服务
@Service
public class ShippingService {
    public void createShipment(String orderId) {
        System.out.println("创建物流: " + orderId);
    }
}

// 通知服务
@Service
public class NotificationService {
    public void sendOrderConfirmation(String userId, String orderId) {
        System.out.println("发送订单确认: " + orderId);
    }
}

// 订单外观
@Service
public class OrderFacade {
    @Autowired
    private InventoryService inventoryService;
    @Autowired
    private PaymentService paymentService;
    @Autowired
    private ShippingService shippingService;
    @Autowired
    private NotificationService notificationService;
    
    public OrderResult placeOrder(OrderRequest request) {
        // 1. 检查库存
        if (!inventoryService.checkStock(request.getProductId(), 
                                          request.getQuantity())) {
            return OrderResult.fail("库存不足");
        }
        
        // 2. 创建订单
        String orderId = createOrder(request);
        
        // 3. 处理支付
        if (!paymentService.processPayment(orderId, request.getAmount())) {
            return OrderResult.fail("支付失败");
        }
        
        // 4. 扣减库存
        inventoryService.reduceStock(request.getProductId(), 
                                      request.getQuantity());
        
        // 5. 创建物流
        shippingService.createShipment(orderId);
        
        // 6. 发送通知
        notificationService.sendOrderConfirmation(request.getUserId(), orderId);
        
        return OrderResult.success(orderId);
    }
    
    private String createOrder(OrderRequest request) {
        return "ORDER_" + System.currentTimeMillis();
    }
}

// Controller 使用
@RestController
public class OrderController {
    @Autowired
    private OrderFacade orderFacade;
    
    @PostMapping("/orders")
    public OrderResult createOrder(@RequestBody OrderRequest request) {
        // 客户端只需调用外观方法，无需了解复杂流程
        return orderFacade.placeOrder(request);
    }
}

框架中的应用

Spring MVC DispatcherServlet

// DispatcherServlet 是前端控制器外观
public class DispatcherServlet extends HttpServlet {
    protected void doDispatch(HttpServletRequest request, 
                              HttpServletResponse response) {
        // 简化了处理请求的整个流程
        // 1. 获取 Handler
        // 2. 获取 HandlerAdapter
        // 3. 处理请求
        // 4. 处理异常
        // 5. 渲染视图
    }
}

JDBC 操作外观

// JdbcTemplate 是 JDBC 的外观
@Repository
public class UserDao {
    @Autowired
    private JdbcTemplate jdbcTemplate;
    
    public User findById(Long id) {
        // 简化复杂的 JDBC 操作
        return jdbcTemplate.queryForObject(
            "SELECT * FROM users WHERE id = ?",
            new BeanPropertyRowMapper<>(User.class),
            id
        );
    }
}

SLF4J 日志外观

// SLF4J 是各种日志框架的外观
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class MyService {
    private static final Logger logger = LoggerFactory.getLogger(MyService.class);
    
    public void doSomething() {
        logger.info("开始执行");
        // 底层可能是 Logback、Log4j2 等
    }
}

外观与代理的区别

外观 代理
简化复杂接口 控制对象访问
聚合多个子系统 包装单个对象
目的是易用性 目的是控制

优缺点

优点 缺点
简化接口 可能成为上帝类
解耦客户端和子系统 增加间接层
提高可维护性

总结

外观模式是简化复杂系统的有效手段。在微服务架构中，API Gateway 就是外观模式的典型应用。合理使用外观模式可以降低系统复杂度，提高代码可读性。

]]>代理模式 (Proxy Pattern)https://ksmaple.github.io/posts/proxy-pattern/Sun, 12 Apr 2026 14:00:00 +0800咔咔https://ksmaple.github.io/posts/proxy-pattern/

概述

代理模式是一种结构型设计模式，它为另一个对象提供一个替身或占位符，以控制对这个对象的访问。

模式结构

代理类型

  1. 静态代理：编译时确定
  2. 动态代理：运行时生成
  3. 虚拟代理：延迟创建开销大的对象
  4. 保护代理：控制访问权限
  5. 缓存代理：缓存结果

静态代理

// 主题接口
public interface Image {
    void display();
}

// 真实主题
public class RealImage implements Image {
    private String fileName;
    
    public RealImage(String fileName) {
        this.fileName = fileName;
        loadFromDisk();
    }
    
    private void loadFromDisk() {
        System.out.println("加载图片: " + fileName);
    }
    
    @Override
    public void display() {
        System.out.println("显示图片: " + fileName);
    }
}

// 代理
public class ProxyImage implements Image {
    private RealImage realImage;
    private String fileName;
    
    public ProxyImage(String fileName) {
        this.fileName = fileName;
    }
    
    @Override
    public void display() {
        if (realImage == null) {
            realImage = new RealImage(fileName);
        }
        realImage.display();
    }
}

// 使用
Image image = new ProxyImage("photo.jpg");
// 第一次调用时才加载
image.display();

动态代理

JDK 动态代理

// 接口
public interface UserService {
    void addUser(String name);
    void deleteUser(Long id);
}

// 实现
public class UserServiceImpl implements UserService {
    @Override
    public void addUser(String name) {
        System.out.println("添加用户: " + name);
    }
    
    @Override
    public void deleteUser(Long id) {
        System.out.println("删除用户: " + id);
    }
}

// 代理处理器
public class LogInvocationHandler implements InvocationHandler {
    private Object target;
    
    public LogInvocationHandler(Object target) {
        this.target = target;
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("[LOG] 调用方法: " + method.getName());
        Object result = method.invoke(target, args);
        System.out.println("[LOG] 方法结束: " + method.getName());
        return result;
    }
}

// 使用
UserService target = new UserServiceImpl();
UserService proxy = (UserService) Proxy.newProxyInstance(
    target.getClass().getClassLoader(),
    target.getClass().getInterfaces(),
    new LogInvocationHandler(target)
);

proxy.addUser("张三");

CGLIB 动态代理

// CGLIB 代理（无需接口）
public class CglibProxy implements MethodInterceptor {
    
    public Object createProxy(Class<?> targetClass) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(targetClass);
        enhancer.setCallback(this);
        return enhancer.create();
    }
    
    @Override
    public Object intercept(Object obj, Method method, 
                           Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("[CGLIB] 前置处理");
        Object result = proxy.invokeSuper(obj, args);
        System.out.println("[CGLIB] 后置处理");
        return result;
    }
}

// 使用
CglibProxy cglibProxy = new CglibProxy();
UserService proxy = (UserService) cglibProxy.createProxy(UserServiceImpl.class);
proxy.addUser("李四");

框架中的应用

Spring AOP

@Service
public class OrderService {
    
    @Transactional
    public void createOrder(Order order) {
        // 事务管理由代理实现
    }
    
    @Cacheable("orders")
    public Order getOrder(Long id) {
        // 缓存由代理实现
    }
}

// Spring 会自动创建代理
// 1. 如果有接口，使用 JDK 动态代理
// 2. 如果没有接口，使用 CGLIB 代理

JPA 延迟加载

@Entity
public class Department {
    @OneToMany(fetch = FetchType.LAZY)
    private List<Employee> employees; // 代理对象
}

// employees 在访问时才真正加载
Department dept = departmentRepository.findById(1L);
// 此时 employees 是代理对象
for (Employee e : dept.getEmployees()) {
    // 第一次遍历时才真正查询数据库
    System.out.println(e.getName());
}

MyBatis Mapper

// MyBatis 使用代理实现 Mapper 接口
@Mapper
public interface UserMapper {
    @Select("SELECT * FROM users WHERE id = #{id}")
    User findById(Long id);
}

// 实际使用时，MyBatis 返回的是代理对象
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
// mapper 是代理对象，实际执行时调用 SqlSession

实际应用：权限控制代理

public interface DocumentService {
    void readDocument(String docId);
    void writeDocument(String docId, String content);
    void deleteDocument(String docId);
}

public class SecurityProxy implements DocumentService {
    private DocumentService target;
    private User currentUser;
    
    public SecurityProxy(DocumentService target, User user) {
        this.target = target;
        this.currentUser = user;
    }
    
    @Override
    public void readDocument(String docId) {
        if (hasPermission("READ")) {
            target.readDocument(docId);
        } else {
            throw new SecurityException("无读取权限");
        }
    }
    
    @Override
    public void writeDocument(String docId, String content) {
        if (hasPermission("WRITE")) {
            target.writeDocument(docId, content);
        } else {
            throw new SecurityException("无写入权限");
        }
    }
    
    private boolean hasPermission(String permission) {
        return currentUser.getPermissions().contains(permission);
    }
}

缓存代理

public class CacheProxy implements UserService {
    private UserService target;
    private Map<Long, User> cache = new ConcurrentHashMap<>();
    
    @Override
    public User getUser(Long id) {
        User user = cache.get(id);
        if (user == null) {
            user = target.getUser(id);
            cache.put(id, user);
        }
        return user;
    }
    
    @Override
    public void updateUser(User user) {
        target.updateUser(user);
        cache.put(user.getId(), user);
    }
}

代理 vs 装饰器

代理 装饰器
控制访问 添加功能
目标对象通常隐藏 目标对象可灵活组合
侧重访问控制 侧重功能扩展

优缺点

优点 缺点
职责分离 增加复杂度
保护目标对象 可能降低性能
扩展目标功能

总结

代理模式是 Spring AOP、Hibernate 延迟加载等框架的基础。理解 JDK 动态代理和 CGLIB 代理的区别对使用 Spring 框架很重要。

]]>装饰器模式 (Decorator Pattern)https://ksmaple.github.io/posts/decorator-pattern/Sun, 12 Apr 2026 13:30:00 +0800咔咔https://ksmaple.github.io/posts/decorator-pattern/

概述

装饰器模式是一种结构型设计模式，它允许你通过将对象放入包含行为的特殊包装对象中来为原对象绑定新的行为。

适用场景

  • 在不修改原类的情况下添加功能
  • 需要动态组合功能
  • 替代多层继承

基础实现

// 组件接口
public interface Coffee {
    double cost();
    String description();
}

// 具体组件
public class SimpleCoffee implements Coffee {
    @Override
    public double cost() {
        return 10;
    }
    
    @Override
    public String description() {
        return "简单咖啡";
    }
}

// 装饰器基类
public abstract class CoffeeDecorator implements Coffee {
    protected Coffee coffee;
    
    public CoffeeDecorator(Coffee coffee) {
        this.coffee = coffee;
    }
    
    @Override
    public double cost() {
        return coffee.cost();
    }
    
    @Override
    public String description() {
        return coffee.description();
    }
}

// 具体装饰器
public class MilkDecorator extends CoffeeDecorator {
    public MilkDecorator(Coffee coffee) {
        super(coffee);
    }
    
    @Override
    public double cost() {
        return super.cost() + 2;
    }
    
    @Override
    public String description() {
        return super.description() + ", 牛奶";
    }
}

public class SugarDecorator extends CoffeeDecorator {
    public SugarDecorator(Coffee coffee) {
        super(coffee);
    }
    
    @Override
    public double cost() {
        return super.cost() + 1;
    }
    
    @Override
    public String description() {
        return super.description() + ", 糖";
    }
}

// 使用
Coffee coffee = new SimpleCoffee();
coffee = new MilkDecorator(coffee);  // 加牛奶
coffee = new SugarDecorator(coffee); // 加糖

System.out.println(coffee.description()); // 简单咖啡, 牛奶, 糖
System.out.println(coffee.cost());        // 13.0

IO 流中的应用

// Java IO 是装饰器模式的经典应用
// FileInputStream 是基础组件
InputStream fileStream = new FileInputStream("file.txt");

// BufferedInputStream 是装饰器，添加缓冲功能
InputStream bufferedStream = new BufferedInputStream(fileStream);

// DataInputStream 是装饰器，添加基本数据类型读取功能
DataInputStream dataStream = new DataInputStream(bufferedStream);

// 组合多个装饰器
BufferedReader reader = new BufferedReader(
    new InputStreamReader(
        new FileInputStream("file.txt"),
        "UTF-8"
    )
);

实际应用：权限装饰器

// 数据服务接口
public interface DataService {
    String getData(String key);
    void saveData(String key, String value);
}

// 基础实现
@Service
public class DataServiceImpl implements DataService {
    @Override
    public String getData(String key) {
        return "data for " + key;
    }
    
    @Override
    public void saveData(String key, String value) {
        System.out.println("保存: " + key + "=" + value);
    }
}

// 日志装饰器
@Component
public class LoggingDataService implements DataService {
    private final DataService delegate;
    
    public LoggingDataService(DataService delegate) {
        this.delegate = delegate;
    }
    
    @Override
    public String getData(String key) {
        System.out.println("[LOG] 获取数据: " + key);
        return delegate.getData(key);
    }
    
    @Override
    public void saveData(String key, String value) {
        System.out.println("[LOG] 保存数据: " + key + "=" + value);
        delegate.saveData(key, value);
    }
}

// 缓存装饰器
@Component
public class CachingDataService implements DataService {
    private final DataService delegate;
    private final Map<String, String> cache = new ConcurrentHashMap<>();
    
    public CachingDataService(DataService delegate) {
        this.delegate = delegate;
    }
    
    @Override
    public String getData(String key) {
        return cache.computeIfAbsent(key, delegate::getData);
    }
    
    @Override
    public void saveData(String key, String value) {
        delegate.saveData(key, value);
        cache.put(key, value);
    }
}

// 组合使用
coffee = new SimpleCoffee();
coffee = new CachingDataService(coffee);
coffee = new LoggingDataService(coffee);

Spring Cache 装饰器

@Service
public class UserService {
    
    // @Cacheable 就是装饰器模式的注解实现
    @Cacheable(value = "users", key = "#id")
    public User getUser(Long id) {
        // 实际查询数据库
        return userRepository.findById(id).orElse(null);
    }
    
    @CacheEvict(value = "users", key = "#user.id")
    public void updateUser(User user) {
        userRepository.save(user);
    }
}

Servlet Filter 链

// Servlet Filter 是装饰器模式的典型应用
public class AuthFilter implements Filter {
    @Override
    public void doFilter(ServletRequest request, 
                         ServletResponse response,
                         FilterChain chain) {
        // 前置处理：认证
        if (isAuthenticated(request)) {
            chain.doFilter(request, response); // 调用下一个装饰器
        } else {
            // 未认证，返回错误
        }
        // 后置处理
    }
}

public class LoggingFilter implements Filter {
    @Override
    public void doFilter(ServletRequest request,
                         ServletResponse response,
                         FilterChain chain) {
        // 记录请求
        chain.doFilter(request, response);
        // 记录响应
    }
}

对比继承

继承 装饰器
静态绑定 动态绑定
编译时确定 运行时确定
类爆炸问题 灵活组合
难以撤销 可以动态添加/移除

优缺点

优点 缺点
比继承更灵活 产生大量小对象
运行时扩展功能 调试较复杂
符合开闭原则

总结

装饰器模式提供了一种灵活的替代继承的方式。在 Java IO、Spring 缓存、Servlet Filter 等框架中都有广泛应用。当需要动态组合功能时，装饰器模式是最佳选择。

]]>适配器模式 (Adapter Pattern)https://ksmaple.github.io/posts/adapter-pattern/Sun, 12 Apr 2026 13:00:00 +0800咔咔https://ksmaple.github.io/posts/adapter-pattern/

概述

适配器模式是一种结构型设计模式，它允许将一个类的接口转换成客户端希望的另一个接口。适配器让原本接口不兼容的类可以合作无间。

适用场景

  • 使用现有类，但其接口不符合需求
  • 需要统一多个类的接口
  • 系统需要与第三方库集成
  • 旧系统升级兼容

实现方式

1. 类适配器（继承）

// 目标接口
public interface MediaPlayer {
    void play(String audioType, String fileName);
}

// 被适配者
public class AdvancedMediaPlayer {
    public void playMp4(String fileName) {
        System.out.println("播放 MP4: " + fileName);
    }
    
    public void playVlc(String fileName) {
        System.out.println("播放 VLC: " + fileName);
    }
}

// 类适配器（继承）
public class MediaAdapter extends AdvancedMediaPlayer implements MediaPlayer {
    @Override
    public void play(String audioType, String fileName) {
        if ("mp4".equalsIgnoreCase(audioType)) {
            playMp4(fileName);
        } else if ("vlc".equalsIgnoreCase(audioType)) {
            playVlc(fileName);
        }
    }
}

// 使用
MediaPlayer player = new MediaAdapter();
player.play("mp4", "movie.mp4");

2. 对象适配器（组合）

// 对象适配器（推荐）
public class MediaAdapter implements MediaPlayer {
    private AdvancedMediaPlayer advancedPlayer;
    
    public MediaAdapter(AdvancedMediaPlayer player) {
        this.advancedPlayer = player;
    }
    
    @Override
    public void play(String audioType, String fileName) {
        if ("mp4".equalsIgnoreCase(audioType)) {
            advancedPlayer.playMp4(fileName);
        } else if ("vlc".equalsIgnoreCase(audioType)) {
            advancedPlayer.playVlc(fileName);
        }
    }
}

实际应用：支付适配器

// 统一的支付接口
public interface PaymentProcessor {
    void processPayment(BigDecimal amount);
    void refund(String transactionId);
}

// 支付宝 SDK
public class AlipaySDK {
    public void pay(double amount) {
        System.out.println("支付宝支付: " + amount);
    }
    
    public void doRefund(String id) {
        System.out.println("支付宝退款: " + id);
    }
}

// 微信支付 SDK
public class WechatPaySDK {
    public void makePayment(BigDecimal amount) {
        System.out.println("微信支付: " + amount);
    }
    
    public void returnMoney(String orderId) {
        System.out.println("微信退款: " + orderId);
    }
}

// 支付宝适配器
public class AlipayAdapter implements PaymentProcessor {
    private AlipaySDK alipay = new AlipaySDK();
    
    @Override
    public void processPayment(BigDecimal amount) {
        alipay.pay(amount.doubleValue());
    }
    
    @Override
    public void refund(String transactionId) {
        alipay.doRefund(transactionId);
    }
}

// 微信适配器
public class WechatPayAdapter implements PaymentProcessor {
    private WechatPaySDK wechatPay = new WechatPaySDK();
    
    @Override
    public void processPayment(BigDecimal amount) {
        wechatPay.makePayment(amount);
    }
    
    @Override
    public void refund(String transactionId) {
        wechatPay.returnMoney(transactionId);
    }
}

// 支付服务
@Service
public class PaymentService {
    private final Map<String, PaymentProcessor> processors = new HashMap<>();
    
    public PaymentService() {
        processors.put("alipay", new AlipayAdapter());
        processors.put("wechat", new WechatPayAdapter());
    }
    
    public void pay(String type, BigDecimal amount) {
        PaymentProcessor processor = processors.get(type);
        if (processor == null) {
            throw new IllegalArgumentException("不支持的支付方式");
        }
        processor.processPayment(amount);
    }
}

框架中的应用

Spring MVC HandlerAdapter

// Spring 使用适配器模式适配不同类型的 Controller
public interface HandlerAdapter {
    boolean supports(Object handler);
    ModelAndView handle(HttpServletRequest request, 
                        HttpServletResponse response, 
                        Object handler);
}

// 适配不同的 Controller 类型
public class SimpleControllerHandlerAdapter implements HandlerAdapter {
    @Override
    public boolean supports(Object handler) {
        return handler instanceof Controller;
    }
    
    @Override
    public ModelAndView handle(HttpServletRequest request,
                               HttpServletResponse response,
                               Object handler) {
        return ((Controller) handler).handleRequest(request, response);
    }
}

// 适配注解 Controller
public class RequestMappingHandlerAdapter implements HandlerAdapter {
    // 处理 @Controller + @RequestMapping
}

Java IO 适配器

// InputStreamReader 是字节流到字符流的适配器
InputStream inputStream = new FileInputStream("file.txt");
Reader reader = new InputStreamReader(inputStream, "UTF-8");

// OutputStreamWriter 是字符流到字节流的适配器
Writer writer = new OutputStreamWriter(System.out);

Arrays.asList()

// 数组转列表的适配器
String[] array = {"a", "b", "c"};
List<String> list = Arrays.asList(array); // 适配器视图

新旧系统兼容

// 旧的用户系统接口
public interface OldUserService {
    String findUserName(int userId);
}

// 新的用户系统接口
public interface NewUserService {
    User findById(Long userId);
}

// 新的实现
public class NewUserServiceImpl implements NewUserService {
    @Override
    public User findById(Long userId) {
        return new User(userId, "username");
    }
}

// 适配器：让新系统兼容旧接口
@Component
public class UserServiceAdapter implements OldUserService {
    @Autowired
    private NewUserService newUserService;
    
    @Override
    public String findUserName(int userId) {
        User user = newUserService.findById((long) userId);
        return user != null ? user.getName() : null;
    }
}

优缺点

优点 缺点
解耦目标类和被适配者 增加系统复杂度
复用现有类 过多适配器使代码难以理解
扩展性好

总结

适配器模式是解决接口不兼容问题的有效手段。对象适配器比类适配器更灵活（通过组合而非继承），是更推荐的方式。在集成第三方库、系统升级等场景中非常实用。

]]>