package com.charlie.web;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

/*
1. 当使用了SpringMVC框架，在一个类上标识 @Controller
2. 标识将该类视为一个控制器，注入到容器
3. 比原生servlet开发要简化很多
 */
@Controller
public class UserServlet {

    /* 编写方法，响应用户请求
    1. login() 方法是用于响应用户的登录请i去
    2. @RequestMapping(value = "/login") 类似于以前在原生Servlet中配置的 url-pattern，参数名value可以省略
    3. 即当用户在浏览器输入 http://localhost:8080/web工程路径/login 就能够访问到 login()
    4. return "login_ok"; 表示返回结果给视图解析器(InternalResourceViewResolver)
        ，视图解析器根据配置，来决定跳转到哪个页面
        <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
            <property name="prefix" value="/WEB-INF/pages/"/>
            <property name="suffix" value=".jsp"/>
        </bean>
        根据上面的配置 return "login_ok";  就是转发到 /WEB-INF/pages/login_ok.jsp
     */
    @RequestMapping(value = "/login")
    public String login() {
        System.out.println("login ok...");
        return "login_ok";
    }
}

package com.charlie.web;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;

@RequestMapping(value = "/user")
@Controller
public class UserHandler {

    /*
    1. method=RequestMethod.POST：表示请求buy目标方法必须是 post
    2. RequestMethod 四个常用选项 POST, GET, PUT, DELETE
    3. SpringMVC 控制器默认支持 GET 和 POST 两种方式，即指定method时，GET和POST方法都可以
    4. buy() 方法请求的url：http://localhost:8080/工程路径/user/buy
    5. @PostMapping (value = "/buy") 等价于 把 method=RequestMethod.POST 的 @RequestMapping 方法
     */
    //@RequestMapping(value = "/buy", method = RequestMethod.POST)
    @PostMapping (value = "/buy")
    public String buy() {
        System.out.println("购买商品");
        return "success";
    }
}

package com.charlie.web;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;

@RequestMapping(value = "/user")
@Controller
public class UserHandler {
   /*
   1. 要求：希望目标方法获取到 username 和 userId, value="/xx/{username}".@PathVariable("username")
   2. 前端页面：<a href="user/reg/kristina/300">占位符演示</a>
   3. value = "/reg/{username}/{userId}" 表示 charlie->{username} 21->{userId}
   4. @PathVariable("username") 需要与路径变量名 {username} 匹配，传入的参数名 String name 可以自定义
   */
   @RequestMapping(value = "/reg/{username}/{userId}")
   public String register(@PathVariable("username") String name, @PathVariable("userId") String id) {
      System.out.println("接收到参数：username=" + name + "，userId=" + id);
      return "success";
   }
}

package com.charlie.web.rest;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;

@Controller
@RequestMapping("/user")
public class BookHandler {  // 处理rest风格的请求-增删改查
    // 查询[GET]
    @GetMapping("/book/{id}")
    public String getBook(@PathVariable("id") String id) {
        System.out.println("查询书籍 id=" + id);
        return "success";
    }

    // 添加[PST]
    @PostMapping("/book")
    public String addBook(String bookName) {
        System.out.println("bookName=" + bookName);
        return "success";
    }

    // 删除[DELETE]
    @RequestMapping(value = "/book/{id}", method = RequestMethod.DELETE)
    public String delBook(@PathVariable("id") String id) {
        System.out.println("删除书籍 id=" + id);
        //return "success";   // 如果这样返回会报错：HTTP Status 405 - JSPs only permit GET POST or HEAD
        /* "redirect:/user/success" 重定向
        1. 第一个/在后端执行，会被解析成 /springmvc/user/success
         */
        return "redirect:/user/success";
    }

    // 如果请求是 /user/success，就转发到 success.jsp
    @RequestMapping("/success")
    public String successGeneral() {
        return "success";   // 由该方法转发到 success.jsp 页面
    }

    // 修改[PUT]
    @PutMapping("/book/{id}")
    public String updateBook(@PathVariable("id") String id) {
        System.out.println("修改书籍 id=" + id);
        return "redirect:/user/success";
    }
}

package com.charlie.web.requestparam;

@Controller
@RequestMapping("/vote")
public class VoteHandler {
    /* @RequestParam(value = "name", required = false)
    1. 获取到超链接传递的数据，请求 http://localhost:8080/springmvc/vote/vote01?name=charlie
    2. @RequestParam 表示会接收提交的参数
    3. value 表示提交的参数名是 name
    4. required=false 表示该参数可以没有；默认true，表示必须传递该参数
    5. 当使用了 @RequestParam(value = "name", required = false) 就将参数name指定给传入形参
     */
    @RequestMapping("/vote01")
    public String test01(@RequestParam(value = "name", required = false) String username) {
        System.out.println("得到的username=" + username);
        return "success";
    }
}

@Controller
@RequestMapping("/vote")
public class VoteHandler {
    /*
    需求：获取http请求头消息，获取到 Accept-Encoding 和 Host
    1. 这个涉及到前面讲过的http协议
    2. @RequestHeader("Http请求头字段")
     */
    @RequestMapping("/vote02")
    public String test02(@RequestHeader("Accept-Encoding") String ae, @RequestHeader("Host") String host) {
        System.out.println("Accept-Encoding=" + ae);
        System.out.println("Host=" + host);
        return "success";
    }
}

@Controller
@RequestMapping("/vote")
public class VoteHandler {
   // 获取servlet api，来获取提交的数据
   @RequestMapping("/vote04")
   public String test04(HttpServletRequest req, HttpServletResponse resp,
                        HttpSession hs) {

      // 获取到session
      HttpSession session = req.getSession();
      System.out.println("session=" + session);
      // 注意：通过参数传入的hs和req.getSession()得到的session对象是同一个对象
      System.out.println("hs=" + hs);

      String username = req.getParameter("username");
      String password = req.getParameter("password");
      System.out.println("username=" + username + "\npassword=" + password);
      return "success";
   }
}

public class VoteHandler {
   /* 演示将提交的数据封装到java对象，springmvc会自动将其放入到request域
   1. springmvc会自动将获取的model模型，放入到request域
   2. 也可以手动将master放入到request域，即 ("master", master)
   3. 这样就可以在跳转到的页面(vote_ok.jsp)，取出数据
   */
   @RequestMapping("/vote05")
   public String test05(Master master, HttpServletRequest req) {
      // 1) 手动添加request域数据
      req.setAttribute("address", "TianJin");
      // 2) 也可以修改master的属性值，根据引用机制，域中的数据也会改变
      master.setName("Charlie");
      // 3) springmvc默认存放对象到request域中，属性名是通过 request域 ("master", master)
      //      属性名：类型名首字母小写
      return "vote_ok";
   }
}

public class VoteHandler {
   // 演示通过Map<String, Object> 设置数据到request域
   @RequestMapping("/vote06")
   public String test06(Master master, Map<String, Object> map) {
      // 1. 需求：通过map对象，添加属性到request域
      // 2. 原理分析：springmvc会遍历map，将map的k-v存放到request域
      map.put("address", "HK");
      //map.put("master", null);  // 将request中k为master的值置为null
      return "vote_ok";
   }
}

public class VoteHandler {
   // 演示通过返回ModelAndView对象，将数据放入到request域
   @RequestMapping("/vote07")
   public ModelAndView test07(Master master) {
      ModelAndView modelAndView = new ModelAndView();
      // 放入属性到modelAndView对象，最终也会放入到request域中
      modelAndView.addObject("address", "CN");
      // 可以把从数据库中得到的数据对象，放入到modelAndView[service-dao-db]
      // 这里指定跳转的视图名称
      modelAndView.setViewName("vote_ok");
      return modelAndView;
   }
}

@RequestMapping("/vote")
public class VoteHandler {
   // 演示如何将数据设置到session中
   @RequestMapping("/vote08")
   public String test08(Master master, HttpSession httpSession) {
      // master对象是默认放在request域中，以下将对象放入到session中
      httpSession.setAttribute("master", master);
      httpSession.setAttribute("address", "JP");
      return "vote_ok";
   }
}

@RequestMapping("/vote")
public class VoteHandler {
   /*
   1. 当Handler的方法被表示 @ModelAttribute
   2. 当调用该Handler的其它方法时，都会先执行该前置方法
   3. 类似于Spring的AOP的前置通知
   4. prepareModel配置方法，会切入到其它方法前执行...
    */
   @ModelAttribute
   public void prepareModel() {
      System.out.println("prepareModel()-------完成准备工作----------");
   }
}

package com.charlie.web.viewresolver;

import org.springframework.stereotype.Component;
import org.springframework.web.servlet.view.AbstractView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Map;

/* 自定义视图
1. MyView 继承了 AbstractView，就可以作为一个视图使用
2. Component(value = "myView") 将视图注入到容器中，名字/id是 myView
 */
@Component(value = "myView")
public class MyView extends AbstractView {
    @Override
    protected void renderMergedOutputModel(Map<String, Object> model, HttpServletRequest request, HttpServletResponse response) throws Exception {
        // 完成视图渲染，并且可以确定要跳转的页面 /WEB-INF/page/my_view.jsp
        System.out.println("进入到自己的视图...");
        /*
        1. 下面就是进行请求转发到 /WEB-INF/pages/my_view.jsp，访问WEB-INF目录下资源需要使用请求转发
        2. /WEB-INF/pages/my_view.jsp 会被springmvc(服务器端)解析成 /springmvc/WEB-INF/pages/my_view.jsp
         */
        request.getRequestDispatcher("/WEB-INF/pages/my_view.jsp").forward(request, response);
    }
}

package com.charlie.web.viewresolver;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
@RequestMapping("/goods")
public class GoodsHandler {
    // 演示直接指定要请求转发的或者是重定向的页面
    @RequestMapping("/order")
    public String order() {
        System.out.println("==========order()=========");
        // 请求转发到 /WEB-INF/pages/my_view.jsp，会被解析到 /springmvc/WEB-INF/pages/my_view.jsp
        //return "forward:/WEB-INF/pages/my_view.jsp";

        /* 直接指定要重定向的页面
        1. 对于重定向来说，不能重定向到 /WEB/-INF/ 目录下
        2. redirect 关键字，表示进行重定向
        3. /login.jsp 会在服务器解析为 /springmvc/login.jsp
         */
        return "redirect:/login.jsp";
    }
}

public class Monster {
    private Integer id;
    private String email;
    
    @DateTimeFormat(pattern = "yyyy-MM-dd")
    private Date birthday;

    @NumberFormat(pattern = "###,###.##")
    private Float salary;
}

package com.charlie.web.datavalid;

import com.charlie.web.datavalid.entity.Monster;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Controller;
import org.springframework.validation.Errors;
import org.springframework.validation.ObjectError;
import org.springframework.web.bind.annotation.RequestMapping;

import javax.validation.Valid;
import java.util.List;
import java.util.Map;


/**
 * MonsterHandler处理器响应用户提交数据
 * @Scope(value = "prototype") 表示每次请求MonsterHandler会生成一个新的对象
 */
@Controller
@Scope(value = "prototype")
public class MonsterHandler {
    /**
     * 显示添加monster的界面
     * 1. 这里的Map<String, Object> map，当向map中添加数据时会默认存放在request域中
     */
    @RequestMapping(value = "/addMonsterUI")
    public String addMonsterUI(Map<String, Object> map) {
        map.put("monster", new Monster());
        // 如果跳转的页面使用了SpringMVC标签，那么就需要准备一个对象，放入request域中，这个对象的属性名monster
        //      对应表单标签的 modelAttribute="monster"
        return "datavalid/monster_addUI";
    }

    /* 编写方法，处理添加妖怪
    1. SpringMVC可以将提交的数据，按照参数名和对象的属性名匹配
    2. 直接封装到对象中
    3. @Valid Monster monster 表示对monster接收的数据进行校验
    4. Errors errors 表示如果校验出现错误，将校验错误信息保存到errors
    5. Map<String, Object> map 表示如果校验出现错误，将校验的错误信息保存到map，提示保存monster对象
    6. 校验发生的时机：在springmvc底层，反射调用目标方法时，会接收http请求的数据，然后根据注解来进行验证，
        在验证过程中，如果出现了错误，就把错误信息填充errors和map。底层：反射+注解
     */
    @RequestMapping(value = "/save")
    public String save(@Valid Monster monster, Errors errors, Map<String, Object> map) {
        System.out.println("------monster------" + monster);
        // 为了看到校验的效果，输出map和errors
        System.out.println("======== map ========");
        for (Map.Entry<String, Object> entry : map.entrySet()) {
            System.out.println("key=" + entry.getKey() + ", value=" + entry.getValue());
        }
        System.out.println("======== errors ========");
        if (errors.hasErrors()) {
            List<ObjectError> allErrors = errors.getAllErrors();
            for (ObjectError error : allErrors) {
                System.out.println("error=" + error);
            }
            return "datavalid/monster_addUI";
        }
        return "datavalid/success";
    }
}

package com.charlie.web.datavalid.entity;

import org.hibernate.validator.constraints.NotEmpty;
import org.hibernate.validator.constraints.Range;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.format.annotation.NumberFormat;

import javax.validation.constraints.NotNull;
import java.util.Date;

public class Monster {
    private Integer id;

    @NotEmpty(message = "邮箱不能为空")
    private String email;

    @NotNull(message = "年龄不能为空")
    // @Range(min = 1, max = 100) 表示接收的age值在1~100之间
    @Range(min = 1, max = 100)
    private Integer age;

    // @NotEmpty 表示name不能为空
    // Asserts that the annotated string, collection, map or array is not {@code null} or empty.
    //@NotEmpty
    private String name;

    @NotNull(message = "生日不能为空")
    @DateTimeFormat(pattern = "yyyy-MM-dd")
    private Date birthday;

    @NotNull(message = "薪水不能为空")
    @NumberFormat(pattern = "###,###.##")
    private Float salary;

    public Monster() {}
}

@Controller
@Scope(value = "prototype")
public class MonsterHandler {
    // 取消绑定monster的name表单提交的值给monster.name属性
    @InitBinder
    public void initBinder(WebDataBinder webDataBinder) {
        /*
        1. 方法上需要标注 @InitBinder，SpringMVC底层会初始化WebDataBinder
        2. 调用 webDataBinder.setDisallowedFields("name"); 表示取消指定属性的绑定，即
            当表单提交的字段为name时，就不再把接收到的name值填充到monster的name属性
        3. 机制：SpringMVC在底层通过反射调用方法时，会接收到http请求的参数和值，使用反射+注解技术，取消对指定属性的填充
        4. setDisallowedFields支持可变参数，可以填写多个字段，如 setDisallowedFields("name", "email");
        5. 如果取消某个属性绑定，验证也就没有意义了，应当把验证的注解去掉，否则可能会报错；name属性会使用默认值，即null
            // @NotEmpty
            private String name;
         */
        webDataBinder.setDisallowedFields("name");
    }
}

package com.charlie.web.filter;

import javax.servlet.*;
import java.io.IOException;

// 编写过滤器，处理中文乱码
public class MyCharacterFilter implements Filter {
   @Override
   public void init(FilterConfig filterConfig) throws ServletException {}

   @Override
   public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse,
                        FilterChain filterChain) throws IOException, ServletException {
      // 加入对编码的处理
      servletRequest.setCharacterEncoding("utf-8");
      // 放行请求，这个规则和JavaWeb中过滤器规则一致
      filterChain.doFilter(servletRequest, servletResponse);
   }

   @Override
   public void destroy() {}
}

package com.charlie.web.json;

import com.charlie.web.json.entity.Dog;
import com.charlie.web.json.entity.User;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.List;

// @ResponseBody可以写在Controller上对类进行注解，这样等价于在该类的所有方法上加上该注解
//@ResponseBody
//@Controller
@RestController // @ResponseBody + @Controller <==> @RestController
public class JsonHandler {

    /**
     * 1. 注解 @ResponseBody 表示返回的数据是json格式
     * 2. SpringMVC底层根据目标方法 @ResponseBody，返回指定格式，根据http请求来进行处理
     * 3. 底层原理在前面自定义@ResponseBody提到，这里原生的SpringMVC使用转换器
     * 4. HttpMessageConverter
     */
    @RequestMapping(value = "/json/dog")
    //@ResponseBody
    public Dog getJson() {
        // 返回对象，springmvc会根据设置，转成json格式数据
        Dog dog = new Dog();
        dog.setName("旺财");
        dog.setAddress("七里台");
        return dog;
    }

    // 编写方法，以json格式返回多个dog
    // @ResponseBody 支持返回集合
    @RequestMapping(value = "/json/dogs")
    //@ResponseBody
    public List<Dog> getJsons() {
        List<Dog> dogs = new ArrayList<>();
        dogs.add(new Dog("旺财", "七里台"));
        dogs.add(new Dog("小白", "八里台"));
        dogs.add(new Dog("阿宝", "张家界"));
        return dogs;
    }
}

package com.charlie.web.json;

import com.charlie.web.json.entity.Dog;
import com.charlie.web.json.entity.User;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.List;

// @ResponseBody可以写在Controller上对类进行注解，这样等价于在该类的所有方法上加上该注解
//@ResponseBody
//@Controller
@RestController // @ResponseBody + @Controller <==> @RestController
public class JsonHandler {
   /**
    * 1. @RequestBody User user 在形参上加上注解 @RequestBody，springMVC就会将提交的json字符串数据填充给指定的JavaBean
    * 2. 如果不添加注解 @RequestBody 的话，返回的数据为 User{userName='null', age=null}
    */
   @RequestMapping(value = "/json/user")
   //@ResponseBody
   public User getUser(@RequestBody User user) {
      // 将前台传过来的数据，以json个格式返回
      System.out.println(user);
      return user;
   }
}

// 因为请求/返回数据的类型都是JSON，所以会找到HttpMessageConverter的实现子类AbstractJackson2HttpMessageConverter
public abstract class AbstractJackson2HttpMessageConverter extends AbstractGenericHttpMessageConverter<Object> {
   /**
    * 处理JSON类型请求数据
    * @param javaType   @RequestBody注解修饰的传入参数：@RequestBody User user，即[simple type, class com.charlie.web.json.entity.User]
    * @param inputMessage 请求数据的封装
    */
    private Object readJavaType(JavaType javaType, HttpInputMessage inputMessage) throws IOException {
      // contentType：请求数据类型，application/json
      MediaType contentType = inputMessage.getHeaders().getContentType();
      // 请求的字符集：UTF-8
      Charset charset = getCharset(contentType);
      // 将请求的数据转换为指定格式(javabean->json)
      ObjectMapper objectMapper = selectObjectMapper(javaType.getRawClass(), contentType);
      Assert.state(objectMapper != null, "No ObjectMapper for " + javaType);

      boolean isUnicode = ENCODINGS.containsKey(charset.name()) ||
              "UTF-16".equals(charset.name()) ||
              "UTF-32".equals(charset.name());
      try {
         if (inputMessage instanceof MappingJacksonInputMessage) {
            Class<?> deserializationView = ((MappingJacksonInputMessage) inputMessage).getDeserializationView();
            if (deserializationView != null) {
               ObjectReader objectReader = objectMapper.readerWithView(deserializationView).forType(javaType);
               if (isUnicode) {
                  return objectReader.readValue(inputMessage.getBody());
               }
               else {
                  Reader reader = new InputStreamReader(inputMessage.getBody(), charset);
                  return objectReader.readValue(reader);
               }
            }
         }
         if (isUnicode) {
            return objectMapper.readValue(inputMessage.getBody(), javaType);
         }
         else {
            Reader reader = new InputStreamReader(inputMessage.getBody(), charset);
            return objectMapper.readValue(reader, javaType);
         }
      }
      catch (InvalidDefinitionException ex) {
         throw new HttpMessageConversionException("Type definition error: " + ex.getType(), ex);
      }
      catch (JsonProcessingException ex) {
         throw new HttpMessageNotReadableException("JSON parse error: " + ex.getOriginalMessage(), ex, inputMessage);
      }
   }

   /**
    * 处理响应数据
    * @param object 返回的javabean对象，即return user;
    * @param type   返回数据的类型 class com.charlie.web.json.entity.User
    * @param outputMessage  返回数据的封装，根据方法上的@ResponseBody可知要返回json数据格式的数据
    */
   @Override
   protected void writeInternal(Object object, @Nullable Type type, HttpOutputMessage outputMessage)
           throws IOException, HttpMessageNotWritableException {

      MediaType contentType = outputMessage.getHeaders().getContentType();  // application/json
      JsonEncoding encoding = getJsonEncoding(contentType); // UTF8

      Class<?> clazz = (object instanceof MappingJacksonValue ?
              ((MappingJacksonValue) object).getValue().getClass() : object.getClass());
      ObjectMapper objectMapper = selectObjectMapper(clazz, contentType);
      Assert.state(objectMapper != null, "No ObjectMapper for " + clazz.getName());

      OutputStream outputStream = StreamUtils.nonClosing(outputMessage.getBody());
      try (JsonGenerator generator = objectMapper.getFactory().createGenerator(outputStream, encoding)) {
         writePrefix(generator, object);

         Object value = object;
         Class<?> serializationView = null;
         FilterProvider filters = null;
         JavaType javaType = null;

         if (object instanceof MappingJacksonValue) {
            MappingJacksonValue container = (MappingJacksonValue) object;
            value = container.getValue();
            serializationView = container.getSerializationView();
            filters = container.getFilters();
         }
         if (type != null && TypeUtils.isAssignable(type, value.getClass())) {
            javaType = getJavaType(type, null);
         }

         ObjectWriter objectWriter = (serializationView != null ?
                 objectMapper.writerWithView(serializationView) : objectMapper.writer());
         if (filters != null) {
            objectWriter = objectWriter.with(filters);
         }
         if (javaType != null && javaType.isContainerType()) {
            objectWriter = objectWriter.forType(javaType);
         }
         SerializationConfig config = objectWriter.getConfig();
         if (contentType != null && contentType.isCompatibleWith(MediaType.TEXT_EVENT_STREAM) &&
                 config.isEnabled(SerializationFeature.INDENT_OUTPUT)) {
            objectWriter = objectWriter.with(this.ssePrettyPrinter);
         }
         objectWriter.writeValue(generator, value);

         writeSuffix(generator, object);
         generator.flush();
      }
      catch (InvalidDefinitionException ex) {
         throw new HttpMessageConversionException("Type definition error: " + ex.getType(), ex);
      }
      catch (JsonProcessingException ex) {
         throw new HttpMessageNotWritableException("Could not write JSON: " + ex.getOriginalMessage(), ex);
      }
   }
}

package com.charlie.web.json;

@RestController // @ResponseBody + @Controller <==> @RestController
public class JsonHandler {
    // 编写方法，相应用户下载文件的请求
    // 构建一个ResponseEntity对象：1) 下载的文件(响应体) 2) http响应头的headers 3) http响应状态
    @RequestMapping(value = "/downFile")
    public ResponseEntity<byte[]> downFile(HttpSession session) throws IOException {
        // 1. 先获取到要下载文件的inputStream
        InputStream resourceAsStream = session.getServletContext().getResourceAsStream("/img/1.png");
        // 2. 开辟一个存放文件的byte数组，使用byte数组可以支持二进制数据(图片、视频)
        byte[] bytes = new byte[resourceAsStream.available()];
        // 3. 将要下载文件的数据，读入到byte[]
        resourceAsStream.read(bytes);
        // 4. 创建返回的HttpStatus
        HttpStatus httpStatus = HttpStatus.OK;
        // 5. 创建headers
        HttpHeaders headers = new HttpHeaders();
        // 指定返回的数据，客户端应当以附件形式处理
        // Content-Type：指示相应内容的格式；Content-Disposition：指示如何处理响应内容
        headers.add("Content-Disposition", "attachment;filename=1.png");

        // 构建ResponseEntity<T>
        ResponseEntity<byte[]> responseEntity = new ResponseEntity<>(bytes, headers, httpStatus);
        return responseEntity;
    }
}

// 处理文件上传的handler
@Controller
public class FileUploadHandler {
    /**
     * 处理文件上传的请求
     * @param file 前端传入的参数名为file：<input type="file" name="file"/>
     *             参数MultipartFile file，即上传的文件
     */
    @RequestMapping(value = "/fileUpload")
    public String fileUpload(@RequestParam(value = "file") MultipartFile file, HttpServletRequest req, String introduce) throws IOException {
        // 接收到提交的文件名
        String fileName = file.getOriginalFilename();
        System.out.println("上传的文件名：" + fileName);
        System.out.println("文件介绍：" + introduce);
        // 得到要把上传的文件保存到哪个路径，全路径：包括文件名
        String fileFullPath = req.getServletContext().getRealPath("/img/" + fileName);
        System.out.println("保存文件的路径：" + fileFullPath);
        // 创建文件
        File saveToFile = new File(fileFullPath);
        // 将上传的文件，转存到saveToFile
        file.transferTo(saveToFile);
        return "success";
    }
}

package com.charlie.web.interceptor;

import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

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

// 拦截器需要注入到容器中，并且需要在spring配置文件中进行配置
@Component
public class MyInterceptor01 implements HandlerInterceptor {
    /**
     * 1. preHandler在目标方法执行前被执行
     * 2. 如果preHandler()返回false，则不再执行目标方法
     * 3. 该方法可以获取到 request, response, handler
     * 4. 这里根据业务，可以进行拦截，并指定跳转到哪个页面
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("--MyInterceptor01--preHandle()...");
        // 获取到用户提交的关键字
        String topic = request.getParameter("topic");
        if ("病毒".equals(topic)) {
            request.getRequestDispatcher("/WEB-INF/pages/warning.jsp").forward(request, response);
            return false;
        }
        System.out.println("得到的topic=" + topic);
        return true;
    }

    /**
     * 1. 在目标方法执行后，执行postHandle()方法
     * 2. 该方法可以获取到目标方法，返回的ModelAndView
     * 3.
     */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("--MyInterceptor01--postHandle()...");
    }

    /**
     * 1. 该方法afterCompletion()在视图渲染后被执行，这里可以进行资源请理工作
     */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("--MyInterceptor01--afterCompletion()...");
    }
}

package com.charlie.web.interceptor;
@Component
public class MyInterceptor02 implements HandlerInterceptor {
    /**
     * 1. pre方法再目标方法执行之前被调用
     * 2. 返回false，则不会再执行目标方法，可以再次响应请求返回页面
     * 3. 不管返回false，还是true，都会执行此拦截器之前的拦截器的afterCompletion方法。
     *      注意：不会执行当前拦截器的afterCompletion方法
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("--MyInterceptor02--preHandler()...");
        return false;
    }

    // 在目标方法被执行之后执行，可以在该方法中访问到目标方法返回的ModelAndView对象
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("--MyInterceptor02--postHandler()...");
    }

    /**
     * 1。若preHandle返回true，则方法在渲染视图之后被执行
     * 2. 若preHandle返回false，则该方法不会被调用
     * 3. 若当前拦截器的下一个拦截器的preHandle方法返回false，则在执行下一个拦截器preHandle方法后马上被执行
     */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("--MyInterceptor02--afterCompletion()...");
    }
}

package com.charlie.web.exception;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RequestMapping;

import javax.servlet.http.HttpServletRequest;

@Controller
public class MyExceptionHandler {
    /**
     * 1. localException方法用于处理局部异常
     * 2. 需要加上 @ExceptionHandler 注解，这里指定处理 算术异常和空指针异常
     * 3. Exception ex：生成的异常对象会传递给ex，通过ex可以得到相关的信息，这里可以加入自己的业务逻辑
     *
     * 当Handler中某方法中出现异常时，会首先在本类中寻找是否有@ExceptionHandler标注的异常处理方法，
     *  然后匹配注解中配置的异常类型，如果符合处理类型，则会将异常传给参数Exception ex并通过该方法进行异常如理；
     * 如果本类中无匹配的异常处理方法，就会查询@ControllerAdvice标注的异常类，进行全局异常处理
     */
    @ExceptionHandler({ArithmeticException.class, NullPointerException.class})
    public String localException(Exception ex, HttpServletRequest req) {
        System.out.println("局部异常信息：" + ex.getMessage());
        // 可以将异常信息带到下一个页面
        req.setAttribute("reason", ex.getMessage());
        return "exception_mes";
    }

    /**
     * 1. 编写方法，模拟异常(算术异常)
     * 2. 如果不做异常处理，则由tomcat默认页面显示，不太友好
     */
    @RequestMapping(value = "/testException01")
    public String test01(Integer num) {
        int i = 9 / num;
        return "success";
    }

    // 模拟抛出自定义异常AgeException
    @RequestMapping(value = "/testException02")
    public String test02() {
        throw new AgeException("年龄必须在1~120之间~~~");
    }

    // 模拟抛出数组越界异常
    @RequestMapping(value = "/testException03")
    public String test03() {
        int[] arr = new int[]{1, 8, 9, 5};
        // 抛出一个数组越界异常 ArrayIndexOutOfBoundsException
        System.out.println(arr[102]);
        return "success";
    }

    // 如果发生了没有归类的异常，可以给出统一提示页面
    @RequestMapping(value = "/testException04")
    public String test04() {
        String str = "China";
        // 这里会抛出StringIndexOutOfBoundsException，该异常没有匹配的局部/全局/自定义处理，
        // 而是作为未知异常的一种进行的统一异常处理，即 <prop key="java.lang.Exception">allEx</prop>
        char c = str.charAt(101);
        return "success";
    }

    @RequestMapping(value = "/testGlobalException")
    public String global() {
        // 1. 这里模拟了一个异常：NumberFormatException
        // 2. 该异常没有在局部异常处理，按照异常处理机制，就会交给全局异常处理类
        int num = Integer.parseInt("hello");
        return "success";
    }
}

package com.charlie.web.exception;

import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;

import javax.servlet.http.HttpServletRequest;

/**
 * 如果在类上标注了 @ControllerAdvice注解，则该类是一个全局异常类
 */
@ControllerAdvice
public class MyGlobalException {
    /**
     * 1. 全局异常就是不管哪个Handler抛出异常，都可以捕获
     * 2. 这里处理的全局异常有 数据格式异常和类转换异常
     * 3. 局部异常处理不了的异常，才会来到全局异常进行处理，如果全局异常仍没有匹配异常，就会显示tomcat默认异常
     * 4. 自定义异常也可以交给全局异常进行处理
     */
    @ExceptionHandler({NumberFormatException.class, ClassCastException.class, AgeException.class})
    public String globalException(Exception ex, HttpServletRequest req) {
        System.out.println("全局异常信息：" + ex.getMessage());
        // 将异常信息带到下一个页面
        req.setAttribute("reason", ex.getMessage());
        return "exception_mes";
    }
}

package com.charlie.web.exception;

import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.ResponseStatus;

// 注解信息是交由tomcat默认异常页面进行处理的
@ResponseStatus(reason = "年龄需要在1~120之间", value = HttpStatus.BAD_REQUEST)
public class AgeException extends RuntimeException {
    public AgeException() {}

    public AgeException(String message) {
        super(message);
    }
}