SpringMVC配置过程

最新推荐文章于 2024-11-24 23:09:35 发布
最新推荐文章于 2024-11-24 23:09:35 发布
阅读量5.5k 收藏 20
点赞数 5
分类专栏： Spring 文章标签： springmvc spring SpringMVC配置
原文链接：https://blog.csdn.net/fyytycoon/article/details/97617327
版权

SpringMVC 配置过程

文章目录

一、创建Maven WEB 项目并添加Spring MVC 依赖

1.创建maven web项目
在这里插入图片描述

在这里插入图片描述

2.Web项目打包方式为war方式
在这里插入图片描述

3.生成web.xml(项目视图)
在这里插入图片描述

4.Web项目的target runtimes为tomcat
在这里插入图片描述

  1. Web项目的编译版本为JDK1.8
    在这里插入图片描述

6.添加Spring MVC项目依赖

	<dependencies>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>4.3.8.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.12</version>
		</dependency>
	</dependencies>

二、添加Spring MVC配置文件并进行基本配置

  1. 在项目的resources的目录中添加核心配置文件（例如spring-configs.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:context="http://www.springframework.org/schema/context"
	xmlns:jdbc="http://www.springframework.org/schema/jdbc"
	xmlns:jee="http://www.springframework.org/schema/jee"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:mvc="http://www.springframework.org/schema/mvc"
	xmlns:util="http://www.springframework.org/schema/util"
	xmlns:jpa="http://www.springframework.org/schema/data/jpa"
	xsi:schemaLocation="
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd
		http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd
		http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.2.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
		http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
		http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd
		http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.2.xsd">

	<!-- 配置组件扫描 -->
	<context:component-scan base-package="cn.spring"></context:component-scan>
	<!--启用MVC默认配置 (@RequestMapping) -->
	<mvc:annotation-driven />
	<!-- 配置视图解析器 -->
	<bean id="viewResolver"
		class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<property name="prefix" value="/WEB-INF/" />
		<property name="suffix" value=".jsp" />
	</bean>
	
</beans>

视图解析器

	处理请求的方法的参数是`String`类型时，默认表示响应给客户端的视图的名称，后续，会经过`ViewResolver`进行处理，得到具体的视图。
	
	首先，应该创建jsp页面，例如在**WEB-INF**下创建**index.jsp**文件，页面内容随意，例如显示“Hello, SpringMVC!!!”字样。
	
	然后，需要设计处理请求的方法的返回值，并配置`ViewResolver`！`ViewResolver`是一个接口，具体使用的实现类是`InternalResourceViewResolver`，需要在Spring的配置文件中配置它的`prefix`和`suffix`属性，分别表示“前缀”和“后缀”，`InternalResourceViewResolver`的工作模式是以**webapp**文件夹为根路径，将“前缀 + 处理请求的方法的返回值 + 后缀”得到具体的JSP文件的位置，刚才创建的JSP文件在**webapp/WEB-INF/index.jsp**，则可以：
	
		/WEB-INF/	+	index	+	.jsp
	
		""	+	/WEB-INF/index.jsp	+	""
	
	还可以是其他组合方式，只要能组合出文件的路径都是正确的，可以在处理请求的方法中返回`"index"`，然后配置为：
	
		<!-- 视图解析器 -->
		<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
			<property name="prefix" value="/WEB-INF/" />
			<property name="suffix" value=".jsp" />
		</bean>
	
	至此，开发完成，可以再次测试访问。
  1. 打开web.xml，配置DispatcherServlet对象
<servlet>
     <servlet-name>dispatcherServlet</servlet-name>
     <servlet-class> org.springframework.web.servlet.DispatcherServlet </servlet-class>
     <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring-configs.xml</param-value>
     </init-param>
     <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
     <servlet-name>dispatcherServlet</servlet-name>
     <url-pattern>*.do</url-pattern>
  </servlet-mapping>

以上配置实现的效果就是：当Tomcat启动时，就会创建DispatcherServlet的对象，并且，DispatcherServlet会读取所配置的spring-configs.xml文件，以加载Spring环境，后续，DispatcherServlet将接收所有以.do为后缀的请求！

前端控制器是spring mvc处理请求的入口，是springmvc的核心，这个控制器一般需要在服务器启动时即初始化。
其中

在配置时，如果不明确DispatcherServlet的包名，可以随意创建某个Java类，在类中声明该Servlet，由Eclipse完成导包，则import语句中就有了该类的全名。

至此，DispatcherServlet就可以接收所有以.do为后缀的请求。

默认情况下，所有的Servlet都是第一次接收并处理请求时才完成的初始化操作，并且，SpringMVC框架是基于Spring框架基础之上的，在项目启动初期，就应该加载整个Spring环境，以保证SpringMVC框架能正常运行！所以，可以通过配置去实现：当启动Tomcat时，就直接初始化DispatcherServlet，在DispatcherServlet中，已经定义了某个属性，值是Spring配置文件的位置，当DispatcherServlet被初始化时，就会读取该配置文件！

在配置时，可以通过<load-on-startup>使得DispatcherServlet是默认直接初始化的！ ** 表示启动时则加载此servlet,数字越小优先级越高. 中的参数名不能变（此名字在DispatcherServlet父类中定义）**

在DispatcherServlet的父类FrameworkServlet中，有contextConfigLocation属性，其作用就是制定Spring配置文件的位置，一旦创建了DispatcherServlet对象，就会自动读取所配置的文件，以加载Spring的环境！

如果需要验证现在的配置结果，可以自定义cn.tedu.spring.User类，然后，在类中显式的定义构造方法：

	public class User {
		public User() {
			System.out.println("创建了User的对象！");
		}
	}

然后在Spring的配置文件中进行配置：

	<bean class="cn.tedu.spring.User" />

由于Tomcat启动时就会初始化DispatcherServlet，进而加载Spring配置文件，就会由Spring框架创建User对象，导致构造方法被执行，所以，当启动Tomcat时，就会看到构造方法中输出的内容！

  1. 2.2.4.创建并配置Spring MVC后端控制器

编写Spring MVC后端控制器，后端控制器在spring mvc中中又称之为handler。


@Controller
@RequestMapping("user")
public class HelloController {
	@RequestMapping("doSayHello.do")
	public ModelAndView doSayHello() {
		ModelAndView mv=new ModelAndView("hello");
		mv.addObject("message", "helloworld");
		return mv;
	}
	
	@RequestMapping("dologin.do")
	public String dologin() {
		return "login";
	}
	
	@RequestMapping(value="handle_login.do",method=RequestMethod.GET)
	public String dohandle_login(String username,String password,HttpSession session) {
		System.out.println(username);
		System.out.println(password);
		if ("root".equals(username)) {
			if ("1234".contentEquals(password)) {
				System.out.println("yes");
				session.setAttribute("username", username);
			}else {
				System.out.println("passnot");
			}
		}else {
			System.out.println("namenot");
		}
		return "index";
	}
}

其中:
1）通过@RequestMapping注解定义url到controller具体方法的映射,这个映射信息会被存储,一般是存储到一个HandlerMapping对象中.
2）ModelAndView对象为一个模型与视图对象，内置一个map对象，主要用于封装业务数据和视图名。
3）ModelAndView构造方法中传递的为视图名，addObject方法可以以key/value形式存储数据。
4）ModelAndView 对象返回时会被spring mvc自动存储到请求作用域，在对应的视图页面可以直接从此作用域获取对应的值。

  1. 创建JSP页面对象

在项目的WEB-INF/pages文件夹下创建hello.jsp文件，然后设置其内容，例如

<body>
   <h1>${message}</h1>
</body>

说明：WEB-INF目录下的资源不能允许通过浏览器地址栏直接访问。

三、Spring MVC拦截器编写及基本配置

拦截器是SpringMVC中的一个核心应用组件,主要用于处理多个Controller的共性问题.当我们的请求由DispatcherServlet派发到具体Controller之前首先要执行拦截器中一些相关方法,在这些方法中可以对请求进行相应预处理(例如权限检测,参数验证),这些方法可以决定对这个请求进行拦截还是放行.

  1. 首先，需要自定义cn.fyy.spring.LoginInterceptor拦截器类，实现HandlerInterceptor：
public class LoginInterceptor implements HandlerInterceptor {
	
		public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
				throws Exception {
			System.out.println("LoginInterceptor.preHandle()");
			return false;
		}
	
		public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
				ModelAndView modelAndView) throws Exception {
			System.out.println("LoginInterceptor.postHandle()");
		}
	
		public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
				throws Exception {
			System.out.println("LoginInterceptor.afterCompletion()");
		}
	
	}
  1. 再定义一个日志拦截器

当我们系统中有多个拦截器时,这些拦截器可以构成一个拦截器链.其原理类似过滤器中的过滤链。在多个拦截器应用中仅当所有匹配的拦截器的preHandle()都执行之后，才会调用Controller中处理请求的方法，然后再执行所有匹配的拦截器的postHandler()，再执行所有匹配的拦截器的afterCompletion()。
在拦截器链中，各拦截器的执行先后顺序取决于配置文件中配置的节点的先后顺序！

@Component
public class LogInterceptor extends HandlerInterceptorAdapter{
	@Override
	public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception {
		System.out.println("log.preHandler");
		
		
		return true;
	}
	@Override
	public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
			throws Exception {
		System.out.println("log.afterCompletion");
	}
}
  1. 拦截器需要在Spring的配置文件中进行配置才可以使用：
 <!-- 配置拦截器 (要注意标签的编写顺序) -->
	<mvc:interceptors>
		<!-- 当存在多个拦截器时，哪个拦截器的方法先执行，要看拦截器配置的顺序 -->
		<mvc:interceptor>
			<mvc:mapping path="/user/*" />
			<ref bean="TimeInterceptor" />
		</mvc:interceptor>
		<mvc:interceptor>
			<!-- 拦截所有请求(这些请求要交给拦截器处理) -->
			<mvc:mapping path="/**" />
			<!-- 定制对哪些请求不拦截 (这些请求不需要拦截处理) -->
			<mvc:exclude-mapping path="/user/dologin.do" />
			<!-- 拦截器对象 -->
			<bean class="cn.spring.LoginInterceptor" />
		</mvc:interceptor>
	</mvc:interceptors>
  1. 如果需要实现“验证登录以决定是否拦截或者放行”的功能，需要重写拦截器类中的preHandle()方法：
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception {
		System.out.println("LoginInterceptor.preHandle()");
		// 获取HttpSession对象
		HttpSession session = request.getSession();
		// 判断Session中有没有登录的数据
		if (session.getAttribute("username") == null) {
			// 没有登录数据，即未登录，则重定向到登录页
			// http://localhost:8080/XX/index.do
			// http://localhost:8080/XX/user/password.do
			String projectName = request.getServletContext().getContextPath();
			response.sendRedirect(projectName + "/user/login.do");
			// 返回false表示拦截，不允许向后执行
			return false;
		}
		// 返回true表示放行，允许向后执行
		return true;
	}

在这里插入图片描述

四、Spring MVC 请求处理

1. 接收请求参数

1.1. 【不推荐】通过HttpServletRequest获取请求参数

可以在处理请求的方法中，添加HttpServletRequest类型的参数，在处理过程中，调用该参数对象的String getParameter(String name)就可以获取请求参数，例如：

	@RequestMapping("handle_reg.do")
	public String handleReg(HttpServletRequest request) {
		System.out.println("UserController.handleReg()");
		String username = request.getParameter("username");
		String password = request.getParameter("password");
		Integer age = Integer.valueOf(request.getParameter("age"));
		String phone = request.getParameter("phone");
		String email = request.getParameter("email");
		
		System.out.println("\tusenrame=" + username);
		System.out.println("\tpassword=" + password);
		System.out.println("\tage=" + age);
		System.out.println("\tphone=" + phone);
		System.out.println("\temail=" + email);
		return null;
	}

通常，并不推荐使用这种做法！主要原因有：

  • 使用比较繁琐，代码量较多；

  • 需要手动实现数据类型的转换；

  • 不便于实现单元测试。

1.2. 【推荐】将请求参数设计为处理请求的方法的参数

假设客户端将提交名为username的参数，则在控制器的方法中添加同名参数即可，参数的类型可以是期望的数据类型，例如期望age是Integer类型的，则声明为Integer age即可：

	@RequestMapping("handle_reg.do")
	public String handleReg(String username, String password, 
			Integer age, String phone, String email) {
		System.out.println("UserController.handleReg()");
		System.out.println("\t[2]username=" + username);
		System.out.println("\t[2]password=" + password);
		System.out.println("\t[2]age=" + age);
		System.out.println("\t[2]phone=" + phone);
		System.out.println("\t[2]email=" + email);
		return null;
	}

使用这种做法时，需要保证参数的名称与客户端提交的请求参数名称保持一致，否则，在控制器中的参数将是null值。

使用这种做法的优点很多，基本上解决了使用HttpServletRequest获取参数时的所有问题！

使用这种做法并不适用于请求参数的数量较多的应用场景！

1.3. 【推荐】使用封装的类型接收较多的请求参数

当客户端提交的请求参数较多时，可以将这些参数全部封装为1个自定义的数据类型，例如：

	public class User {

		private String username;
		private String password;
		private Integer age;
		private String phone;
		private String email;
		
		// SET/GET
	}

然后，将该类型作为处理请求的方法的参数即可：

	@RequestMapping("handle_reg.do")
	public String handleReg(User user) {
		System.out.println("UserController.handleReg()");
		System.out.println("\t" + user);
		return null;
	}

在使用这种做法时，需要保证客户端提交的请求参数，与自定义的数据类型中的属性名称是保持一致的！

2.响应处理

2.1 重定向

当处理请求的方法的返回值是String类型的，则返回的字符串使用redirect:作为前缀，加上重定向的目标路径，就可以实现重定向的效果。

在这里插入图片描述

2.2 转发

在这里插入图片描述

2.2.1 执行转发

当处理请求的方法的返回值是String类型，默认情况下，返回值就表示转发的意思，返回值将经过视图解析器，确定转发到的目标页面。

转发时，处理请求的方法的返回值也可以使用forward:作为前缀，由于默认就是转发，所以不必显式的添加前缀。

2.2.2 【不推荐】通过HttpServletRequest封装需要转发的数据

假设在登录过程中，仅当用户名为root且密码是1234时允许登录，否则，在错误提示页面中提示错误的原因。

由于错误信息可能有2种，分别是用户名错误和密码错误，使用JSP页面结合EL表达式可以显示转发的数据，在控制器转发之前，就需要将错误信息封装到HttpServletRequest对象中，则后续JSP页面才可以通过EL表达式读取HttpServletRequest对象中的数据。

可以在处理请求的方法的参数列表中添加HttpServletRequest类型的参数，当添加多项参数时（既有用户名、密码，又有HttpServletRequest），各参数不必区分先后顺序，当添加了参数后，调用HttpServletRequest参数对象的setAttribute(String name, String value)方法封装需要转发的数据即可，无需获取转发器对象执行转发，只要最后返回字符串就表示转发：

	@RequestMapping("handle_login.do")
	public String handleLogin(String username, String password,
			HttpServletRequest request) {
		// 日志
		System.out.println("UserController.handleLogin()");
		
		// 判断用户名是否正确
		if ("root".equals(username)) {
			// 是：判断密码是否正确
			if ("1234".equals(password)) {
				// 是：登录成功，重定向到主页
				return "redirect:index.do";
			} else {
				// 否：密码错误
				request.setAttribute("errorMessage", "密码错误");
				return "error";
			}
		} else {
			// 否：用户名错误
			request.setAttribute("errorMessage", "用户名错误");
			return "error";
		}
	}

当然，这种做法依然是不推荐的，使用了HttpServletRequest作为参数后不便于执行单元测试。

2.2.3 【更不推荐】使用ModelAndView

使用ModelAndView作为处理请求的方法的返回值类型，在返回结果之前，调用ModelAndView对象的setViewName(String viewName)方法确定转发的视图名称，调用addObject(String name, Object value)方法封装需要转发的数据，然后返回结果即可：

	@RequestMapping("handle_login.do")
	public ModelAndView handleLogin(String username, String password) {
		// 创建返回值对象
		ModelAndView mav = new ModelAndView();
		
		// 判断用户名是否正确
		if ("root".equals(username)) {
			// 是：判断密码是否正确
			if ("1234".equals(password)) {
				// 是：登录成功，重定向到主页
				return null;
			} else {
				// 否：密码错误
				mav.addObject("errorMessage", "ModelAndView：密码错误");
				mav.setViewName("error");
				return mav;
			}
		} else {
			// 否：用户名错误
			mav.addObject("errorMessage", "ModelAndView：用户名错误");
			mav.setViewName("error");
			return mav;
		}
		
	}

因为对于初学SpringMVC的人来说，ModelAndView是一个新的、比较麻烦的数据类型，并且SpringMVC提供了更简单的操作方式，所以不推荐使用ModelAndView。

2.2.4 【推荐】使用ModelMap封装需要转发的数据

使用ModelMap的方式与使用HttpServletRequest几乎完全相同：

	@RequestMapping("handle_login.do")
	public String handleLogin(String username, String password,
			ModelMap modelMap) {
		// 日志
		System.out.println("UserController.handleLogin()");
		
		// 判断用户名是否正确
		if ("root".equals(username)) {
			// 是：判断密码是否正确
			if ("1234".equals(password)) {
				// 是：登录成功，重定向到主页
				return "redirect:index.do";
			} else {
				// 否：密码错误
				modelMap.addAttribute("errorMessage", "ModelMap：密码错误");
				return "error";
			}
		} else {
			// 否：用户名错误
			modelMap.addAttribute("errorMessage", "ModelMap：用户名错误");
			return "error";
		}
	}

相比HttpServletRequest而言，使用ModelMap更加易于实现单元测试，并且更加轻量级，所以，推荐使用这种方式来封装需要转发的数据。

2.2.5Model对象 （重点）

将响应数据直接封装为model中。

@RequestMapping("doModel")
public String doModel(Model model) {
		model.addAttribute("data", "modal");
		return "response";
}

当我们返回具体view时，系统底层会自动将model对象存储到request作用域。

2.2.6Map对象（了解）

将响应数据封装到Map中（我建议假如使用map对数据进行封装，可直接采用model对象）

@RequestMapping("doMap01")
public String doMap01(Map<String,Object> map) {
	map.put("data", "map..");
	return "response";
}
SpringMVC配置
Love_MinJuan的博客
05-20 190
SpringMVC简介： 在 Spring 的基本架构中，红色圈起来的 Spring Web MVC 就是本系列的主角SpringMVC，它属于Spring基本架构里面的一个组成部分，是SpringFrameWork的后续产品，已融合在Spring Web Flow里面，所以后期在和Spring进行整合的时候，几乎不需要别的什么配置。 SpringMVC（Spring+MVC）是一个MVC框架,是在Spring的基础上,对MVC思想的一个实现。也是对Servlet做的一个封装,换成controller层，
SpringMVC 的配置
qq_52589982的博客
07-06 303
1.引入依赖 2.新建mvc.xml配置文件 2.1开启spring的注解扫描 2.2 引入springMVC核心功能 2.3 引入视图解析器 3.配置web.xml文件 声明前端控制器DispatcherServlet
Spring MVC：原理、配置与基础应用详解
最新发布
ZERO141239的博客
11-24 1097
Spring MVC 通过精妙的设计原理、细致的配置体系以及贴合实际的应用示例，展现强大 Web 开发能力。理解其原理有助于排查问题、优化性能；掌握配置可灵活定制项目架构；实践应用能快速搭建功能模块。后续我们将深入探究其高级特性，如异常处理、拦截器、异步处理等，进一步挖掘 Spring MVC 潜力，敬请期待。
Spring MVC基础配置
22 | Nothing is impossible
09-05 258
Spring MVC基础配置
SpringMVC配置及使用
sjg_sjk的博客
05-02 980
1、什么是SpringMVCSpringMVC是web层的一个MVC框架，类似于struts22.SpringMVC的基本配置和常见使用2.1 基于xml的配置SpringMVC所需要的jar包上传本次例子的目录在介绍springmvc的配置之前，先来看看springmvc的执行流程上图揭示了springmvc的执行流程，也就是一个响应从发出到解析的过程。上述的前端控制器、处理器映射器、处理器适配...
springMVC配置好的环境
04-16
在“springMVC配置好的环境”中，我们通常包括了运行 Spring MVC 应用所需的所有组件和设置，这些组件可能包括但不限于： 1. **Spring Framework**：Spring 是整个应用的基础，它提供了依赖注入（DI）、面向切面...
SpringMvc web.xml配置实现原理过程解析
08-18
SpringMvc web.xml配置实现原理过程解析 SpringMvc 中的web.xml配置是实现原理过程解析的关键一步。在这篇文章中，我们将详细介绍SpringMvc web.xml配置实现原理过程解析的过程，包括过滤器CharacterEncodingFilter...
SpringMVC环境配置
05-28
通过这个环境，开发者可以学习如何使用SpringMVC来设计和实现业务逻辑，利用Maven管理项目依赖，借助Tomcat运行和调试Web应用，同时，还能理解SSM框架如何协同工作，提升开发效率。在实践中不断探索和掌握这些知识点...
springMVC框架搭建流程
徐刘根的博客
10-24 4089
1、创建Dynamic Web Project 2、导入spring和springmvc所需要的文件 3、配置web.xml文件 3.1 监听spring上下文容器 3.2 加载spring的xml文件到spring的上下文容器(spring-context.xml) 3.3 配置spring MVC的DispatcherServlet 3.4 加载spring
springMVC 入门配置（方便我以后快速复习）
热门推荐
靠脑袋是真滴记不住啊！！！！！！！！
06-20 1万+
1.0 springMVC 的作用 springMVC 在我看来是用spring的有点来实现MVC架构 这样可以整合许多优秀的框架中的功能 例如本篇重点介绍的spring同mybatis 的整合 2.0 环境配置 开发工具 eclipse jar包 spring-web spring-webmvc 3.0 步骤 编写web.xml 使拦截器执行springmvc的拦...
springMVC 配置
weixin_44076712的博客
07-24 143
dispatcher-servlet.xml 版本 spring 5.2.0 <?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/
构建Spring项目的一些配置文件
一天不学习，就浑身难受
08-16 270
web.xml基础配置 <?xml version="1.0" encoding="UTF-8"?> <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jc
史上最全最强SpringMVC详细示例实战教程
weixin_30786617的博客
06-05 1156
SpringMVC学习笔记---- 一、SpringMVC基础入门，创建一个HelloWorld程序 1.首先，导入SpringMVC需要的jar包。 2.添加Web.xml配置文件中关于SpringMVC的配置 <!--configure the setting of springmvcDispatcherServlet and configure the mapp...
SpringMVC注解配置详解
例如，SpringMVC中的@Controller、@RequestMapping、@Service、@Repository和@Autowired等注解，使得类和方法的职责更加明确，同时也简化了依赖注入的过程。 @Autowired注解是Spring中自动装配bean的关键工具。它...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值