第四十七章 Spring之假如让你来写MVC——闪存管理器篇

🕗 发布于 2025-01-22 12:11 spring mvc java

Spring源码阅读目录

第一部分——IOC篇

第一章 Spring之最熟悉的陌生人——IOC
第二章 Spring之假如让你来写IOC容器——加载资源篇
第三章 Spring之假如让你来写IOC容器——解析配置文件篇
第四章 Spring之假如让你来写IOC容器——XML配置文件篇
第五章 Spring之假如让你来写IOC容器——BeanFactory和FactoryBean
第六章 Spring之假如让你来写IOC容器——Scope和属性填充
第七章 Spring之假如让你来写IOC容器——属性填充特别篇：SpEL表达式
第八章 Spring之假如让你来写IOC容器——拓展篇
第九章 Spring之源码阅读——环境搭建篇
第十章 Spring之源码阅读——IOC篇

第二部分——AOP篇

第三部分——事务篇

第二十五章 Spring之曾经的老朋友——事务
第二十六章 Spring之假如让你来写事务——初稿篇
第二十七章 Spring之假如让你来写事务——铁三角篇
第二十八章 Spring之假如让你来写事务——属性篇
第二十九章 Spring之假如让你来写事务——状态篇
第三十章 Spring之假如让你来写事务——管理篇
第三十一章 Spring之假如让你来写事务——融入IOC容器篇
第三十二章 Spring之源码阅读——事务篇

第四部分——MVC篇

前言

对于Spring一直都是既熟悉又陌生，说对它熟悉吧，平时用用没啥问题，但面试的时候被问的一脸懵逼，就很尴尬，都不好意思在简历上写着熟悉Spring了
在这里插入图片描述

所以决定花点时间研究研究Spring的源码。主要参考的书籍是：《Spring源码深度解析（第2版）》、《Spring揭秘》、《Spring技术内幕：深入解析Spring架构与设计原理（第2版）》

书接上回，在上篇 第四十六章 Spring之假如让你来写MVC——主题解析器篇 中，A君已经完成了 主题解析器 部分的功能了。接下来看看 A君会有什么骚操作吧

尝试动手写IOC容器

出场人物：A君（苦逼的开发）、老大（项目经理）

背景：老大要求 A君在一周内开发个简单的 IOC容器

前情提要：A君已经完成了 主题解析器 部分的功能了。。。

第四十一版闪存管理器

“A君，就快结束了，今天在完成一个组件吧。” 老大说道

“啊，还没玩啊，还有啥组件？” A君都快崩溃了

“哈哈哈，不多了，就剩两个组件了。” 老大笑道

“那今天是什么？” A君问道

“就是重定向和转发，转发过程中需要存储的数据，去渲染视图。” A君问道

“那要如何实现呢？” A君疑惑道

“其实也不难，保留在内存中就行了，等过期后在失效掉。不过，看了下代码，你之前似乎并未实现 重定向视图，这部分内容你也补充下吧！” 老大解释道

“好吧。” A君无奈应到，只能默默回去干活了

闪存数据结构

走出办公室后，A君径直回到了自己的工位上，开始琢磨闪存的事情了。按照老大的说法，闪存存在着过期时间，那就不能是简单的Map能解决的，除了过期时间，闪存也可能存在着一个key，多个value的情况，如：复选框。同时也可以根据目标请求路径存储数据。基于上述这么多情况，自然就得定义个单独的类来进行处理了。A君新增FlashMap类，代码如下：

/**
 * 闪存
 */
public final class FlashMap extends HashMap<String, Object> implements Comparable<FlashMap> {

    private final MultiValueMap<String, String> targetRequestParams = new LinkedMultiValueMap<>(3);
    /**
     * 目标请求路径
     */
    private String targetRequestPath;
    /**
     * 过期时间
     */
    private long expirationTime = -1;

    public void startExpirationPeriod(int timeToLive) {
        this.expirationTime = System.currentTimeMillis() + timeToLive * 1000;
    }

    public FlashMap addTargetRequestParams(MultiValueMap<String, String> params) {
        if (params != null) {
            params.forEach((key, values) -> {
                for (String value : values) {
                    addTargetRequestParam(key, value);
                }
            });
        }
        return this;
    }

    public FlashMap addTargetRequestParam(String name, String value) {
        if (StringUtils.hasText(name) && StringUtils.hasText(value)) {
            this.targetRequestParams.add(name, value);
        }
        return this;
    }

    public MultiValueMap<String, String> getTargetRequestParams() {
        return this.targetRequestParams;
    }


    public boolean isExpired() {
        return (this.expirationTime != -1 && System.currentTimeMillis() > this.expirationTime);
    }

    @Override
    public int compareTo(FlashMap other) {
        int thisUrlPath = (this.targetRequestPath != null ? 1 : 0);
        int otherUrlPath = (other.targetRequestPath != null ? 1 : 0);
        if (thisUrlPath != otherUrlPath) {
            return otherUrlPath - thisUrlPath;
        } else {
            return other.targetRequestParams.size() - this.targetRequestParams.size();
        }
    }
//省略其他代码。。。
}

闪存管理器

闪存数据结构 定义好之后，接着就是如何管理它了，直接操作FlashMap对象也不是不行，但是毕竟还是太过麻烦了，也不好管理。与其如此，不如直接定义个管理者，让它进行统一操作。管理器也简单，就干两件事：增加、更新。A君新增FlashMapManager接口，代码如下：

/**
 * 闪存管理器
 */
public interface FlashMapManager {
    /**
     * 清除闪存
     *
     * @param request
     * @param response
     * @return
     */
    FlashMap retrieveAndUpdate(HttpServletRequest request, HttpServletResponse response);

    /**
     * 保存闪存
     *
     * @param flashMap
     * @param request
     * @param response
     */
    void saveOutputFlashMap(FlashMap flashMap, HttpServletRequest request, HttpServletResponse response);
}

接下来就是抽象类了，哪些可以提取出来呢？A君开动脑瓜开始思考：清理要怎么清理？保存要怎么保存？

清理：首当其冲的自然是过期数据了，这个不用怀疑。还有就是每个url需要保留多少数据？对于一次请求来说，请求结束也意味着这些数据已经失效，其生命周期很短，这就意味着闪存不可能存储很多数据。那就定一个规则：每次都拉出一个倒霉鬼进行清理，目标url为空的优先，参数多的优先谁叫他占内存呢（笑）？
保存：这就更简单了，获取已有数据和现有数据合并即可了

思绪整理完毕后，A君新增AbstractFlashMapManager类，代码如下：

public abstract class AbstractFlashMapManager implements FlashMapManager {

    private static final Object DEFAULT_FLASH_MAPS_MUTEX = new Object();
    /**
     * 180s
     */
    private int flashMapTimeout = 180;
    private UrlPathHelper urlPathHelper = UrlPathHelper.defaultInstance;

@Override
    public final FlashMap retrieveAndUpdate(HttpServletRequest request, HttpServletResponse response) {
        List<FlashMap> allFlashMaps = retrieveFlashMaps(request);
        if (CollectionUtils.isEmpty(allFlashMaps)) {
            return null;
        }
        /**
         *获取过期数据
         */
        List<FlashMap> mapsToRemove = getExpiredFlashMaps(allFlashMaps);
        /**
         * targetPath、参数多的会优先被清理
         */
        FlashMap match = getMatchingFlashMap(allFlashMaps, request);
        if (match != null) {
            mapsToRemove.add(match);
        }

        if (!mapsToRemove.isEmpty()) {
            Object mutex = getFlashMapsMutex(request);
            if (mutex != null) {
                synchronized (mutex) {
                    //清除数据
                    allFlashMaps = retrieveFlashMaps(request);
                    if (allFlashMaps != null) {
                        allFlashMaps.removeAll(mapsToRemove);
                        updateFlashMaps(allFlashMaps, request, response);
                    }
                }
            } else {
                allFlashMaps.removeAll(mapsToRemove);
                updateFlashMaps(allFlashMaps, request, response);
            }
        }

        return match;
    }

@Override
    public final void saveOutputFlashMap(FlashMap flashMap, HttpServletRequest request, HttpServletResponse response) {
        if (CollectionUtils.isEmpty(flashMap)) {
            return;
        }
        /**
         * 修正地址
         */
        String path = decodeAndNormalizePath(flashMap.getTargetRequestPath(), request);
        flashMap.setTargetRequestPath(path);
        //设置开始时间
        flashMap.startExpirationPeriod(getFlashMapTimeout());

        /**
         * 获取对象锁
         */
        Object mutex = getFlashMapsMutex(request);
        if (mutex != null) {
            synchronized (mutex) {
                /**
                 * 获取老数据
                 */
                List<FlashMap> allFlashMaps = retrieveFlashMaps(request);
                allFlashMaps = (allFlashMaps != null ? allFlashMaps : new CopyOnWriteArrayList<>());
                /**
                 * 添加并更新数据
                 */
                allFlashMaps.add(flashMap);
                updateFlashMaps(allFlashMaps, request, response);
            }
        } else {
            List<FlashMap> allFlashMaps = retrieveFlashMaps(request);
            allFlashMaps = (allFlashMaps != null ? allFlashMaps : new ArrayList<>(1));
            allFlashMaps.add(flashMap);
            updateFlashMaps(allFlashMaps, request, response);
        }
    }

protected abstract List<FlashMap> retrieveFlashMaps(HttpServletRequest request);

    protected abstract void updateFlashMaps(
            List<FlashMap> flashMaps, HttpServletRequest request, HttpServletResponse response);

//省略其他代码。。。
}

抽象类已经把大部分逻辑提取出来了，剩下的部分就是从哪里获取数据？从哪里更新数据？这个有可能是Cookie，也有可能是Session。老样子，这里还是以Session为例，这个很简单，直接从Session中的获取值就行了。A君新增SessionFlashMapManager类，代码如下：

public class SessionFlashMapManager extends AbstractFlashMapManager {

    private static final String FLASH_MAPS_SESSION_ATTRIBUTE = SessionFlashMapManager.class.getName() + ".FLASH_MAPS";

    @Override
    protected List<FlashMap> retrieveFlashMaps(HttpServletRequest request) {
        HttpSession session = request.getSession(false);
        return (session != null ? (List<FlashMap>) session.getAttribute(FLASH_MAPS_SESSION_ATTRIBUTE) : null);
    }

    @Override
    protected void updateFlashMaps(List<FlashMap> flashMaps, HttpServletRequest request, HttpServletResponse response) {
        WebUtils.setSessionAttribute(request, FLASH_MAPS_SESSION_ATTRIBUTE, (!flashMaps.isEmpty() ? flashMaps : null));
    }

    @Override
    protected Object getFlashMapsMutex(HttpServletRequest request) {
        return WebUtils.getSessionMutex(request.getSession());
    }
}

重定向视图

闪存管理器 是定义好了，可是在哪里用呢？A君不经一阵挠头。总不能在DispatcherServlet中弄吧。又思索了一阵，A君忽然发现，不论 重定向 还是转发，其实都是在返回值里边定义，转发还好说，直接通过分发器就行了，接着就是 重定向 了，不如定一个视图来进行处理。实现是解决了，但是还有个问题：这个视图要干什么？A君又想了下，所谓 重定向 无非就是uri的定义罢了。重定向 到哪里？要不要带参数？要带哪些参数？这个就是 重定向视图 要处理的重点了。好啦，一切都敲定了。A君新增RedirectView类，代码如下：

/**
 * 重定向视图
 */
public class RedirectView extends AbstractUrlBasedView implements SmartView {

    /**
     * 是否是绝对路径
     */
    private boolean contextRelative = false;
    /**
     * 是否兼容 HTTP/1.0
     */
    private boolean http10Compatible = true;
    /**
     * 暴露模型属性
     */
    private boolean exposeModelAttributes = true;
    /**
     * URL 编码
     */
    private String encodingScheme;
    /**
     * 响应码
     */
    private HttpStatus statusCode;

    /**
     * 是否将当前请求的查询参数传递到目标 URL
     */
    private boolean propagateQueryParams = false;

    /**
     * 主机名
     */
    private String[] hosts;

 @Override
    protected void renderMergedOutputModel(Map<String, Object> model, HttpServletRequest request,HttpServletResponse response) throws IOException {

        String targetUrl = createTargetUrl(model, request);
        targetUrl = updateTargetUrl(targetUrl, model, request, response);
        //保存到闪存中
        RequestContextUtils.saveOutputFlashMap(targetUrl, request, response);
        // 重定向
        sendRedirect(request, response, targetUrl, this.http10Compatible);
    }

    /**
     * 构建重定向url
     *
     * @param model
     * @param request
     * @return
     * @throws UnsupportedEncodingException
     */
    protected final String createTargetUrl(Map<String, Object> model, HttpServletRequest request)
            throws UnsupportedEncodingException {

        StringBuilder targetUrl = new StringBuilder();
        if (this.contextRelative && getUrl().startsWith("/")) {
            targetUrl.append(getContextPath(request));
        }
        targetUrl.append(getUrl());

        String enc = this.encodingScheme;
        /**
         * 编码为空，使用请求编码
         */
        if (enc == null) {
            enc = request.getCharacterEncoding();
        }
        /**
         * 请求编码还是为空，使用默认编码
         */
        if (enc == null) {
            enc = WebUtils.DEFAULT_CHARACTER_ENCODING;
        }
        /**
         * 是否追加参数
         */
        if (isPropagateQueryProperties()) {
            appendCurrentQueryParams(targetUrl, request);
        }
        /**
         * 是否暴露模型数据
         */
        if (this.exposeModelAttributes) {
            appendQueryProperties(targetUrl, model, enc);
        }
        return targetUrl.toString();
    }
//省略其他方法。。。
}

这个类基本上就是在构建url，拼接参数

修改`UrlBasedViewResolver`

之前在写UrlBasedViewResolver时候，A君并没有支持 重定向、转发，这回就可以加上了。改动的点也比较简单，在渲染的时候，做个判断就行了。A君修改createView方法，改动如下：

@Override
    protected View createView(String viewName, Locale locale) throws Exception {
        /**
         * 是否能够处理
         */
        if (!canHandle(viewName, locale)) {
            return null;
        }
        /**
         * 重定向
         */
        if (viewName.startsWith(REDIRECT_URL_PREFIX)) {
            String redirectUrl = viewName.substring(REDIRECT_URL_PREFIX.length());
            RedirectView view = new RedirectView(redirectUrl,
                    isRedirectContextRelative(), isRedirectHttp10Compatible());
            String[] hosts = getRedirectHosts();
            if (hosts != null) {
                view.setHosts(hosts);
            }
            return applyLifecycleMethods(REDIRECT_URL_PREFIX, view);
        }
        /**
         * 转发
         */
        if (viewName.startsWith(FORWARD_URL_PREFIX)) {
            String forwardUrl = viewName.substring(FORWARD_URL_PREFIX.length());
            InternalResourceView view = new InternalResourceView(forwardUrl);
            return applyLifecycleMethods(FORWARD_URL_PREFIX, view);
        }
        return super.createView(viewName, locale);
    }

修改`DispatcherServlet`

现在组件基本准备好了，既然是组件，那么DispatcherServlet就当之无愧了。首先需要的是初始化该组件，A君新增initFlashMapManager方法，代码如下：

    protected void initStrategies() {
        /**
         *1.初始化文件上传
         */
        initMultipartResolver();
        /**
         * 2.初始化国际化
         */
        initLocaleResolver();
        /**
         * 3.初始化主题
         */
        initThemeResolver();
        /**
         * 4.初始化url处理器
         */
        initHandlerMappings();
        /**
         * 5.初始化适配器
         */
        initHandlerAdapters();
        /**
         * 6.初始化异常处理
         */
        initHandlerExceptionResolvers();
        /**
         * 初始化视图
         */
        initViewResolvers();
        /**
         * 初始化闪存管理器
         */
        initFlashMapManager();
    }

    private void initFlashMapManager() {
        this.flashMapManager = new SessionFlashMapManager();
    }

还有一个问题：谁去清理闪存？谁去创建闪存对象？当下 A君对doService方法进行修改，改动如下：

    protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {
        Map<String, Object> attributesSnapshot = null;
        if (WebUtils.isIncludeRequest(request)) {
            //清理include
            attributesSnapshot = new HashMap<>();
            Enumeration<?> attrNames = request.getAttributeNames();
            while (attrNames.hasMoreElements()) {
                String attrName = (String) attrNames.nextElement();
                if (this.cleanupAfterInclude || attrName.startsWith(DEFAULT_STRATEGIES_PREFIX)) {
                    attributesSnapshot.put(attrName, request.getAttribute(attrName));
                }
            }
        }
        //设置国际化处理器
        request.setAttribute(LOCALE_RESOLVER_ATTRIBUTE, this.localeResolver);
        //设置主题处理器
        request.setAttribute(THEME_RESOLVER_ATTRIBUTE, this.themeResolver);
        /**
         * 存在闪存管理器
         */
        if (this.flashMapManager != null) {
            FlashMap inputFlashMap = this.flashMapManager.retrieveAndUpdate(request, response);
            if (inputFlashMap != null) {
                /**
                 * 已存在，转成不可修改的
                 */
                request.setAttribute(INPUT_FLASH_MAP_ATTRIBUTE, Collections.unmodifiableMap(inputFlashMap));
            }
            //不存在，建立新的缓存
            request.setAttribute(OUTPUT_FLASH_MAP_ATTRIBUTE, new FlashMap());
            request.setAttribute(FLASH_MAP_MANAGER_ATTRIBUTE, this.flashMapManager);
        }
        doDispatch(request, response);
    }

就新增了对于闪存的处理，并无太多东西

测试

好了，现在一切都完成了，又可以开始愉快地测试了。这次测试主要就集中在 控制器 上，其他地方基本就不用改动。A君新增HelloController代码：

@Controller
public class HelloController {
    // 首页视图
    @RequestMapping("/index")
    public String home(Model model) {
        // 将 Flash 属性添加到重定向的请求中
        model.addAttribute("message", "Form submitted successfully!");
        return "redirect:hello";
    }

    @RequestMapping("/hello")
    public String hello(String message, Model model) {
        model.addAttribute("message", message);
        return "hello";
    }
}

添加一个hello.jsp，代码如下：


<%@page isELIgnored="false"%>
<html>
<body>
<h2>This message is: ${requestScope.message}</h2>
</body>
</html>

然后就可以添加测试代码，如下：

@Test
    public void v41() throws LifecycleException {
        System.out.println("############# 第四十一版： 闪存管理器篇 #############");
        Tomcat tomcat = new Tomcat();
        //设置端口
        tomcat.setPort(8082);
        //设置静态资源路径
        String webApp = new File("src/main/resources/v41").getAbsolutePath();
        Context context = tomcat.addWebapp("/test/", webApp);
        tomcat.start();
        //挂起
        tomcat.getServer().await();
    }

测试结果如下：

在这里插入图片描述

可以看到，经过 重定向 后，url后边也拼上参数。OK，现在 A君也可以下班了

在这里插入图片描述

总结

正所谓树欲静而风不止，欲知后事如何，请看下回分解(✪ω✪)

原文地址：https://blog.csdn.net/weixin_42789334/article/details/144970305

免责声明：本站文章内容转载自网络资源，如侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：Java并发容器使用
下一篇：【腾讯云】docker创建网络遇到Unable to enable SKIP DNAT rule

【优选算法】3----快乐数
这是第三篇算法题，也是十分的不好想，虽然定位在简单，但我感觉还是有些难度的~
阅读更多2025-01-22
算法竞赛之差分进阶——等差数列差分 python
给定区间 [ l, r ]，把数组[ l, r ] 区间中的数加上一个首项s、末项e、公差为d的等差数列如何实现？
阅读更多2025-01-22
Linux:进程控制
• 另外，进程⼀旦变成僵⼫状态，那就⼑枪不⼊，“杀⼈不眨眼”的kill -9 也⽆能为⼒，因为谁也没有办法杀死⼀个已经死去的进程。通常，⽗⼦代码共享，⽗⼦再不写⼊时，数据也是共享的，当任意⼀⽅试图写⼊
阅读更多2025-01-22
2024：CSDN上的收获与蜕变——我的技术成长之旅
2024：CSDN上的收获与蜕变——我的技术成长之旅
阅读更多2025-01-22
【C】memory 详解
【C】memory详解
阅读更多2025-01-22
OpenMP并行编程实例系列3 —— 线程设置
等待同步：用在并行域内，所有线程执行到 barrier 都要停下等待，直到所有线程都执行到 barrier，然后再继续往下执行。指定并行域中的串行任务，创建仅由一个线程执行的任务，先到先执行，其他线程
阅读更多2025-01-22
【GitHub】登录时的2FA验证
如何进行2FA认证，以及验证后如何在新设备或新浏览器登录
阅读更多2025-01-22
【Python项目】小区监控图像拼接系统
科技的介入正在重塑我们的生活方式，而越来越多的人也开始享受这种由科技带来的便利和变化。例如，监控画面分散，安保人员需要在多个屏幕上查看不同的区域，这不仅增加了管理难度，也降低了监控效率。该系统利用先进
阅读更多2025-01-22
Mysql触发器（学习自用）
仅供学习使用，如有错误，欢迎指正。
阅读更多2025-01-22
堆的实现（C语言详解版）
（Heap）是一种特殊的完全二叉树，它满足父节点的值总是不大于或不小于其子节点的值。这种数据结构常用于实现优先队列，以及在各种排序算法中快速找到最大或最小元素。和。在最大堆中，父节点的值总是大于或等于
阅读更多2025-01-22