你知道@RequestMapping的name属性有什么用吗？【享学Spring MVC】

每篇一句

牛逼架构师：把复杂问题简单化，把简单问题搞没
菜逼架构师：把简单问题复杂化

前言

不知这个标题能否勾起你的好奇心和求知欲？在spring mvc的使用中，若我说@requestmapping是最为常用的一个注解你应该没啥意见吧。若你细心的话你能发现它有一个name属性(spring4.1后新增)，大概率你从来都没有使用过且鲜有人知。

我本人搜了搜相关文章，也几乎没有一篇文章较为系统化的介绍它。可能有人会说搜不到就代表不重要/不流行嘛，我大部分统一这个观点，但这块知识点我觉得还挺有意思，因此本文就针对性的弥补市面的空白，带你了解name属性的作用和使用。更为重要的是借此去了解学习spring mvc非常重要的uri builder模式

@requestmapping的name属性

首先看此属性在@requestmapping中的定义：

@target({elementtype.method, elementtype.type})
@retention(retentionpolicy.runtime)
@documented
@mapping
public @interface requestmapping {
    // @since 4.1
    string name() default "";
    ...
}

javadoc描述：为此映射分配名称，它可以使用在类上，也可以标注在方法上。

在分析requestmappinghandlermapping源码的时候指出过：它的createrequestmappinginfo()方法会把注解的name封装到requestmappinginfo.name属性里。因为它既可以在类上又可以在方法上，因此一样的它需要combine，但是它的combine逻辑稍微特殊些，此处展示如下：

requestmappinginfo：

    // 此方法来自接口：requestcondition
    @override
    public requestmappinginfo combine(requestmappinginfo other) {
        string name = combinenames(other);
        patternsrequestcondition patterns = this.patternscondition.combine(other.patternscondition);
        requestmethodsrequestcondition methods = this.methodscondition.combine(other.methodscondition);
        ...
        return new requestmappinginfo( ... );
    }

    @nullable
    private string combinenames(requestmappinginfo other) {
        if (this.name != null && other.name != null) {
            string separator = requestmappinginfohandlermethodmappingnamingstrategy.separator;
            return this.name + separator + other.name;
        } else if (this.name != null) {
            return this.name;
        } else {
            return other.name;
        }
    }

逻辑不难，就是类+"#"+方法的拼接，但是我们知道其实绝大部分情况下我们都从来没有指定过name属性，那么此处就不得不提这个策略接口：handlermethodmappingnamingstrategy了，它用于缺省的名字生成策略器

handlermethodmappingnamingstrategy

为处理程序handlermethod方法分配名称的策略接口。此接口可以在abstracthandlermethodmapping里配置生成name，然后这个name可以用于abstracthandlermethodmapping#gethandlermethodsformappingname(string)方法进行查询~

// @since 4.1
@functionalinterface // 函数式接口
public interface handlermethodmappingnamingstrategy<t> {
    
    // determine the name for the given handlermethod and mapping.
    // 根据handlermethod 和 mapping拿到一个name
    string getname(handlermethod handlermethod, t mapping);
}

它的唯一实现类是：requestmappinginfohandlermethodmappingnamingstrategy（目前而言requestmappinginfo的唯一实现只有@requestmapping，但设计上是没有强制绑定必须是这个注解~）

requestmappinginfohandlermethodmappingnamingstrategy

此类提供name的默认的生成规则（若没指定的话）的实现

// @since 4.1
public class requestmappinginfohandlermethodmappingnamingstrategy implements handlermethodmappingnamingstrategy<requestmappinginfo> {
    // 类级别到方法级别的分隔符（当然你也是可以改的）
    public static final string separator = "#";

    @override
    public string getname(handlermethod handlermethod, requestmappinginfo mapping) {
        if (mapping.getname() != null) { // 若使用者自己指定了，那就以指定的为准
            return mapping.getname();
        }
        // 自动生成的策略
        stringbuilder sb = new stringbuilder();
        
        // 1、拿到类名
        // 2、遍历每个字母，拿到所有的大写字母
        // 3、用拿到的大写字母拼接 # 拼接方法名。如：testcontroller#getfoo()最终结果是：tc#getfoo
        string simpletypename = handlermethod.getbeantype().getsimplename();
        for (int i = 0; i < simpletypename.length(); i++) {
            if (character.isuppercase(simpletypename.charat(i))) {
                sb.append(simpletypename.charat(i));
            }
        }
        sb.append(separator).append(handlermethod.getmethod().getname());
        return sb.tostring();
    }

}

简单总结这部分逻辑如下：

1. 类上的name值 + '#' + 方法的name值
2. 类上若没指定，默认值是：类名所有大写字母拼装
3. 方法上若没指定，默认值是：方法名

name属性有什么用（如何使用）？

说了这么多，小伙伴可能还是一头雾水？有什么用？如何用？

其实在接口的javadoc里有提到了它的作用：应用程序可以在下面这个静态方法的帮助下按名称构建控制器方法的url，它借助的是mvcuricomponentsbuilder的frommappingname方法实现：

mvcuricomponentsbuilder：
    
    // 静态方法：根据mappingname，获取到一个methodargumentbuilder
    public static methodargumentbuilder frommappingname(string mappingname) {
        return frommappingname(null, mappingname);
    }
    public static methodargumentbuilder frommappingname(@nullable uricomponentsbuilder builder, string name) {
        ...
        map<string, requestmappinginfohandlermapping> map = wac.getbeansoftype(requestmappinginfohandlermapping.class);
        ...
        for (requestmappinginfohandlermapping mapping : map.values()) {
            // 重点：根据名称找到list<handlermethod> handlermethods
            // 依赖的是gethandlermethodsformappingname()这个方法，它是从mappingregistry里查找
            handlermethods = mapping.gethandlermethodsformappingname(name);
        }
        ...
        handlermethod handlermethod = handlermethods.get(0);
        class<?> controllertype = handlermethod.getbeantype();
        method method = handlermethod.getmethod();
        // 构建一个methodargumentbuilder
        return new methodargumentbuilder(builder, controllertype, method);
    }

说明：methodargumentbuilder是mvcuricomponentsbuilder的一个public静态内部类，持有controllertype、method、argumentvalues、baseurl等属性...

它的使用场景，我参考了spring的官方文档，截图如下：

官方文档说：它能让你非常方便的在jsp页面上使用它，形如这样子：

<%@ taglib uri="http://www.springframework.org/tags" prefix="s" %>
...
<a href="${s:mvcurl('pac#getaddress').arg(0,'us').buildandexpand('123')}">get address</a>

这么写至少感觉比你这样拼装url：pagecontext.request.contextpath//people/1/addresses/china 要更加靠谱点，且更加面向对象点吧~

说明：使用此s:mvcurl函数是要求你导入spring标签库的支持的~

此处应有疑问：jsp早就过时了，现在谁还用呢？难道spring4.1新推出来的name属性这么快就寿终正寝了？
当然不是，spring作为这么优秀的框架，设计上都是功能都是非常模块化的，该功能自然不是和jsp强耦合的（spring仅是提供了对jsp标签库而顺便内置支持一下下而已~）。
在上面我截图的最后一段话也讲到了，大致意思是：
示例依赖于spring标记库（即meta-inf/spring.tld）中申明的mvcurl函数，此函数的声明如下：

<function>
    <description>helps to prepare a url to a spring mvc controller method.</description>
    <name>mvcurl</name>
    <function-class>org.springframework.web.servlet.mvc.method.annotation.mvcuricomponentsbuilder</function-class>
    <function-signature>org.springframework.web.servlet.mvc.method.annotation.mvcuricomponentsbuilder.methodargumentbuilder frommappingname(java.lang.string)</function-signature>
</function>

可见它最终的处理函数是mvcuricomponentsbuilder.frommappingname(java.lang.string)()这个方法而已（文末有详细介绍，请关联起来看本文）~
因为，如果你是其它模版技术（如thymeleaf）也是很容易自定义一个这样类似的函数的，那么你就依旧可以使用此便捷、强大的功能来帮助你开发。

通过name属性的引入，就顺利过渡到了接下来要将的重点，也是本文的重中之重：spring mvc支持的强大的uri builder模式。

---

uri builder

spring mvc作为一个web层框架，避免不了处理uri、url等和http协议相关的元素，因此它提供了非常好用、功能强大的uri builder模式来完成，这就是本文重点需要讲述的脚手架~
spring mvc从3.1开始提供了一种机制，可以通过uricomponentsbuilder和uricomponents面向对象的构造和编码uri。

uricomponents

它表示一个不可变的uri组件集合，将组件类型映射到字符串值。

uri：统一资源标识符。 url：统一资源定位符。
还是傻傻分不清楚？这里我推荐一篇通俗易懂的 供你参考

它包含用于所有组件的方便getter，与java.net.uri类似，但具有更强大的编码选项和对uri模板变量的支持。

// @since 3.1  自己是个抽象类。一般构建它我们使用uricomponentsbuilder构建器
public abstract class uricomponents implements serializable {

    // 捕获uri模板变量名
    private static final pattern names_pattern = pattern.compile("\\{([^/]+?)\\}");
    
    @nullable
    private final string scheme;
    @nullable
    private final string fragment;

    // 唯一构造，是protected 的
    protected uricomponents(@nullable string scheme, @nullable string fragment) {
        this.scheme = scheme;
        this.fragment = fragment;
    }

    ... // 省略它俩的get方法（无set方法）
    @nullable
    public abstract string getschemespecificpart();
    @nullable
    public abstract string getuserinfo();
    @nullable
    public abstract string gethost();
    // 如果没有设置port，就返回-1
    public abstract int getport();
    @nullable
    public abstract string getpath();
    public abstract list<string> getpathsegments();
    @nullable
    public abstract string getquery();
    public abstract multivaluemap<string, string> getqueryparams();

    // 此方法是public且是final的哦~
    // 注意它的返回值还是uricomponents
    public final uricomponents encode() {
        return encode(standardcharsets.utf_8);
    }
    public abstract uricomponents encode(charset charset);

    // 这是它最为强大的功能：对模版变量的支持
    // 用给定map映射中的值替换**所有**uri模板变量
    public final uricomponents expand(map<string, ?> urivariables) {
        return expandinternal(new maptemplatevariables(urivariables));
    }
    // 给定的是变量数组，那就按照顺序替换
    public final uricomponents expand(object... urivariablevalues) {...}
    public final uricomponents expand(uritemplatevariables urivariables) { ... }

    // 真正的expand方法，其实还是子类来实现的
    abstract uricomponents expandinternal(uritemplatevariables urivariables);
    // 规范化路径移除**序列**，如“path/…”。
    // 请注意，规范化应用于完整路径，而不是单个路径段。
    public abstract uricomponents normalize();
    // 连接所有uri组件以返回完全格式的uri字符串。
    public abstract string touristring();
    public abstract uri touri();

    @override
    public final string tostring() {
        return touristring();
    }

    // 拷贝
    protected abstract void copytouricomponentsbuilder(uricomponentsbuilder builder);
    ... // 提供静态工具方法expanduricomponent和sanitizesource
}

它包含有和http相关的各个部分：如schema、port、path、query等等。此抽象类有两个实现类：opaqueuricomponents和hierarchicaluricomponents

hierarchical：分层的 opaque：不透明的

由于在实际使用中会使用构建器来创建实例，所以都是面向抽象类编程，并不需要关心具体实现，因此实现类部分此处省略~

uricomponentsbuilder

从命名中就可以看出，它使用了builder模式，用于构建uricomponents。实际应用中我们所有的uricomponents都应是通过此构建器构建出来的~

// @since 3.1
public class uricomponentsbuilder implements uribuilder, cloneable {
    ... // 省略所有正则（包括提取查询参数、scheme、port等等等等）
    ... // 它所有的构造函数都是protected的
    
    // ******************鞋面介绍它的实例化静态方法（7种）******************

    // 创建一个空的bulder，里面schema，port等等啥都木有
    public static uricomponentsbuilder newinstance() {
        return new uricomponentsbuilder();
    }
    // 直接从path路径里面，分析出一个builder。较为常用
    public static uricomponentsbuilder frompath(string path) {...}
    public static uricomponentsbuilder fromuri(uri uri) {...}
    // 比如这种：/hotels/42?filter={value}
    public static uricomponentsbuilder fromuristring(string uri) {}
    // 形如这种：https://example.com/hotels/42?filter={value}
    // fromuri和fromhttpurl的使用方式差不多~~~~
    public static uricomponentsbuilder fromhttpurl(string httpurl) {}
    
    // httprequest是httpmessage的子接口。它的原理是：fromuri(request.geturi())（调用上面方法fromuri）
    // 然后再调用本类的adaptfromforwardedheaders（request.getheaders()）
    // 解释：从头forwarded、x-forwarded-proto等拿到https、port等设置值~~
    // 详情请参见http标准的forwarded头~
    // @since 4.1.5
    public static uricomponentsbuilder fromhttprequest(httprequest request) {}
    // origin 里面放的是跨域访问的域名地址。比如 www.a.com 访问 www.b.com会形成跨域
    // 这个时候访问 www.b.com 的时候,请求头里会携带 origin:www.a.com（b服务需要通过这个来判断是否允许a服务跨域访问）
    // 方法可以获取到协议,域名和端口。个人觉得此方法没毛卵用~~~
    // 和fromuristring()方法差不多，不过比它精简（因为这里只需要关注scheme、host和port）
    public static uricomponentsbuilder fromoriginheader(string origin) {}

    // *******************下面都是实例方法*******************
    // @since 5.0.8
    public final uricomponentsbuilder encode() {
        return encode(standardcharsets.utf_8);
    }
    public uricomponentsbuilder encode(charset charset) {}

    // 调用此方法生成一个uricomponents
    public uricomponents build() {
        return build(false);
    }
    public uricomponents build(boolean encoded) {
        // encoded=true，取值就是fully_encoded 全部编码
        // 否则只编码模版或者不编码
        return buildinternal(encoded ? encodinghint.fully_encoded :
                (this.encodetemplate ? encodinghint.encode_template : encodinghint.none)
                );
    }
    // buildinternal内部就会自己new子类：opaqueuricomponents或者hierarchicaluricomponents
    // 以及执行uricomponents.expand方法了（若指定了参数的话），使用者不用关心了
    
    // 显然这就是个多功能方法了：设置好参数。build后立马expand
    public uricomponents buildandexpand(map<string, ?> urivariables) {
        return build().expand(urivariables);
    }
    public uricomponents buildandexpand(object... urivariablevalues) {}

    //build成为一个uri。注意这里编码方式是：encodinghint.encode_template
    @override
    public uri build(object... urivariables) {
        return buildinternal(encodinghint.encode_template).expand(urivariables).touri();
    }
    @override
    public uri build(map<string, ?> urivariables) {
        return buildinternal(encodinghint.encode_template).expand(urivariables).touri();
    }

    // @since 4.1
    public string touristring() { ... }

    // ====重构/重新设置builder====
    public uricomponentsbuilder uri(uri uri) {}
    public uricomponentsbuilder uricomponents(uricomponents uricomponents) {}
    @override
    public uricomponentsbuilder scheme(@nullable string scheme) {
        this.scheme = scheme;
        return this;
    }
    @override
    public uricomponentsbuilder userinfo(@nullable string userinfo) {
        this.userinfo = userinfo;
        resetschemespecificpart();
        return this;
    }
    public uricomponentsbuilder host(@nullable string host){ ... }
    ... // 省略其它部分

    // 给url后面拼接查询参数(键值对)
    @override
    public uricomponentsbuilder query(@nullable string query) {}
    // 遇上相同的key就替代，而不是直接在后面添加了（上面query是添加）
    @override
    public uricomponentsbuilder replacequery(@nullable string query) {}
    @override
    public uricomponentsbuilder queryparam(string name, object... values) {}
    ... replacequeryparam

    // 可以先单独设置参数，但不expend哦~
    public uricomponentsbuilder urivariables(map<string, object> urivariables) {}

    @override
    public object clone() {
        return clonebuilder();
    }
    // @since 4.2.7
    public uricomponentsbuilder clonebuilder() {
        return new uricomponentsbuilder(this);
    }
    ...
}

api都不难理解，此处我给出一些使用案例供以参考：

public static void main(string[] args) {
    string url;
    uricomponents uricomponents = uricomponentsbuilder.newinstance()
            //.encode(standardcharsets.utf_8)
            .scheme("https").host("www.baidu.com").path("/test").path("/{template}") //此处{}就成 不要写成${}
            //.urivariables(传一个map).build();
            .build().expand("myhome"); // 此效果同上一句，但推荐这么使用，方便一些
    url = uricomponents.touristring();
    system.out.println(url); // https://www.baidu.com/test/myhome

    // 从url字符串中构造（注意：touristring方法内部是调用了build和expend方法的~）
    system.out.println(uricomponentsbuilder.fromhttpurl(url).touristring()); // https://www.baidu.com/test/myhome
    system.out.println(uricomponentsbuilder.fromuristring(url).touristring()); // https://www.baidu.com/test/myhome

    // 给url中放添加参数 query和replacequery
    uricomponents = uricomponentsbuilder.fromhttpurl(url).query("name=中国&age=18").query("&name=二次拼接").build();
    url = uricomponents.touristring();
    // 效果描述：&test前面这个&不写也是木有问题的。并且两个name都出现了哦~~~
    system.out.println(uricomponents.touristring()); // https://www.baidu.com/test/myhome?name=中国&name=二次拼接&age=18

    uricomponents = uricomponentsbuilder.fromhttpurl(url).query("name=中国&age=18").replacequery("name=二次拼接").build();
    url = uricomponents.touristring();
    // 这种够狠：后面的直接覆盖前面“所有的”查询串
    system.out.println(uricomponents.touristring()); // https://www.baidu.com/test/myhome?name=二次拼接

    //queryparam/queryparams/replacequeryparam/replacequeryparams
    // queryparam：一次性指定一个key，queryparams一次性可以搞多个key
    url = "https://www.baidu.com/test/myhome"; // 重置一下
    uricomponents = uricomponentsbuilder.fromhttpurl(url).queryparam("name","中国","美国").queryparam("age",18)
            .queryparam("name","英国").build();
    url = uricomponents.touristring();
    // 发现是不会有repalace的效果的~~~~~~~~~~~~~
    system.out.println(uricomponents.touristring()); // https://www.baidu.com/test/myhome?name=中国&name=美国&name=英国&age=18
    
    // 关于repalceparam相关方法，交给各位自己去试验吧~~~

    // 不需要domain，构建局部路径，它也是把好手
    uricomponents = uricomponentsbuilder.frompath("").path("/test").build();
    // .frompath("/").path("/test") --> /test
    // .frompath("").path("/test") --> /test
    // .frompath("").path("//test") --> /test
    // .frompath("").path("test") --> /test
    system.out.println(uricomponents.touristring()); // /test?name=fsx
}

使用这种方式来构建url还是非常方便的，它的容错性非常高，写法灵活且不容易出错，完全面向模块化思考，值得推荐。

1. uri构建的任意部分（包括查询参数、scheme等等）都是可以用{}这种形式的模版参数的
2. 被替换的模版中还支持这么来写：/myurl/{name:[a-z]}/show，这样用expand也能正常赋值

它还有个子类：servleturicomponentsbuilder，是对servlet容器的适配，也非常值得一提

servleturicomponentsbuilder

它主要是扩展了一些静态工厂方法，用于创建一些相对路径（相当于当前请求httpservletrequest）。

// @since 3.1
public class servleturicomponentsbuilder extends uricomponentsbuilder {
    @nullable
    private string originalpath;
    
    // 不对外提供public的构造函数
    // initfromrequest：设置schema、host、port（http默认80，https默认443）
    public static servleturicomponentsbuilder fromcontextpath(httpservletrequest request) {
        servleturicomponentsbuilder builder = initfromrequest(request);
        // 注意：此处路径全部替换成了contextpath
        builder.replacepath(request.getcontextpath());
        return builder;
    }

    // if the servlet is mapped by name, e.g. {@code "/main/*"}, the path
    // 它在uricomponentsbuildermethodargumentresolver中有用
    public static servleturicomponentsbuilder fromservletmapping(httpservletrequest request) {}

    public static servleturicomponentsbuilder fromrequesturi(httpservletrequest request) {
        servleturicomponentsbuilder builder = initfromrequest(request);
        builder.initpath(request.getrequesturi());
        return builder;
    }
    private void initpath(string path) {
        this.originalpath = path;
        replacepath(path);
    }
    public static servleturicomponentsbuilder fromrequest(httpservletrequest request) {}

    // fromcurrentxxx方法... 
    public static servleturicomponentsbuilder fromcurrentcontextpath() {}
    // 生路其它current方法
    
    // @since 4.0 移除掉originalpath的后缀名，并且把此后缀名return出来~~
    // 此方法必须在uricomponentsbuilder.path/pathsegment方法之前调用~
    @nullable
    public string removepathextension() { }
}

说明：spring5.1后不推荐使用它来处理x-forwarded-*等请求头了，推荐使用forwardedheaderfilter来处理~

使用uricomponentsbuilder类的最大好处是方便地注入到controller中，在方法参数中可直接使用。详见uricomponentsbuildermethodargumentresolver，它最终return的是：servleturicomponentsbuilder.fromservletmapping(request)，这样我们在controller内就可以非常容易且优雅的得到uri的各个部分了（不用再自己通过request慢慢get）~

---

mvcuricomponentsbuilder

此类效果类似于servleturicomponentsbuilder，它负责从controller控制器标注有@requestmapping的方法中获取uricomponentsbuilder，从而构建出uricomponents。

// @since 4.0
public class mvcuricomponentsbuilder {

    // bean工厂里·uricomponentscontributor·的通用名称
    // 关于uricomponentscontributor，requestparammethodargumentresolver和pathvariablemethodargumentresolver都是它的子类
    public static final string mvc_uri_components_contributor_bean_name = "mvcuricomponentscontributor";
    // 用于创建动态代理对象
    private static final springobjenesis objenesis = new springobjenesis();
    // 支持ant风格的path
    private static final pathmatcher pathmatcher = new antpathmatcher();
    // 参数名
    private static final parameternamediscoverer parameternamediscoverer = new defaultparameternamediscoverer();

    // 课件解析查询参数、path参数最终是依赖于我们的methodargumentresolver
    // 他们也都实现了uricomponentscontributor接口~~~
    private static final compositeuricomponentscontributor defaulturicomponentscontributor;
    static {
        defaulturicomponentscontributor = new compositeuricomponentscontributor(new pathvariablemethodargumentresolver(), new requestparammethodargumentresolver(false));
    }

    // final的，只能通过构造器传入
    private final uricomponentsbuilder baseurl;
    
    // 此构造方法是protected的
    protected mvcuricomponentsbuilder(uricomponentsbuilder baseurl) {
        this.baseurl = baseurl;
    }

    // 通过baseurl创建一个实例
    public static mvcuricomponentsbuilder relativeto(uricomponentsbuilder baseurl) {
        return new mvcuricomponentsbuilder(baseurl);
    }

    // 从控制器里。。。
    // 这个一个控制器类里有多个mapping，那么只会有第一个会被生效
    public static uricomponentsbuilder fromcontroller(class<?> controllertype) {
        return fromcontroller(null, controllertype);
    }

    // 注意此方法也是public的哦~~~~  builder可以为null哦~~
    public static uricomponentsbuilder fromcontroller(@nullable uricomponentsbuilder builder, class<?> controllertype) {

        // 若builder为null，那就用它servleturicomponentsbuilder.fromcurrentservletmapping()，否则克隆一个出来
        builder = getbaseurltouse(builder);

        // 拿到此控制器的pathprefixes。
        // 关于requestmappinghandlermapping的pathprefixes，出门右拐有详细说明来如何使用
        string prefix = getpathprefix(controllertype);
        builder.path(prefix);

        // 找到类上的requestmapping注解，若没标注，默认就是'/'
        // 若有此注解，拿出它的mapping.path()，若是empty或者paths[0]是empty，都返回'/'
        // 否则返回第一个：paths[0]
        string mapping = getclassmapping(controllertype);
        builder.path(mapping);

        return builder;
    }

    // 这个方法应该是使用得最多的~~~~ 同样的借用了methodintrospector.selectmethods这个方法
    // 它的path是结合来的：string path = pathmatcher.combine(typepath, methodpath);
    // frommethodinternal方法省略，但最后一步调用了applycontributors(builder, method, args)这个方法
    // 它是使用`compositeuricomponentscontributor`来处理赋值url的template（可以自己配置，也可以使用默认的）
    // 默认使用的便是pathvariablemethodargumentresolver和requestparammethodargumentresolver

    // 当在处理请求的上下文之外使用mvcuricomponentsbuilder或应用与当前请求不匹配的自定义baseurl时，这非常有用。
    public static uricomponentsbuilder frommethodname(class<?> controllertype, string methodname, object... args) {

        method method = getmethod(controllertype, methodname, args);
        // 第一个参数是baseurl，传的null 没传就是servleturicomponentsbuilder.fromcurrentservletmapping()
        return frommethodinternal(null, controllertype, method, args);
    }
    // @since 4.2
    public static uricomponentsbuilder frommethod(class<?> controllertype, method method, object... args) {}
    // @since 4.2
    public static uricomponentsbuilder frommethod(uricomponentsbuilder baseurl, @nullable class<?> controllertype, method method, object... args) {}

    // info必须是methodinvocationinfo类型
    // create a {@link uricomponentsbuilder} by invoking a "mock" controller method.  用于mock
    // 请参见on方法~~
    public static uricomponentsbuilder frommethodcall(object info) {}
    public static <t> t on(class<t> controllertype) {
        return controller(controllertype);
    }
    // 此方法是核心：controllermethodinvocationinterceptor是个私有静态内部类
    // 实现了org.springframework.cglib.proxy.methodinterceptor接口以及
    // org.aopalliance.intercept.methodinterceptor接口
    // org.springframework.web.servlet.mvc.method.annotation.mvcuricomponentsbuilder.methodinvocationinfo接口
    // reflectionutils.isobjectmethod(method)
    public static <t> t controller(class<t> controllertype) {
        assert.notnull(controllertype, "'controllertype' must not be null");
        return controllermethodinvocationinterceptor.initproxy(controllertype, null);
    }

    // @since 4.1
    // 请看上面对@requestmapping注解中name属性的介绍和使用
    // ${s:mvcurl('pc#getperson').arg(0,"123").build()
    // 这个标签s:mvcurl它对应的解析函数其实就是mvcuricomponentsbuilder.frommappingname
    // 也就是这个方法`pc#getperson`就二十所谓的mappingname，若不指定它由handlermethodmappingnamingstrategy生成
    // 底层依赖方法：requestmappinginfohandlermapping.gethandlermethodsformappingname
    public static methodargumentbuilder frommappingname(string mappingname) {
        return frommappingname(null, mappingname);
    }

    // **************以上都是静态工厂方法，下面是些实例方法**************
    // 调用的是静态方法fromcontroller，see class-level docs
    public uricomponentsbuilder withcontroller(class<?> controllertype) {
        return fromcontroller(this.baseurl, controllertype);
    }
    // withmethodname/withmethodcall/withmappingname/withmethod等都是依赖于对应的静态工厂方法，略
}

mvcuricomponentsbuilder提供的功能被广泛应用到mock接口中，并且它提供的mvcuricomponentsbuilder#frommappingname的api是集成模版引擎的关键，我个人认为所想深入了解spring mvc或者在此基础上扩展，了解它的uri builder模式的必要性还是较强的。

总结

本文所叙述的内容整体生可能比较冷，可能大多数人没有接触过甚至没有听过，但并不代表它没有意义。
你和同伴都使用spring mvc，差异化如何体现出来呢？我觉得有一个方向就是向他/她展示这些"真正的技术"~

== 若对spring、springboot、mybatis等源码分析感兴趣，可加我wx：fsx641385712，手动邀请你入群一起飞 ==
== 若对spring、springboot、mybatis等源码分析感兴趣，可加我wx：fsx641385712，手动邀请你入群一起飞 ==