《spring实战》学习笔记第二章开发Web应用

最新推荐文章于 2023-03-05 12:09:09 发布

晦暗天明

最新推荐文章于 2023-03-05 12:09:09 发布

阅读量496

点赞数

本文链接：https://blog.csdn.net/qq_37960629/article/details/114846481

版权

《spring实战》学习笔记专栏收录该内容

6 篇文章 1 订阅

订阅专栏

深入研究 Spring MVC 并会看到如何展现模型数据和处理表单输入。

2. 1　展现信息

关于@Date注解

package tacos;

import lombok.Data;
import lombok.RequiredArgsConstructor;

@Data
@RequiredArgsConstructor
public class Ingredient {
  
  private final String id;
  private final String name;
  private final Type type;
  
  public static enum Type {
    WRAP, PROTEIN, VEGGIES, CHEESE, SAUCE
  }

}

Ingredient 类不寻常的一点是它似乎缺少了常见的 getter 和 setter 方法，以及 equals()、 hashCode()、 toString() 等方法。没有这些方法，部分原因是节省空间，此外还因为我们使用了名为 Lombok 的库（这是一个非常棒的库，它能够在运行时动态生成这些方法）。实际上，类级别的@ Data 注解就是由 Lombok 提供

可以在 pom. xml 中手动加入Lombok库

    <dependency>
    	<groupId>org.projectlombok</groupId>
    	<artifactId>lombok</artifactId>
    	<optional>true</optional> 
    </dependency>

Lombok 非常有用，但你也要知道，它是可选的。在开发 Spring 应用的时候，它并不是必备的，所以如果你不想使用它的话，完全可以手动编写这些缺失的方法。

2. 1. 2　创建控制器类

在 Spring MVC 框架中，控制器是重要的参与者。它们的主要职责是处理 HTTP 请求，要么将请求传递给视图以便于渲染 HTML（浏览器展现），要么直接将数据写入响应体（ RESTful）。

代码案例

// tag::head[]
package tacos.web;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

import javax.validation.Valid;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.Errors;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;

import lombok.extern.slf4j.Slf4j;
import tacos.Ingredient;
import tacos.Ingredient.Type;
import tacos.Taco;

@Slf4j
@Controller
@RequestMapping("/design")
public class DesignTacoController {

//end::head[]

@ModelAttribute
public void addIngredientsToModel(Model model) {
	List<Ingredient> ingredients = Arrays.asList(
	  new Ingredient("FLTO", "Flour Tortilla", Type.WRAP),
	  new Ingredient("COTO", "Corn Tortilla", Type.WRAP),
	  new Ingredient("GRBF", "Ground Beef", Type.PROTEIN),
	  new Ingredient("CARN", "Carnitas", Type.PROTEIN),
	  new Ingredient("TMTO", "Diced Tomatoes", Type.VEGGIES),
	  new Ingredient("LETC", "Lettuce", Type.VEGGIES),
	  new Ingredient("CHED", "Cheddar", Type.CHEESE),
	  new Ingredient("JACK", "Monterrey Jack", Type.CHEESE),
	  new Ingredient("SLSA", "Salsa", Type.SAUCE),
	  new Ingredient("SRCR", "Sour Cream", Type.SAUCE)
	);
	
	Type[] types = Ingredient.Type.values();
	for (Type type : types) {
	  model.addAttribute(type.toString().toLowerCase(),
	      filterByType(ingredients, type));
	}
}
	
//tag::showDesignForm[]
  @GetMapping
  public String showDesignForm(Model model) {
    model.addAttribute("design", new Taco());
    return "design";
  }

//end::showDesignForm[]
 

//tag::processDesignValidated[]
  @PostMapping
  public String processDesign(@Valid @ModelAttribute("design") Taco design, Errors errors, Model model) {
    if (errors.hasErrors()) {
      return "design";
    }

    // Save the taco design...
    // We'll do this in chapter 3
    log.info("Processing design: " + design);

    return "redirect:/orders/current";
  }

//end::processDesignValidated[]

//tag::filterByType[]
  private List<Ingredient> filterByType(
      List<Ingredient> ingredients, Type type) {
    return ingredients
              .stream()
              .filter(x -> x.getType().equals(type))
              .collect(Collectors.toList());
  }

//end::filterByType[]
// tag::foot[]
}
// end::foot[]

注解说明

@Slf4j是 Lombok 所提供的注解，在运行时，它会在这个类中自动生成一个 SLF4J（ Simple Logging Facade for Java） Logger。这个简单的注解和在类中通过如下代码显式声明的效果是一样的：

private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger( DesignTacoController.class);

@ Controller，这个注解会将这个类识别为控制器，并且将其作为组件扫描的候选者，

@ RequestMapping 注解，当@ RequestMapping 注解用到类级别的时候，它能够指定该控制器所处理的请求类型。例如将处理路径以“/ design” 开头的请求。

处理 GET 请求

@GetMapping 注解对类级别的@ RequestMapping 进行了细化。@ GetMapping 结合类级别的@ RequestMapping，指明当接收到对“/ design” 的 HTTP GET 请求时，将会调用 showDesignForm() 来处理请求。

@GetMapping 是一个相对较新的注解，是在 Spring 4. 3 引入的。在 Spring 4. 3 之前，你可能需要使用方法级别的@ RequestMapping 注解作为替代：

@RequestMapping( method= RequestMethod. GET)

　 Spring MVC 的请求映射注解

@RequestMapping 通用的请求处理
@GetMapping 处理 HTTP GET 请求
@PostMapping 处理 HTTP POST 请求
@PutMapping 处理 HTTP PUT 请求
@DeleteMapping 处理 HTTP DELETE 请求
@PatchMapping 处理 HTTP PATCH 请求

设计视图

showDesignForm() 这个案例方法最后返回“ design”，这是视图的逻辑名称，会用来将模型渲染到视图上。

在控制器完成它的工作之后，现在就该视图登场了。 Spring 提供了多种定义视图的方式，包括 JavaServer Pages（ JSP）、 Thymeleaf、 FreeMarker、 Mustache 和基于 Groovy 的模板。

本案例中使用 Thymeleaf，我们需要添加另外一个依赖到项目构建中。

    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-thymeleaf</artifactId>
    </dependency>

在运行时， Spring Boot 的自动配置功能会发现 Thymeleaf 在类路径中，因此会为 Spring MVC 创建支撑 Thymeleaf 视图的 bean。

Thymeleaf 模板就是增加一些额外元素属性的 HTML，这些属性能够指导模板如何渲染 request 数据。举例来说，如果有一个请求属性的 key 为“ message”，我们想要使用 Thymeleaf 将其渲染到一个 HTML < p> 标签中，那么在 Thymeleaf 模板中我们可以这样写：

<p th:text="${message}"> placeholder message</p>

当模板渲染成 HTML 的时候，< p> 元素体将会被替换为 Servlet Request 中 key 为“ message” 的属性值。“ th: text” 是 Thymeleaf 命名空间中的属性，它会执行这个替换过程。${} 会告诉它要使用某个请求属性

Thymeleaf 还提供了一个属性“ th: each”，它会迭代一个元素集合，为集合中的每个条目渲染 HTML。

< input> 复选框元素，还有一个为复选框提供标签的< span> 元素。复选框使用 Thymeleaf 的 th: value 来为渲染出的< input> 元素设置 value 属性。类似的还有th: text 。

值得注意的是，在 Spring Boot 应用中，静态内容要放到根路径的“/ static” 目录下。然后使用Thymeleaf 的@{} 操作符，用来生成一个相对上下文的路径，以便于引用我们需要的静态制件（ artifact）。

2. 2　处理表单提交

案例代码

   <form method="POST" th:object="${design}">

    <span class="validationError"
          th:if="${#fields.hasErrors('ingredients')}"
          th:errors="*{ingredients}">Ingredient Error</span>

    <div class="grid">
      <div class="ingredient-group" id="wraps">
      <h3>Designate your wrap:</h3>
      <div th:each="ingredient : ${wrap}">
        <input name="ingredients" type="checkbox" th:value="${ingredient.id}" />
        <span th:text="${ingredient.name}">INGREDIENT</span><br/>
      </div>
      </div>

	  <div class="ingredient-group" id="proteins">
      <h3>Pick your protein:</h3>
      <div th:each="ingredient : ${protein}">
        <input name="ingredients" type="checkbox" th:value="${ingredient.id}" />
        <span th:text="${ingredient.name}">INGREDIENT</span><br/>
      </div>
      </div>

	  <div class="ingredient-group" id="cheeses">
      <h3>Choose your cheese:</h3>
      <div th:each="ingredient : ${cheese}">
        <input name="ingredients" type="checkbox" th:value="${ingredient.id}" />
        <span th:text="${ingredient.name}">INGREDIENT</span><br/>
      </div>
      </div>

	  <div class="ingredient-group" id="veggies">
      <h3>Determine your veggies:</h3>
      <div th:each="ingredient : ${veggies}">
        <input name="ingredients" type="checkbox" th:value="${ingredient.id}" />
        <span th:text="${ingredient.name}">INGREDIENT</span><br/>
      </div>
      </div>

	  <div class="ingredient-group" id="sauces">
      <h3>Select your sauce:</h3>
      <div th:each="ingredient : ${sauce}">
        <input name="ingredients" type="checkbox" th:value="${ingredient.id}" />
        <span th:text="${ingredient.name}">INGREDIENT</span><br/>
      </div>
      </div>
      </div>

      <div>

      <h3>Name your taco creation:</h3>
      <input type="text" th:field="*{name}"/>
      <span th:text="${#fields.hasErrors('name')}">XXX</span>
      <span class="validationError"
            th:if="${#fields.hasErrors('name')}"
            th:errors="*{name}">Name Error</span>
      <br/>

      <button>Submit your taco</button>
      </div>
    </form>

仔细看一下视图中的< form> 标签，你将会发现它的 method 属性被设置成了 POST。除此之外，< form> 并没有声明 action 属性。这意味着当表单提交的时候，浏览器会收集表单中的所有数据，并以 HTTP POST 请求的形式将其发送至服务器端，发送路径与渲染表单的 GET 请求路径相同，也就是“/ design”。

因此，在该 POST 请求的接收端，我们需要有一个控制器处理方法。在 DesignTacoController 中，我们会编写一个新的处理器方法来处理针对“/ design” 的 POST 请求。

　使用@ PostMapping 来处理 POST 请求

  @PostMapping
  public String processDesign(Taco  design) {
    // Save the taco design...
    // We'll do this in chapter 3
    log.info("Processing design: " + design);

    return "redirect:/orders/current";
  }

当表单提交的时候，表单中的输入域会绑定到 Taco 对象的属性中，该对象会以参数的形式传递给 processDesign()。从这里开始， processDesign() 就可以针对 Taco 对象采取任意操作了。

2. 3　校验表单输入

有种校验方法就是在 processDesign() 和 processOrder() 方法中添加大量乱七八糟的 if/ then 代码块，逐个检查，确保每个输入域都满足对应的校验规则。但是，这样会非常烦琐，并且难以阅读和调试。

幸运的是， Spring 支持 Java 的 Bean 校验 API（ Bean Validation API，也被称为 JSR- 303）。这样的话，我们能够更容易地声明检验规则，而不必在应用程序代码中显式编写声明逻辑。

要在 Spring MVC 中应用校验，我们需要。

在要被校验的类上声明校验规则：具体到我们的场景中，也就是 Taco 类。
在控制器方法中声明要进行校验：具体来讲，也就是 DesignTacoController 的 processDesign() 方法和 OrderController 的 processOrder() 方法。
修改表单视图以展现校验错误。

2. 3. 1 　声明校验规则

@NotBlank 注解：用户没有提交空白字段。
@ CreditCardNumber 注解。这个注解声明该属性的值必须是合法的信用卡号，它要能通过 Luhn 算法的检查。这能防止用户有意或无意地输入错误的数据，但是该检查并不能确保这个信用卡号真的分配给了某个账户，也不能保证这个账号能够用来进行支付。
@Pattern 注解：正则表达式
@ Digits 注解，能够确保它的值包含 3 位数字。

所有的校验注解都包含了一个 message 属性，该属性定义了当输入的信息不满足声明的校验规则时要给用户展现的消息。

2. 3. 2　在表单绑定的时候执行校验

在Controller控制器中对应方法中的参数加入@Valid注解，就可以启动校验器，

案例代码：

  @PostMapping
  public String processDesign(@Valid @ModelAttribute("design") Taco design, Errors errors, Model model) {
    if (errors.hasErrors()) {
      return "design";
    }

    // Save the taco design...
    // We'll do this in chapter 3
    log.info("Processing design: " + design);

    return "redirect:/orders/current";
  }

@Valid 注解会告诉 Spring MVC 要对提交的 Taco 对象进行校验，而校验时机是在它绑定完表单数据之后、调用 processDesign() 之前。如果存在校验错误，那么这些错误的细节将会捕获到一个 Errors 对象中并传递给 processDesign()。 processDesign() 方法的前几行会查阅 Errors 对象，调用其 hasErrors() 方法判断是否有校验错误。如果存在校验错误，那么这个方法将不会处理 Taco 对象并返回“ design” 视图名，表单会重新展现。

为了对提交的 Order 对象进行校验， OrderController 的 processOrder() 方法也需要进行类似的变更，

  @PostMapping
  public String processOrder(@Valid Order order, Errors errors) {
    if (errors.hasErrors()) {
      return "orderForm";
    }
    
    log.info("Order submitted: " + order);
    return "redirect:/";
  }

2. 3. 3　展现校验错误

Thymeleaf 提供了便捷访问 Errors 对象的方法，这就是借助 fields 及其 th: errors 属性。举例来说，为了展现信用卡字段的校验错误，我们可以添加一个< span> 元素，该元素会将对错误的引用用到订单的表单模板上，

代码如下

      <span th:text="${#fields.hasErrors('name')}">XXX</span>
      <span class="validationError"
            th:if="${#fields.hasErrors('name')}"
            th:errors="*{name}">Name Error</span>
      <br/>

< span> 元素使用 class 属性来为错误添加样式，以引起用户的注意。

th: if 属性来决定是否要显示该元素。

fields 属性的 hasErrors() 方法会检查 ccNumber 域是否存在错误，如果存在，就将会渲染< span>。

th: errors 属性引用了 ccNumber 输入域，如果该输入域存在错误，那么它会将< span> 元素的占位符内容替换为校验信息。

2. 4　使用视图控制器

视图控制器：也就是只将请求转发到视图而不做其他事情的控制器。

案例代码：

package tacos.web;

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.ViewControllerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class WebConfig implements WebMvcConfigurer {

  @Override
  public void addViewControllers(ViewControllerRegistry registry) {
    registry.addViewController("/").setViewName("home");
  }

}

WebMvcConfigurer 接口： WebMvcConfigurer 定义了多个方法来配置 Spring MVC。尽管只是一个接口，但是它提供了所有方法的默认实现，只需要覆盖所需的方法即可。

addViewControllers() 方法会接收一个 ViewControllerRegistry 对象，我们可以使用它注册一个或多个视图控制器。在这里，我们调用 registry 的 addViewController() 方法，将“/” 传递了进去，视图控制器将会针对该路径执行 GET 请求。这个方法会返回 ViewControllerRegistration 对象，我们马上基于该对象调用了 setViewName() 方法，用它指明当请求“/” 的时候要转发到“ home” 视图上。

2. 5　选择视图模板库

Spring 非常灵活，能够支持很多常见的模板方案。通常需要配置。

JSP 并不需要在构建文件中添加任何特殊的依赖。这是因为 Servlet 容器本身（默认是 Tomcat）会实现 JSP，因此不需要额外的依赖。但是，如果你选择使用 JSP，会有另外一个问题。事实上， Java Servlet 容器包括嵌入式的Tomcat 和 Jetty 容器，通常会在“/ WEB- INF” 目录下寻找 JSP。如果我们将应用构建成一个可执行的 JAR 文件，就无法满足这种需求了。因此，只有在将应用构建为 WAR 文件并部署到传统的 Servlet 容器中时，才能选择 JSP 方案。如果你想要构建可执行的 JAR 文件，那么必须选择 Thymeleaf、 FreeMarker 或其他方案。

缓存模板

启用/ 禁用模板缓存的属性

FreeMarker 属性： spring. freemarker. cache
Groovy 属性： Templates spring. groovy. template. cache
Mustache 属性： spring. mustache. cache
Thymeleaf 属性： spring. thymeleaf. cache

默认情况下，这些属性都设置成了 true，以便于启用缓存。我们可以将缓存属性设置为 false，从而禁用所选模板引擎的缓存。例如，要禁用 Thymeleaf 缓存，我们只需要在 application. properties 中添加如下这行代码：

spring.thymeleaf.cache = false

唯一需要注意的是，在将应用部署到生产环境之前，一定要删除这一行代码（或者将其设置为 true）。

2. 6 　小结

Spring 提供了一个强大的 Web 框架，名为 Spring MVC，能够用来为 Spring 应用开发 Web 前端。
Spring MVC 是基于注解的，通过像@ RequestMapping、@ GetMapping 和@ PostMapping 这样的注解来启用请求处理方法的声明。
大多数的请求处理方法最终会返回一个视图的逻辑名称，比如 Thymeleaf 模板，请求会转发到这样的视图上（同时会带有任意的模型数据）。
Spring MVC 支持校验，这是通过 Java Bean Validation API 和 Validation API 的实现（如 Hibernate Validator）完成的。
对于没有模型数据和逻辑处理的 HTTP GET 请求，可以使用视图控制器。
除了 Thymeleaf 之外， Spring 支持各种视图方案，包括 FreeMarker、 Groovy Templates 和 Mustache。

晦暗天明

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
1
评论
《spring实战》学习笔记第二章开发Web应用

深入研究 Spring MVC 并会看到如何展现模型数据和处理表单输入。2. 1　展现信息关于@Date注解package tacos;import lombok.Data;import lombok.RequiredArgsConstructor;@Data@RequiredArgsConstructorpublic class Ingredient { private final String id; private final ..
复制链接

扫一扫