SpringMVC

最新推荐文章于 2022-06-14 20:31:10 发布
最新推荐文章于 2022-06-14 20:31:10 发布
阅读量199 收藏
点赞数
文章标签： mvc spring java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48696905/article/details/120400734
版权

一、Spring MVC简介

Spring MVC是什么

Spring MVC 是 Spring 提供的一个基于 MVC 设计模式的轻量级 Web 开发框架，本质上相当于 Servlet。

Spring MVC 是结构最清晰的 Servlet+JSP+JavaBean 的实现，是一个典型的教科书式的 MVC 构架，不像 Struts 等其它框架都是变种或者不是完全基于 MVC 系统的框架。

Spring MVC 角色划分清晰，分工明细，并且和 Spring 框架无缝结合。Spring MVC 是当今业界最主流的 Web 开发框架，以及最热门的开发技能。

在 Spring MVC 框架中，Controller 替换 Servlet 来担负控制器的职责，用于接收请求，调用相应的 Model 进行处理，处理器完成业务处理后返回处理结果。Controller 调用相应的 View 并对处理结果进行视图渲染，最终客户端得到响应信息。

Spring MVC 框架采用松耦合可插拔的组件结构，具有高度可配置性，比起其它 MVC 框架更具有扩展性和灵活性。

此外，Spring MVC 的注解驱动和对 REST 风格的支持，也是它最具特色的功能。无论是在框架设计，还是扩展性、灵活性等方面都全面超越了 Struts2 等 MVC 框架。并且由于 Spring MVC 本身就是 Spring 框架的一部分，所以可以说与 Spring 框架是无缝集成，性能方面具有先天的优越性，对于开发者来说，开发效率也高于其它的 Web 框架，在企业中的应用越来越广泛，成为主流的 MVC 框架。

Spring MVC优点

  • 清晰地角色划分，Spring MVC 在 Model、View 和 Controller 方面提供了一个非常清晰的角色划分，这 3 个方面真正是各司其职，各负其责。
  • 灵活的配置功能，可以把类当作 Bean 通过 XML 进行配置。
  • 提供了大量的控制器接口和实现类，开发者可以使用 Spring 提供的控制器实现类，也可以自己实现控制器接口。
  • 真正做到与 View 层的实现无关。它不会强制开发者使用 JSP，可以根据项目需求使用 Velocity、FreeMarker 等技术。
  • 国际化支持
  • 面向接口编程
  • 与 Spring 框架无缝集成

二、搭建 Spring MVC 环境

搭建步骤如下：

  1. 创建 Web 项目并引入 JAR 包
  2. Spring MVC 配置：在 web.xml 中配置 Servlet，创建 Spring MVC 的配置文件
  3. 创建 Controller（处理请求的控制器）
  4. 创建 View（使用 JSP 作为视图）
  5. 部署运行

1. 创建Web项目并引入JAR包

创建Maven Web项目在 pom.xml 文件中添加以下依赖：

		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>3.8.1</version>
			<scope>test</scope>
		</dependency>

		<!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<version>1.18.12</version>
			<scope>provided</scope>
		</dependency>

		<!-- https://mvnrepository.com/artifact/org.springframework/spring-core -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>5.3.5</version>
		</dependency>

		<!-- https://mvnrepository.com/artifact/org.springframework/spring-beans -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-beans</artifactId>
			<version>5.3.5</version>
		</dependency>

		<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>5.3.5</version>
		</dependency>

		<!-- https://mvnrepository.com/artifact/org.springframework/spring-aop -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-aop</artifactId>
			<version>5.3.5</version>
		</dependency>

		<dependency>
			<groupId>com.google.protobuf</groupId>
			<artifactId>protobuf-java</artifactId>
			<version>2.4.1</version>
			<scope>compile</scope>
		</dependency>

		<!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>druid</artifactId>
			<version>1.2.6</version>
		</dependency>

		<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>5.1.16</version>
		</dependency>

		<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjrt -->
		<dependency>
			<groupId>org.aspectj</groupId>
			<artifactId>aspectjtools</artifactId>
			<version>1.9.5</version>
		</dependency>

		<dependency>
			<groupId>aopalliance</groupId>
			<artifactId>aopalliance</artifactId>
			<version>1.0</version>
		</dependency>

		<dependency>
			<groupId>org.aspectj</groupId>
			<artifactId>aspectjweaver</artifactId>
			<version>1.9.0</version>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-jdbc</artifactId>
			<version>5.3.5</version>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-tx</artifactId>
			<version>5.3.5</version>
		</dependency>

		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis-spring</artifactId>
			<version>1.3.2</version>
		</dependency>

		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis</artifactId>
			<version>3.4.6</version>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>5.3.9</version>
		</dependency>

		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>javax.servlet-api</artifactId>
			<version>3.1.0</version>
			<scope>provided</scope>
		</dependency>

2.Spring MVC配置

1）定义DispatcherServlet

Spring MVC 是基于 Servlet 的，DispatcherServlet 是整个 Spring MVC 框架的核心，主要负责截获请求并将其分派给相应的处理器处理。

配置 Spring MVC，首先要定义 DispatcherServlet。跟所有 Servlet 一样，用户必须在 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" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
    version="3.0">
    <display-name>springMVC</display-name>
    <!-- 部署 DispatcherServlet -->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!-- 表示容器再启动时立即加载servlet -->
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <!-- 处理所有URL -->
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

Spring MVC 初始化时将在应用程序的 WEB-INF 目录下查找配置文件，该配置文件的命名规则是“servletName-servlet.xml”，例如 springmvc-servlet.xml。

可以将 Spring MVC 的配置文件存放在应用程序目录中的任何地方，但需要使用 servlet 的 init-param 元素加载配置文件，通过 contextConfigLocation 参数来指定 Spring MVC 配置文件的位置。

<!-- 部署 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-servlet.xml</param-value>
    </init-param>
    <!-- 表示容器再启动时立即加载servlet -->
    <load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
    <servlet-name>springmvc</servlet-name>
    <url-pattern>/</url-pattern>
</servlet-mapping>

此处使用 Spring 资源路径的方式进行指定，即 classpath:springmvc-servlet.xml。

配置了一个名为“springmvc”的 Servlet。该 Servlet 是 DispatcherServlet 类型，它就是 Spring MVC 的入口，

通过 <load-on-startup>1</load-on-startup> 配置标记容器在启动时就加载此 DispatcherServlet，即自动启动。

然后通过 servlet-mapping 映射到“/”，即 DispatcherServlet 需要截获并处理该项目的所有 URL 请求。

2）创建Spring MVC配置文件

在 WEB-INF 目录下创建 springmvc-servlet.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"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!-- LoginController控制器类，映射到"/login" -->
    <bean name="/login"
          class="com.yao.controller.LoginController"/>
    <!-- LoginController控制器类，映射到"/register" -->
    <bean name="/register"
          class="com.yao.controller.RegisterController"/>
</beans>

3.创建Controller

在 src 目录下创建 com.yao.controller 包，并在该包中创建 RegisterController 和 LoginController 两个传统风格的控制器类（实现 Controller 接口），分别处理首页中“注册”和“登录”超链接的请求。

Controller 是控制器接口，接口中只有一个方法 handleRequest，用于处理请求和返回 ModelAndView。

LoginController 

package com.yao.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 LoginController implements Controller {
    public ModelAndView handleRequest(HttpServletRequest arg0,
            HttpServletResponse arg1) throws Exception {
        return new ModelAndView("/WEB-INF/jsp/register.jsp");
    }
}

RegisterController

package com.yao.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 RegisterController implements Controller {
    public ModelAndView handleRequest(HttpServletRequest arg0,
            HttpServletResponse arg1) throws Exception {
        return new ModelAndView("/WEB-INF/jsp/login.jsp");
    }
}

4. 创建View

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>
    <a href="${pageContext.request.contextPath }/register"> 注册</a>
    <br /> 
    <a href="${pageContext.request.contextPath }/login"> 登录</a>
</body>
</html>

在 WEB-INF 下创建 jsp 文件夹，将 login.jsp 和 register.jsp 放到 jsp 文件夹下。

login.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>
    登录页面！
</body>
</html>

register.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>
    注册页面！
</body>
</html>

5. 部署运行

将项目部署到 Tomcat 服务器，首先访问 index.jsp 页面

当用户单击“注册”超链接时，根据 springmvc-servlet.xml 文件中的映射将请求转发给 RegisterController 控制器处理，处理后跳转到 /WEB-INF/jsp 下的 register.jsp 视图。

同理，当单击“登录”超链接时，控制器处理后转到 /WEB-INF/jsp下的 login.jsp 视图。

三、Spring MVC视图解析器（ViewResolver）

视图解析器（ViewResolver），负责将逻辑视图名解析为具体的视图对象。

Spring MVC 提供了很多视图解析类，其中每一项都对应 Java Web 应用中特定的某些视图技术。下面介绍一些常用的视图解析类。

URLBasedViewResolver

UrlBasedViewResolver 是对 ViewResolver 的一种简单实现，主要提供了一种拼接 URL 的方式来解析视图。

UrlBasedViewResolver 通过 prefix 属性指定前缀，suffix 属性指定后缀。当 ModelAndView 对象返回具体的 View 名称时，它会将前缀 prefix 和后缀 suffix 与具体的视图名称拼接，得到一个视图资源文件的具体加载路径，从而加载真正的视图文件并反馈给用户。

使用 UrlBasedViewResolver 除了要配置前缀和后缀属性之外，还需要配置“viewClass”，表示解析成哪种视图。

<bean id="viewResolver" class="org.springframework.web.servlet.view.UrlBasedViewResolver">            
    <property name="viewClass" value="org.springframework.web.servlet.view.InternalResourceViewResolver"/> <!--不能省略-->
    <!--前缀-->
    <property name="prefix" value="/WEB-INF/jsp/"/>
    <!--后缀-->
    <property name="suffix" value=".jsp"/>  
 </bean>

上述视图解析器配置了前缀和后缀两个属性，这样缩短了 view 路径。

因此RegisterController 和 LoginController 控制器类的视图路径仅需提供 register 和 login，视图解析器将会自动添加前缀和后缀，此处解析为 /WEB-INF/jsp/register.jsp 和 /WEB-INF/jsp/login.jsp。

上述 viewClass 值为 InternalResourceViewResolver，它用来展示 JSP 页面。如果需要使用 jstl 标签展示数据，将 viewClass 属性值指定为 JstlView 即可。

存放在 /WEB-INF/ 目录下的内容不能直接通过 request 请求得到，所以为了安全性考虑，通常把 jsp 文件放在 WEB-INF 目录下。

InternalResourceViewResolver

InternalResourceViewResolver 为“内部资源视图解析器”，是 URLBasedViewResolver 的子类，拥有 URLBasedViewResolver 的一切特性。

InternalResourceViewResolver 能自动将返回的视图名称解析为 InternalResourceView 类型的对象。InternalResourceView 会把 Controller 处理器方法返回的模型属性都存放到对应的 request 属性中，然后通过 RequestDispatcher 在服务器端把请求 forword 重定向到目标 URL。也就是说，使用 InternalResourceViewResolver 视图解析时，无需再单独指定 viewClass 属性。

<bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <!--前缀-->
    <property name="prefix" value="/WEB-INF/jsp/"/>
    <!--后缀-->
    <property name="suffix" value=".jsp"/>  
 </bean>

四、Spring MVC执行流程

在学习框架之前，首先了解一下 Spring MVC 框架的整体请求流程和使用到的 API 类。

Spring MVC 框架是高度可配置的，包含多种视图技术，例如 JSP、FreeMarker、Tiles、iText 和 POI。Spring MVC 框架并不关心使用的视图技术，也不会强迫开发者只使用 JSP。

Spring MVC 执行流程

  1. 用户点击某个请求路径，发起一个 HTTP request 请求，该请求会被提交到 DispatcherServlet（前端控制器）
  2. 由 DispatcherServlet 请求一个或多个 HandlerMapping（处理器映射器），并返回一个执行链（HandlerExecutionChain）
  3. DispatcherServlet 将执行链返回的 Handler 信息发送给 HandlerAdapter（处理器适配器）
  4. HandlerAdapter 根据 Handler 信息找到并执行相应的 Handler（常称为 Controller）
  5. Handler 执行完毕后会返回给 HandlerAdapter 一个 ModelAndView 对象（Spring MVC的底层对象，包括 Model 数据模型和 View 视图信息）
  6. HandlerAdapter 接收到 ModelAndView 对象后，将其返回给 DispatcherServlet 
  7. DispatcherServlet 接收到 ModelAndView 对象后，会请求 ViewResolver（视图解析器）对视图进行解析
  8. ViewResolver 根据 View 信息匹配到相应的视图结果，并返回给 DispatcherServlet
  9. DispatcherServlet 接收到具体的 View 视图后，进行视图渲染，将 Model 中的模型数据填充到 View 视图中的 request 域，生成最终的 View（视图）
  10. 视图负责将结果显示到浏览器（客户端）

Spring MVC接口

1）DispatcherServlet（前端控制器）

Spring MVC 的所有请求都要经过 DispatcherServlet 来统一分发。DispatcherServlet 相当于一个转发器或中央处理器，控制整个流程的执行，对各个组件进行统一调度，以降低组件之间的耦合性，有利于组件之间的拓展。

2）HandlerMapping（处理器映射器）

其作用是根据请求的 URL 路径，通过注解或者 XML 配置，寻找匹配的处理器（Handler）信息。

3）HandlerAdapter（处理器适配器）

其作用是根据映射器找到的处理器（Handler）信息，按照特定规则执行相关的处理器。

4）Handler（处理器）

和 Java Servlet 扮演的角色一致。其作用是执行相关的请求处理逻辑，并返回相应的数据和视图信息，将其封装至 ModelAndView 对象中。

5）ViewResolver（视图解析器）

其作用是进行解析操作，通过 ModelAndView 对象中的 View 信息将逻辑视图名解析成真正的视图 View（如通过一个 JSP 路径返回一个真正的 JSP 页面）。

6）View（视图）

其本身是一个接口，实现类支持不同的 View 类型（JSP、FreeMarker、Excel 等）。

以上组件中，需要开发人员进行开发的是处理器（Handler，常称Controller）和视图（View）。通俗的说，要开发处理该请求的具体代码逻辑，以及最终展示给用户的界面。


五、@Controller和@RequestMapping注解

Spring 2.5 版本新增了 Spring MVC 注解功能，用于替换传统的基于 XML 的 Spring MVC 配置。

之前创建了两个传统风格的控制器，它们是实现 Controller 接口的类。

传统风格的控制器不仅需要在配置文件中部署映射，而且只能编写一个处理方法，不够灵活。

使用基于注解的控制器具有以下 2 个优点：

  1. 在基于注解的控制器类中可以编写多个处理方法，进而可以处理多个请求（动作），这就允许将相关的操作编写在同一个控制器类中，从而减少控制器类的数量，方便以后维护。
  2. 基于注解的控制器不需要在配置文件中部署映射，仅需要使用 @RequestMapping 注解一个方法进行请求处理即可。

Controller注解

@Controller 注解用于声明某类的实例是一个控制器。

package com.yao.controller;
import org.springframework.stereotype.Controller;

@Controller
public class IndexController {
    // 处理请求的方法
}

Spring MVC 使用扫描机制找到应用中所有基于注解的控制器类，所以，为了让控制器类被 Spring MVC 框架扫描到，需要在配置文件中声明 spring-context，并使用 <context:component-scan/> 元素指定控制器类的基本包（请确保所有控制器类都在基本包及其子包下）。


在配置文件 springmvc-servlet.xml 中添加以下代码：

<!-- 使用扫描机制扫描控制器类，控制器类都在com.yao.controller包及其子包下 -->
<context:component-scan base-package="com.yao.controller" />

RequestMapping注解

一个控制器内有多个处理请求的方法，如 UserController 里通常有增加用户、修改用户信息、删除指定用户、根据条件获取用户列表等。每个方法负责不同的请求操作，而 @RequestMapping 就负责将请求映射到对应的控制器方法上。

在基于注解的控制器类中可以为每个请求编写对应的处理方法。使用 @RequestMapping 注解将请求与处理方法一 一对应即可。

@RequestMapping 注解可用于类或方法上。用于类上，表示类中的所有响应请求的方法都以该地址作为父路径。

@RequestMapping 注解常用属性如下

1. value 属性

value 属性是 @RequestMapping 注解的默认属性，如果只有 value 属性时，可以省略该属性名，如果有其它属性，则必须写上 value 属性名称。

@RequestMapping(value="toUser")
@RequestMapping("toUser")

value 属性支持通配符匹配，如 @RequestMapping(value="toUser/*") 表示 http://localhost:8080/toUser/1 或 http://localhost:8080/toUser/hahaha 都能够正常访问。

2. path属性

path 属性和 value 属性都用来作为映射使用。即 @RequestMapping(value="toUser") 和 @RequestMapping(path="toUser") 都能访问 toUser() 方法。

path 属性支持通配符匹配，如 @RequestMapping(path="toUser/*") 表示 http://localhost:8080/toUser/1 或 http://localhost:8080/toUser/hahaha 都能够正常访问。

3. name属性

name属性相当于方法的注释，使方法更易理解。如 @RequestMapping(value = "toUser",name = "获取用户信息")。

4. method属性

method 属性用于表示该方法支持哪些 HTTP 请求。如果省略 method 属性，则说明该方法支持全部的 HTTP 请求。

@RequestMapping(value = "toUser",method = RequestMethod.GET) 表示该方法只支持 GET 请求。也可指定多个 HTTP 请求，如 @RequestMapping(value = "toUser",method = {RequestMethod.GET,RequestMethod.POST})，说明该方法同时支持 GET 和 POST 请求。

5. params属性

params 属性用于指定请求中规定的参数

@RequestMapping(value = "toUser",params = "type")
public String toUser() {
    
    return "showUser";
}

以上代码表示请求中必须包含 type 参数时才能执行该请求。即 http://localhost:8080/toUser?type=xxx 能够正常访问 toUser() 方法，而 http://localhost:8080/toUser 则不能正常访问 toUser() 方法。

@RequestMapping(value = "toUser",params = "type=1")
public String toUser() {
    
    return "showUser";
}

以上代码表示请求中必须包含 type 参数，且 type 参数为 1 时才能够执行该请求。即 http://localhost:8080/toUser?type=1 能够正常访问 toUser() 方法，而 http://localhost:8080/toUser?type=2 则不能正常访问 toUser() 方法。

6. header属性

header 属性表示请求中必须包含某些指定的 header 值。

@RequestMapping(value = "toUser",headers = "Referer=http://www.xxx.com") 表示请求的 header 中必须包含了指定的“Referer”请求头，以及值为“http://www.xxx.com”时，才能执行该请求。

7. consumers属性

consumers 属性用于指定处理请求的提交内容类型（Content-Type），例如：application/json、text/html。如 @RequestMapping(value = "toUser",consumes = "application/json")。

8. produces属性

produces 属性用于指定返回的内容类型，返回的内容类型必须是 request 请求头（Accept）中所包含的类型。如 @RequestMapping(value = "toUser",produces = "application/json")。

produces 属性还可以指定返回值的编码。如 @RequestMapping(value = "toUser",produces = "application/json,charset=utf-8")，表示返回 utf-8 编码。



使用 @RequestMapping 来完成映射，具体包括 4 个方面的信息项：请求 URL、请求参数、请求方法和请求头。

通过请求URL进行映射

1）方法级别注解

package com.yao.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller
public class IndexController {
    @RequestMapping(value = "/index/login")
    public String login() {
        return "login";
    }
    @RequestMapping(value = "/index/register")
    public String register() {
        return "register";
    }
}

2）类级别注解

package com.yao.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller
@RequestMapping("/index")
public class IndexController {
    @RequestMapping("/login")
    public String login() {
        return "login";
    }
    @RequestMapping("/register")
    public String register() {
        return "register";
    }
}

在类级别注解的情况下，控制器类中的所有方法都将映射为类级别的请求。 

为了方便维护程序，建议开发者采用类级别注解，将相关处理放在同一个控制器类中。例如，对用户的增、删、改、查等处理方法都可以放在 UserController 控制类中。

通过请求参数、请求方法进行映射

@RequestMapping 使用请求参数、请求方法来映射请求，通过多个条件可以让请求映射更加精确。

未完待续。。。。后面会补充

Night-Monkey
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
使用MVC的实现登录注册功能
日常笔记 | 干货分享 | 毕设源码 | 毕设指导 | 答辩指导
05-05 9300
MVC的使用 使用MVC的实现登录注册功能 M:代表模型层，解决问题的功能具体实现。比如向数据库添加数据、查询数据 V:代表视图，用户和机器的交互页面。用来展示信息（一般用html,js，css…） C:控制层，用来连接用户提交的操作和调用后台功能（servlet实现） 先写V层： 简单的html页面，这里只显示登录界面，其他的界面很容易写，简单的页面跳转。 提示。登录页面： action=“servletControll”。将登录的内容提交都处理登录的的servlet.注册页面的数据提交到处理注册页面的s
控制器Controller（保姆级教程）
Hiss的博客
03-31 7038
控制器Controller（保姆级教程）实现Controller接口使用注解@Controller（声明Spring类的实例是一个控制器） 控制器复杂提供访问应用程序的行为 通常通过接口定义和注解定义两种方法实现。 实现Controller接口 1.new module 2.Add framework support(添加web的支持) 3.Structure——artifacts 新建lib导jar包 4.web.xml中配置DispatcherServlet 5.新建springmvc-servl
Spring: Controller的登录页面跳转
eldridgec的博客
09-28 6092
登录页面和登录按钮不能同时调用同一个方法，需要做跳转，否则一上来就会调用MD5密码验证，导致异常org.springframework.web.util.NestedServletException @RequestMapping(&quot;/login&quot;) public String login(HttpSession session) { return &quot;/sysadmin/login/logi...
使用SpringMVC实现用户注册和登录的小例子
热门推荐
hfut_csdn_wxq的博客
11-13 2万+
使用SpringMVC实现用户注册和登录的小例子 1.新建Dynamic Web Project，名称RequestMappingTest 2.导入jar包 3.添加相关文件 4.文件代码 loginForm.jsp &amp;lt;%@ page language=&quot;java&quot; contentType=&quot;text/html; charset=UTF-8&quot; pageEncoding=&quo
SpringMVC（2）——基于注解的控制器
二木成林
11-14 1192
目录 概述 Controller注解类型 RequestMapping注解类型 方法级别注解 类级别注解 实例 概述 传统风格的控制器不仅需要在配置文件中部署映射,而且只能编写一个处理方法,不够灵活。 使用基于注解的控制器具有以下两个优点： (1)在基于注解的控制器类中可以编写多个处理方法,进而可以处理多个请求(动作),这就允许将相关的操作编写在同一个控制器类中,从而减少...
SpringMVC（一·）
weixin_42322925的博客
02-17 460
MVC模式与Spring MVC工作原理 MVC模式 MVC的概念 基于Servlet的MVC模式 Spring MVC工作原理 Spring MVC接口 第一个简单的Spring MVC应用 MVC思想将一个应用分成3个基本部分，即Model（模型）、View（视图）和Controller（控制器），让这三个部分·以最低的耦合进行协同工作，从而提 高应用的可扩展性及可维护性。Spring MVC是一款优秀的基于MVC思想的额应用框架，它是Spring提供的一个实现了Web MVC设计模式的轻量级Web
SpringMVC demo 完整源码实例下载
05-02
SpringMVC是一款强大的Java web开发框架，用于构建高效、可维护的Web应用程序。在这个"SpringMVC demo 完整源码实例下载"中，我们能够深入理解并学习SpringMVC的核心概念和实际应用。 首先，SpringMVC是Spring框架...
springmvc思维导图
07-25
springmvc的概念、springmvc的运行原理（前端控制器、处理器映射器、处理器适配器、处理器、视图解析器）、同步请求的方式（ModelAndView、String、无返回值、默认的绑定值）、异步请求的注解、请求参数的封装（简单...
Spring+SpringMVC+Mybatis框架整合例子(SSM) 下载
07-21
Spring、SpringMVC和Mybatis是Java开发中最常用的三大开源框架，它们的整合使用，通常被称为SSM框架。这个框架组合提供了完整的后端服务解决方案，包括依赖注入（DI）、面向切面编程（AOP）、模型-视图-控制器（MVC...
springMVC学习
03-11
SpringMVC 学习指南 SpringMVC 是 Spring 框架中的一个 web 组件，它提供了丰富的功能来构建稳健的 web 应用。 SpringMVC 的核心思想是基于每个逻辑和功能是高可配置的架构和设计的。下面是 SpringMVC 的学习指南：...
Spring MVC入门
qq_41193133的博客
03-03 244
一、Spring MVC工作原理 Spring MVC框架主要有DispatcherServlet、处理器映射、控制器、视图解析器、视图组成。其工作的流程： （1）客户端发起的http请求提交到DispatcherServlet； （2）由DispatcherServlet控制器寻找一个或多个HandlerMapping，找到处理请求的Controller； （3）DispatcherServle...
玩一玩Spring Boot框架（可视化04）
qq_56244269的博客
06-14 1189
Spring Boot官网：https://spring.io/projects/spring-boot，当前Spring Boot GA (General Availability)版是2.7.0利用创建项目然后再配置项目基本信息 添加相关依赖 设置项目名称与保存位置 单击【Finish】按钮，完成项目初始化关闭数据源自动配置查看数据源自动配置类 - DataSourceAutoConfiguration启动项目访问 添加路由函数，通过参数向前端模板页面传递数据 在里创建，跟路由函数里的逻辑视图名相对应
springmvc源码阅读笔记 -- handleRequest
zghwaicsdn的专栏
04-24 1201
HandlerAdapter的handler方法基于注解@RequestMapping处理流程. HandlerAdapter用于适配各种处理器成相同的处理功能。 在HandlerAdapter中有基本的四种处理器 1.实现Servlet的handler处理器 2.实现Controller的handler处理器 3.实现HttpRequestHanlder的hanlder处理器 4
SpringMVC源码系列(五)HandlerAdapter中handle方法的调用过程
二狗家有矿
02-18 362
1.写在前面 笔者前面已经介绍过了如何获取对应的Handler,以及如何获取对应的HandlerAdapter，也就是从Url和方法的映射到找到对应的适配器，笔者已经讲完了。接下笔者讲的是如何调用，以及视图的解析。今天这篇博客要讲的就是HandlerAdapter的调用 2.HandlerAdapter的调用 笔者还是带大家看下原来的代码，具体的内容如下： protected void doDispatch(HttpServletRequest request, HttpServletRespon
【JAVA】拦截请求参数并设置请求头
qq_31665011的博客
01-19 9868
    业务中遇到了一些场景，需要对请求做统一拦截，用请求参数计算新的变量设置到请求头中。     以下分别用Filter和Interceptor两种方式实现，（建议使用Filter的方法，因为Interceptor的方法仅仅对Post和GET方法有效，并不支持PUT等其他方法，主要原因是因为HttpServletRequest接口的实现类不同，以下仅支持了POST和GET方法） 场景： 我...
springmvc 业务处理控制器的三种实现和全注解实现方式
银魄清辉自夜凝的博客
04-11 382
一、实现Controller接口 public class HelloContronller implements Controller{ @Override public ModelAndView handleRequest(HttpServletRequest arg0, HttpServletResponse arg1) throws Exception { System.o...
springmvc编写一个handle
Fly to sky
05-08 1032
1.配置web.xml文件 2.配置spring-mvc.xml包括处理器适配器处理器解析器 视图解析器 3.创建一个handle集成 controlerpackage springmvc;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import org.s
SpringMVC注解配置详解
"SpringMVC详解及注解说明文档，涵盖了基于注解的配置，Spring框架集成，以及如何利用注解实现IoC功能。" 在Java开发领域，SpringMVC是Spring框架的一个重要组件，用于构建Web应用程序。它遵循模型-视图-控制器...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Night-Monkey

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值