`

Spring_MVC(2)控制层处理

MVCSpringJSPWebServlet 
阅读更多

言归正传，研究一下注解下的控制层。
我习惯于使用JSTL展示页面，因此需要在原lib基础上增加jstl.jar和standard.jar，详细lib依赖如下：

引用

aopalliance-1.0.jar
commons-logging-1.1.1.jar
log4j-1.2.15.jar
spring-beans-2.5.6.jar
spring-context-2.5.6.jar
spring-context-support-2.5.6.jar
spring-core-2.5.6.jar
spring-tx-2.5.6.jar
spring-web-2.5.6.jar
spring-webmvc-2.5.6.jar
standard.jar
jstl.jar


上一篇文中，我们定义了控制器AccountController：
AccountController.java

Java代码 复制代码
  1. /**  
  2.  * 2010-1-23  
  3.  */  
  4. package org.zlex.spring.controller;   
  5.   
  6. import javax.servlet.http.HttpServletRequest;   
  7. import javax.servlet.http.HttpServletResponse;   
  8.   
  9. import org.springframework.beans.factory.annotation.Autowired;   
  10. import org.springframework.stereotype.Controller;   
  11. import org.springframework.web.bind.ServletRequestUtils;   
  12. import org.springframework.web.bind.annotation.RequestMapping;   
  13. import org.springframework.web.bind.annotation.RequestMethod;   
  14. import org.zlex.spring.service.AccountService;   
  15.   
  16. /**  
  17.  *   
  18.  * @author <a href="mailto:zlex.dongliang@gmail.com">梁栋</a>  
  19.  * @version 1.0  
  20.  * @since 1.0  
  21.  */  
  22. @Controller  
  23. @RequestMapping("/account.do")   
  24. public class AccountController {   
  25.   
  26.     @Autowired  
  27.     private AccountService accountService;   
  28.   
  29.     @RequestMapping(method = RequestMethod.GET)   
  30.     public void hello(HttpServletRequest request, HttpServletResponse response)   
  31.             throws Exception {   
  32.   
  33.         String username = ServletRequestUtils.getRequiredStringParameter(   
  34.                 request, "username");   
  35.         String password = ServletRequestUtils.getRequiredStringParameter(   
  36.                 request, "password");   
  37.         System.out.println(accountService.verify(username, password));   
  38.     }   
  39. }  
/**
 * 2010-1-23
 */
package org.zlex.spring.controller;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.ServletRequestUtils;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.zlex.spring.service.AccountService;

/**
 * 
 * @author <a href="mailto:zlex.dongliang@gmail.com">梁栋</a>
 * @version 1.0
 * @since 1.0
 */
@Controller
@RequestMapping("/account.do")
public class AccountController {

	@Autowired
	private AccountService accountService;

	@RequestMapping(method = RequestMethod.GET)
	public void hello(HttpServletRequest request, HttpServletResponse response)
			throws Exception {

		String username = ServletRequestUtils.getRequiredStringParameter(
				request, "username");
		String password = ServletRequestUtils.getRequiredStringParameter(
				request, "password");
		System.out.println(accountService.verify(username, password));
	}
}


先说注解@RequestMapping
这里使用注解@RequestMapping(method = RequestMethod.GET)指定这个方法为get请求时调用。同样，我们可以使用注解@RequestMapping(method = RequestMethod.POST)指定该方法接受post请求。

Java代码 复制代码
  1. @Controller  
  2. @RequestMapping("/account.do")   
  3. public class AccountController {   
  4.   
  5.     @RequestMapping(method = RequestMethod.GET)   
  6.     public void get() {   
  7.     }   
  8.   
  9.     @RequestMapping(method = RequestMethod.POST)   
  10.     public void post() {   
  11.     }   
  12. }  
@Controller
@RequestMapping("/account.do")
public class AccountController {

	@RequestMapping(method = RequestMethod.GET)
	public void get() {
	}

	@RequestMapping(method = RequestMethod.POST)
	public void post() {
	}
}


这与我们久别的Servlet很相像，类似于doGet()和doPost()方法！
我们也可以将其改造为多动作控制器，如下代码所示：

Java代码 复制代码
  1. @Controller  
  2. @RequestMapping("/account.do")   
  3. public class AccountController {   
  4.   
  5.     @RequestMapping(params = "method=login")     
  6.     public void login() {   
  7.     }   
  8.   
  9.     @RequestMapping(params = "method=logout")     
  10.     public void logout() {   
  11.     }  
@Controller
@RequestMapping("/account.do")
public class AccountController {

	@RequestMapping(params = "method=login")  
	public void login() {
	}

	@RequestMapping(params = "method=logout")  
	public void logout() {
	}


这样，我们可以通过参数“method”指定不同的参数值从而通过请求（"/account.do?method=login"和"/account.do?method=logout"）调用不同的方法！
注意：使用多动作控制器必须在配置文件中加入注解支持！

Xml代码 复制代码
  1. <bean  
  2.         class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter" />   
<bean
		class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter" />


当然，我们也可以将注解@RequestMapping指定到某一个方法上，如：

Java代码 复制代码
  1. @Controller  
  2. public class AccountController {   
  3.        
  4.     @RequestMapping("/a.do")   
  5.     public void a() {}   
  6.   
  7.     @RequestMapping("/b.do")   
  8.     public void b() {}   
  9. }  
@Controller
public class AccountController {
	
	@RequestMapping("/a.do")
	public void a() {}

	@RequestMapping("/b.do")
	public void b() {}
}


这样，请求“a.do”和“b.do”将对应不同的方法a() 和b()。这使得一个控制器可以同时承载多个请求！
@RequestMapping("/account.do")是@RequestMapping(value="/account.do")的简写！
再说输入参数！
这里的方法名可以随意定义，但是参数和返回值却又要求！
为什么？直接看源代码，我们就能找到答案！
AnnotationMethodHandlerAdapter.java部分源代码——有关参数部分：

Java代码 复制代码
  1. @Override  
  2. protected Object resolveStandardArgument(Class parameterType, NativeWebRequest webRequest)   
  3.         throws Exception {   
  4.   
  5.     HttpServletRequest request = (HttpServletRequest) webRequest.getNativeRequest();   
  6.     HttpServletResponse response = (HttpServletResponse) webRequest.getNativeResponse();   
  7.   
  8.     if (ServletRequest.class.isAssignableFrom(parameterType)) {   
  9.         return request;   
  10.     }   
  11.     else if (ServletResponse.class.isAssignableFrom(parameterType)) {   
  12.         this.responseArgumentUsed = true;   
  13.         return response;   
  14.     }   
  15.     else if (HttpSession.class.isAssignableFrom(parameterType)) {   
  16.         return request.getSession();   
  17.     }   
  18.     else if (Principal.class.isAssignableFrom(parameterType)) {   
  19.         return request.getUserPrincipal();   
  20.     }   
  21.     else if (Locale.class.equals(parameterType)) {   
  22.         return RequestContextUtils.getLocale(request);   
  23.     }   
  24.     else if (InputStream.class.isAssignableFrom(parameterType)) {   
  25.         return request.getInputStream();   
  26.     }   
  27.     else if (Reader.class.isAssignableFrom(parameterType)) {   
  28.         return request.getReader();   
  29.     }   
  30.     else if (OutputStream.class.isAssignableFrom(parameterType)) {   
  31.         this.responseArgumentUsed = true;   
  32.         return response.getOutputStream();   
  33.     }   
  34.     else if (Writer.class.isAssignableFrom(parameterType)) {   
  35.         this.responseArgumentUsed = true;   
  36.         return response.getWriter();   
  37.     }   
  38.     return super.resolveStandardArgument(parameterType, webRequest);   
  39. }  
		@Override
		protected Object resolveStandardArgument(Class parameterType, NativeWebRequest webRequest)
				throws Exception {

			HttpServletRequest request = (HttpServletRequest) webRequest.getNativeRequest();
			HttpServletResponse response = (HttpServletResponse) webRequest.getNativeResponse();

			if (ServletRequest.class.isAssignableFrom(parameterType)) {
				return request;
			}
			else if (ServletResponse.class.isAssignableFrom(parameterType)) {
				this.responseArgumentUsed = true;
				return response;
			}
			else if (HttpSession.class.isAssignableFrom(parameterType)) {
				return request.getSession();
			}
			else if (Principal.class.isAssignableFrom(parameterType)) {
				return request.getUserPrincipal();
			}
			else if (Locale.class.equals(parameterType)) {
				return RequestContextUtils.getLocale(request);
			}
			else if (InputStream.class.isAssignableFrom(parameterType)) {
				return request.getInputStream();
			}
			else if (Reader.class.isAssignableFrom(parameterType)) {
				return request.getReader();
			}
			else if (OutputStream.class.isAssignableFrom(parameterType)) {
				this.responseArgumentUsed = true;
				return response.getOutputStream();
			}
			else if (Writer.class.isAssignableFrom(parameterType)) {
				this.responseArgumentUsed = true;
				return response.getWriter();
			}
			return super.resolveStandardArgument(parameterType, webRequest);
		}


也就是说，如果我们想要在自定义的方法中获得一些个“标准”输入参数，参数类型必须包含在以下类型中：

引用

ServletRequest
ServletResponse
HttpSession
Principal
Locale
InputStream
OutputStream
Reader
Writer


当然，上述接口其实都是对于HttpServletRequest和HttpServletResponse的扩展。
此外，我们还可以定义自己的参数。
注意：自定义参数必须是实现类，绝非接口！Spring容器将帮你完成对象初始化工作！
比如说上文中，我们需要参数username和password。我们可以这么写：

Java代码 复制代码
  1. @RequestMapping(method = RequestMethod.GET)   
  2. public void hello(String username,String password) {   
  3.     System.out.println(accountService.verify(username, password));   
  4. }  
	@RequestMapping(method = RequestMethod.GET)
	public void hello(String username,String password) {
		System.out.println(accountService.verify(username, password));
	}


如果参数名不能与这里的变量名保持一致，那么我们可以使用注解@RequestParam进行强制绑定，代码如下所示：

Java代码 复制代码
  1. @RequestMapping(method = RequestMethod.GET)   
  2. public void hello(@RequestParam("username") String u,   
  3.         @RequestParam("password") String p) {   
  4.     System.out.println(accountService.verify(u, p));   
  5. }  
	@RequestMapping(method = RequestMethod.GET)
	public void hello(@RequestParam("username") String u,
			@RequestParam("password") String p) {
		System.out.println(accountService.verify(u, p));
	}


这比起我们之前写的代码有所简洁：

Java代码 复制代码
  1. @RequestMapping(method = RequestMethod.GET)   
  2. public void hello(HttpServletRequest request, HttpServletResponse response)   
  3.         throws Exception {   
  4.   
  5.     String username = ServletRequestUtils.getRequiredStringParameter(   
  6.             request, "username");   
  7.     String password = ServletRequestUtils.getRequiredStringParameter(   
  8.             request, "password");   
  9.     System.out.println(accountService.verify(username, password));   
  10. }  
	@RequestMapping(method = RequestMethod.GET)
	public void hello(HttpServletRequest request, HttpServletResponse response)
			throws Exception {

		String username = ServletRequestUtils.getRequiredStringParameter(
				request, "username");
		String password = ServletRequestUtils.getRequiredStringParameter(
				request, "password");
		System.out.println(accountService.verify(username, password));
	}


ServletRequestUtils类的工作已经由Spring底层实现了，我们只需要把参数名定义一致即可，其内部取参无需关心！
除了传入参数，我们还可以定义即将传出的参数，如加入ModelMap参数：

Java代码 复制代码
  1. @SuppressWarnings("unchecked")   
  2. @RequestMapping(method = RequestMethod.GET)   
  3. public Map hello(String username, String password, ModelMap model) {   
  4.   
  5.     System.out.println(accountService.verify(username, password));   
  6.        
  7.     model.put("msg", username);   
  8.   
  9.     return model;   
  10. }  
	@SuppressWarnings("unchecked")
	@RequestMapping(method = RequestMethod.GET)
	public Map hello(String username, String password, ModelMap model) {

		System.out.println(accountService.verify(username, password));
		
		model.put("msg", username);

		return model;
	}


这时，我们没有定义页面名称，Spring容器将根据请求名指定同名view，即如果是jap页面，则account.do->account.jsp！
不得不承认，这样写起来的确减少了代码量！
接着说输出参数！
通过ModelMap，我们可以绑定输出到的页面的参数，但最终我们将要返回到何种页面呢？再次查看AnnotationMethodHandlerAdapter源代码！
AnnotationMethodHandlerAdapter.java部分源代码——有关返回值部分：

Java代码 复制代码
  1. @SuppressWarnings("unchecked")   
  2. public ModelAndView getModelAndView(Method handlerMethod, Class handlerType, Object returnValue,   
  3.         ExtendedModelMap implicitModel, ServletWebRequest webRequest) {   
  4.   
  5.     if (returnValue instanceof ModelAndView) {   
  6.         ModelAndView mav = (ModelAndView) returnValue;   
  7.         mav.getModelMap().mergeAttributes(implicitModel);   
  8.         return mav;   
  9.     }   
  10.     else if (returnValue instanceof Model) {   
  11.         return new ModelAndView().addAllObjects(implicitModel).addAllObjects(((Model) returnValue).asMap());   
  12.     }   
  13.     else if (returnValue instanceof Map) {   
  14.         return new ModelAndView().addAllObjects(implicitModel).addAllObjects((Map) returnValue);   
  15.     }   
  16.     else if (returnValue instanceof View) {   
  17.         return new ModelAndView((View) returnValue).addAllObjects(implicitModel);   
  18.     }   
  19.     else if (returnValue instanceof String) {   
  20.         return new ModelAndView((String) returnValue).addAllObjects(implicitModel);   
  21.     }   
  22.     else if (returnValue == null) {   
  23.         // Either returned null or was 'void' return.   
  24.         if (this.responseArgumentUsed || webRequest.isNotModified()) {   
  25.             return null;   
  26.         }   
  27.         else {   
  28.             // Assuming view name translation...   
  29.             return new ModelAndView().addAllObjects(implicitModel);   
  30.         }   
  31.     }   
  32.     else if (!BeanUtils.isSimpleProperty(returnValue.getClass())) {   
  33.         // Assume a single model attribute...   
  34.         ModelAttribute attr = AnnotationUtils.findAnnotation(handlerMethod, ModelAttribute.class);   
  35.         String attrName = (attr != null ? attr.value() : "");   
  36.         ModelAndView mav = new ModelAndView().addAllObjects(implicitModel);   
  37.         if ("".equals(attrName)) {   
  38.             Class resolvedType = GenericTypeResolver.resolveReturnType(handlerMethod, handlerType);   
  39.             attrName = Conventions.getVariableNameForReturnType(handlerMethod, resolvedType, returnValue);   
  40.         }   
  41.         return mav.addObject(attrName, returnValue);   
  42.     }   
  43.     else {   
  44.         throw new IllegalArgumentException("Invalid handler method return value: " + returnValue);   
  45.     }   
  46. }   
		@SuppressWarnings("unchecked")
		public ModelAndView getModelAndView(Method handlerMethod, Class handlerType, Object returnValue,
				ExtendedModelMap implicitModel, ServletWebRequest webRequest) {

			if (returnValue instanceof ModelAndView) {
				ModelAndView mav = (ModelAndView) returnValue;
				mav.getModelMap().mergeAttributes(implicitModel);
				return mav;
			}
			else if (returnValue instanceof Model) {
				return new ModelAndView().addAllObjects(implicitModel).addAllObjects(((Model) returnValue).asMap());
			}
			else if (returnValue instanceof Map) {
				return new ModelAndView().addAllObjects(implicitModel).addAllObjects((Map) returnValue);
			}
			else if (returnValue instanceof View) {
				return new ModelAndView((View) returnValue).addAllObjects(implicitModel);
			}
			else if (returnValue instanceof String) {
				return new ModelAndView((String) returnValue).addAllObjects(implicitModel);
			}
			else if (returnValue == null) {
				// Either returned null or was 'void' return.
				if (this.responseArgumentUsed || webRequest.isNotModified()) {
					return null;
				}
				else {
					// Assuming view name translation...
					return new ModelAndView().addAllObjects(implicitModel);
				}
			}
			else if (!BeanUtils.isSimpleProperty(returnValue.getClass())) {
				// Assume a single model attribute...
				ModelAttribute attr = AnnotationUtils.findAnnotation(handlerMethod, ModelAttribute.class);
				String attrName = (attr != null ? attr.value() : "");
				ModelAndView mav = new ModelAndView().addAllObjects(implicitModel);
				if ("".equals(attrName)) {
					Class resolvedType = GenericTypeResolver.resolveReturnType(handlerMethod, handlerType);
					attrName = Conventions.getVariableNameForReturnType(handlerMethod, resolvedType, returnValue);
				}
				return mav.addObject(attrName, returnValue);
			}
			else {
				throw new IllegalArgumentException("Invalid handler method return value: " + returnValue);
			}
		}
	}


返回值的定义十分庞大，或者说可怕的if-else多少有点让我觉得厌恶！
我们可以定义以下类型的返回值：

引用

ModelAndView
Model
View
Map
String
null


ModelAndView、Model和View都是Spring之前版本所特有的元素，Map对应于传入参数ModelMap，String定义页面名称，null即对应void类型方法！
最常用的实现方式如下：

Java代码 复制代码
  1. @SuppressWarnings("unchecked")   
  2. @RequestMapping(method = RequestMethod.GET)   
  3. public String hello(String username, String password, ModelMap model) {   
  4.   
  5.     System.out.println(accountService.verify(username, password));   
  6.   
  7.     model.put("msg", username);   
  8.   
  9.     return "account";   
  10. }  
	@SuppressWarnings("unchecked")
	@RequestMapping(method = RequestMethod.GET)
	public String hello(String username, String password, ModelMap model) {

		System.out.println(accountService.verify(username, password));

		model.put("msg", username);

		return "account";
	}


当然，对于我来说在返回值中写入这么一个字符串多少有点不能接受，于是我还是乐于使用输入参数ModelMap+输出参数Map的方式。
给出一个完整的AccountController实现：
AccountController.java

Java代码 复制代码
  1. /**  
  2.  * 2010-1-23  
  3.  */  
  4. package org.zlex.spring.controller;   
  5.   
  6. import java.util.Map;   
  7.   
  8. import org.springframework.beans.factory.annotation.Autowired;   
  9. import org.springframework.stereotype.Controller;   
  10. import org.springframework.ui.ModelMap;   
  11. import org.springframework.web.bind.annotation.RequestMapping;   
  12. import org.springframework.web.bind.annotation.RequestMethod;   
  13. import org.zlex.spring.service.AccountService;   
  14.   
  15. /**  
  16.  *   
  17.  * @author <a href="mailto:zlex.dongliang@gmail.com">梁栋</a>  
  18.  * @version 1.0  
  19.  * @since 1.0  
  20.  */  
  21. @Controller  
  22. @RequestMapping("/account.do")   
  23. public class AccountController {   
  24.   
  25.     @Autowired  
  26.     private AccountService accountService;   
  27.   
  28.     @SuppressWarnings("unchecked")   
  29.     @RequestMapping(method = RequestMethod.GET)   
  30.     public Map hello(String username, String password, ModelMap model) {   
  31.   
  32.         System.out.println(accountService.verify(username, password));   
  33.   
  34.         model.put("msg", username);   
  35.         return model;   
  36.     }   
  37. }  
/**
 * 2010-1-23
 */
package org.zlex.spring.controller;

import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.zlex.spring.service.AccountService;

/**
 * 
 * @author <a href="mailto:zlex.dongliang@gmail.com">梁栋</a>
 * @version 1.0
 * @since 1.0
 */
@Controller
@RequestMapping("/account.do")
public class AccountController {

	@Autowired
	private AccountService accountService;

	@SuppressWarnings("unchecked")
	@RequestMapping(method = RequestMethod.GET)
	public Map hello(String username, String password, ModelMap model) {

		System.out.println(accountService.verify(username, password));

		model.put("msg", username);
		return model;
	}
}


最后说注解@Session
如果想将某个ModelMap中的参数指定到Session中，可以使用@Session注解，将其绑定为Session熟悉，代码如下所示：

Java代码 复制代码
  1. @Controller  
  2. @RequestMapping("/account.do")   
  3. @SessionAttributes("msg")   
  4. public class AccountController {   
  5.   
  6.     @Autowired  
  7.     private AccountService accountService;   
  8.   
  9.     @SuppressWarnings("unchecked")   
  10.     @RequestMapping(method = RequestMethod.GET)   
  11.     public Map hello(String username, String password, ModelMap model) {   
  12.   
  13.         System.out.println(accountService.verify(username, password));   
  14.   
  15.         model.put("msg", username);   
  16.         return model;   
  17.     }   
  18.   
  19. }  
@Controller
@RequestMapping("/account.do")
@SessionAttributes("msg")
public class AccountController {

	@Autowired
	private AccountService accountService;

	@SuppressWarnings("unchecked")
	@RequestMapping(method = RequestMethod.GET)
	public Map hello(String username, String password, ModelMap model) {

		System.out.println(accountService.verify(username, password));

		model.put("msg", username);
		return model;
	}

}


当然，我们还需要配置一下对应的视图解析器，给出完整配置：
servelt.xml

Xml代码 复制代码
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans  
  3.     xmlns="http://www.springframework.org/schema/beans"  
  4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  5.     xmlns:p="http://www.springframework.org/schema/p"  
  6.     xmlns:context="http://www.springframework.org/schema/context"  
  7.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd   
  8.         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">  
  9.     <context:component-scan  
  10.         base-package="org.zlex.spring.controller" />  
  11.     <bean  
  12.         id="urlMapping"  
  13.         class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping" />  
  14.     <bean  
  15.         class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter" />  
  16.     <bean  
  17.         id="jstlViewResolver"  
  18.         class="org.springframework.web.servlet.view.InternalResourceViewResolver"  
  19.         p:viewClass="org.springframework.web.servlet.view.JstlView"  
  20.         p:prefix="/WEB-INF/page/"  
  21.         p:suffix=".jsp" />  
  22. </beans>   
<?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:p="http://www.springframework.org/schema/p"
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
	<context:component-scan
		base-package="org.zlex.spring.controller" />
	<bean
		id="urlMapping"
		class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping" />
	<bean
		class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter" />
	<bean
		id="jstlViewResolver"
		class="org.springframework.web.servlet.view.InternalResourceViewResolver"
		p:viewClass="org.springframework.web.servlet.view.JstlView"
		p:prefix="/WEB-INF/page/"
		p:suffix=".jsp" />
</beans>


这里使用了JstlView作为视图解析器。同时，指定前缀路径为"/WEB-INF/page/"，后缀路径为".jsp"。也就是说，Spring容器将会在这个路径中寻找匹配的jsp文件！
注意加入xmlns:p="http://www.springframework.org/schema/p"命名空间！
再给出页面内容：
taglib.jsp

Jsp代码 复制代码
  1. <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>   
  2. <%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt"%>   
  3. <%@ taglib prefix="sql" uri="http://java.sun.com/jsp/jstl/sql"%>   
  4. <%@ taglib prefix="x" uri="http://java.sun.com/jsp/jstl/xml"%>   
  5. <%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions"%>   
  6. <%@ taglib prefix="spring" uri="http://www.springframework.org/tags"%>   
  7. <%@ taglib prefix="form" uri="http://www.springframework.org/tags/form"%>   
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt"%>
<%@ taglib prefix="sql" uri="http://java.sun.com/jsp/jstl/sql"%>
<%@ taglib prefix="x" uri="http://java.sun.com/jsp/jstl/xml"%>
<%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions"%>
<%@ taglib prefix="spring" uri="http://www.springframework.org/tags"%>
<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form"%>


account.jap

Jsp代码 复制代码
  1. <%@ page language="java" contentType="text/html; charset=UTF-8"  
  2.     pageEncoding="UTF-8"<spa
    分享到：
    | Spring_MVC(1)构建简单web应用
    评论
    3 楼 liutao1600 2013-05-07  
    学习了，太好了
    2 楼 tamsiuloong 2010-06-28  
    UTF
    tamsiuloong 写道
    楼主你好，我是基于下面配置的urlMpping
    <bean id="urlMapping"
    class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">

    <property name="mappings">
    <props>
    <prop key="site/site.do">siteAction</prop>
    </bean>
    如果我也想使用基于注解的控制器，我应该怎样做？

    同时使用二者，可以吗？
    1 楼 tamsiuloong 2010-06-28  
    楼主你好，我是基于下面配置的urlMpping
    <bean id="urlMapping"
    class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">

    <property name="mappings">
    <props>
    <prop key="site/site.do">siteAction</prop>
    </bean>
    如果我也想使用基于注解的控制器，我应该怎样做？
    发表评论

    您还没有登录,请您登录后再发表评论

相关推荐

    spring_mvc.zip_spring_spring mvc_springmvc_springmvc架构

    Spring MVC 是一个基于Java的轻量级Web应用框架，它是Spring框架的重要组成部分，主要用于构建控制器层，实现模型-视图-控制器（MVC）的设计模式。这个“spring_mvc.zip”压缩包很可能是为了帮助初学者快速入门...

    spring_mvc代码_spring_mvc代码实例_

    Spring MVC 是 Spring 框架的一个模块，专为构建 Web 应用程序提供了一种模型-视图-控制器（MVC）架构。它简化了Java Web应用开发，将业务逻辑、数据处理和用户界面分离，使得开发者可以更专注于业务逻辑，而无需...

    开发Spring MVC应用程序补充—程序源码下载.rar_spring_spring mvc_spring mvc 源码_sp

    7. **服务层与数据访问**：学习如何整合Spring MVC与Service层，以及DAO层进行数据库操作，例如使用@Autowired进行依赖注入。 8. **异常处理**：配置和实现全局和局部异常处理器，确保优雅地处理错误和异常。 9. *...

    spring_mvc2

    2. **Model-View-Controller**（MVC）架构模式：Spring MVC遵循这一模式，将应用程序逻辑分为模型（Model）、视图（View）和控制器（Controller）三部分，实现业务逻辑与展示层的分离。 3. **控制器（Controller）*...

    _Spring_mvc.zip_spring mvc

    2. **Model-View-Controller (MVC)**：设计模式，Spring MVC遵循这一模式，其中Model代表业务数据，View负责展示，Controller处理用户交互。 3. **Controller**：控制器接口（Controller或者ViewController）处理...

    Spring_MVC_3.0实战指南

    Spring MVC是Spring框架的一个重要组成部分，它提供了模型-视图-控制器（MVC）架构，使开发者能够将业务逻辑、数据处理和用户界面有效地分离，从而实现更高效、可维护的代码结构。 在Spring MVC中，核心概念包括...

    Hotel_SPring_MVC

    它为开发者提供了强大的控制层，使得开发过程更加模块化，易于测试和维护。在"Hotel_SPring_MVC"这个Demo中，我们可以深入探讨Spring MVC的关键组件和它们如何协同工作来构建一个简单的酒店预订系统。 1. **模型...

    Spring_MVC.rar

    通过深入研究源代码，可以学习到如何配置Spring MVC，如何编写控制器，如何进行数据访问，以及如何处理视图和用户交互等关键知识点。对于想要在服务器开发领域尤其是MVC模型中提升自己的人来说，这是一个宝贵的实践...

    spring-mvc-jquery.zip_jquery_mvc jquery_spring jquery_spring mvc

    Spring MVC提供了一种模块化的方式来组织和处理HTTP请求，通过Controller、Service、DAO等层分离业务逻辑和数据访问。它还支持依赖注入，使得代码更易于测试和维护。在Spring MVC 3.0版本中，引入了更多改进，如支持...

    spring_mvc框架搭建demo

    Spring MVC 是一个基于Java的轻量级Web应用框架，它实现了模型-视图-控制器（MVC）设计模式，使得开发者能够将业务逻辑、数据处理和用户界面分离，从而更高效地构建可维护的Web应用。这个“spring_mvc框架搭建demo”...

    spring_mvc_test

    - Spring MVC可与Spring Security（安全）、Spring Data（数据访问）、MyBatis（持久层）等技术无缝集成。 在"spring_mvc_test"项目中，包含了基础的Spring MVC实践，以及英文和中文文档，可以帮助开发者快速理解...

    Spring_MVC_教程_快速入门_深入分析

    5. 双亲上下文的说明：Spring MVC可以和Spring IoC容器一起使用，允许Spring MVC控制器依赖注入服务或持久层对象。这种情况下，DispatcherServlet上下文是作为Spring父上下文的子上下文存在。 6. mvc.xml配置文件：...

    Spring_MVC_MYBatis企业应用实战

    Spring MVC作为Spring框架的一部分，是用于构建Web应用程序的模型-视图-控制器（MVC）架构，而MyBatis则是一个优秀的持久层框架，它支持定制化SQL、存储过程以及高级映射。这两者的结合，为企业级应用提供了高效且...

    the-mvc-spring-and-web-study.rar_Java spring mvc_The Web_mvc_spr

    2. **Spring框架**：Spring框架的基础知识，包括IoC容器、AOP、数据访问层支持等。 3. **Web开发**：Web应用的基本架构和工作原理，可能包括HTTP协议、Servlet和JSP等。 4. **MVC模式**：模型-视图-控制器模式的解释...

    mybatis_spring_MVC_demo

    3. **MVC控制器**：项目中的Controller类（如UserController.java）实现了MVC模式中的Controller层，处理HTTP请求，并调用Service层的方法来执行业务逻辑。这些Controller通常使用Spring的@RequestMapping注解来映射...

    Spring_MVC详解学习

    Spring MVC框架的核心组件包括控制器（Controller）、模型对象（Model）、分派器（Dispatcher）和处理程序对象（Handler）。控制器负责接收用户的请求并进行处理，模型对象代表数据和业务逻辑，分派器负责将请求分发...

    spring_MVC中文教程pdf

    Spring框架以轻量级控制反转（IoC）和面向切面编程（AOP）为内核，提供了展现层Spring MVC和持久层Spring JDBC等多种技术的整合方案。 2. Spring的设计思想： Spring框架的设计思想来自于Rod Johnson的实用主义设计...

    深入浅出学Spring_Web_MVC

    4. **数据类型转换**：了解Spring Web MVC如何自动处理数据类型转换。 5. **数据格式化**：学习如何对数据进行格式化处理。 6. **数据验证**：理解声明式数据验证的工作原理。 7. **视图解析器**：掌握各种视图解析...

    基于注解方式的spring_mvc_jdbcTemplate

    6. **异常处理**：Spring MVC提供了全局异常处理机制，可以通过`@ExceptionHandler`注解在控制器类或单独的`@ControllerAdvice`类中捕获和处理异常。 总结来说，"基于注解方式的spring_mvc_jdbcTemplate"项目是一个...

Magicbox
Global site tag (gtag.js) - Google Analytics