七、SpringMVC高级技术

/**
 * 描述:
 * 类【ServletConfig】
 *
 * @author ouYangHao
 * @create 2019-09-09 16:19
 */
/*相当于springmvc.xml*/
@Configuration
@EnableWebMvc
@ComponentScan(basePackages = "com.ooyhao.spring.**.controller")
public class ServletConfig{

    @Bean
    public MultipartResolver multipartResolver(){
        StandardServletMultipartResolver resolver = 
          new StandardServletMultipartResolver();
        return resolver;
    }

    @Bean
    public SpringResourceTemplateResolver templateResolver(){
        SpringResourceTemplateResolver resolver = 
          new SpringResourceTemplateResolver();
        resolver.setPrefix("/WEB-INF/templates/");
        resolver.setSuffix(".html");
        resolver.setCharacterEncoding("utf-8");
        resolver.setCacheable(true);
        resolver.setTemplateMode(TemplateMode.HTML);
        return resolver;
    }

    @Bean
    public SpringTemplateEngine templateEngine(){
        SpringTemplateEngine engine = new SpringTemplateEngine();
        engine.setTemplateResolver(templateResolver());
        engine.setEnableSpringELCompiler(true);
        return engine;
    }

    @Bean
    public ThymeleafViewResolver viewResolver(){
        ThymeleafViewResolver resolver = new ThymeleafViewResolver();
        resolver.setCharacterEncoding("utf-8");
        resolver.setTemplateEngine(templateEngine());
        return resolver;
    }
}

package com.ooyhao.spring.controller;

import com.ooyhao.spring.bean.User;
import com.ooyhao.spring.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.multipart.MultipartFile;

import javax.validation.Valid;
import java.io.File;
import java.io.IOException;

@Controller
public class IndexController {

    @Autowired
    private UserService userService;

    @GetMapping("/")
    public String home(){
        return "home";
    }

    @GetMapping("/register")
    public String toRegister(Model model){
        model.addAttribute("user",new User());
        return "register";
    }

    /*处理表单数据，并验证*/
    @PostMapping("/register")
    public String register(@Valid User user, MultipartFile file, 
                           BindingResult bindingResult, Model model) 
      throws IOException {
        if (bindingResult.hasErrors()){
            System.out.println("错误数目:" + bindingResult.getErrorCount());
            model.addAttribute(user);
            return "register";//注册失败，重新返回到注册页面
        }
        if (!file.isEmpty()){
            file.transferTo(
              new File(System.currentTimeMillis()
                       +file.getOriginalFilename().substring(
    						file.getOriginalFilename().indexOf("."))));
        }
        userService.saveUser(user);
        return "redirect:/registerSuccess";
    }

    @GetMapping("/registerSuccess")
    public String registerSuccess(){
        return "registerSuccess";
    }

    @GetMapping("/registerFail")
    public String registerFail(){
        return "registerFail";
    }
}

@PostMapping("/register")
public String register(@RequestPart("file") byte[] file){}


@PostMapping("/register")
public String register(@RequestPart("file") Part file){}

public interface MultipartFile extends InputStreamSource {

	String getName();

	@Nullable
	String getOriginalFilename();

	@Nullable
	String getContentType();

	boolean isEmpty();

	long getSize();

	byte[] getBytes() throws IOException;

	@Override
	InputStream getInputStream() throws IOException;

	default Resource getResource() {
		return new MultipartFileResource(this);
	}

	void transferTo(File dest) throws IOException, IllegalStateException;

	default void transferTo(Path dest) throws IOException, IllegalStateException {
		FileCopyUtils.copy(getInputStream(), Files.newOutputStream(dest));
	}
}

public class WebInit extends 
  AbstractAnnotationConfigDispatcherServletInitializer  {


    /*配置文件上传的一些参数*/
    /**
     *  MultipartConfigElement与 <multipart-config></multipart-config> 的默认值相同。
     *  都必须配置保存路径。
     * @param registration
     */
    @Override
    protected void customizeRegistration(
      ServletRegistration.Dynamic registration){
        MultipartConfigElement configElement = new MultipartConfigElement(
                "D:\\data\\upload\\",
                52428800,
                52428800,
                0);
        registration.setMultipartConfig(configElement);
    }

    @Override
    protected Class<?>[] getRootConfigClasses() {
        return new Class[]{
                RootConfig.class
        };
    }

    @Override
    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{
                ServletConfig.class
        };
    }

    @Override
    protected String[] getServletMappings() {
        return new String[]{
                "/"
        };
    }
}

package com.ooyhao.spring.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.FilterType;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;

@ComponentScan(basePackages = "com.ooyhao.spring", useDefaultFilters = true,excludeFilters = {
        @ComponentScan.Filter(type = FilterType.ANNOTATION,classes = EnableWebMvc.class)
})
@Configuration
public class RootConfig {

}

package com.ooyhao.spring.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.multipart.MultipartResolver;
import org.springframework.web.multipart.support.StandardServletMultipartResolver;
import org.springframework.web.servlet.config.annotation.DefaultServletHandlerConfigurer;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import org.thymeleaf.spring5.SpringTemplateEngine;
import org.thymeleaf.spring5.templateresolver.SpringResourceTemplateResolver;
import org.thymeleaf.spring5.view.ThymeleafViewResolver;
import org.thymeleaf.templatemode.TemplateMode;

@EnableWebMvc //开启webmvc
@ComponentScan(basePackages = "com.ooyhao.spring.**.controller")
@Configuration //标注为一个配置类
public class ServletConfig implements WebMvcConfigurer {

    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        configurer.enable();
    }

    /*配置文件上传*/
    @Bean
    public MultipartResolver multipartResolver(){
        StandardServletMultipartResolver resolver = new StandardServletMultipartResolver();
        return resolver;
    }

    /*配置模板解析器*/
    @Bean
    public SpringResourceTemplateResolver templateResolver(){
        SpringResourceTemplateResolver resolver =
                new SpringResourceTemplateResolver();
        resolver.setCacheable(true);
        resolver.setPrefix("/WEB-INF/templates/");
        resolver.setSuffix(".html");
        resolver.setCharacterEncoding("utf-8");
        resolver.setTemplateMode(TemplateMode.HTML);
        return resolver;
    }

    /*配置模板引擎*/
    @Bean
    public SpringTemplateEngine templateEngine(){
        SpringTemplateEngine engine = new SpringTemplateEngine();
        engine.setEnableSpringELCompiler(true);
        engine.setTemplateResolver(templateResolver());
        return engine;
    }

    /*配置视图解析器*/
    @Bean
    public ThymeleafViewResolver thymeleafViewResolver(){
        ThymeleafViewResolver resolver = new ThymeleafViewResolver();
        resolver.setTemplateEngine(templateEngine());
        resolver.setCharacterEncoding("utf-8");
        return resolver;
    }
}

package com.ooyhao.spring.controller;

import com.ooyhao.spring.bean.User;
import com.ooyhao.spring.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.multipart.MultipartFile;

import javax.validation.Valid;
import java.io.File;
import java.io.IOException;

@Controller
public class IndexController {

    @Autowired
    private UserService userService;

    @GetMapping("/")
    public String home(){
        return "home";
    }

    @GetMapping("/register")
    public String toRegister(Model model){
        model.addAttribute("user",new User());
        return "register";
    }

    /*处理表单数据，并验证*/
    @PostMapping("/register")
    public String register(@Valid User user, MultipartFile file, BindingResult bindingResult, Model model) throws IOException {
        if (bindingResult.hasErrors()){
            System.out.println("错误数目:" + bindingResult.getErrorCount());
            model.addAttribute(user);
            return "register";//注册失败，重新返回到注册页面
        }
        if (!file.isEmpty()){
            file.transferTo(new File(System.currentTimeMillis()+file.getOriginalFilename().substring(file.getOriginalFilename().indexOf("."))));
        }
        userService.saveUser(user);
        return "redirect:/registerSuccess";
    }

    @GetMapping("/registerSuccess")
    public String registerSuccess(){
        return "registerSuccess";
    }

    @GetMapping("/registerFail")
    public String registerFail(){
        return "registerFail";
    }
}

/*将参数写到路径上*/
@GetMapping("/article/{id}")
@ResponseBody
public Article article(@PathVariable(value = "id") Integer id){
    Article article = null;
    try{
      article = articleService.findArticleById(id);
    }catch (ArticleNotFoundException e){
      e.printStackTrace();
    }
    return article;
}

//Service:
public Article findArticleById(Integer id) {
  Article article = articles.get(id);
  if (article == null){
    throw new ArticleNotFoundException();
  }
  return article;
}


public class ArticleNotFoundException extends RuntimeException {}

@ResponseStatus(value = HttpStatus.NOT_FOUND,reason = "Not Found")
public class ArticleNotFoundException extends RuntimeException {}

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface ResponseStatus {

	@AliasFor("code")
	HttpStatus value() default HttpStatus.INTERNAL_SERVER_ERROR;

	@AliasFor("value")
	HttpStatus code() default HttpStatus.INTERNAL_SERVER_ERROR;

	String reason() default "";
}

@GetMapping("/article/{id}")
@ResponseBody
public Article article(@PathVariable(value = "id") Integer id){
 	Article article = articleService.findArticleById(id);
  	return article;
}

@ExceptionHandler(ArticleNotFoundException.class)
@ResponseBody
public Map<String,Object> handleNotFoundException(){
    Map<String,Object> map = new HashMap<>();
    map.put("code",404);
    map.put("message","数据未查询到");
    return map;
}

/**
@ExceptionHandler的作用主要在于声明一个或多个类型的异常，当符合条件的Controller抛出这些异常之后将会对这些异常进行捕获，然后按照其标注的方法的逻辑进行处理，从而改变返回的视图信息。
 */ 
@ControllerAdvice
public class SpringControllerAdvice {
    @ExceptionHandler(RuntimeException.class)
    public ModelAndView runtimeExceptionHandler(RuntimeException e) {
        e.printStackTrace();
        return new ModelAndView("error");
    }
}

/**
	对于@InitBinder，该注解的主要作用是绑定一些自定义的参数。一般情况下我们使用的参数通过@RequestParam，@RequestBody或者@ModelAttribute等注解就可以进行绑定了，但对于一些特殊类型参数，比如Date，它们的绑定Spring是没有提供直接的支持的，我们只能为其声明一个转换器，将request中字符串类型的参数通过转换器转换为Date类型的参数，从而供给@RequestMapping标注的方法使用。
*/
@ControllerAdvice
public class SpringControllerAdvice {
    @InitBinder
    public void globalInitBinder(WebDataBinder binder) {
        binder.addCustomFormatter(new DateFormatter("yyyy-MM-dd"));
  }
}

/**
关于@ModelAttribute的用法，除了用于方法参数时可以用于转换对象类型的属性之外，其还可以用来进行方法的声明。如果声明在方法上，并且结合@ControllerAdvice，该方法将会在@ControllerAdvice所指定的范围内的所有接口方法执行之前执行，并且@ModelAttribute标注的方法的返回值还可以供给后续会调用的接口方法使用。
 */ 
public class GlobalExceptionHandler {
	@ModelAttribute
  	//应用到所有@RequestMapping注解方法
 	 //此处将键值对添加到全局，注解了@RequestMapping的方法都可以获得此键值对
 	 public void addUser(Model model) { 
  		model.addAttribute("msg", "此处将键值对添加到全局，注解了@RequestMapping的方法都可以获得此键值对");
     }
}

@ControllerAdvice    
public class GlobalExceptionHandler {    

    private final static String ERROR_PAGE = "error";    
	
  	//异常处理
    @ExceptionHandler(Exception.class)    
    public ModelAndView handle(Exception e){     
        ModelAndView mv = new ModelAndView();    
        mv.addObject("message", e.getMessage());    
        mv.setViewName(ERROR_PAGE);    
        return mv;    
    }    

    @ModelAttribute
    //应用到所有@RequestMapping注解方法
    //此处将键值对添加到全局，注解了@RequestMapping的方法都可以获得此键值对
    public void addUser(Model model) { 
        model.addAttribute("msg", "此处将键值对添加到全局，注解了@RequestMapping的方法都可以获得此键值对");
    }  

    @InitBinder  
    //应用到所有@RequestMapping注解方法，在其执行之前初始化数据绑定器
    //用来设置WebDataBinder，用于自动绑定前台请求参数到Model中。
    public void initBinder(WebDataBinder binder) {  
    } 
}

/**
 * 描述:
 * 类【GlobalExceptionHandler】
 *
 * @author ouYangHao
 * @create 2019-09-10 10:51
 */
@ControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(ArticleNotFoundException.class)
    @ResponseBody
    public Map<String,Object> handleNotFoundException(){
        Map<String,Object> map = new HashMap<>();
        map.put("code",404);
        map.put("message","数据未查询到");
        return map;
    }
}

/*将参数写到路径上*/
  @GetMapping("/article/{id}")
  public String article(@PathVariable(value = "id") Integer id, Model model){
  model.addAttribute("id",id);
  model.addAttribute("username","ooyhao");
  return "redirect:/article/id/{id}";
}


@RequestMapping("/article/id/{id}")
@ResponseBody
public String articleId(@PathVariable(value = "id") Integer id){
  return "id:"+id;
}

@GetMapping("/article/{id}")
public String article(@PathVariable(value = "id") Integer id, RedirectAttributes attributes){
    Article article = articleService.findArticleById(id);
    attributes.addAttribute("id",id);
    attributes.addAttribute("username","ooyhao");
    attributes.addFlashAttribute(article);
    return "redirect:/article/id/{id}";
}


@RequestMapping("/article/id/{id}")
@ResponseBody
public Map<String,Object> articleId(@PathVariable(value = "id") Integer id,String username, Model model){
    Map<String,Object> map = new HashMap<>();
    map.put("id",id);
    map.put("username",username);
    map.put("article",model.asMap().get("article"));
    return map;
}