SpringMvc实战--在一个页面显示Controller中所有的方法信息

0.说明

本博客记录的是如何显示SpringMVC框架中所有使用@RequestMapping注解标注的方法.

由于项目需要,web框架使用SpringMVC.前端\客户端\后端是分开的不同组的人,所以不可避免的要编写\更新大量的接口说明文档.这大大降低了效率,因此实现了显示SpringMVC中所有接受请求的方法的信息的功能.

总体思想:从Spring容器中找到所有加了RequestMapping注解的方法,并且集中显示.

1.用处

显示SpringMVC中所有加了@RequestMapping注解的方法信息

2.实现

2.0.环境说明

使用maven开发,别的不多说了.直接上pom

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${org.springframework.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${org.springframework.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${org.springframework.version}</version>
            <scope>test</scope>
        </dependency>

其中

<org.springframework.version>3.2.13.RELEASE</org.springframework.version>

底层的spring core之类的也是3.2.13.RELEASE

2.1.显示所有请求信息

细心的同学可能发现了.在springMVC项目启动的时候,会出现很多的信息.

其中,和咱们这个文章相关的就是这个类输出的信息了:

2015-05-18 12:18:47,253 INFO  org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping - Mapped "{[/guide/display/search],methods=[GET],params=[],headers=[],consumes=[],produces=[application/json;charset=UTF-8],custom=[]}" onto public java.lang.String com.renren.toro.waltz.web.controller.guide.DisplayController.search()

2015-05-18 12:18:47,253 INFO  org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping - Mapped "{[/guide/display],methods=[GET],params=[],headers=[],consumes=[],produces=[],custom=[]}" onto public org.springframework.web.servlet.ModelAndView com.renren.toro.waltz.web.controller.guide.DisplayController.index()

2015-05-18 12:18:47,253 INFO  org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping - Mapped "{[/guide/display/detail],methods=[GET],params=[],headers=[],consumes=[],produces=[],custom=[]}" onto public org.springframework.web.servlet.ModelAndView com.renren.toro.waltz.web.controller.guide.DisplayController.detail(int)

2015-05-18 12:18:47,255 INFO  org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping - Mapped "{[/logout],methods=[GET],params=[],headers=[],consumes=[],produces=[application/json;charset=UTF-8],custom=[]}" onto public java.lang.String com.renren.toro.waltz.web.controller.LogoutController.logout(javax.servlet.http.HttpServletRequest,javax.servlet.http.HttpServletResponse)

还有很多,只是截取了一段.

这个RequestMappingHandlerMapping 类会输出所有的Map信息.

下面介绍信息中的数据

这里以这一条输出作为实例:

2015-05-18 12:18:47,255 INFO  org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping - Mapped "{[/logout],methods=[GET],params=[],headers=[],consumes=[],produces=[application/json;charset=UTF-8],custom=[]}" onto public java.lang.String com.renren.toro.waltz.web.controller.LogoutController.logout(javax.servlet.http.HttpServletRequest,javax.servlet.http.HttpServletResponse)

序号	名称	说明
1	/logout	对应的接受请求的url
2	methods	接受请求的方法
3	params	请求的参数
4	headers	请求的header信息
5	consumes	接受请求的类型
6	produces	返回的数据类型

后边会输出对应的类和方法信息:

onto public java.lang.String com.renren.toro.waltz.web.controller.LogoutController.logout(javax.servlet.http.HttpServletRequest,javax.servlet.http.HttpServletResponse)

 因此从这里入手.

我这里使用了annotation-driven,所以可以直接

@Autowired
    private RequestMappingHandlerMapping requestMappingHandlerMapping;

这样就可以在一个handler方法中获取所有的添加了@RequestMapping的方法了.

具体如下:

        // request methods
        Map<RequestMappingInfo, HandlerMethod> handlerMethods = requestMappingHandlerMapping.getHandlerMethods();
        Set<RequestMappingInfo> keySet = handlerMethods.keySet();

        for (RequestMappingInfo requestMappingInfo : keySet) {
            // 请求路径
            String path = requestMappingInfo.getPatternsCondition().toString();

            // 请求方法
            String requestMethod = requestMappingInfo.getMethodsCondition().toString();
     
            // 返回header类型
            String responseType = requestMappingInfo.getProducesCondition().toString();

            RequestMethodItem item = new RequestMethodItem();
            
            item.setPath(path);26             item.setMethod(handlerMethod.toString().replace(" ", "<br>"));
            item.setResponseType(responseType);
            
            items.add(item);
        }

这里需要写一个Item对象来存储这些信息,方便一起"打包"传给jsp页面,方便显示,由于只是一个POJO,就不帖代码了.

2.2.显示请求所对应的handler方法信息

可以使用requestMappingInfo中的getMethodsCondition()方法获取Controller类

从Map<RequestMappingInfo, HandlerMethod>这个Map中,使用对应的RequestMappingInfo作为key到这个map中查找对应的HandlerMethod

我们来具体看一下这个类:

HandlerMethod

/**
 * Encapsulates information about a handler method consisting of a {@linkplain #getMethod() method}
 * and a {@linkplain #getBean() bean}. Provides convenient access to method parameters,
 * method return value, method annotations.
 *
 * <p>The class may be created with a bean instance or with a bean name (e.g. lazy-init bean,
 * prototype bean). Use {@link #createWithResolvedBean()} to obtain a {@link HandlerMethod}
 * instance with a bean instance resolved through the associated {@link BeanFactory}.
 *
 * @author Arjen Poutsma
 * @author Rossen Stoyanchev
 * @since 3.1
 */

一个包含了getMethod和getBean的类.

里边有用的方法:

getMethodParameters() 获得参数列表

通过这个方法,可以获得这个方法所对应的参数信息.该方法返回的是:MethodParameter[]

2.3.显示handler方法的参数信息

遍历2.2中说到的MethodParameter[] 可以获得具体的每一个参数的信息

使用其中的方法:

getParameterName(); 参数名

getParameterType(); 参数类型

getParameterAnnotations(); 参数注解

 

一切似乎就这样美妙的完成了.但是,学习过java class 规范的同学应该记得,javac在编译的时候,会抹去参数名称信息;

那么,getParameterName()获取到的会是什么呢?

看注释,果然如我所料:

注意returns描述的括号中的内容.

有可能是null,如果参数名称没有在class文件中,或者在开始时没有设置ParameterNameDiscoverer.

查看javac -help

输出如下:

果断加上-g参数再进行一次编译

在maven中这个参数应该加在org.apache.maven.plugins插件配置中

        　　<plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <compilerArguments>
                        <!-- show all debug info -->
                        <g />
                    </compilerArguments>
                </configuration>
            </plugin>    

在complierArguments中添加一个<g/>

那么,第一个问题解决了,参数名称信息已经包含在了class文件中了.

第二个问题,怎么在开始的时候指定ParameterNameDiscoverer?

查遍google stackoverflow无果...

spring doc也翻了翻,没找到,无奈,只能debug.查调用方.

思路如下,在接受参数的时候,如果不加@RequestParam注解,spring也能实现参数注入.一顿折腾.发现spring直接在spring-core中使用了asm的代码来操作字节码.最终完成了读取class文件中对应方法的的参数名

而初始化ParameterNameDiscoverer的代码在org.springframework.web.method.support.InvocableHandlerMethod类中找到了使用的方式.

直接声明了一个本地变量,使用LocalVariableTableParameterNameDiscoverer,实现类;然后调用initParameterNameDiscovery方法完成了初始化.

 

仔细看过LocalVariableTableParameterNameDiscoverer里边有很多虚拟机内缓存的实践,有大量的map结构用于存储数据,进而减少字节码操作.

鉴于这里只要springmvc容器启动,就不会出现class文件变动的情况,所以在本地变量中加上了static.

 

至此,就完成了显示所有@RequestMapping的信息的工作.

2.4.扩展功能

但是,由于只知道了对应的handlerMethod的参数,类,请求方式等信息,还是会出现可能的歧义,不够明确的指出接口的作用和意义.

所以定义了一个注解

@Inherited
@Target({ ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface WaltzDocument {
    /**
     * 注释内容,推荐使用html标签进行编辑<br>
     * 2015年5月7日:下午4:27:30<br>
     * <br>
     * 
     * @return
     */
    String info();

    /**
     * 返回给页面的参数,推荐使用html标签进行编辑 <br>
     * 2015年5月16日:下午4:05:32<br>
     * <br>
     * 
     * @return
     */
    String[] params() default "";

    /**
     * 接口提供者 <br>
     * 2015年5月7日:下午4:27:43<br>
     * <br>
     * 
     * @return
     */
    String author();

    /**
     * 接口状态 <br>
     * 2015年5月7日:下午4:34:06<br>
     * <br>
     * 
     * @return
     * <pre>
     * </pre>
     */
    Status status();

    public static enum Status {
        /**
         * 假接口
         */
        fake,
        /**
         * 开发
         */
        developing,
        /**
         * 开发完成
         */
        done,

        ;
    }
}

在扫描对应的handlerMethod的同时,获取对应的注解:

handlerMethod.getMethodAnnotation(WaltzDocument.class);

之后把这个注解中对应的参数一同设置到Item中.方便显示.

同时还结合了javadoc的功能,可以直接跳转到具体方法的javadoc页面查看具体说明文档.

页面上,结合一下Bootstrap和datatables就可以完成分页\筛选\搜索\排序的功能,进一步方便使用.

最终效果:

3.思考

3.1.spring中"虚拟机内"缓存的使用

在spring中,有很多的"虚拟机内换存",所谓虚拟机内缓存,利用虚拟机内的内存空间来实现一些变量的存储,当调用查询方法的时候,先使用查询的key在对应的缓存map中进行查找,这样可以大大降低底层IO操作的次数和频度.像本文中提到的LocalVariableTableParameterNameDiscoverer类,下层的获取方法参数名的方式是使用asm处理字节码.使用ClassReader和LocalVariableTableParameterNameDiscoverer提供的内部类ParameterNameDiscoveringVisitor来实现字节码操作.

数据要求不可变:这种虚拟机内缓存,对数据也是有一定的要求的.要数据的key不可变.试想,调用put方法是的hash值是A0,而想要get时hash值却变成了A1,这样就不能正确的获取数据,反而会造成缓存map越来越大,map的命中率越来越低和不断的扩容.最终导致的是大量无用内存占用和性能下降,最差情况会到导致OOM.

缓存对象大小要求有限:这种虚拟机内缓存只是用于数量有限(放置于map中的对象小于内存大小要求)的情况,试想,如果是一个无限大小的数据集合要做缓存,那最终的结构就是OOM了.否则要考虑使用一些软连接,虚连接形式的对象声明来避免这个问题了.

3.2.java参数抹去

jvm在执行方法的时候,实际上是不需要知道参数的名称的,jvm关心的只是参数的类型.所以,javac抹去了所有的参数信息,替换成paramOfString0....

测试代码如下:

public class Test {
    public static void main(
                    String[] mainArgs) {
        System.out.println("beenoisy");
    }

    public static void test(
                    int thisIsAIntArg,
                    String thisIsAObjectArg) {
        System.out.println("Test.test()");
    }
}

javac Test.java编译出来的字节码:

而同样的代码,添加了-g参数,就会带上参数名称信息,相信这是对class文件压缩的一种体现,但是却某种程度上的削弱了jvm运行时的一些功能.

同样,java对集合类型的泛型也是采取抹去处理的.在thinking in java中也说过,java的泛型不是真正的泛型.估计也是类似的考量.

3.3.怎样提高前后端开发效率

尽量减少无用功.

代码是最好的文档,然文档跟着代码改变.

一体化的文档体系\bug追踪体系\需求分派体系对于效率提升十分重要.

当然,这个小工具还是开发开始阶段紧急弄出来的,很多地方没有很好的遵循规范,后期如果有时间,考虑做成一个通用工具来集成到spring中.

最后,附上完整代码:

Controller:

import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.LocalVariableTableParameterNameDiscoverer;
import org.springframework.core.MethodParameter;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.method.RequestMappingInfo;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping;

import com.google.common.collect.Lists;
import com.renren.toro.waltz.common.annotation.WaltzDocument;
import com.renren.toro.waltz.common.annotation.WaltzDocument.Status;
import com.renren.toro.waltz.common.interceptor.performance.CountTime;
import com.renren.toro.waltz.dev.controller.support.RequestMethodItem;
import com.renren.toro.waltz.dev.controller.support.RequestMethodParameter;

/**
 * 显示所有请求 <br>
 * 2015年5月6日:下午5:03:51
 * 
 * @author Keen <br>
 */
@Controller
@RequestMapping("dev/param")
public class ParamController {
    @Autowired
    private RequestMappingHandlerMapping requestMappingHandlerMapping;
    
    private static LocalVariableTableParameterNameDiscoverer discoverer = new LocalVariableTableParameterNameDiscoverer();

    @RequestMapping("")
    @WaltzDocument(info = "参数显示页面", author = "ziyi.wang", status = Status.done)
    @CountTime
    public ModelAndView exe() {
        // items
        List<RequestMethodItem> items = Lists.newArrayList();

        // request methods
        Map<RequestMappingInfo, HandlerMethod> handlerMethods = requestMappingHandlerMapping.getHandlerMethods();
        Set<RequestMappingInfo> keySet = handlerMethods.keySet();

        for (RequestMappingInfo requestMappingInfo : keySet) {
            // 请求路径
            String path = requestMappingInfo.getPatternsCondition().toString();

            // 请求方法
            String requestMethod = requestMappingInfo.getMethodsCondition().toString();

            // Controller的处理方法
            HandlerMethod handlerMethod = handlerMethods.get(requestMappingInfo);

            // 参数
            MethodParameter[] methodParameters = handlerMethod.getMethodParameters();
            
            // 返回header类型
            String responseType = requestMappingInfo.getProducesCondition().toString();

            List<RequestMethodParameter> parameters = Lists.newArrayListWithExpectedSize(methodParameters.length);
            for (MethodParameter methodParameter : methodParameters) {
                // 参数名称
                // 如果没有discover参数会是null.参考LocalVariableTableParameterNameDiscoverer
                methodParameter.initParameterNameDiscovery(discoverer);
                String parameterName = methodParameter.getParameterName();

                // 参数类型
                Class<?> parameterType = methodParameter.getParameterType();

                // 参数注解
                Object[] parameterAnnotations = methodParameter.getParameterAnnotations();

                // 注解
                String annoation = Arrays.toString(parameterAnnotations);

                RequestMethodParameter parameter = new RequestMethodParameter();
                parameter.setAnnoation(annoation);
                parameter.setName(parameterName);
                parameter.setType(parameterType.toString());
                parameters.add(parameter);
            }

            WaltzDocument documentAnnotation = handlerMethod.getMethodAnnotation(WaltzDocument.class);

            RequestMethodItem item = new RequestMethodItem();
            
            item.setPath(path);
            item.setRequestMethod(requestMethod);
            item.setParameters(parameters);
            item.setMethod(handlerMethod.toString().replace(" ", "<br>"));
            item.setDocument(documentAnnotation);
            item.setResponseType(responseType);
            
            items.add(item);
        }

        Collections.sort(items);

        ModelAndView mav = new ModelAndView("dev/param");
        mav.addObject("items", items);
        return mav;
    }
}

POJO:

import java.util.List;

import com.renren.toro.waltz.common.annotation.WaltzDocument;

/**
 * 条目 <br>
 * 2015年5月7日:下午3:26:15
 * 
 * @author Keen <br>
 */
public class RequestMethodItem implements Comparable<RequestMethodItem> {
    private String path;
    private String requestMethod;
    private String method;
    private String responseType;
    private List<RequestMethodParameter> parameters;
    private WaltzDocument document;

    public String getPath() {
        return path.replace("[", "").replace("]", "");
    }

    public void setPath(
                    String path) {
        this.path = path;
    }

    public String getRequestMethod() {
        return requestMethod;
    }

    public void setRequestMethod(
                    String requestMethod) {
        this.requestMethod = requestMethod;
    }

    public String getMethod() {
        String a = getA();
        return method + a;
    }

    private String getA() {
        String methodName = method.split("<br>")[2];

        String classPath = methodName.split("\\(")[0];

        String[] packageSplit = classPath.split("\\.");
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < packageSplit.length; i++) {
            sb.append(packageSplit[i]);
            if (i < packageSplit.length - 1) {
                if (i == packageSplit.length - 2) {
                    sb.append(".html#");
                } else {
                    sb.append("/");
                }
            }
        }

        sb.append("(");
        String methodPath = methodName.split("\\(")[1];
        sb.append(methodPath.replace(",", ", "));

        String href = sb.toString();
        String a = "<br>\n<a href='http://svn.d.xiaonei.com/toro/waltz/renren-toro-waltz-web/trunk/doc/" + href
                        + "' target='_blank'>详细接口文档</a>";
        return a;
    }

    public void setMethod(
                    String method) {
        this.method = method;
    }

    public List<RequestMethodParameter> getParameters() {
        return parameters;
    }

    public void setParameters(
                    List<RequestMethodParameter> parameters) {
        this.parameters = parameters;
    }

    public WaltzDocument getDocument() {
        return document;
    }

    public void setDocument(
                    WaltzDocument document) {
        this.document = document;
    }

    public String getResponseType() {
        return responseType;
    }

    public void setResponseType(
                    String responseType) {
        this.responseType = responseType;
    }

    public String getResponseParams() {
        WaltzDocument document = this.getDocument();
        if (document == null) {
            return "";
        }
        String[] params = document.params();
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < params.length; i++) {
            sb.append(params[i]).append("<hr>\n");
        }
        
        return sb.toString();
    }

    @Override
    public String toString() {
        return "Item [path=" + path + ", requestMethod=" + requestMethod + ", method=" + method + ", responseType="
                        + responseType + ", parameters=" + parameters + ", document=" + document + "]";
    }

    @Override
    public int compareTo(
                    RequestMethodItem o) {
        return this.getPath().compareTo(o.getPath());
    }
}

/**
 * 参数 <br>
 * 2015年5月7日:下午3:26:31
 * 
 * @author Keen <br>
 */
public class RequestMethodParameter {
    private String name;
    private String annoation;
    private String type;

    public String getName() {
        return name;
    }

    public void setName(
                    String name) {
        this.name = name;
    }

    public String getAnnoation() {
        return annoation;
    }

    public void setAnnoation(
                    String annoation) {
        this.annoation = annoation;
    }

    public String getType() {
        return type;
    }

    public void setType(
                    String type) {
        this.type = type;
    }

    @Override
    public String toString() {
        return "Parameter [name=" + name + ", annoation=" + annoation + ", type=" + type + "]";
    }
}

jsp

<%@ page language="java" pageEncoding="UTF-8"%>  
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
<%@ page import="java.util.Arrays"%>
<html>
<head>
<title>Waltz 接口查看页</title>

<!-- 新 Bootstrap 核心 CSS 文件 -->
<link rel="stylesheet" href="http://cdn.bootcss.com/bootstrap/3.3.4/css/bootstrap.min.css">

<!-- 可选的Bootstrap主题文件（一般不用引入） -->
<link rel="stylesheet" href="http://cdn.bootcss.com/bootstrap/3.3.4/css/bootstrap-theme.min.css">

<!-- jQuery文件。务必在bootstrap.min.js 之前引入 -->
<script src="http://cdn.bootcss.com/jquery/1.11.2/jquery.min.js"></script>

<!-- 最新的 Bootstrap 核心 JavaScript 文件 -->
<script src="http://cdn.bootcss.com/bootstrap/3.3.4/js/bootstrap.min.js"></script>


<!-- datatables -->
<script type="text/javascript" charset="utf8" src="http://cdn.datatables.net/1.10.7/js/jquery.dataTables.min.js"></script>
<script type="text/javascript" charset="utf8" src="http://cdn.datatables.net/plug-ins/1.10.7/integration/bootstrap/3/dataTables.bootstrap.js"></script>


</head>
<body>
    <table id="paramTable" class="table table-striped table-hover table-bordered table-condensed display">
        <thead>
            <tr>
                <th>No.</th>
                <th>docment</th>
                <th>author</th>
                <th>status</th>
                <th>path</th>
                <th>requestMethod</th>
                <th>responseType</th>
                <th>responseParams</th>
                <th>controllerMethod</th>
                <th>parameters</th>
            </tr>

        </thead>
        <tbody>
            <c:forEach items="${items}" var="i" varStatus="x">
                <tr>
                    <td>${x.count}</td>
                    <td>${i.document.info()}</td>
                    <td>${i.document.author()}</td>
                    <td>${i.document.status()}</td>
                    <td>${i.path}<br><a href='http://xxx.com${i.path}' target='_blank'>跳转查看</a></td>
                    <td>${i.requestMethod}</td>
                    <td>${i.responseType}</td>
                    <td>${i.responseParams}</td>
                    <td>${i.method}</td>
                    <td>
                        <c:if test="${i.parameters.size() > 0 }">
                        <table class="table table-striped table-hover table-bordered table-condensed">
                            <thead>
                                <tr>
                                    <th>parameterName</th>
                                    <th>parameterType</th>
                                    <th>parameterAnnotations</th>
                                </tr>
                            </thead>
                            <tbody>
                                <c:forEach items="${i.parameters}" var="p">
                                    <tr>
                                        <td>${p.name}</td>
                                        <td>${p.type}</td>
                                        <td>${p.annoation}</td>
                                    </tr>
                                </c:forEach>
                            </tbody>
                        </table>
                        </c:if>
                    </td>
                </tr>
            </c:forEach>
        </tbody>
        <tfoot>
            <tr>
                <th>No.</th>
                <th>docment</th>
                <th>author</th>
                <th>status</th>
                <th>path</th>
                <th>requestMethod</th>
                <th>responseType</th>
                <th>responseParams</th>
                <th>controllerMethod</th>
                <th>parameters</th>
            </tr>
        </tfoot>
    </table>
    
    <script type="text/javascript">
        $(document).ready(function() {
            // Setup - add a text input to each footer cell
            $('#paramTable tfoot th').each( function () {
                var title = $('#paramTable thead th').eq( $(this).index() ).text();
                $(this).html( '<input type="text" placeholder="Search '+title+'" />' );
            });
         
            // DataTable
            var table = $('#paramTable').DataTable({
                paging: false
            });
         
            // Apply the search
            table.columns().eq(0).each(function(colIdx){
                $('input', table.column(colIdx).footer()).on('keyup change',function () {
                    table.column( colIdx ).search( this.value ).draw();
                });
            });
        });
    </script>
    
</body>
</html>