首页 > 程序开发 > 软件开发 > Java >

spring构建教程之spring web 应用程序

2017-11-03

spring构建教程之spring web 应用程序。1)本文部分文字描述转自:“Spring In Action(中 英文版)”,旨在review “spring(5)构建 spring web 应用程序”的相关知识。

spring构建教程之spring web 应用程序。
1)本文部分文字描述转自:“Spring In Action(中/英文版)”,旨在review “spring(5)构建 spring web 应用程序”的相关知识;
【1】spring mvc 起步
【1.1】跟踪spring mvc的请求
1)请求时一个十分繁忙的家伙,下图展示了请求使用spring mvc所经历的 站点;
\
对以上调用过程的分析(Analysis):(不能再干货——请求使用spring mvc 所经历的调用过程)
step1)请求旅程的第一站是spring 的 DispatchServlet: 与大多数java web 框架一样,spring mvc所有请求都会通过一个前端控制器 servlet,而DispatchServlet就是前端控制器;
step2)接着,DispatchServlet的任务是将请求发送给 spring mvc控制器。因为应用程序中有很多控制器,在发送之前DispatchServlet需要查询一个或多个控制器映射来确定请求的下一站在哪里;处理器映射会根据所携带的URL信息来进行决策;
step3)DispatchServlet会将请求发送给选中的控制器;到了控制器 , 请求会卸下其负载(用于提交的info),并耐心等待控制器处理这些 info;
step4)处理器完成逻辑处理后,会产生一些info,这些info 需要返回给用户并在浏览器上显示。这些info 被称为 模型;(干货——模型的定义);这些info 需要以用户友好的方式进行格式化,一般会是 HTML,所以,info需要发送给一个视图(view),通常会是 JSP;控制器所做的最后一件事情是将模型数据打包,并标示出用于渲染输出的视图名。它接下来会将请求连同模型和视图名发送回DispatchServlet;(总结:这样,控制器就不会与特定的视图相耦合了,传递给DispatchServlet的视图名并不直接表示某个特定的JSP,。实际上,它仅仅传递了一个逻辑名称,这个名字将会用来产生结果的真正视图)(干货——引入了逻辑名称,由控制器传递给DispatchServlet,前者还传递了模型(响应info的打包))
step5)DispatchServlet将会使用视图解析器来将逻辑视图名匹配为一个特定的视图实现,可能是也可能不是JSP;
step6)通过控制器传递过来的逻辑名称,DispatchServlet知道由哪个视图渲染结果。DispatchServlet交付模型数据到某个视图的实现,请求的任务完成了;
step7)视图将使用模型数据渲染输出,这个输出会通过响应对象传递给客户端;
【1.2】搭建spring mvc
【1.2.1】配置DispatchServlet
1)intro toDispatchServlet:DispatchServlet 是 spring mvc的核心,它负责将请求路由到其他组件中;(干货——引入了路由的概念,路由分发)
2)使用java 将DispatchServlet 配置在 servlet容器中,而不会再使用 web.xml 文件;
public class SpitterWebInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {    
  @Override
  protected Class[] getRootConfigClasses() {
    return new Class[] { RootConfig.class };
  }
  @Override
  protected Class[] getServletConfigClasses() {  // 指定配置类.
    return new Class[] { WebConfig.class };
  }
  @Override
  protected String[] getServletMappings() { // 将DispatcherServlet映射到 "/"
    return new String[] { "/" };
  }
}
public abstract class AbstractAnnotationConfigDispatcherServletInitializer
  extends AbstractDispatcherServletInitializer {    // org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer
 @Override
 protected WebApplicationContext createRootApplicationContext() {
  Class[] configClasses = getRootConfigClasses();
  if (!ObjectUtils.isEmpty(configClasses)) {
   AnnotationConfigWebApplicationContext rootAppContext = new AnnotationConfigWebApplicationContext();
   rootAppContext.register(configClasses);
   return rootAppContext;
  }
  else {
   return null;
  }
 }
 @Override
 protected WebApplicationContext createServletApplicationContext() {
  AnnotationConfigWebApplicationContext servletAppContext = new AnnotationConfigWebApplicationContext();
  Class[] configClasses = getServletConfigClasses();
  if (!ObjectUtils.isEmpty(configClasses)) {
   servletAppContext.register(configClasses);
  }
  return servletAppContext;
 }
 protected abstract Class[] getRootConfigClasses();
 protected abstract Class[] getServletConfigClasses(); 
}
对上述代码的分析(Analysis):要理解上述代码是如何工作的?我们只需要知道扩展 AbstractAnnotationConfigDispatcherServletInitializer 的任意类都会自动配置 DispatcherServlet 和 Spring 应用上下文,spring应用上下文会位于应用程序的 servlet上下文中;
3)关于 AbstractAnnotationConfigDispatcherServletInitializer 的剖析:在 servlet3.0环境中,容器会在类路径中查找实现 javax.servlet.ServletContainerInitializer 接口的类,如果能发现的话,就会用来配置 servlet容器;
3.1)spring 提供了这个接口的实现,名为 SpringServletContainerInitializer:这个类反过来又会查找实现 WebApplicationInitializer 的类并将配置的任务交给它们来完成;
3.2)spring3.2 引入了一个便利的 WebApplicationInitializer 基础实现,也就是AbstractAnnotationConfigDispatcherServletInitializer。因为我们的SpitterWebInitializer扩展了 AbstractAnnotationConfigDispatcherServletInitializer(同时也就实现了 WebApplicationInitializer) ,。因此当部署到 servlet3.0 容器的时候,容器会自动发现它,并用它来配置servlet上下文;
\
4)上述代码中的SpitterWebInitializer 类 重写了三个AbstractAnnotationConfigDispatcherServletInitializer 的方法:
method1)getServletMappings方法:它会将一个或多个路径映射到 DispatcherServlet上;在本例中,它映射的是“/“,这表示它会是 应用的默认 servlet,它会处理进入应用的所有请求;(为了理解其他两个方法,首先要理解 DispatcherServlet和一个 servlet 监听器的关系)
【1.2.2】 两个应用上下文之间的故事
1)当 DispatcherServlet启动的时候,它会创建spring 应用上下文,并加载配置文件或配置类中所声明的 bean;在getServletConfigClasses()方法中,我们要求 DispatcherServlet 加载应用上下文时,使用定义在 WebConfig配置类(使用java 配置)中的 bean;(在spring 应用中,还有另外一个应用上下文,由 ContextLoaderListener 创建)
2)我们希望 DispatcherServlet加载包含 Web组件的bean,如控制器,视图解析器以及处理器映射,而 ContextLoaderListener 要加载应用中的其他bean。这些bean 通常是 驱动应用后端的中间层 和 数据层组件;
3)实际上,AbstractAnnotationConfigDispatcherServletInitializer 会同时创建 DispatcherServlet 和 ContextLoaderListener。
3.1)getServletConfigClasses()方法:返回的带有 @Configuration注解的类将会用来定义 DispatcherServlet应用上下文中的bean。
3.2)getRootConfigClasses()方法:返回的带有@Configuration注解的类将会用来配置 ContextLoaderListener 创建的应用上下文中的bean;
4)如果按照这种方式配置 DispatcherServlet,而不使用web.xml的话。唯一的问题在于:它只能部署到支持 servlet3.0 的服务器中才能正常工作;
【1.2.3】启用spring mvc
1)启动 spring mvc组件的方法也不止一种:可以使用 启用注解驱动的spring mcv;
2)我们创建的最简单的spring mvc 配置是一个带有 @EnableWebMvc注解的类:
@Configuration
@EnableWebMvc
public class WebConfig {
}
2.1)以上代码的确能够启用 spring mvc,但还有不少问题要解决:(problems)
problem1)没有配置视图解析器:这样的话,spring默认会使用 BeanNameViewResolver,这个视图解析器会查找ID 与 视图名称匹配的bean,并且查找的bean 要实现 View 接口,它以这样的方式来解析视图;
problem2)没有启用组件扫描:这样的话,spring 只能找到显式声明在配置类中的控制器;
problem3)这样配置的话,这样配置的话,DispatcherServlet 会映射为 应用的默认servlet:所以它会处理所有的请求,包括对静态资源的请求,如图片等;(大多数cases下,这不是你想要的效果)
2.2)修改WebConfig这个spring mvc配置类, 修改后的内容为:
@Configuration
@EnableWebMvc //启用spring mvc.
@ComponentScan("com.spring.chapter5.spittr.web") // 启用组件扫描.
public class WebConfig extends WebMvcConfigurerAdapter {
  @Bean
  public ViewResolver viewResolver() { // 配置JSP视图解析器.
    InternalResourceViewResolver resolver = new InternalResourceViewResolver();
    resolver.setPrefix("/WEB-INF/views/");
    resolver.setSuffix(".jsp");
    return resolver;
  } 
  @Override
  public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) { // 配置静态资源处理.
    configurer.enable();
  } 
  @Override
  public void addResourceHandlers(ResourceHandlerRegistry registry) {
    // TODO Auto-generated method stub
    super.addResourceHandlers(registry);
  }
}
对以上代码的分析(Analysis):新的 WebConfig 扩展了WebMvcConfigurerAdapter类,重写了其 configureDefaultServletHandling()方法,通过调用DefaultServletHandlerConfigurer.enable()方法,我们要求 DispatcherServlet 将对静态资源的请求转发到 Servlet容器中默认的Servlet上,而不是使用 DispatcherServlet 本身来处理此类请求;
3)RootConfig 的源码定义如下:
@Configuration
@ComponentScan(basePackages={"com.spring.chapter5.spittr"}, 
    excludeFilters={
        @Filter(type=FilterType.ANNOTATION, value=EnableWebMvc.class)
    })
public class RootConfig {
}
【1.3】Spittr 应用简介(Spittr 应用 == Twitter系统
1)Spitter 应用有两个基本的概念: 应用用户 和 用户发布的info(Spittle)
2)通过配置 DispatcherServlet来启用基本的 spring mvc 组件并确定了目标应用,让我们进入核心内容:使用 spring mvc 控制器处理 web 请求;
【2】编写基本的控制器
1)intro:控制器只是方法上添加了 @RequestMapping 注解 的类,该注解声明了它们所要处理的请求;(干货——注解@RequestMapping的作用)
2)看个荔枝:若控制器类要处理 ”/“ 请求,并渲染应用的首页,控制器定义如下:
@Controller // 声明一个控制器
@RequestMapping("/")
public class HomeController {
  @RequestMapping(method = GET) // 处理对 ”/“ 的get请求;
  public String home(Model model) {
    return "home"; //视图名为home
  }
}
对上述代码的分析(Analysis):
A1)@Controller注解:是一个构造型注解,它基于 @Component注解。在这里,它的目的是 辅助实现组件扫描,因为 HomeController 带有 @Controller注解,因此组件扫描器会自动找到 HomeController,并将其声明为 spring应用上下文中的一个 bean;(干货——@Controller注解的作用)
A2)@RequestMapping注解:它的value属性指定了这个方法所要处理的请求路径,method细化了所要处理的HTTP方法;
3)鉴于配置InternalResourceViewResolver的方式,视图名"home" 将会解析为 "WEB-INF/views/home.jsp"路径的JSP(参见【1.2.3】章节下面的2.2)下面的InternalResourceViewResolver定义及其其前缀和后缀);Spitter 应用的首页为:
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ page session="false" %>

Welcome to Spitter

\
【2.1】测试控制器
1)测试用例如下:上面的测试用例貌似很low,没有断言当接收到针对 ”/“ GET 请求时会调用home()方法;
2)spring包含了一种 mock spring mvc 并针对控制器执行 HTTP 请求的机制:这样的话,就没有必要再启动web 服务器和浏览器了;(干货——引入了mock spring mvc 并针对控制器执行 HTTP 请求的机制)
3)如何测试 spring mvc的控制器?
public class HomeControllerTest {
	
	@Test
	public void testHomePage() throws Exception {
		HomeController controller = new HomeController();
		String result = controller.home(null);
		System.out.println(result);
	}
}
对以上代码的分析(Analysis): 这次没有直接调用 home()方法,而是发起了对 "/" 的 GET 请求,并断言结果视图 名称为 home;(这个测试用例,一点干货都没得,哎)
【2.2】定义类级别的请求处理
1)拆分 @RequestMapping注解,并将其路径映射部分放到类级别上;
 //拆分前
@Controller
public class HomeController {
  @RequestMapping(value="/", method = GET)
  public String home(Model model) {
    return "home";
  }
}

//拆分后
@Controller
@RequestMapping("/")
public class HomeController {
  @RequestMapping(method = GET)
  public String home(Model model) {
    return "home";
  }
}
2)也可以设置多个映射路径,修改@RequestMapping注解如下:
@Controller
@RequestMapping({"/" ,"/homepage"}) // 设置多个映射路径.
public class HomeController() {
    ......
}
【2.3】传递模型数据到视图中
1)在 Spittr 应用中,需要有一个页面展现最近提交的 Spittle列表;
2)处理steps:
step1)首先,需要定义一个数据访问的 Repository(能够获取 Spittle列表的 Repository);
public interface SpittleRepository {
  List findRecentSpittles();
  List findSpittles(long max, int count);    
  Spittle findOne(long id);
  void save(Spittle spittle);
}
// 为了获取最新的20个 Spittle 对象,我们可以这样调用 findSpittles(long max, int count):
// List recent =  spittleRepository.findSpittles(Long.MAX_VALUE, 20);
step2)Spittle 的源码如下:
public class Spittle {

	private final Long id;
	private final String message;
	private final Date time;
	private Double latitude;
	private Double longitude;

	public Spittle(String message, Date time) {
		this(null, message, time, null, null);
	}

	public Spittle(Long id, String message, Date time, Double longitude,
			Double latitude) {
		this.id = id;
		this.message = message;
		this.time = time;
		this.longitude = longitude;
		this.latitude = latitude;
	}

	public long getId() {
		return id;
	}

	public String getMessage() {
		return message;
	}

	public Date getTime() {
		return time;
	}

	public Double getLongitude() {
		return longitude;
	}

	public Double getLatitude() {
		return latitude;
	}

	@Override
	public boolean equals(Object that) {
		return EqualsBuilder.reflectionEquals(this, that, "id", "time");
	}

	@Override
	public int hashCode() {
		return HashCodeBuilder.reflectionHashCode(this, "id", "time");
	}
}
对以上代码的分析(Analysis):使用了 Apache Common Lang 包来实现了 equals()方法 和 hashCode()方法;(downloading from apache commons lang)
step3)测试 SpittleController处理针对 "/spittles" 的GET请求:(使用 spring 的 MockMvc 来断言新的处理器方法中你所期望的行为)
	@Test
	public void shouldShowRecentSpittles() throws Exception {
		List expectedSpittles = createSpittleList(20);
		SpittleRepository mockRepository = mock(SpittleRepository.class);
		when(mockRepository.findSpittles(Long.MAX_VALUE, 20)).thenReturn(
				expectedSpittles);
		SpittleController controller = new SpittleController(mockRepository);
		SpittleController controller = new SpittleController(mockRepository);
		MockMvc mockMvc = standaloneSetup(controller).setSingleView(
				new InternalResourceView("/WEB-INF/views/spittles.jsp"))
				.build();
		mockMvc.perform(get("/spittles"))
				.andExpect(view().name("spittles"))
				.andExpect(model().attributeExists("spittleList"))
				.andExpect(
						model().attribute("spittleList",
								hasItems(expectedSpittles.toArray())));
	}

	private List createSpittleList(int count) {
		List spittles = new ArrayList();
		for (int i = 0; i < count; i++) {
			spittles.add(new Spittle("Spittle " + i, new Date()));
		}
		return spittles;
	}
step4)SpittleController:在模型中放入最新的 Spittle列表
@Controller
@RequestMapping("/spittles")
public class SpittleController {

	private static final String MAX_LONG_AS_STRING = "9223372036854775807";

	private SpittleRepository spittleRepository;

	@Autowired
	public SpittleController(SpittleRepository spittleRepository) {
		this.spittleRepository = spittleRepository;
	}
	@RequestMapping(method = RequestMethod.GET)
	public String spittles(Model model) { // Model实际上就是一个Map,他会传递给视图,这样就能渲染到client.
		model.addAttribute(spittleRepository.findSpittles(Long.MAX_VALUE, 20));
		return "spittles";
	}
}
对上述代码的分析(Analysis):
A1)当调用 addAttribute()方法而不指定key时,那么key 会根据值的对象类型推断确定。因为它是一个List,所以推断key == spittleList。
A2)如果你想显示指定模型的key的话,可以这样指定:
@RequestMapping(method = RequestMethod.GET)
	public String spittles(Model model) {
		model.addAttribute("spittleList", spittleRepository.findSpittles(Long.MAX_VALUE, 20));
		return "spittles";
	}
A3)我们还可以将该方法改写为:当处理器方法像这样返回对象或集合时,这个值会被放到模型中,且模型key会被推断为 spittleList;且逻辑视图的名称将会根据请求路径推断得出,因为请求路径是 "/spittles" 的 GET请求,所以视图名称会是 spittles(去掉斜线即可);
@RequestMapping(method=RequestMethod.GET)
	public List spittles() {
		return spittleRepository.findSpittles(Long.MAX_VALUE, 20));
	}

\

Attention)不管选择哪种方式编写 spittles()方法,所达到的效果是一样的。

A1)模型中会存储一个Spittle列表,key 为 spitleList,然后该列表会被发送到 spittles的视图中;

A2)按照InternalResourceViewResolver, 视图解析器的配置,视图的JSP将是 /WEB-INF/views/spittles.jsp;该jsp的源码如下:

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<%@ taglib prefix="s" uri="http://www.springframework.org/tags"%>
<%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %>

Spit it out...


Recent Spittles

  • (, )

Show more

\

\

【3】接收请求的输入

1)spring mvc 以多种方式将客户端中的数据传送到控制器的处理器方法中包括:查询参数, 表单参数,路径变量等;
【3.1】处理查询参数
1)Spittr应用需求的第一件事: 展现分页的 Spittle列表;
2)为了实现分页,处理器方法要接受如下参数:
parameter1)before参数:表明查询出的id 要在这个值之前;
parameter2)count参数:表明每页的 Spittle 数量;
@Test
 public void shouldShowPagedSpittles() throws Exception {
  List expectedSpittles = createSpittleList(50);
  SpittleRepository mockRepository = mock(SpittleRepository.class);
  when(mockRepository.findSpittles(238900, 50)).thenReturn(
    expectedSpittles);
  SpittleController controller = new SpittleController(mockRepository);
  MockMvc mockMvc = standaloneSetup(controller).setSingleView(
    new InternalResourceView("/WEB-INF/views/spittles.jsp"))
    .build();
  mockMvc.perform(get("/spittles?max=238900&count=50"))
    .andExpect(view().name("spittles"))
    .andExpect(model().attributeExists("spittleList"))
    .andExpect(
      model().attribute("spittleList",
        hasItems(expectedSpittles.toArray())));
对以上代码的分析(Analysis):上述方法的关键区别在于它针对 "/spittles" 发送 GET 请求,同时还传入了 max 和 count参数;
@RequestMapping(method=RequestMethod.GET)
public List spittles(
@RequestParam("max") long max,
@RequestParam("count") int count) {
return spittleRepository.findSpittles(max, count);
}
@RequestMapping(method = RequestMethod.GET)
 public List spittles(
    @RequestParam("max") long max,
   @RequestParam("count") int count) {
  return spittleRepository.findSpittles(max, count);
 }
3)SpittleController中的处理器方法要同时处理有参数和没有参数的case,修改 @RequestParam注解,让它能够接收参数;@RequestParam注解的defaultValue属性可以完成这个任务.
@RequestMapping(method = RequestMethod.GET)
 public List spittles(
   @RequestParam(value = "max", defaultValue = MAX_LONG_AS_STRING) long max,
   @RequestParam(value = "count", defaultValue = "20") int count) {
  return spittleRepository.findSpittles(max, count);
 }
4)请求中的查询参数是往控制器中传递信息的常用手段。另外一种方式很流行,就是将传递参数作为请求路径的一部分;
\
【3.2】通过路径参数接收输入
1)应用需求:工具给定 Id 来展现某个 Spittle 记录,通过使用 @RequestParam 注解,让它接收ID 作为查询参数;
@RequestMapping(value = "/show", method = RequestMethod.GET)
 public String showSpittle(@RequestParam("spittle_id") long spittleId,
   Model model) {
  model.addAttribute(spittleRepository.findOne(spittleId));
  return "spittle";
 }
对以上代码的分析(Analysis):对 "/spittles/12345" 发起 GET 请求要优于对 "/spittles/show/spittle_id=12345" 发起请求。前者能够识别出查询的资源,而后者描述的是带有参数的一个操作——本质上是通过 HTTP 发起的 RPC(远程过程调用协议);
2)Spittr应用以面向资源的控制器作为目标,下面给出测试用例
@Test
 public void testSpittle() throws Exception {
  Spittle expectedSpittle = new Spittle("Hello", new Date());
  SpittleRepository mockRepository = mock(SpittleRepository.class);
  when(mockRepository.findOne(12345)).thenReturn(expectedSpittle);
  SpittleController controller = new SpittleController(mockRepository);
  MockMvc mockMvc = standaloneSetup(controller).build();
  mockMvc.perform(get("/spittles/12345"))
    .andExpect(view().name("spittle"))
    .andExpect(model().attributeExists("spittle"))
    .andExpect(model().attribute("spittle", expectedSpittle));
 }
3)我们编写的 @RequestMapping注解要包含变量部分,这部分代表了 Spittle ID;为了实现这种路径变量,spring mvc 允许我们 在 @RequestMapping 路径中添加占位符。占位符的名称要用 大括号"({})" 括起来;下面的方法使用了占位符:
@RequestMapping(value = "/{spittleId}", method = RequestMethod.GET)
 public String spittle(@PathVariable("spittleId") long spittleId, Model model) {
  model.addAttribute(spittleRepository.findOne(spittleId));
  return "spittle";
 }
// 因为 方法的参数名与占位符的名称相同,所以可以去掉 @PathVariable 中的value属性;
// 如果@PathVariable 中 没有 value属性,它会假设占位符的名称与方法的参数名相同;
@RequestMapping(value = "/{spittleId}", method = RequestMethod.GET)
 public String spittle(@PathVariable long spittleId, Model model) {
  model.addAttribute(spittleRepository.findOne(spittleId));
  return "spittle";
 }
\
【4】处理表单
1)展现一个表单,允许用户注册
@Controller
 @RequestMapping("/spitter")
 public class SpitterController {
  @RequestMapping(value = "/register", method = GET)  // 这意味 这将会使用 /WEB-INF/views/registerForm.jsp 这个JSP 来渲染注册表单;
  public String showRegistrationForm() {
   return "registerForm";
  }
 }
2)测试展现表单的控制器方法;
public void shouldShowRegistration() throws Exception {
  SpitterController controller = new SpitterController();
  MockMvc mockMvc = standaloneSetup(controller).build();
  mockMvc.perform(get("/spitter/register")).andExpect(
    view().name("registerForm"));
 }
3)注册表单的JSP
【4.1】编写处理表单的控制器
1)intro:控制器需要接受表单数据并将其保存为 Spitter对象;
2)测试处理表单的控制器方法
@Test
 public void shouldProcessRegistration() throws Exception {
  SpitterRepository mockRepository = mock(SpitterRepository.class);
  Spitter unsaved = new Spitter("jbauer", "24hours", "Jack", "Bauer");
  Spitter saved = new Spitter(24L, "jbauer", "24hours", "Jack", "Bauer");
  when(mockRepository.save(unsaved)).thenReturn(saved);
  SpitterController controller = new SpitterController(mockRepository);
  MockMvc mockMvc = standaloneSetup(controller).build();
  mockMvc.perform(
    post("/spitter/register").param("firstName", "Jack")
      .param("lastName", "Bauer").param("username", "jbauer")
      .param("password", "24hours")).andExpect(
    redirectedUrl("/spitter/jbauer"));
  verify(mockRepository, atLeastOnce()).save(unsaved);
 }
2)处理所提交的表单并注册新用户
@Controller
 @RequestMapping("/spitter")
 public class SpitterController {
  private SpitterRepository spitterRepository;

  @Autowired
  public SpitterController(SpitterRepository spitterRepository) {
   this.spitterRepository = spitterRepository;
  }

  @RequestMapping(value = "/register", method = GET)
  public String showRegistrationForm() {
   return "registerForm";
  }

  @RequestMapping(value = "/register", method = POST)
  public String processRegistration(Spitter spitter) {
   spitterRepository.save(spitter);
   return "redirect:/spitter/" + spitter.getUsername();  // 当InternalResourceViewResolver 视图解析器看到 "redirect:" 前缀时,它就知道要将其解析为重定向的规则,而不是视图名称;
  }
 }
Attention)除了前缀"redirect:",InternalResourceViewResolver 视图解析器哈可以识别 "forward:"前缀:当发现此前缀时,请求将会前往(forward) 指定的URL 路径,而不是重定向了;
\
【4.2】校验表单
1)intro:如果输入的username 或 password为空的话,如果不处理的话,就会出现安全问题;
2)使用spring 对 java 校验API的支持: 从spring3.0 开始,在 spring mvc中提供了对ajva 校验API的支持。在spring mvc中要使用 java校验API的话,并不需要什么额外的配置。只要保证在类路径下包含这个java API的实现即可;
3)java校验API 定义了多个注解,位于 javax.validataion.constraints 包中;
\
\
4)Spitter 包含了要提交到 Spittle Post 请求中的域;
public class Spitter {
  private Long id;
  @NotNull
  @Size(min=5, max=16)
  private String username;
 
 @NotNull
  @Size(min=5, max=25)
  private String password;

  @NotNull
  @Size(min=2, max=30)
  private String firstName;

  @NotNull
  @Size(min=2, max=30)
  private String lastName;
  ...
  }
2)启用校验功能的processRegistration()方法;
@RequestMapping(value = "/register", method = POST)
 public String processRegistration(@Valid Spitter spitter, Errors errors) {
  if (errors.hasErrors()) {
   return "registerForm";
  }
  spitterRepository.save(spitter);
  return "redirect:/spitter/" + spitter.getUsername();
 }
Attention)
A1)@Valid注解:告知spring, 需要确保这个对象满足校验限制;
A2)在 Spiter属性上添加校验限制并不能阻止表单提交。即便用户没有填写某个域或者某个域所给定的值超过了最大长度,processRegistration方法依然会被调用;
\

相关文章
最新文章
热点推荐