Spring MVC

1. 简介

Spring Web MVC是基于Servlet API构建的原始Web框架，从一开始就包含在Spring Framework中。正式名称“Spring Web MVC”来自其源模块的名称（ spring-webmvc ），但它通常被称为“Spring MVC”。

Spring MVC 的作用主要覆盖的是表述层，例如：请求映射、数据输入、视图界面、请求分发等等

2. 核心组件与调用流程

Spring MVC与许多其他Web框架一样，是围绕前端控制器模式设计的，其中中央 Servlet DispatcherServlet 做整体请求处理调度

SpringMVC涉及组件理解：

1. DispatcherServlet : SpringMVC提供，我们需要使用web.xml配置使其生效，它是整个流程处理的核心，所有请求都经过它的处理和分发！[ CEO ]
2. HandlerMapping : SpringMVC提供，我们需要进行IoC配置使其加入IoC容器方可生效，它内部缓存handler(controller方法)和handler访问路径数据，被DispatcherServlet调用，用于查找路径对应的handler。[秘书]
3. HandlerAdapter : SpringMVC提供，我们需要进行IoC配置使其加入IoC容器方可生效，它可以处理请求参数和处理响应数据数据，每次DispatcherServlet都是通过handlerAdapter间接调用handler，他是handler和DispatcherServlet之间的适配器。[经理]
4. Handler : handler又称处理器，他是Controller类内部的方法简称，是由我们自己定义，用来接收参数，向后调用业务，最终返回响应结果！[打工人]
5. ViewResovler : SpringMVC提供，我们需要进行IoC配置使其加入IoC容器方可生效，视图解析器主要作用简化模版视图页面查找的，但是需要注意，前后端分离项目，后端只返回JSON数据，不返回页面，那就不需要视图解析器。所以，视图解析器，相对其他的组件不是必须的。[财务]

3. 入门使用

1. 导入依赖

<properties>
    <spring.version>6.0.6</spring.version>
    <servlet.api>9.1.0</servlet.api>
    <maven.compiler.source>17</maven.compiler.source>
    <maven.compiler.target>17</maven.compiler.target>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>

<dependencies>
    <!-- springioc相关依赖  -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <!-- web相关依赖  -->
    <!-- 在 pom.xml 中引入 Jakarta EE Web API 的依赖 -->
    <!--
        在 Spring Web MVC 6 中，Servlet API 迁移到了 Jakarta EE API，因此在配置 DispatcherServlet 时需要使用
         Jakarta EE 提供的相应类库和命名空间。错误信息 “‘org.springframework.web.servlet.DispatcherServlet’
         is not assignable to ‘javax.servlet.Servlet,jakarta.servlet.Servlet’” 表明你使用了旧版本的
         Servlet API，没有更新到 Jakarta EE 规范。
    -->
    <dependency>
        <groupId>jakarta.platform</groupId>
        <artifactId>jakarta.jakartaee-web-api</artifactId>
        <version>${servlet.api}</version>
        <scope>provided</scope>
    </dependency>
    <!-- springwebmvc相关依赖  -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>${spring.version}</version>
    </dependency>
</dependencies>

2. 编写配置类实现 WebMvcConfigurer 接口：需注入 HandlerMapping 和 HandlerAdapter 到 IoC 容器中，使用 @EnableWebMvc 即可自动注入

@EnableWebMvc
@ComponentScan("com.springmvc")
@Configuration
public class SpringMVCConfig implements WebMvcConfigurer {
}

3. 配置 web.xml 或 AbstractAnnotationConfigDispatcherServletInitializer 实现类：这里用 Java类实现代替 web.xml的实现；如果用web.xml实现的话需配置 DispatcherServlet

public class MyWebAppInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {
    // 这个是指定 root IoC 容器配置类使用，待后面 SSM 整合再使用
	@Override
	protected Class<?>[] getRootConfigClasses() {
		return new Class[0];
	}

	@Override
	protected Class<?>[] getServletConfigClasses() {
		return new Class[]{SpringMVCConfig.class}; // 这里填配置类
	}

	@Override
	protected String[] getServletMappings() {
		return new String[]{"/"}; // 配置 servlet 拦截所有请求
	}
}

4. 添加访问接口：访问 项目名/hello/world 即可得到结果（一般会乱码）

@RequestMapping("hello")
@RestController
public class HelloController {

    // 访问地址 /hello/world
	@RequestMapping("world")
	public String hello() {
		return "我的妈呀,666";
	}
}

4. SpringMVC接收数据

4.1 访问路径设置

@RequestMapping 注解的作用就是将请求的 URL 地址和处理请求的方式（handler方法）关联起来，建立映射关系。

@RequestMapping 注解可以用于类级别和方法级别，用在类上则表示控制器上的通用请求路径和处理方法，方法上则表示对应方法的请求路径和处理方法

更多不同处理方法映射注解：这些注解只能在方法上，不能在类上

• @GetMapping
• @PostMapping
• @PutMapping
• @DeleteMapping
• @PatchMapping

4.2 接收参数（重点）

4.2.1 param 和 json参数比较

在 HTTP 请求中，我们可以选择不同的参数类型，如 param 类型和 JSON 类型。下面对这两种参数类型进行区别和对比：

1. 参数编码：

   param 类型的参数会被编码为 ASCII 码。例如，假设 name=john doe，则会被编码为 name=john%20doe。而 JSON 类型的参数会被编码为 UTF-8。

2. 参数顺序：

   param 类型的参数没有顺序限制。但是，JSON 类型的参数是有序的。JSON 采用键值对的形式进行传递，其中键值对是有序排列的。

3. 数据类型：

   param 类型的参数仅支持字符串类型、数值类型和布尔类型等简单数据类型。而 JSON 类型的参数则支持更复杂的数据类型，如数组、对象等。

4. 嵌套性：

   param 类型的参数不支持嵌套。但是，JSON 类型的参数支持嵌套，可以传递更为复杂的数据结构。

5. 可读性：

   param 类型的参数格式比 JSON 类型的参数更加简单、易读。但是，JSON 格式在传递嵌套数据结构时更加清晰易懂。

总的来说，param 类型的参数适用于单一的数据传递，而 JSON 类型的参数则更适用于更复杂的数据结构传递。根据具体的业务需求，需要选择合适的参数类型。在实际开发中，常见的做法是：在 GET 请求中采用 param 类型的参数，而在 POST 请求中采用 JSON 类型的参数传递。

4.2.2 param参数接收

1. 简单类型：只要形参数名和类型与传递参数相同，即可自动接收
2. 实体接收：属性名需与 param 参数名相同，java中将调用对应 set 方法给实体类对象设置值
3. @RequestParam注解 ：将 Servlet 请求参数（即查询参数或表单数据）绑定到控制器中的方法参数
   • required ：默认 true
   • defaultValue ：可填写默认值
   • name | value ：指定参数名
4. 特殊场景：相同参数名多个值可用集合接收，但必须使用 @RequestParam 注解

4.2.3 路径参数接收

首先在 @RequestMapping("/user/{id}/{name}") 使用 {} 定义参数名

在形参中使用 @PathVariable 指定路径参数，参数名相同将自动赋值，否则需指定对应路径中的参数名：

@GetMapping("/user/{id}/{name}")
@ResponseBody
public String getUser(@PathVariable Long id, 
                      @PathVariable("name") String uname) {
    System.out.println("id = " + id + ", uname = " + uname);
    return "user_detail";
}

4.2.4 json参数接收

首先需要导入 json 解析依赖

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.15.0</version>
</dependency>

并在配置类上添加 @EnableWebMvc 注解，或在 web.xml 中配置 <mvc:annotation-driven> 标签，该注解会完成以下动作

• 将 handlerMapping 加入到 IoC 容器中
• 将 handlerAdapter 加入到 IoC 容器中
• 添加 jackson 转化器

用实体类接收 json 数据，需使用 @RequestBody 注解接收数据

@PostMapping("/person")
@ResponseBody
public String addPerson(@RequestBody Person person) {
  return "success";
}

4.3 接收Cookie数据和接收请求头数据

可以使用 @CookieValue 注释将 HTTP Cookie 的值绑定到控制器中的方法参数。

可以使用 @RequestHeader 批注将请求标头绑定到控制器中的方法参数。

4.4 原生 API 对象

如果想要获取请求或者响应对象，或者会话等，可以直接在形参列表传入，并且不分先后顺序

支持的原生API对象：https://docs.spring.io/spring-framework/reference/web/webmvc/mvc-controller/ann-methods/arguments.html

Controller method argument 控制器方法参数	Description
jakarta.servlet.ServletRequest, jakarta.servlet.ServletResponse	请求/响应对象
jakarta.servlet.http.HttpSession	强制存在会话。因此，这样的参数永远不会为 null 。
java.io.InputStream, java.io.Reader	用于访问由 Servlet API 公开的原始请求正文。
java.io.OutputStream, java.io.Writer	用于访问由 Servlet API 公开的原始响应正文。
@PathVariable	接收路径参数注解
@RequestParam	用于访问 Servlet 请求参数，包括多部分文件。参数值将转换为声明的方法参数类型。
@RequestHeader	用于访问请求标头。标头值将转换为声明的方法参数类型。
@CookieValue	用于访问Cookie。Cookie 值将转换为声明的方法参数类型。
@RequestBody	用于访问 HTTP 请求正文。正文内容通过使用 HttpMessageConverter 实现转换为声明的方法参数类型。
java.util.Map, org.springframework.ui.Model, org.springframework.ui.ModelMap	共享域对象，并在视图呈现过程中向模板公开。
Errors, BindingResult	验证和数据绑定中的错误信息获取对象！

5. SpringMVC响应数据

5.1 页面跳转控制

该小节内容现在基本不再使用，因为现在的主要开发模式都是使用前后端分离模式后端一般返回 Json 数据，故本节粗略记录。

配置jsp视图解析器：

@EnableWebMvc
@Configuration
@ComponentScan(basePackages = "com.springmvc.controller")
public class SpringMvcConfig implements WebMvcConfigurer {

    //配置jsp对应的视图解析器
    @Override
    public void configureViewResolvers(ViewResolverRegistry registry) {
        //快速配置jsp模板语言对应的
        registry.jsp("/WEB-INF/views/",".jsp");
    }
}

返回视图：除以下方式，也可将返回类型改为 void 同时用参数 ModelAndView 类型指定数据和视图

// 使用字符串类型即可返回 jsp 页面 ，前缀即上面配置的 /WEB-INF/views/ 后缀即上面配置的 .jsp
@GetMapping("jump")
public String jumpJsp(Model model){
    System.out.println("FileController.jumpJsp");
    model.addAttribute("msg","request data!!");
    return "home";
}

转发和重定向，返回以下字符串

• "redirect:/demo" ：重定向
• "forward:/demo" ：转发

5.2 返回JSON数据（重点）

前置准备：参考4.2.4，需先导入 jackson 依赖，并启用 @EnableWebMvc 注解

• @ResponseBody 注解：写在方法上或者类上，在类上代表类中的所有方法以 json形式返回数据
• @RestController 注解：写在类上，相当于类上既写了 @Controller 注解，又写了 @ResponseBody 注解

5.3 返回静态资源

资源本身已经是可以直接拿到浏览器上使用的程度了，不需要在服务器端做任何运算、处理。典型的静态资源包括图片、纯HTML文件。

如果将图片放在 webapp/images 目录下，直接通过 localhost:8080/images/1.jpg 将无法直接获取到

问题分析

• DispatcherServlet 的 url-pattern 配置的是“/”
• url-pattern 配置“/”表示整个 Web 应用范围内所有请求都由 SpringMVC 来处理
• 对 SpringMVC 来说，必须有对应的 @RequestMapping 才能找到处理请求的方法
• 现在 images/mi.jpg 请求没有对应的 @RequestMapping 所以返回 404

解决方案：开启静态资源处理，当找不到对应请求路径，且对应路径存在静态资源时可直接访问

@EnableWebMvc
@ComponentScan("com.springmvc")
@Configuration
public class SpringMVCConfig implements WebMvcConfigurer {

    // 开启静态资源处理 <mvc:default-servlet-handler/>
	@Override
	public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
		configurer.enable();
	}

}

6. RESTFul风格设计

RESTful（Representational State Transfer）是一种软件架构风格，用于设计网络应用程序和服务之间的通信。它是一种基于标准 HTTP 方法的简单和轻量级的通信协议，广泛应用于现代的Web服务开发。

个人吐槽：目前还没见过真正按这个规范开发的，这么开发也不一定方便，前端需要不断切换不同请求方式，且有的业务不仅仅是下面几种处理方式，不同人对业务的理解可能会有一定歧意，不如 Post 到底

风格设计规范：

1. HTTP协议请求方式要求

REST 风格主张在项目设计、开发过程中，具体的操作符合HTTP协议定义的请求方式的语义。

操作	请求方式
查询操作	GET
保存操作	POST
删除操作	DELETE
更新操作	PUT

2. URL路径风格要求

REST风格下每个资源都应该有一个唯一的标识符，例如一个 URI（统一资源标识符）或者一个 URL（统一资源定位符）。资源的标识符应该能明确地说明该资源的信息，同时也应该是可被理解和解释的

使用URL+请求方式确定具体的动作，他也是一种标准的HTTP协议请求

操作	传统风格	REST 风格
保存	/CRUD/saveEmp	URL 地址：/CRUD/emp 请求方式：POST
删除	/CRUD/removeEmp?empId=2	URL 地址：/CRUD/emp/2 请求方式：DELETE
更新	/CRUD/updateEmp	URL 地址：/CRUD/emp 请求方式：PUT
查询	/CRUD/editEmp?empId=2	URL 地址：/CRUD/emp/2 请求方式：GET

7. SpringMVC其他扩展

7.1 全局异常处理机制

对于异常的处理，一般分为两种方式：

• 编程式异常处理：是指在代码中显式地编写处理异常的逻辑。它通常涉及到对异常类型的检测及其处理，例如使用 try-catch 块来捕获异常，然后在 catch 块中编写特定的处理代码，或者在 finally 块中执行一些清理操作。在编程式异常处理中，开发人员需要显式地进行异常处理，异常处理代码混杂在业务代码中，导致代码可读性较差。
• 声明式异常处理：则是将异常处理的逻辑从具体的业务逻辑中分离出来，通过配置等方式进行统一的管理和处理。在声明式异常处理中，开发人员只需要为方法或类标注相应的注解（如 @Throws 或 @ExceptionHandler），就可以处理特定类型的异常。相较于编程式异常处理，声明式异常处理可以使代码更加简洁、易于维护和扩展。

基于注解异常声明异常处理：

1. 声明异常处理控制器类 ：@RestControllerAdvice 或 @ControllerAdvice ，注意：要确保该类能被组件扫描到

/**
 * @RestControllerAdvice = @ControllerAdvice + @ResponseBody 使用这个前需确保已经引入 jackson 依赖
 * @ControllerAdvice 代表当前类的异常处理controller! 
 */
@RestControllerAdvice
public class GlobalExceptionHandler {
  
}

2. 声明异常处理hander方法：@ExceptionHandler ，返回值的处理与 Controller 返回一样处理

/**
 * 异常处理handler 
 * @ExceptionHandler(HttpMessageNotReadableException.class) 
 * 该注解标记异常处理Handler,并且指定发生异常调用该方法
 */
@ExceptionHandler(HttpMessageNotReadableException.class)
public Object handlerJsonDateException(HttpMessageNotReadableException e){
    return null;
}

/**
 * 当发生空指针异常会触发此方法
 */
@ExceptionHandler(NullPointerException.class)
public Object handlerNullException(NullPointerException e){
    return null;
}

/**
 * 所有异常都会触发此方法，但是如果有具体的异常处理Handler，具体异常处理Handler优先级更高。
 * 例如: 发生NullPointerException异常，会触发handlerNullException方法,不会触发handlerException方法
 */
@ExceptionHandler(Exception.class)
public Object handlerException(Exception e){
    return null;
}

7.2 Spring MVC 拦截器

拦截器 Springmvc VS 过滤器 javaWeb：

• 相似点
  • 拦截：必须先把请求拦住，才能执行后续操作
  • 过滤：拦截器或过滤器存在的意义就是对请求进行统一处理
  • 放行：对请求执行了必要操作后，放请求过去，让它访问原本想要访问的资源
• 不同点
  • 工作平台不同
    • 过滤器工作在 Servlet 容器中
    • 拦截器工作在 SpringMVC 的基础上
  • 拦截的范围
    • 过滤器：能够拦截到的最大范围是整个 Web 应用
    • 拦截器：能够拦截到的最大范围是整个 SpringMVC 负责的请求
  • IOC 容器支持
    • 过滤器：想得到 IOC 容器需要调用专门的工具方法，是间接的
    • 拦截器：它自己就在 IOC 容器中，所以可以直接从 IOC 容器中装配组件，也就是可以直接得到 IOC 容器的支持

选择：用 SpringMVC 的拦截器能够实现，就不使用过滤器。

拦截器的使用：

1. 创建拦截器类

public class Process01Interceptor implements HandlerInterceptor {


    // 在处理请求的目标 handler 方法前执行。返回true：放行 false：不放行
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("request = " + request + ", response = " + response + ", handler = " + handler);
        System.out.println("Process01Interceptor.preHandle");
        return true;
    }
 
    // 在目标 handler 方法之后，handler报错不执行
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("request = " + request + ", response = " + response + ", handler = " + handler + ", modelAndView = " + modelAndView);
        System.out.println("Process01Interceptor.postHandle");
    }
 
    // 渲染视图之后执行(最后),一定执行
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("request = " + request + ", response = " + response + ", handler = " + handler + ", ex = " + ex);
        System.out.println("Process01Interceptor.afterCompletion");
    }
}

对应方法执行位置：

2. 配置类添加拦截器：重写 addInterceptors() 方法

//添加拦截器
@Override
public void addInterceptors(InterceptorRegistry registry) { 
    // 将拦截器添加到Springmvc环境,默认拦截所有Springmvc分发的请求
    registry.addInterceptor(new Process01Interceptor());
    // addPathPatterns("/common/request/one") 添加拦截路径
    // registry.addInterceptor(new Process01Interceptor()).addPathPatterns("/common/request/one","/common/request/tow");
    // excludePathPatterns("/common/request/tow"); 排除路径,排除应该在拦截的范围内
    // registry.addInterceptor(new Process01Interceptor())
    // .addPathPatterns("/common/request/one","/common/request/tow")
    // .excludePathPatterns("/common/request/tow");
}

多个拦截器执行顺序：先配置的先执行 preHandle() ，后执行 postHandle() 和 afterCompletion()

7.3 参数校验

JSR 303 是 Java 为 Bean 数据合法性校验提供的标准框架，它已经包含在 JavaEE 6.0 标准中。JSR 303 通过在 Bean 属性上标注类似于 @NotNull、@Max 等标准的注解指定校验规则，并通过标准的验证接口对Bean进行验证。

注解	规则
@Null	标注值必须为 null
@NotNull	标注值不可为 null
@AssertTrue	标注值必须为 true
@AssertFalse	标注值必须为 false
@Min(value)	标注值必须大于或等于 value
@Max(value)	标注值必须小于或等于 value
@DecimalMin(value)	标注值必须大于或等于 value
@DecimalMax(value)	标注值必须小于或等于 value
@Size(max,min)	标注值大小必须在 max 和 min 限定的范围内
@Digits(integer,fratction)	标注值值必须是一个数字，且必须在可接受的范围内
@Past	标注值只能用于日期型，且必须是过去的日期
@Future	标注值只能用于日期型，且必须是将来的日期
@Pattern(value)	标注值必须符合指定的正则表达式

JSR 303 只是一套标准，需要提供其实现才可以使用。Hibernate Validator 是 JSR 303 的一个参考实现，除支持所有标准的校验注解外，它还支持以下的扩展注解：

注解	规则
@Email	标注值必须是格式正确的 Email 地址
@Length	标注值字符串大小必须在指定的范围内
@NotEmpty	标注值字符串不能是空字符串
@Range	标注值必须在指定的范围内

Spring 4.0 版本已经拥有自己独立的数据校验框架，同时支持 JSR 303 标准的校验框架。Spring 在进行数据绑定时，可同时调用校验框架完成数据校验工作。在SpringMVC 中，可直接通过注解驱动 @EnableWebMvc 的方式进行数据校验。Spring 的 LocalValidatorFactoryBean 既实现了 Spring 的 Validator 接口，也实现了 JSR 303 的 Validator 接口。只要在Spring容器中定义了一个LocalValidatorFactoryBean，即可将其注入到需要数据校验的 Bean中。Spring本身并没有提供JSR 303的实现，所以必须将JSR 303的实现者的jar包放到类路径下。

配置 @EnableWebMvc后，SpringMVC 会默认装配好一个 LocalValidatorFactoryBean，通过在处理方法的入参上标注 @Validated 注解即可让 SpringMVC 在完成数据绑定后执行数据校验的工作。

参数校验使用：

1. 导入依赖：未导入时配置了不会生效，也不会报错

<!-- 校验注解实现-->
<dependency>
    <groupId>org.hibernate.validator</groupId>
    <artifactId>hibernate-validator</artifactId>
    <version>8.0.0.Final</version>
</dependency>
<dependency>
    <groupId>org.hibernate.validator</groupId>
    <artifactId>hibernate-validator-annotation-processor</artifactId>
    <version>8.0.0.Final</version>
</dependency>

2. 在VO类中配置校验注解

@Data
public class Query {

	@NotBlank
	private String name;

	@Min(10)
	private int age;
}

3. 在需要校验的地方配置 @Valid 或 @Validated 注解 ：
   • @Validated ：是spring提供的对 @Valid 的封装，@Validated 在 @Valid 之上提供了分组功能和验证排序功能，但不支持嵌套校验的功能
   • BindResult ：在校验参数的后面添加 BindResult 可以获取校验结果，但添加后将不会报异常，个人更推荐用全局校验异常处理方案

@RestController
public class HelloController {

	@RequestMapping("hello")
	public String hello(@Valid Query query) {
		System.out.println(query);
		return "我的妈呀,666";
	}
}

4. 增加校验异常统一处理：这里我尝试使用 MethodArgumentNotValidException 无法捕获到校验异常，用 BindException 才能捕获到

@RestControllerAdvice  // 注意，使用这个注解前需确认已经引入了 jackson 依赖，不然会报 Could not find acceptable representation
public class GlobalExceptionHandler {

	@ExceptionHandler(MethodArgumentNotValidException.class)
	public Object handleMethodArgumentNotValidException(MethodArgumentNotValidException e) {
		System.out.println(e);
		return "发生了一点小小的MethodArgumentNotValidException";
	}

	@ExceptionHandler(BindException.class)
	public Result handleMethodBindException(BindException e) {
		List<ObjectError> allErrors = e.getAllErrors();
		List<String> errMsg = new ArrayList<>();
		for (ObjectError error : allErrors) {
			errMsg.add(Objects.requireNonNull(error.getCodes())[0] + "：" + error.getDefaultMessage());
		}
		return new Result<>(false, null, errMsg);
	}

	@ExceptionHandler(Exception.class)
	public Object handleException(Exception e) {
		System.out.println(e);
		return "发生了一点小小的Exception";
	}
}

7.4 乱码问题解决

1. 响应乱码

在配置类中加入转换器

@Override
public void extendMessageConverters(List<HttpMessageConverter<?>> converters) {
    for (HttpMessageConverter<?> converter : converters) {
        // 解决 Controller 返回普通文本中文乱码问题
        if (converter instanceof StringHttpMessageConverter) {
            ((StringHttpMessageConverter) converter).setDefaultCharset(StandardCharsets.UTF_8);
        }
        // 解决 Controller 返回json对象中文乱码问题
        if (converter instanceof MappingJackson2HttpMessageConverter) {
            ((MappingJackson2HttpMessageConverter) converter).setDefaultCharset(StandardCharsets.UTF_8);
        }
    }
}

2. 控制台乱码

增加 VM options -Dfile.encoding=UTF-8