跟着 Spring MVC 学习 23 种设计模式

于 2025-06-21 09:44:10 发布
阅读量593 收藏 8
点赞数 8
CC 4.0 BY-SA版权
分类专栏： # 设计模式23+1条 文章标签： Spring MVC 学习 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/csdn_tom_168/article/details/148800166

以下是 Spring MVC 框架中涉及的 23 种设计模式的分类、技术原理及代码示例：

一、创建型模式

1. 工厂方法模式 (Factory Method)

作用：定义创建对象的接口，由子类决定实例化哪个类。

Spring MVC 实现：

  • HandlerMapping 工厂：根据请求映射规则选择具体的 HandlerAdapter。
public interface HandlerMapping {
    HandlerExecutionChain getHandler(HttpServletRequest request);
}

// 具体实现（RequestMappingHandlerMapping）
public class RequestMappingHandlerMapping implements HandlerMapping {
    @Override
    public HandlerExecutionChain getHandler(HttpServletRequest request) {
        // 根据请求路径查找对应的 Controller 方法
        return lookupHandlerMethod(request);
    }
}
2. 抽象工厂模式 (Abstract Factory)

作用：创建一组相关或依赖的对象，而无需指定具体类。

Spring MVC 实现：

  • ViewResolver 抽象工厂：根据视图名称解析不同的视图实现（如 JSP、Thymeleaf）。
public interface ViewResolver {
    View resolveViewName(String viewName, Locale locale);
}

// 具体实现（InternalResourceViewResolver）
public class InternalResourceViewResolver implements ViewResolver {
    @Override
    public View resolveViewName(String viewName, Locale locale) {
        return new InternalResourceView("/WEB-INF/views/" + viewName + ".jsp");
    }
}
3. 单例模式 (Singleton)

作用：确保一个类只有一个实例，并提供全局访问点。

Spring MVC 实现：

  • DispatcherServlet 实例：通过 WebApplicationContext 确保全局唯一。
public class DispatcherServlet extends FrameworkServlet {
    @Override
    protected WebApplicationContext createWebApplicationContext(WebApplicationContext parent) {
        return getWebApplicationContext(); // 返回全局唯一的上下文
    }
}
4. 建造者模式 (Builder)

作用：逐步构建复杂对象，允许用户通过链式调用设置属性。

Spring MVC 实现：

  • RequestMappingHandlerAdapter 配置：通过链式调用配置消息转换器。
@Configuration
public class WebConfig implements WebMvcConfigurer {
    @Override
    public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
        converters.add(new MappingJackson2HttpMessageConverter()); // 添加 JSON 转换器
    }
}
5. 原型模式 (Prototype)

作用：通过克隆现有对象创建新实例。

Spring MVC 实现：

  • Model 原型：通过 ModelMap 克隆模型数据。
@Controller
public class MyController {
    @GetMapping("/data")
    public String getData(Model model) {
        model.addAttribute("key", "value");
        ModelMap clonedModel = (ModelMap) model.asMap().clone(); // 克隆模型
        return "view";
    }
}

二、结构型模式

6. 适配器模式 (Adapter)

作用：将接口转换为客户端期望的另一个接口。

Spring MVC 实现：

  • HandlerAdapter 适配器：适配不同控制器（如 Controller、HttpRequestHandler）。
public interface HandlerAdapter {
    boolean supports(Object handler);
    ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler);
}

// 具体适配器（SimpleControllerHandlerAdapter）
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);
    }
}
7. 装饰器模式 (Decorator)

作用：动态为对象添加附加功能。

Spring MVC 实现：

  • HandlerInterceptor 装饰器：为请求处理添加拦截功能（如日志、权限）。
public class LoggingInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        System.out.println("Request received: " + request.getRequestURI());
        return true;
    }
}
8. 代理模式 (Proxy)

作用：通过代理对象控制对原对象的访问。

Spring MVC 实现：

  • AOP 代理：通过 JDK 动态代理或 CGLIB 代理增强控制器。
@Aspect
@Component
public class LoggingAspect {
    @Before("execution(* com.example.controller.*.*(..))")
    public void logBefore(JoinPoint joinPoint) {
        System.out.println("Method called: " + joinPoint.getSignature().getName());
    }
}
9. 外观模式 (Facade)

作用：为复杂子系统提供简化的接口。

Spring MVC 实现：

  • DispatcherServlet 外观：封装请求分发流程。
public class DispatcherServlet extends FrameworkServlet {
    @Override
    protected void doService(HttpServletRequest request, HttpServletResponse response) {
        // 1. 获取 Handler
        // 2. 准备 ModelAndView
        // 3. 渲染视图
    }
}
10. 桥接模式 (Bridge)

作用：将抽象与实现解耦，使两者可以独立变化。

Spring MVC 实现：

  • MultipartResolver 桥接：桥接不同文件上传实现（如 Commons FileUpload、Servlet 3.0）。
public interface MultipartResolver {
    boolean isMultipart(HttpServletRequest request);
    MultipartHttpServletRequest resolveMultipart(HttpServletRequest request);
}

// 具体实现（StandardServletMultipartResolver）
public class StandardServletMultipartResolver implements MultipartResolver {
    @Override
    public boolean isMultipart(HttpServletRequest request) {
        return ServletFileUpload.isMultipartContent(request);
    }
}
11. 组合模式 (Composite)

作用：将对象组合成树形结构，以表示“部分-整体”的层次结构。

Spring MVC 实现：

  • HandlerExecutionChain 组合：组合处理器和拦截器。
public class HandlerExecutionChain {
    private final Object handler;
    private final List<HandlerInterceptor> interceptors = new ArrayList<>();

    public HandlerExecutionChain(Object handler) {
        this.handler = handler;
    }

    public void addInterceptor(HandlerInterceptor interceptor) {
        interceptors.add(interceptor);
    }
}
12. 享元模式 (Flyweight)

作用：共享对象以减少内存占用。

Spring MVC 实现：

  • HandlerMapping 复用：通过 RequestMappingInfo 缓存映射信息。
public class RequestMappingInfo {
    private final Pattern pattern;
    private final RequestMethod[] methods;

    public RequestMappingInfo(Pattern pattern, RequestMethod[] methods) {
        this.pattern = pattern;
        this.methods = methods;
    }

    public Pattern getPattern() {
        return pattern;
    }
}

三、行为型模式

13. 模板方法模式 (Template Method)

作用：定义算法骨架，将某些步骤延迟到子类实现。

Spring MVC 实现：

  • AbstractViewController 模板：定义视图渲染流程，子类实现具体步骤。
public abstract class AbstractViewController extends WebContentGenerator implements View {
    @Override
    public void render(Map<String, ?> model, HttpServletRequest request, HttpServletResponse response) {
        // 公共逻辑（如内容协商）
        renderMergedOutputModel(model, request, response); // 调用子类实现
    }

    protected abstract void renderMergedOutputModel(Map<String, ?> model, HttpServletRequest request, HttpServletResponse response);
}
14. 观察者模式 (Observer)

作用：定义对象间的一对多依赖，当一个对象状态改变时，所有依赖者收到通知。

Spring MVC 实现：

  • ApplicationEvent 监听器：监听上下文刷新事件。
public class ContextRefreshedEventListener implements ApplicationListener<ContextRefreshedEvent> {
    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        System.out.println("Context refreshed: " + event.getApplicationContext().getId());
    }
}
15. 策略模式 (Strategy)

作用：定义一系列算法，并将每个算法封装起来，使它们可以互换。

Spring MVC 实现：

  • ContentNegotiationStrategy 策略：根据请求头选择内容类型（如 JSON、XML）。
public interface ContentNegotiationStrategy {
    MediaType resolveMediaType(HttpServletRequest request);
}

// 具体策略（HeaderContentNegotiationStrategy）
public class HeaderContentNegotiationStrategy implements ContentNegotiationStrategy {
    @Override
    public MediaType resolveMediaType(HttpServletRequest request) {
        String acceptHeader = request.getHeader("Accept");
        return MediaType.parseMediaType(acceptHeader);
    }
}
16. 命令模式 (Command)

作用：将请求封装为对象，以便用不同的请求、队列或日志参数化其他对象。

Spring MVC 实现：

  • HandlerMethod 命令：封装控制器方法调用。
public class HandlerMethod {
    private final Object bean;
    private final Method method;

    public Object invoke(Object... args) {
        try {
            return method.invoke(bean, args); // 封装方法调用
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}
17. 责任链模式 (Chain of Responsibility)

作用：将请求的发送者和接收者解耦，使多个对象都有机会处理请求。

Spring MVC 实现：

  • Interceptor 链：通过拦截器链处理请求。
public class HandlerExecutionChain {
    private final List<HandlerInterceptor> interceptors = new ArrayList<>();

    public boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) {
        for (HandlerInterceptor interceptor : interceptors) {
            if (!interceptor.preHandle(request, response, handler)) {
                return false; // 终止责任链
            }
        }
        return true;
    }
}
18. 备忘录模式 (Memento)

作用：捕获并保存对象的内部状态，以便后续恢复。

Spring MVC 实现：

  • Model 状态保存：通过 ModelMap 保存模型状态快照。
public class ModelMap implements Map<String, Object> {
    private final Map<String, Object> model = new LinkedHashMap<>();

    public void addAttribute(String attributeName, Object attributeValue) {
        model.put(attributeName, attributeValue);
    }

    public Map<String, Object> asMap() {
        return model;
    }
}
19. 状态模式 (State)

作用：允许对象在内部状态改变时改变行为。

Spring MVC 实现：

  • View 状态管理：通过状态机管理视图渲染状态。
public enum ViewState {
    RENDERED,
    NOT_RENDERED
}

// 状态管理
public class InternalResourceView implements View {
    private ViewState state = ViewState.NOT_RENDERED;

    @Override
    public void render(Map<String, ?> model, HttpServletRequest request, HttpServletResponse response) {
        state = ViewState.RENDERED; // 修改状态
    }
}
20. 访问者模式 (Visitor)

作用：在对象结构中定义新操作，而无需修改结构本身。

Spring MVC 实现：

  • ModelAndViewContainer 访问者：通过访问者模式访问模型和视图。
public interface ModelAndViewContainerVisitor {
    void visitModel(ModelMap model);
    void visitView(View view);
}

// 具体访问者（ModelAndViewLogger）
public class ModelAndViewLogger implements ModelAndViewContainerVisitor {
    @Override
    public void visitModel(ModelMap model) {
        System.out.println("Model: " + model);
    }

    @Override
    public void visitView(View view) {
        System.out.println("View: " + view);
    }
}
21. 解释器模式 (Interpreter)

作用：给定一种语言，定义其文法表示，并构建解释器来解释语言中的句子。

Spring MVC 实现：

  • SpEL 表达式解析：通过 SpelExpressionParser 解析表达式。
ExpressionParser parser = new SpelExpressionParser();
Expression expression = parser.parseExpression("'Hello, ' + name");
EvaluationContext context = new StandardEvaluationContext();
context.setVariable("name", "World");
String result = expression.getValue(context, String.class); // 输出 "Hello, World"
22. 迭代器模式 (Iterator)

作用：提供一种顺序访问集合元素的方法，而无需暴露其内部表示。

Spring MVC 实现：

  • Model 迭代器：遍历模型属性。
public class ModelMap implements Map<String, Object> {
    private final Map<String, Object> model = new LinkedHashMap<>();

    @Override
    public Set<Entry<String, Object>> entrySet() {
        return model.entrySet(); // 返回迭代器
    }
}
23. 中介者模式 (Mediator)

作用：定义一个中介对象来封装一系列对象之间的交互。

Spring MVC 实现：

  • DispatcherServlet 作为中介者：协调 HandlerMapping、HandlerAdapter、ViewResolver 等组件之间的交互。
public class DispatcherServlet extends FrameworkServlet {
    @Override
    protected void doDispatch(HttpServletRequest request, HttpServletResponse response) {
        // 1. 通过 HandlerMapping 获取 Handler
        // 2. 通过 HandlerAdapter 调用 Handler
        // 3. 通过 ViewResolver 渲染视图
    }
}

总结

Spring MVC 框架通过灵活运用 23 种设计模式，实现了高扩展性、低耦合性和灵活性。这些模式覆盖了对象创建、结构组织、行为交互等各个方面，是学习 Java Web 框架设计的经典案例。

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值