以下是一个简单的Spring MVC纯注解
启动案例：
1. 创建一个Spring MVC配置类`AppConfig`，用于配置视图解析器、处理器映射器和控制器。
```java
@Configuration
@EnableWebMvc
@ComponentScan(basePackages = "com.example")
public class AppConfig implements WebMvcConfigurer {
@Override
public void configureViewResolvers(ViewResolverRegistry registry) {
registry.jsp("/WEB-INF/views/", ".jsp");
}
@Override
public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
configurer.enable();
}
@Bean
public MyController myController() {
return new MyController();
}
@Override
public void addViewControllers(ViewControllerRegistry registry) {
registry.addViewController("/").setViewName("index");
}
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(new MyInterceptor());
}
@Override
public void addArgumentResolvers(List<HandlerMethodArgumentResolver> resolvers) {
resolvers.add(new MyArgumentResolver());
}
@Override
public void addReturnValueHandlers(List<HandlerMethodReturnValueHandler> handlers) {
handlers.add(new MyReturnValueHandler());
}
}
```
在上面的配置类
中，使用注解`@Configuration`标识为Spring配置类，使用注解`@EnableWebMvc`启用Spring MVC支持，使用注解`@ComponentScan`扫描注解`@Controller`的控制器类。其
中，`configureViewResolvers()`方法配置了JSP视图解析器，`configureDefaultServletHandling()`方法启用了默认的Servlet处理器，`myController()`方法定义了一个控制器Bean，`addViewControllers()`方法配置了根路径的视图控制器，`addInterceptors()`方法添加了一个拦截器，`addArgumentResolvers()`方法添加了一个参数解析器，`addReturnValueHandlers()`方法添加了一个返回值处理器。
2. 创建一个控制器类`MyController`，处理`/hello`路径的请求。
```java
@Controller
public class MyController {
@RequestMapping("/hello")
public String hello(Model model) {
model.addAttribute("message", "Hello, Spring MVC!");
return "hello";
}
}
```
在上面的控制器类
中，使用注解`@Controller`标识为控制器类，`hello()`方法处理`/hello`路径的请求，并将消息添加到模型
中，返回名为`hello`的JSP视图。
3. 创建一个拦截器类`MyInterceptor`，拦截所有请求并打印日志。
```java
public class MyInterceptor implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
System.out.println("Request URL: " + request.getRequestURL());
return true;
}
}
```
在上面的拦截器类
中，实现了`HandlerInterceptor`接口，重写了`preHandle()`方法，在请求处理前打印请求URL。
4. 创建一个参数解析器类`MyArgumentResolver`，用于解析请求参数并注入控制器方法参数。
```java
public class MyArgumentResolver implements HandlerMethodArgumentResolver {
@Override
public boolean supportsParameter(MethodParameter parameter) {
return parameter.getParameterType().equals(MyModel.class);
}
@Override
public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
MyModel model = new MyModel();
model.setMessage(webRequest.getParameter("message"));
return model;
}
}
```
在上面的参数解析器类
中，实现了`HandlerMethodArgumentResolver`接口，重写了`supportsParameter()`方法和`resolveArgument()`方法，用于判断是否支持参数类型和解析参数并返回控制器方法参数。
5. 创建一个返回值处理器类`MyReturnValueHandler`，用于处理控制器方法返回值并渲染模型和视图。
```java
public class MyReturnValueHandler implements HandlerMethodReturnValueHandler {
@Override
public boolean supportsReturnType(MethodParameter returnType) {
return returnType.getParameterType().equals(String.class);
}
@Override
public void handleReturnValue(Object returnValue, MethodParameter returnType, ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception {
mavContainer.setViewName((String) returnValue);
MyModel model = (MyModel) webRequest.getAttribute("myModel", RequestAttributes.SCOPE_REQUEST);
mavContainer.getModel().put("message", model.getMessage());
}
}
```
在上面的返回值处理器类
中，实现了`HandlerMethodReturnValueHandler`接口，重写了`supportsReturnType()`方法和`handleReturnValue()`方法，用于判断是否支持返回值类型和处理返回值并渲染模型和视图。
6. 在`web.xml`
中配置`DispatcherServlet`和`ContextLoader
Listener`。
```xml
<web-app>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/
applicationContext.xml</param-value>
</context-param>
<
listener>
<
listener-class>org.springframework.web.context.ContextLoader
Listener</
listener-class>
</
listener>
<servlet>
<servlet-name>myServlet</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextClass</param-name>
<param-value>org.springframework.web.context.support.AnnotationConfigWeb
ApplicationContext</param-value>
</init-param>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>com.example.AppConfig</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>myServlet</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
</web-app>
```
在上面的配置
中，使用`ContextLoader
Listener`
加载根配置类`
applicationContext.xml`，使用`DispatcherServlet`
加载Spring MVC配置类`AppConfig`，并映射到根路径`"/"`。
至此，一个简单的Spring MVC纯注解
启动案例就完成了。
扫一扫
873
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
