java Spring mvc项目接入skywalking spring mvc实现

转载

gjnet 2024-01-19 13:03:37

1、什么是 SpringMVC ?

　　在介绍什么是 SpringMVC 之前，我们先看看 Spring 的基本架构。如下图：

java Spring mvc项目接入skywalking spring mvc实现_xml

　　我们可以看到，在 Spring 的基本架构中，红色圈起来的 Spring Web MVC ，也就是本系列的主角 SpringMVC，它是属于Spring基本架构里面的一个组成部分，属于SpringFrameWork的后续产品，已经融合在Spring Web Flow里面，所以我们在后期和 Spring 进行整合的时候，几乎不需要别的什么配置。

　　SpringMVC 是类似于 Struts2 的一个 MVC 框架，在实际开发中，接收浏览器的请求响应，对数据进行处理，然后返回页面进行显示，但是上手难度却比 Struts2 简单多了。而且由于 Struts2 所暴露出来的安全问题，SpringMVC 已经成为了大多数企业优先选择的框架。

　　那么多的不说，我们直接通过一个实例来看看 SpringMVC 的魔力。

2、创建 web 工程，并导入相应的 jar 包。

java Spring mvc项目接入skywalking spring mvc实现_mvc_02

　　这里我们加入了 Spring 3.2 的所有 jar 包，正好也佐证了上面所说的 SpringMVC 是 Spring 架构的一部分，注意：一定要包括红色椭圆圈起来的 spring-webmvc-3.2.0.RELEASE.jar

3、新建 SpringMVC 全局配置文件

　　在 src 目录下新建 springmvc.xml 文件，并添加如下代码：

java Spring mvc项目接入skywalking spring mvc实现_mvc_03

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc-4.2.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-4.2.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd">
 
 
</beans>

4、在 web.xml 文件中配置前端过滤器　

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://java.sun.com/xml/ns/javaee"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">
<display-name>SpringMVC_01</display-name>
<!-- 配置前端控制器DispatcherServlet -->
<servlet>
<servlet-name>springmvc</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<!-- 对应上一步创建全局配置文件的文件名以及目录 -->
<param-value>classpath:springmvc.xml</param-value>
</init-param>
</servlet>
 
<servlet-mapping>
<servlet-name>springmvc</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>
</web-app>

5、编写处理器 Handler

package com.ys.controller;
 
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;
 
public class HelloController implements Controller{
 
@Override
public ModelAndView handleRequest(HttpServletRequest request,
HttpServletResponse response) throws Exception {
ModelAndView modelView = new ModelAndView();
//类似于 request.setAttribute()
modelView.addObject("name","张三");
modelView.setViewName("/WEB-INF/view/index.jsp");
return modelView;
}
 
}

6、在 springmvc.xml 文件中配置 Handler,处理器映射器，处理器适配器，以及视图解析器　　

　　在 springmvc.xml 文件中添加如下代码：

<!-- 配置Handler -->   
<bean name="/hello.do" class="com.ys.controller.HelloController" />
<!-- 配置处理器映射器
将bean的name作为url进行查找，需要在配置Handler时指定bean name（就是url）-->
<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping" />
<!-- 配置处理器适配器，所有适配器都得实现 HandlerAdapter接口 -->
<bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter" />
 
<!-- 配置视图解析器
进行jsp解析，默认使用jstl标签，classpath下得有jstl的包-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" />

7、在 /WEB-INF/view 目录下创建 index.jsp 文件

java Spring mvc项目接入skywalking spring mvc实现_xml_04

<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
hello:${name}
</body>
</html>

8、在浏览器输入 http://localhost:8080/SpringMVC_01/hello.do

java Spring mvc项目接入skywalking spring mvc实现_spring_05

1、SpringMVC 详细介绍

　　通过入门实例，我们大概知道 SpringMVC 的作用，那么它到底是什么呢？

　　Spring Web MVC是一种基于Java的实现了Web MVC设计模式的请求驱动类型的轻量级Web框架，即使用了MVC架构模式的思想，将web层进行职责解耦，基于请求驱动指的就是使用请求-响应模型，框架的目的就是帮助我们简化开发，Spring Web MVC也是要简化我们日常Web开发的。

　　与之相反的是基于组件的、事件驱动的Web框架，如Tapestry、JSF等，在此就不介绍了。

　　Spring Web MVC也是服务到工作者模式的实现，但进行可优化。前端控制器是DispatcherServlet；应用控制器其实拆为处理器映射器(Handler Mapping)进行处理器管理和视图解析器(View Resolver)进行视图管理；页面控制器/动作/处理器为Controller接口（仅包含ModelAndView handleRequest(request, response) 方法）的实现（也可以是任何的POJO类）；支持本地化（Locale）解析、主题（Theme）解析及文件上传等；提供了非常灵活的数据验证、格式化和数据绑定机制；提供了强大的约定大于配置（惯例优先原则）的契约式编程支持。

2、SpringMVC 处理请求流程

java Spring mvc项目接入skywalking spring mvc实现_mvc_06

第一步：用户发送请求到前端控制器（DispatcherServlet）。

第二步：前端控制器请求 HandlerMapping 查找 Handler，可以根据 xml 配置、注解进行查找。

第三步：处理器映射器 HandlerMapping 向前端控制器返回 Handler

第四步：前端控制器调用处理器适配器去执行 Handler

第五步：处理器适配器执行 Handler

第六步：Handler 执行完成后给适配器返回 ModelAndView

第七步：处理器适配器向前端控制器返回 ModelAndView

　　　　ModelAndView 是SpringMVC 框架的一个底层对象，包括 Model 和 View

第八步：前端控制器请求试图解析器去进行视图解析

　　　　根据逻辑视图名来解析真正的视图。

第九步：试图解析器向前端控制器返回 view

第十步：前端控制器进行视图渲染

　　　　就是将模型数据（在 ModelAndView 对象中）填充到 request 域

第十一步：前端控制器向用户响应结果

下面我们对上面出现的一些组件进行解释：

1、前端控制器DispatcherServlet（不需要程序员开发）。
　　作用：接收请求，响应结果，相当于转发器，中央处理器。有了DispatcherServlet减少了其它组件之间的耦合度。
2、处理器映射器HandlerMapping（不需要程序员开发）。
　　作用：根据请求的url查找Handler。
3、处理器适配器HandlerAdapter（不需要程序员开发）。
　　作用：按照特定规则（HandlerAdapter要求的规则）去执行Handler。
4、处理器Handler（需要程序员开发）。
　　注意：编写Handler时按照HandlerAdapter的要求去做，这样适配器才可以去正确执行Handler
5、视图解析器ViewResolver（不需要程序员开发）。
　　作用：进行视图解析，根据逻辑视图名解析成真正的视图（view）
6、视图View（需要程序员开发jsp）。
　　注意：View是一个接口，实现类支持不同的View类型（jsp、freemarker、pdf…）
ps:不需要程序员开发的，需要程序员自己做一下配置即可。

　　可以总结出：需要我们开发的工作只有处理器 Handler 的编写以及视图比如JSP页面的编写。可能你还对诸如前端控制器、处理器映射器等等名词不太理解，那么接下来我们对其进行详细的介绍。

3、配置前端控制器

　　在 web.xml 文件中进行如下配置：

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://java.sun.com/xml/ns/javaee"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">
<display-name>SpringMVC_01</display-name>
<!-- 配置前端控制器DispatcherServlet -->
<servlet>
<servlet-name>springmvc</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!--springmvc.xml 是自己创建的SpringMVC全局配置文件，用contextConfigLocation作为参数名来加载
如果不配置 contextConfigLocation，那么默认加载的是/WEB-INF/servlet名称-servlet.xml，在这里也就是 springmvc-servlet.xml
-->
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:springmvc.xml</param-value>
</init-param>
</servlet>
 
<servlet-mapping>
<servlet-name>springmvc</servlet-name>
<!--第一种配置：*.do,还可以写*.action等等，表示以.do结尾的或者以.action结尾的URL都由前端控制器DispatcherServlet来解析
第二种配置：/,所有访问的 URL 都由DispatcherServlet来解析，但是这里最好配置静态文件不由DispatcherServlet来解析
错误配置：/*,注意这里是不能这样配置的，应为如果这样写，最后转发到 jsp 页面的时候，仍然会由DispatcherServlet进行解析，
而这时候会找不到对应的Handler，从而报错！！！
-->
<url-pattern>*.do</url-pattern>
</servlet-mapping>
</web-app>

4、配置处理器适配器

　　在 springmvc.xml 文件中配置。用来约束我们所需要编码的 Handler类。

　　第一种配置：编写 Handler 时必须要实现 Controller

<!-- 配置处理器适配器，所有适配器都得实现 HandlerAdapter接口 -->
<bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter" />

　　我们可以查看源码：　

java Spring mvc项目接入skywalking spring mvc实现_mvc_07

　　第二种配置：编写 Handler 时必须要实现 HttpRequestHandler

<!-- 配置处理器适配器第二种方法，所有适配器都得实现 HandlerAdapter接口 ，这样配置所有Handler都得实现 HttpRequestHandler接口-->
<bean class="org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter" />

java Spring mvc项目接入skywalking spring mvc实现_xml_08

5、编写 Handler

　　在 springmvc.xml 文件中配置。通俗来讲，就是请求的 URL 到我们这里所编写的 Handler 类的某个方法进行一些业务逻辑处理。

　　我们在上面讲解了两个处理器适配器来约束 Handler，那么我们就通过上面两种配置分别编写两个 Handler

　　第一种：实现Controller 接口

package com.ys.controller;
 
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;
 
public class HelloController implements Controller{
 
@Override
public ModelAndView handleRequest(HttpServletRequest request,
HttpServletResponse response) throws Exception {
ModelAndView modelView = new ModelAndView();
//类似于 request.setAttribute()
modelView.addObject("name","张三");
modelView.setViewName("/WEB-INF/view/index.jsp");
return modelView;
}
 
}

　　第二种：实现 HttpRequestHandler 接口

package com.ys.controller;
 
import java.io.IOException;
 
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
import org.springframework.web.HttpRequestHandler;
 
public class HelloController2 implements HttpRequestHandler{
 
@Override
public void handleRequest(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
request.setAttribute("name", "张三");
request.getRequestDispatcher("/WEB-INF/view/index.jsp").forward(request, response);
}
 
}

　　总结：通常我们使用第一种方式来编写 Handler ，但是第二种没有返回值，我们可以通过 response 修改相应内容，比如返回 json 数据。

response.setCharacterEncoding("utf-8");
response.setContentType("application/json;charset=utf-8");
response.getWriter().write("json字符串");

　所以具体使用哪一种根据实际情况来判断。

5、配置处理器映射器

　　在 springmvc.xml 文件中配置。通俗来讲就是请求的 URL 怎么能被 SpringMVC 识别，从而去执行我们上一步所编写好的 Handler

　　第一种方法：

<!-- 配置Handler -->   
<bean name="/hello.do" class="com.ys.controller.HelloController2" />
 
<!-- 配置处理器映射器
将bean的name作为url进行查找，需要在配置Handler时指定bean name（就是url）-->
<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping" />

　这样配置的话，那么请求的 URL，必须为 http://localhost:8080/项目名/hello.do　　

　　第二种方法：

<!-- 配置Handler -->   
<bean id="hello1" class="com.ys.controller.HelloController" />
<bean id="hello2" class="com.ys.controller.HelloController" />
<!-- 第二种方法：简单URL配置处理器映射器 -->
<bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
<property name="mappings">
<props>
<prop key="/hello1.do">hello1</prop>
<prop key="/hello2.do">hello2</prop>
</props>
</property>
</bean>

　　这种配置请求的 URL可以为 http://localhost:8080/项目名/hello1.do，或者http://localhost:8080/项目名/hello2.do

总结：上面两种处理器映射器配置可以并存，前端控制器会正确的去判断 url 用哪个 Handler 去处理。

6、配置视图解析器

　　第一种配置:

<!-- 配置视图解析器
进行jsp解析，默认使用jstl标签，classpath下得有jstl的包-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" />

　如果这样配，那么在 Handler 中返回的必须是路径+jsp页面名称+".jsp"　

　　第二种配置：

<!--配置视图解析器  -->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!-- 返回视图页面的前缀 -->
<property name="prefix" value="/WEB-INF/view"></property>
<!-- 返回页面的后缀 -->
<property name="suffix" value=".jsp"></property>
</bean>

　　如果这样配，那么在 Handler 中只需要返回在 view 文件夹下的jsp 页面名就可以了。

7、DispatcherServlet.properties

　　上面我们讲解了各种配置，可能有人会问这么多配置，万一少配置了一样，那不就不能运行了，那我们能不能不配置呢？答案是肯定的，SpringMVC 给我们提供了一个 DispatcherServlet.properties 文件。系统会首先加载这里面的配置，如果我们没有配置，那么就默认使用这个文件的配置；如果我们配置了，那么就优先使用我们手动配置的。

java Spring mvc项目接入skywalking spring mvc实现_mvc_09

　　在 SpringMVC 运行之前，会首先加载 DispatcherServlet.properties 文件里面的内容，那么我们来看看这里面都是什么。

# Default implementation classes for DispatcherServlet's strategy interfaces.
# Used as fallback when no matching beans are found in the DispatcherServlet context.
# Not meant to be customized by application developers.
 
org.springframework.web.servlet.LocaleResolver=org.springframework.web.servlet.i18n.AcceptHeaderLocaleResolver
 
org.springframework.web.servlet.ThemeResolver=org.springframework.web.servlet.theme.FixedThemeResolver
 
org.springframework.web.servlet.HandlerMapping=org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping,\
org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping
 
org.springframework.web.servlet.HandlerAdapter=org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter,\
org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter,\
org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter
 
org.springframework.web.servlet.HandlerExceptionResolver=org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerExceptionResolver,\
org.springframework.web.servlet.mvc.annotation.ResponseStatusExceptionResolver,\
org.springframework.web.servlet.mvc.support.DefaultHandlerExceptionResolver
 
org.springframework.web.servlet.RequestToViewNameTranslator=org.springframework.web.servlet.view.DefaultRequestToViewNameTranslator
 
org.springframework.web.servlet.ViewResolver=org.springframework.web.servlet.view.InternalResourceViewResolver
 
org.springframework.web.servlet.FlashMapManager=org.springframework.web.servlet.support.SessionFlashMapManager

　　我们可以从上面得出，如果我们不手动进行各种配置，那么也有会默认的

　　①、处理器适配器默认：org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter

　　②、处理器映射器默认：org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping

　　③、视图解析器默认：org.springframework.web.servlet.view.InternalResourceViewResolver

前两篇博客我们讲解了基于XML 的入门实例，以及SpringMVC运行的详细流程。但是我们发现基于 XML 的配置还是比较麻烦的，而且，每个 Handler 类只能有一个方法，在实际开发中肯定是不可能这样来进行开发的。那么这篇博客我们就讲解实际开发中用的最多的基于注解配置的SpringMVC配置。

　　项目结构为：

java Spring mvc项目接入skywalking spring mvc实现_mvc_10

1、在 web.xml 文件中配置前端处理器

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://java.sun.com/xml/ns/javaee"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">
<display-name>SpringMVC_01</display-name>
<!-- 配置前端控制器DispatcherServlet -->
<servlet>
<servlet-name>springmvc</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!--springmvc.xml 是自己创建的SpringMVC全局配置文件，用contextConfigLocation作为参数名来加载
如果不配置 contextConfigLocation，那么默认加载的是/WEB-INF/servlet名称-servlet.xml，在这里也就是 springmvc-servlet.xml
-->
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:springmvc.xml</param-value>
</init-param>
</servlet>
 
<servlet-mapping>
<servlet-name>springmvc</servlet-name>
<!--第一种配置：*.do,还可以写*.action等等，表示以.do结尾的或者以.action结尾的URL都由前端控制器DispatcherServlet来解析
第二种配置：/,所有访问的 URL 都由DispatcherServlet来解析，但是这里最好配置静态文件不由DispatcherServlet来解析
错误配置：/*,注意这里是不能这样配置的，应为如果这样写，最后转发到 jsp 页面的时候，仍然会由DispatcherServlet进行解析，
而这时候会找不到对应的Handler，从而报错！！！
-->
<url-pattern>/</url-pattern>
</servlet-mapping>
</web-app>

2、在 springmvc.xml 文件中配置处理器映射器，处理器适配器，视图解析器

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc-4.2.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-4.2.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd">
<!--注解处理器映射器  -->   
<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping"></bean>
 
<!--注解处理器适配器  -->   
<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter"></bean>  
 
<!--使用mvc:annotation-driven可以代替上面的映射器和适配器
这里面会默认加载很多参数绑定方法，比如json转换解析器就默认加载，所以优先使用下面的配置
-->
<!-- <mvc:annotation-driven></mvc:annotation-driven> -->
 
 
<!--单个配置Handler  -->
<!-- <bean class="com.ys.controller.HelloController"></bean> -->
 
<!--批量配置Handler,指定扫描的包全称  -->
<context:component-scan base-package="com.ys.controller"></context:component-scan>
 
 
<!--配置视图解析器  -->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!-- 返回视图页面的前缀 -->
<property name="prefix" value="/WEB-INF/view/"></property>
<!-- 返回页面的后缀 -->
<property name="suffix" value=".jsp"></property>
</bean>
</beans>

3、编写 Handler

package com.ys.controller;
 
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
 
//使用@Controller注解表示这个类是一个Handler
@Controller
public class HelloController {
 
//@RequestMapping注解括号里面的表示访问的URL
@RequestMapping("hello")
public ModelAndView hello(){
ModelAndView modelView = new ModelAndView();
//类似于 request.setAttribute()
modelView.addObject("name","张三");
//配置返回的视图名，由于我们在springmvc.xml中配置了前缀和后缀，这里直接写视图名就好
modelView.setViewName("index");
//modelView.setViewName("/WEB-INF/view/index.jsp");
return modelView;
}
 
}

　　注意@Controller注解和@RequestMapping注解的用法

4、编写视图 index.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
hello:${name}
</body>
</html>

1、Spring mvc介绍

SpringMVC框架是以请求为驱动，围绕Servlet设计，将请求发给控制器，然后通过模型对象，分派器来展示请求结果视图。其中核心类是DispatcherServlet，它是一个Servlet，顶层是实现的Servlet接口。

2、SpringMVC使用

需要在web.xml中配置DispatcherServlet。并且需要配置spring监听器ContextLoaderListener

<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<servlet>
<servlet-name>springmvc</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!-- 如果不设置init-param标签，则必须在/WEB-INF/下创建xxx-servlet.xml文件，其中xxx是servlet-name中配置的名称。 -->
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:spring/springmvc-servlet.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>springmvc</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>

3、SpringMVC运行原理

如图所示：

java Spring mvc项目接入skywalking spring mvc实现_spring_11

java Spring mvc项目接入skywalking spring mvc实现_spring_12

流程说明：

（1）客户端（浏览器）发送请求，直接请求到DispatcherServlet。

（2）DispatcherServlet根据请求信息调用HandlerMapping，解析请求对应的Handler。

（3）解析到对应的Handler后，开始由HandlerAdapter适配器处理。

（4）HandlerAdapter会根据Handler来调用真正的处理器开处理请求，并处理相应的业务逻辑。

（5）处理器处理完业务后，会返回一个ModelAndView对象，Model是返回的数据对象，View是个逻辑上的View。

（6）ViewResolver会根据逻辑View查找实际的View。

（7）DispaterServlet把返回的Model传给View。

（8）通过View返回给请求者（浏览器）

4、DispatcherServlet详细解析

首先看下源码：

package org.springframework.web.servlet;

@SuppressWarnings("serial")
public class DispatcherServlet extends FrameworkServlet {

public static final String MULTIPART_RESOLVER_BEAN_NAME = "multipartResolver";
public static final String LOCALE_RESOLVER_BEAN_NAME = "localeResolver";
public static final String THEME_RESOLVER_BEAN_NAME = "themeResolver";
public static final String HANDLER_MAPPING_BEAN_NAME = "handlerMapping";
public static final String HANDLER_ADAPTER_BEAN_NAME = "handlerAdapter";
public static final String HANDLER_EXCEPTION_RESOLVER_BEAN_NAME = "handlerExceptionResolver";
public static final String REQUEST_TO_VIEW_NAME_TRANSLATOR_BEAN_NAME = "viewNameTranslator";
public static final String VIEW_RESOLVER_BEAN_NAME = "viewResolver";
public static final String FLASH_MAP_MANAGER_BEAN_NAME = "flashMapManager";
public static final String WEB_APPLICATION_CONTEXT_ATTRIBUTE = DispatcherServlet.class.getName() + ".CONTEXT";
public static final String LOCALE_RESOLVER_ATTRIBUTE = DispatcherServlet.class.getName() + ".LOCALE_RESOLVER";
public static final String THEME_RESOLVER_ATTRIBUTE = DispatcherServlet.class.getName() + ".THEME_RESOLVER";
public static final String THEME_SOURCE_ATTRIBUTE = DispatcherServlet.class.getName() + ".THEME_SOURCE";
public static final String INPUT_FLASH_MAP_ATTRIBUTE = DispatcherServlet.class.getName() + ".INPUT_FLASH_MAP";
public static final String OUTPUT_FLASH_MAP_ATTRIBUTE = DispatcherServlet.class.getName() + ".OUTPUT_FLASH_MAP";
public static final String FLASH_MAP_MANAGER_ATTRIBUTE = DispatcherServlet.class.getName() + ".FLASH_MAP_MANAGER";
public static final String EXCEPTION_ATTRIBUTE = DispatcherServlet.class.getName() + ".EXCEPTION";
public static final String PAGE_NOT_FOUND_LOG_CATEGORY = "org.springframework.web.servlet.PageNotFound";
private static final String DEFAULT_STRATEGIES_PATH = "DispatcherServlet.properties";
protected static final Log pageNotFoundLogger = LogFactory.getLog(PAGE_NOT_FOUND_LOG_CATEGORY);
private static final Properties defaultStrategies;
static {
try {
ClassPathResource resource = new ClassPathResource(DEFAULT_STRATEGIES_PATH, DispatcherServlet.class);
defaultStrategies = PropertiesLoaderUtils.loadProperties(resource);
}
catch (IOException ex) {
throw new IllegalStateException("Could not load 'DispatcherServlet.properties': " + ex.getMessage());
}
}

/** Detect all HandlerMappings or just expect "handlerMapping" bean? */
private boolean detectAllHandlerMappings = true;

/** Detect all HandlerAdapters or just expect "handlerAdapter" bean? */
private boolean detectAllHandlerAdapters = true;

/** Detect all HandlerExceptionResolvers or just expect "handlerExceptionResolver" bean? */
private boolean detectAllHandlerExceptionResolvers = true;

/** Detect all ViewResolvers or just expect "viewResolver" bean? */
private boolean detectAllViewResolvers = true;

/** Throw a NoHandlerFoundException if no Handler was found to process this request? **/
private boolean throwExceptionIfNoHandlerFound = false;

/** Perform cleanup of request attributes after include request? */
private boolean cleanupAfterInclude = true;

/** MultipartResolver used by this servlet */
private MultipartResolver multipartResolver;

/** LocaleResolver used by this servlet */
private LocaleResolver localeResolver;

/** ThemeResolver used by this servlet */
private ThemeResolver themeResolver;

/** List of HandlerMappings used by this servlet */
private List<HandlerMapping> handlerMappings;

/** List of HandlerAdapters used by this servlet */
private List<HandlerAdapter> handlerAdapters;

/** List of HandlerExceptionResolvers used by this servlet */
private List<HandlerExceptionResolver> handlerExceptionResolvers;

/** RequestToViewNameTranslator used by this servlet */
private RequestToViewNameTranslator viewNameTranslator;

private FlashMapManager flashMapManager;

/** List of ViewResolvers used by this servlet */
private List<ViewResolver> viewResolvers;

public DispatcherServlet() {
super();
}

public DispatcherServlet(WebApplicationContext webApplicationContext) {
super(webApplicationContext);
}

@Override
protected void onRefresh(ApplicationContext context) {
initStrategies(context);
}

protected void initStrategies(ApplicationContext context) {
initMultipartResolver(context);
initLocaleResolver(context);
initThemeResolver(context);
initHandlerMappings(context);
initHandlerAdapters(context);
initHandlerExceptionResolvers(context);
initRequestToViewNameTranslator(context);
initViewResolvers(context);
initFlashMapManager(context);
}
}

DispatcherServlet类中的属性beans：

HandlerMapping：用于handlers映射请求和一系列的对于拦截器的前处理和后处理，大部分用@Controller注解。
HandlerAdapter：帮助DispatcherServlet处理映射请求处理程序的适配器，而不用考虑实际调用的是 哪个处理程序。
HandlerExceptionResolver：处理映射异常。
ViewResolver：根据实际配置解析实际的View类型。
LocaleResolver：解决客户正在使用的区域设置以及可能的时区，以便能够提供国际化视野。
ThemeResolver：解决Web应用程序可以使用的主题，例如提供个性化布局。
MultipartResolver：解析多部分请求，以支持从HTML表单上传文件。
FlashMapManager：存储并检索可用于将一个请求属性传递到另一个请求的input和output的FlashMap，通常用于重定向。

在Web MVC框架中，每个DispatcherServlet都拥自己的WebApplicationContext，它继承了ApplicationContext。WebApplicationContext包含了其上下文和Servlet实例之间共享的所有的基础框架beans。

HandlerMapping：

HandlerMapping接口处理请求的映射
HandlerMapping接口的实现类：
SimpleUrlHandlerMapping类通过配置文件把URL映射到Controller类。
DefaultAnnotationHandlerMapping类通过注解把URL映射到Controller类。

HandlerAdapter：

HandlerAdapter接口-处理请求映射
AnnotationMethodHandlerAdapter：通过注解，把请求URL映射到Controller类的方法上。
HandlerExceptionResolver：
HandlerExceptionResolver接口-异常处理接口
SimpleMappingExceptionResolver通过配置文件进行异常处理。
AnnotationMethodHandlerExceptionResolver：通过注解进行异常处理。

ViewResolver：

ViewResolver接口解析View视图。

UrlBasedViewResolver类通过配置文件，把一个视图名交给到一个View来处理。

SpringMVC 注解详解

spring mvc 中有很多的注解，每个注解都有自己的功能，下面我们就对spring mvc中的注解一一作出介绍。关于spring的注解还没有总结，请等待后续blog更新。

@controller

org.springframework.stereotype.Controller注解类型用于指示当前类是一个控制器。 Spring使用扫描机制查找应用程序中所有基于注解的控制器类，分发器会扫描使用该注解类的方法，并检测方法是否使用了@RequestMapping注解，只用使用了@RequestMapping注解的方法才能用来处理请求。

为了保证spring能找到控制器，需要完成两件事情：

在spring mvc的配置文件的头文件中引入spring-context。
在spring mvc 的配置文件中使用context:component-scan/，该元素的功能是启动包扫描功能，以便注册有@Controller、@Service、@Repository、@Component等注解的类成为spring的bean。

<context:component-scan base-package = "com.chris.controller"/>

@RequestMapping

该注解类型指示spring用哪一个类或方法来处理请求动作，可以用于类或方法。

@Controller
// RequestMapping可以用来注释一个控制器类，此时，所有方法都将映射为相对于类级别的请求, 
// 表示该控制器处理所有的请求都被映射到 user属性所指示的路径下
@RequestMapping(value="/user")
public class UserController{
    // 映射请求 user/register
    @RequestMapping(value="/register",method=RequestMethod.GET)
	 public String registerForm() {
		 // 跳转到注册页面
	     return "registerForm";
	 }
     // 映射请求 user/login
     @RequestMapping("/login")
	 public String login( Model model) {
	     return "loginForm";
	 }
}

@RequestMapping可以指定一些属性

value：用来映射一个请求和一个方法，是其默认属性，如果在使用@RequestMapping时只有这个属性，则可以省略关键字value.
method：该属性用来指定该方法仅仅处理哪些HTTP请求的处理方式，例如GET、POST。
consumes：用来指定处理请求提交内容的类型。
produces：用来指定返回的内容类型，返回的内容类型必须是request请求头（Accept）中包含的类型。
params：指明request中必须包含哪些参数时，才让该方法处理。例如下面的代码指明方法只处理其中名为"myParam"，值为"myValue"的请求。

@RequestMapping(value="/hello", method = RequestMethod.POST,
 params = "myParam = myValue")

headers 指明request中必须包含某些header值，才能让该方法处理请求，例如

@RequestMapping(value="/hello", method = RequestMethod.POST,
 header = "bolgID = ")

在使用@RequestMapping指定的方法中，如果要访问HttpServletRequest或HttpSession，可以将其直接作为参数，Spring会将对象传递给方法。

@RequestMapping("/hello")
public String login(HttpSession session) {
    return "hello";
}

@RequestParam

该注解将指定的请求参数赋值给方法中的形参。

@RequestMapping("/hello") {
    public String login(
        @RequestParam("loginName") String loginName,
        @RequestParam("password") String password
    ) {
        return "login";
    }
}

在执行上面函数时，springmvc 会将Request中的loginName,password从参数中取出来赋值给函数的形参。
@RequestParam中的属性如下：

name：绑定参数在Request中的名称。
value：name属性的别名。
required：参数是否必须绑定。
defaultValue：如果没有传递参数而使用的默认值。

@RequestParam(value="loginname",required=true,defaultValue="admin")

@PathVariable

@PathVariable只支持一个属性value，类型为String，表示绑定的名称，如果省略则表示绑定同名参数。

@RequestMapping("path/{userId}")
public String login(@PathVariable Integer userId) {
    return "login";
}

加入请求url为http://localhost:8080/path/3，则上述函数在执行时会自动将userId值映射为3。

@RequestHeader

将请求头信息区书记映射到处理方法上。其主要有如下属性

name：指定请求头绑定的名称。
value：name属性的别名。
required：参数是否必须绑定。
defaultValue：如果没有传递参数而使用的默认值。

和@PathVariable的属性相同。下面给出用法实例

@RequestMapping("/hello") {
    public String login(
        @RequestHeader("User-Agent") String userAgent,
        @RequestHeader(value="Accept") String[] accepts
    ) {
        return "login";
    }
}

@CookieValue

将请求的Cookie书记映射到功能处理方法参数上。其支持的属性如下：

name：指定请求头绑定的名称。
value：name属性的别名。
required：参数是否必须绑定。
defaultValue：如果没有传递参数而使用的默认值。
用法和@RequestParam相同，这里不再赘述。

@SessionAttribute

该注解允许我们有选择的将指定Model中的哪些属性转存到HttpSession对象中。其只能声明在类上。他包含3个属性。

java Spring mvc项目接入skywalking spring mvc实现_xml_13

使用如下

@Controller
// 将Model中的属性名为user的放入HttpSession对象当中
@SessionAttributes("user")
public class SessionAttributesController{

	@RequestMapping(value="/{formName}")
	 public String loginForm(@PathVariable String formName){
		// 动态跳转页面
		return formName;
	}

	@RequestMapping(value="/login")
	 public String login(
			 @RequestParam("loginname") String loginname,
			 @RequestParam("password") String password,
			 Model model ) {
		 User user = new User();
		 user.setLoginname(loginname);
		 user.setPassword(password);
		 user.setUsername("admin");
		 model.addAttribute("user",user);
		 return "welcome";
	 }
}

@ModelAttribute

@ModelAttribute只有一个属性value，类型为String，表示绑定数据类型的名称。其使用方法以及表现形式比较多变，容我娓娓道来。@ModelAttribute主要用来修饰方法，被其修饰的方法会在Controller中每个方法执行前被执行，因此在一个Controller类要映射多个URL时，要谨慎使用。
我个人理解被@ModelAttribute修饰的方法，是在执行映射方法前对Model的预处理。

注解返回具体类的方法

@Controller
public class ModelAttribute1Controller{

    // 使用@ModelAttribute注释的value属性，
    // 来指定model属性的名称,model属性对象就是方法的返回值
	@ModelAttribute("loginname")
	public String userModel( 
			@RequestParam("loginname") String loginname){
		return loginname;
	}

	@RequestMapping(value="/login1")
	 public String login() {
		 return "result1";
	 }
}

userModel会先于login执行，并在Model中以loginname为属性名称，userModel返回值为属性值，在Model中放入了一个属性。

注解无返回值的方法

@Controller
public class ModelAttribute2Controller{

	// model属性名称和model属性对象由model.addAttribute()实现，
    // 前提是要在方法中加入一个Model类型的参数。
	// 注意：当URL或者post中不包含对应的参数时，程序会抛出异常。
	@ModelAttribute
	public void userModel( 
			@RequestParam("loginname") String loginname,
			@RequestParam("password") String password,
			 Model model){
		model.addAttribute("loginname", loginname);
		model.addAttribute("password", password);
	}

	@RequestMapping(value="/login2")
	 public String login() {
		 return "result2";
	 }
}

在这个例子中userModel先于login执行，相当于将一段对model的预处理逻辑单独放到一个函数中。

注解返回具体类的方法

@Controller
public class ModelAttribute3Controller{

    // model属性的名称没有指定，它由返回类型隐含表示，
    // 如这个方法返回User类型，那么这个model属性的名称是user。
    // 这个例子中model属性名称由返回对象类型隐含表示，
    // model属性对象就是方法的返回值。它不需要指定特定的参数。
	@ModelAttribute
	public User userModel3( 
			@RequestParam("loginname") String loginname,
			@RequestParam("password") String password){
		return new UserUpperCase(loginname, password);
	}

	@RequestMapping(value="/login3")
	 public String login3() {
		 return "result3";
	 }
}

例子中@ModelAttribue没有参数，修饰的函数的返回值为User的对象，这时会以类名的首字母小写为属性名，返回值为属性值，在Model中放入一个属性。

java Spring mvc项目接入skywalking spring mvc实现_xml_14

@ModelAttribute和@RequestMapping同时注解同一个方法

@Controller
public class ModelAttribute4Controller{
	
    // 这时这个方法的返回值并不是表示一个视图名称，而是model属性的值，
     //视图名称是@RequestMapping的value值。
    // Model属性名称由@ModelAttribute(value="")指定，相当于在request中封装了
    //username（key）=admin（value）。
	@RequestMapping(value="/login")
	@ModelAttribute(value="username")
	 public String login() {
		 return "admin";
	 }
}

此时login方法的返回值不在是一个视图的名称，而是model属性的值，视图的名称仍然是@RequestMapping的value值"/login"。处理结束后页面继续跳转到login.jsp。

注释一个方法的参数

@Controller
public class ModelAttribute5Controller{
    @RequestMapping(value="/login")
    public String login(@ModelAttribute("user") User user) {
    user.setUsername("管理员");
        return "result";
    }
}

spring mvc 中有很多的注解，每个注解都有自己的功能，下面我们就对spring mvc中的注解一一作出介绍。关于spring的注解还没有总结，请等待后续blog更新。

@controller

为了保证spring能找到控制器，需要完成两件事情：

在spring mvc的配置文件的头文件中引入spring-context。
在spring mvc 的配置文件中使用context:component-scan/，该元素的功能是启动包扫描功能，以便注册有@Controller、@Service、@Repository、@Component等注解的类成为spring的bean。

<context:component-scan base-package = "com.chris.controller"/>

@RequestMapping

该注解类型指示spring用哪一个类或方法来处理请求动作，可以用于类或方法。

@Controller
// RequestMapping可以用来注释一个控制器类，此时，所有方法都将映射为相对于类级别的请求, 
// 表示该控制器处理所有的请求都被映射到 user属性所指示的路径下
@RequestMapping(value="/user")
public class UserController{
    // 映射请求 user/register
    @RequestMapping(value="/register",method=RequestMethod.GET)
	 public String registerForm() {
		 // 跳转到注册页面
	     return "registerForm";
	 }
     // 映射请求 user/login
     @RequestMapping("/login")
	 public String login( Model model) {
	     return "loginForm";
	 }
}

@RequestMapping可以指定一些属性

value：用来映射一个请求和一个方法，是其默认属性，如果在使用@RequestMapping时只有这个属性，则可以省略关键字value.
method：该属性用来指定该方法仅仅处理哪些HTTP请求的处理方式，例如GET、POST。
consumes：用来指定处理请求提交内容的类型。
produces：用来指定返回的内容类型，返回的内容类型必须是request请求头（Accept）中包含的类型。
params：指明request中必须包含哪些参数时，才让该方法处理。例如下面的代码指明方法只处理其中名为"myParam"，值为"myValue"的请求。

@RequestMapping(value="/hello", method = RequestMethod.POST,
 params = "myParam = myValue")

headers 指明request中必须包含某些header值，才能让该方法处理请求，例如

@RequestMapping(value="/hello", method = RequestMethod.POST,
 header = "bolgID = ")

在使用@RequestMapping指定的方法中，如果要访问HttpServletRequest或HttpSession，可以将其直接作为参数，Spring会将对象传递给方法。

@RequestMapping("/hello")
public String login(HttpSession session) {
    return "hello";
}

@RequestParam

该注解将指定的请求参数赋值给方法中的形参。

@RequestMapping("/hello") {
    public String login(
        @RequestParam("loginName") String loginName,
        @RequestParam("password") String password
    ) {
        return "login";
    }
}

在执行上面函数时，springmvc 会将Request中的loginName,password从参数中取出来赋值给函数的形参。
@RequestParam中的属性如下：

name：绑定参数在Request中的名称。
value：name属性的别名。
required：参数是否必须绑定。
defaultValue：如果没有传递参数而使用的默认值。

@RequestParam(value="loginname",required=true,defaultValue="admin")

@PathVariable

@PathVariable只支持一个属性value，类型为String，表示绑定的名称，如果省略则表示绑定同名参数。

@RequestMapping("path/{userId}")
public String login(@PathVariable Integer userId) {
    return "login";
}

加入请求url为http://localhost:8080/path/3，则上述函数在执行时会自动将userId值映射为3。

@RequestHeader

将请求头信息区书记映射到处理方法上。其主要有如下属性

name：指定请求头绑定的名称。
value：name属性的别名。
required：参数是否必须绑定。
defaultValue：如果没有传递参数而使用的默认值。

和@PathVariable的属性相同。下面给出用法实例

@RequestMapping("/hello") {
    public String login(
        @RequestHeader("User-Agent") String userAgent,
        @RequestHeader(value="Accept") String[] accepts
    ) {
        return "login";
    }
}

@CookieValue

将请求的Cookie书记映射到功能处理方法参数上。其支持的属性如下：

name：指定请求头绑定的名称。
value：name属性的别名。
required：参数是否必须绑定。
defaultValue：如果没有传递参数而使用的默认值。
用法和@RequestParam相同，这里不再赘述。

@SessionAttribute

该注解允许我们有选择的将指定Model中的哪些属性转存到HttpSession对象中。其只能声明在类上。他包含3个属性。

java Spring mvc项目接入skywalking spring mvc实现_xml_13

使用如下

@Controller
// 将Model中的属性名为user的放入HttpSession对象当中
@SessionAttributes("user")
public class SessionAttributesController{

	@RequestMapping(value="/{formName}")
	 public String loginForm(@PathVariable String formName){
		// 动态跳转页面
		return formName;
	}

	@RequestMapping(value="/login")
	 public String login(
			 @RequestParam("loginname") String loginname,
			 @RequestParam("password") String password,
			 Model model ) {
		 User user = new User();
		 user.setLoginname(loginname);
		 user.setPassword(password);
		 user.setUsername("admin");
		 model.addAttribute("user",user);
		 return "welcome";
	 }
}

@ModelAttribute

注解返回具体类的方法

@Controller
public class ModelAttribute1Controller{

    // 使用@ModelAttribute注释的value属性，
    // 来指定model属性的名称,model属性对象就是方法的返回值
	@ModelAttribute("loginname")
	public String userModel( 
			@RequestParam("loginname") String loginname){
		return loginname;
	}

	@RequestMapping(value="/login1")
	 public String login() {
		 return "result1";
	 }
}

userModel会先于login执行，并在Model中以loginname为属性名称，userModel返回值为属性值，在Model中放入了一个属性。

注解无返回值的方法

@Controller
public class ModelAttribute2Controller{

	// model属性名称和model属性对象由model.addAttribute()实现，
    // 前提是要在方法中加入一个Model类型的参数。
	// 注意：当URL或者post中不包含对应的参数时，程序会抛出异常。
	@ModelAttribute
	public void userModel( 
			@RequestParam("loginname") String loginname,
			@RequestParam("password") String password,
			 Model model){
		model.addAttribute("loginname", loginname);
		model.addAttribute("password", password);
	}

	@RequestMapping(value="/login2")
	 public String login() {
		 return "result2";
	 }
}

在这个例子中userModel先于login执行，相当于将一段对model的预处理逻辑单独放到一个函数中。

注解返回具体类的方法

@Controller
public class ModelAttribute3Controller{

    // model属性的名称没有指定，它由返回类型隐含表示，
    // 如这个方法返回User类型，那么这个model属性的名称是user。
    // 这个例子中model属性名称由返回对象类型隐含表示，
    // model属性对象就是方法的返回值。它不需要指定特定的参数。
	@ModelAttribute
	public User userModel3( 
			@RequestParam("loginname") String loginname,
			@RequestParam("password") String password){
		return new UserUpperCase(loginname, password);
	}

	@RequestMapping(value="/login3")
	 public String login3() {
		 return "result3";
	 }
}

例子中@ModelAttribue没有参数，修饰的函数的返回值为User的对象，这时会以类名的首字母小写为属性名，返回值为属性值，在Model中放入一个属性。

java Spring mvc项目接入skywalking spring mvc实现_xml_14

@ModelAttribute和@RequestMapping同时注解同一个方法

@Controller
public class ModelAttribute4Controller{
	
    // 这时这个方法的返回值并不是表示一个视图名称，而是model属性的值，
     //视图名称是@RequestMapping的value值。
    // Model属性名称由@ModelAttribute(value="")指定，相当于在request中封装了
    //username（key）=admin（value）。
	@RequestMapping(value="/login")
	@ModelAttribute(value="username")
	 public String login() {
		 return "admin";
	 }
}

此时login方法的返回值不在是一个视图的名称，而是model属性的值，视图的名称仍然是@RequestMapping的value值"/login"。处理结束后页面继续跳转到login.jsp。

注释一个方法的参数

@Controller
public class ModelAttribute5Controller{
    @RequestMapping(value="/login")
    public String login(@ModelAttribute("user") User user) {
    user.setUsername("管理员");
        return "result";
    }
}

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：智慧校园架构建设智慧校园框架图

下一篇：java ffmpegframegrabber 总帧数 ffmpeg通过代码改变帧率

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯