Spring Web MVC

// 1. 实现 Controller 接口，当然也可以直接使用其内置的实现类
// 2. 重写 handleRequest 方法
// 注意，方法的返回值是 ModelAndView
public class FooController implements Controller {
    @Override
    public ModelAndView handlerRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
        return new ModelAndView("home", "msg", "hello, this is from Controller interface"); // 返回 home 页面，携带 ${msg} 数据
    }
}
// <bean name="/foo" class="imdemo.controllers.FooController" />
// curl http://localhost:8888/foo

@Controller
public class FooController {
    @RequestMapping("/a")
    public ModelAndView aaa() {
        return new ModelAndView("home", "msg", "hello, this is from Controller interface");
    }
    @RequestMapping("/b")
    public String bbb(Model model) {
        model.addAttribute("msg", "hello, this is from Controller interface");
        return "home";
    }
}
// 不需要实现接口，简单，解耦合；一个 Controller 类可以有多个 handler
// 另注意，需要在配置中启用 Component-Scan

@Controller
public class BookController {
    @Autowired private BookService bookService;

    @RequestMapping(value="/books")
    public ModelAndView books () {
        return new ModelAndView("home", "books", bookService.findAll());
    }

    @RequestMapping(value = "/book/{publishDate}", method = RequestMethod.GET)
    public String getId(@RequestParam @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) Date publishDate, Model model) {
        model.addAttribute("books", bookService.findByPublishDate(publishDate));
        return "home";
    }

    @PostMapping(value = "/book")
    public String insert(@Valid Book book, BindingResult result, RedirectAttributes attributes) {
        if (result.hasErrors()) {
            return "input";
        }
        attributes.addAttribute("book", bookService.createBook(book));
        return "redirect: /books";
    }

    @DeleteMapping(value = "/book/{id}")
    public String delete(int id) {
        bookService.deleteById(id);
        return "home";
    }

    @GetMapping("/book/{p1}/{p2}")
    @ResponseBody
    public String bookPV(@PathVariable int p1, @PathVariable int p2, ModelMap map) {
        return String.valueOf(p1 + p2);
    }

    @GetMapping(value = "/book/{id:\\d{6}}-{name:[a-z]{3}}")
    public String bookWildcard(@PathVariable int id, @PathVariable String name, Model model) {
        model.addAttribute("message", "id: " + id + " name:" + name);
        return "debug";
    }

    // 注意，此功能需要在配置文件中启用
    @GetMapping(value = "/books/{id}") // GET /books/42;q=11;r=22
    public void findBook(@PathVariable String id, @MatrixVariable int q) {
        // id == 42
        // q == 11
    }
}
// @GetMapping/@PostMapping/@PutMapping/@DeleteMapping/@PatchMapping

// 请求内容类型必须为 text/html
@RequestMapping(value="/aaa", consumes="text/html");
// 客户端接收 json 且编码为 utf-8
@RequestMapping(value="/bbb", produces="application/json; charset=UTF-8");
// 请求的参数必须包含 id=215 与 name 不等于 abc
@RequestMapping(value="/ccc", params={"id=215", "name!=abc"});
// 请求头部信息中必须包含 Host=localhost:8888
@RequestMapping(value="/ddd", headers="Host=localhost:8888");

<filter>
  <filter-name>hmf</filter-name>
  <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
</filter>
<filter-mapping>
  <filter-name>hmf</filter-name>
  <url-pattern>/*</url-pattern>
</filter-mapping>

return new RedirectView("xxx");
return "redirect: /xxx";
return "forward: /xxx";

@RequestMapping("/")
public String aaa (RedirectAttributes attributes) {
    // 将会使用 url 重写方式。在下一个页面中，使用 ${param.msg} 访问
    attributes.addAttribute("msg", "url parameter");

    // 将会将数据保存在 session 中，下一次请求后清除掉，使用 ${gsm} 访问
    // 注意，这种方式，需要转发到一个新的 handler 请求，不能是一个 jsp
    attributes.addFlashAttribute("gsm", "session parameter");

    return "redirect: /xxx";
}

@InitBinder
public void init (WebDataBinder binder) {
    CustomDateEditor dateEditor = new CustomDateEditor(new SimpleDateFormat("yyyy-MM-dd"), true);
    binder.registerCustomEditor(Date.class, dateEditor);
}

public class MyDateConverter implements Converter<String, Date> {
    public Date convert(String datestr) {
        // 只是示例，实际要考虑更多，比如异常处理等
        return new SimpleDateFormat("yyyy-MM-dd").parse("2011-10-23");
    }
}

<bean name="conversionService" class="org.springframework.context.support.ConversionServiceFactoryBean">
  <property name="converters">
    <set>
      <bean class="imdemo.converter.MyDateConverter" />
    </set>
  </property>
</bean>

<mvc:annotation-driven conversion-service="conversionService" />

class Book {
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date created_at;
}

public class book {
    @notnull
    @size(min = 3, max = 10)
    private string name;

    @range(min = 10, max = 100)
    private int count;
}

public String submit(@Valid Book book, Errors errors) {
    if (errors.hasErrors()) {
        return "input";
    }
    System.out.println("normal flow");
    return "home";
}

public String add(Emp emp, Model model) {
    try {
        empService.addEmp(emp);
    } catch (DbException e) {
        model.addAttribute("msg", e);
        return "warn";
    } catch (DataException e) {
        model.addAttribute("msg", e.getMessage());
        return "input";
    } catch (MyBatisSystemException e) {
        return "unknown err";
    } catch (Exception e) {
        return "unknown err";
    }

    return "success";
}

public class MyExceptionResolver extends AbstractHandlerExceptionResolver {
    @Override
    protected ModelAndView doResolveException(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
        if (ex instanceof DbException) {
            return new ModelAndView("shujukucuowu");
        } else if (ex instanceof TypeMismatchException) {
            return new ModelAndView("shujukucuowu");
        }
        return null;
    }
}

<bean id="exceptionResolver" class="com.nf147.test01.exceptionhandler.MyExceptionResolver" />

@Controller
@RequestMapping("/eee")
public class Emp3Controller {

    @Autowired
    private EmpService empService;

    @RequestMapping(method = RequestMethod.POST, produces = "text/plain; charset=UTF-8")
    public String add(Emp emp, Model model) throws Exception {
        empService.addEmp(emp);
        return "success";
    }

    @RequestMapping(method = RequestMethod.GET)
    public String selectAll(Model model) {
        List<Emp> empList = empService.selectAll();
        model.addAttribute("empList", empList);
        return "emp_index";
    }



    // 下面这些注解，只能作用于本类之中

    @ExceptionHandler(DbException.class)
    public String handlerDbException (Exception ex, Model model, WebRequest request) {
        model.addAttribute("err", ex.getMessage());
        return "err1"; // 默认返回 status 200
    }

    @ExceptionHandler(DataException.class)
    @ResponseStatus(value = HttpStatus.NOT_FOUND, reason = "数据库的错误")
    public ModelAndView handlerDbException2 () {
        return new ModelAndView("err2");
    }

    @ExceptionHandler(Exception.class)
    public ResponseEntity handlerDbException4 () {
        return ResponseEntity.status(333).body("dkfjs");
    }
}

@Component
@ControllerAdvice
public class AllControllerAdvice {
    // 这个处理，对所有的 Controller 都会有效
    @ExceptionHandler(Exception.class)
    @ResponseStatus(value = HttpStatus.URI_TOO_LONG)
    @ResponseBody
    public String handlerDbException3 () {
        return "ksjfksd";
    }

    @ExceptionHandler(RuntimeException.class)
    public String handlerDbException4 () {
        return "runtime";
    }
}

<table>
  <thead>
    <tr>
      <th th:text="#{msgs.headers.name}">Name</th>
      <th th:text="#{msgs.headers.price}">Price</th>
    </tr>
  </thead>
  <tbody>
    <tr th:each="prod: ${allProducts}">
      <td th:text="${prod.name}">Oranges</td>
      <td th:text="${#numbers.formatDecimal(prod.price, 1, 2)}">0.99</td>
    </tr>
  </tbody>
</table>

<servlet>
  <servlet-name>mvc</servlet-name>
  <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

  <multipart-config>
    <max-file-size>5242880</max-file-size>        <!-- 上传文件的大小限制，比如下面表示 5 M -->
    <max-request-size>10485760</max-request-size> <!-- 一次表单提交中文件的大小限制，必须下面代表 10 M -->
    <file-size-threshold>0</file-size-threshold>  <!-- 多大的文件会被自动保存到硬盘上。0 代表所有 -->
  </multipart-config>
</servlet>

<bean id="multipartResolver" class="org.springframework.web.multipart.support.StandardServletMultipartResolver" />

<form:form action="/file/upload" method="post" enctype="multipart/form-data">
  <input type="file" name="mfile" />
  <input name="desc" placeholder="文件描述" />
  <input type="submit" value="上传" />
</form:form>

@PostMapping("/upload")
public String upload(MultipartFile mfile) throws Exception {
    String savePath = "xxx";
    if(!mfile.isEmpty()) {
        mfile.transferTo(new File(savePath + mfile.getOriginalFilename()));
    }
    return "file/index";
}

@GetMapping(value = "/download")
ResponseEntity<InputStreamResource> downloadFile() throws IOException {
    FileSystemResource file = new FileSystemResource("/home/vip/logo.png");

    HttpHeaders headers = new HttpHeaders();
    headers.setCacheControl("no-cache, no-store, must-revalidate");
    headers.setContentType(MediaType.APPLICATION_OCTET_STREAM);
    headers.setContentLength(file.contentLength());
    headers.setContentDispositionFormData("attachment", file.getFilename());

    return ResponseEntity.ok().headers(headers).body(new InputStreamResource(file.getInputStream()));
}

@PostMapping("/book")
public String imageshangchuan(MultipartFile ufile, Model model, HttpServletRequest request, @Valid Book book, BindingResult bookResult) {
    if (bookResult.hasErrors()) {
        return "book_input";
    }

    List<String> errors = new ArrayList<>();
    if (ufile.isEmpty()) {
        errors.add("文件为空错误");
    }
    if (ufile.getSize() > 1024 * 1024 * 5) {
        errors.add("文件超出大小，请重新选择！");
    }
    if (!ufile.getContentType().contains("image/")) {
        errors.add("只允许上传图片文件！");
    }
    if (!errors.isEmpty()) {
        model.addAttribute("errs", errors);
        return "book_input";
    }

    String basePath = request.getServletContext().getRealPath("/img");
    String relativePath; // 图片的保存路径
    try {
        relativePath = makeRelativePath(ufile.getOriginalFilename());
        File target = new File(basePath + relativePath);
        target.getParentFile().mkdir();
        ufile.transferTo(target);
    } catch (IOException e) {
        model.addAttribute("err", "文件上传失败，请重试！");
        return "book_input";
    }

    book.setCover(relativePath);
    try {
        System.out.println("对" + book + "进行保存等操作");
    } catch (Exception e) {
        // 实际业务中，要考虑异常的处理
        model.addAttribute("err", "something");
        return "book_input";
    }
    return "book_home";
}

public String makeRelativePath(String fileName) {
    Date now = new Date();
    String[] fileNames = splitFileString(fileName);
    return String.format("%s%s%supload_%s_%s.%s",
                         File.separator,
                         new SimpleDateFormat("yyyyMMdd").format(now),
                         File.separator,
                         fileNames[0],
                         new SimpleDateFormat("hhmmss").format(now),
                         fileNames[1]
                         );
}

public String[] splitFileString(String fileName) {
    int dotPos = fileName.lastIndexOf(".");
    String ext = fileName.substring(dotPos + 1);
    String name = fileName.substring(0, dotPos);
    return new String[]{name, ext};
}

public class MyCorsFilter extends CorsFilter {
    public MyCorsFilter() {
        super(configurationSource());
    }

    private static UrlBasedCorsConfigurationSource configurationSource() {
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();

        CorsConfiguration config = new CorsConfiguration();
        config.setAllowedOrigins(Collections.singletonList("http://domain.com"));
        config.setAllowCredentials(true);

        CorsConfiguration config2 = new CorsConfiguration();
        config2.setAllowedOrigins(Collections.singletonList("http://domain.com"));
        config2.setAllowCredentials(true);

        source.registerCorsConfiguration("/**", config);
        source.registerCorsConfiguration("/xxx", config2);

        return source;
    }
}

<mvc:cors>
  <mvc:mapping path="/xxx"
               allowed-origins="http://localhost:7070"
               allowed-methods="GET, POST"
               allowed-headers="Accept-Charset, Accept, Content-Type"
               allow-credentials="true" />
  <mvc:mapping path="/yyy/*"
               allowed-origins="*"
               allowed-methods="*"
               allowed-headers="*" />
</mvc:cors>

// 将跨域设置在类上，那么所有的 mapping 都会使用这个策略
// 如果不加参数，那么将会使用配置中的默认参数
@CrossOrigin
public class CORSController {
    public String cors(@RequestParam(defaultValue = "callback") String callback, HttpServletResponse response) {
        // 最原始的方式，手动写请求头
        response.setHeader("Access-Control-Allow-Origin", "http://192.168.163.1:8081");
        return callback + "('hello')";
    }


    // 将跨域设置在方法上
    @RequestMapping("/cors")
    @CrossOrigin(origins = {"http://localhost:8080", "http://remotehost:82323"},
                 methods = {RequestMethod.GET, RequestMethod.POST},
                 allowedHeaders = {"Content-Type", "skfjksdjfk"},
                 allowCredentials = "true",
                 maxAge = 1898978
                 )
    @RequestMapping("/rrr")
    public String rrr(@RequestParam(defaultValue = "callback") String callback) {
        return callback + "('rrr')";
    }
}

// 请求内容类型必须为 text/html
@RequestMapping(value="/aaa", consumes="text/html");

// 客户端接收 json 且编码为 utf-8
@RequestMapping(value="/bbb", produces="application/json; charset=UTF-8");

<!--启用 mvc 的常用注解-->
<mvc:annotation-driven validator="myValidator" conversion-service="conversionService">
    <mvc:message-converters>
        <!--@ResponseBody 的 UTF-8 编码-->
        <bean class="org.springframework.http.converter.StringHttpMessageConverter">
            <constructor-arg value="UTF-8"/>
        </bean>

        <!-- Fail On Empty Beans... -->
        <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
            <property name="objectMapper">
                <bean class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean">
                    <property name="failOnEmptyBeans" value="false"/>
                </bean>
            </property>
        </bean>
    </mvc:message-converters>
</mvc:annotation-driven>