SpringMVC自定义ViewSolver(视图解析器) 和 Convert(类型转换器)

ViewSolver的作用我就不多说了.
Convert的作用说一下:

在前端传递给后端数据的时候，会有一些问题，如数据的类型转换，数据的格式化，数据的校验等
SpringMVC有一个WebDataBind（DataBinder） 来完成数据绑定功能，而这个WebDataBind又有许多组件来完成各种功能

ConversionService组件：负责数据类型转换和格式化功能，将请求信息填充到入参对象中，不同类型的转换和格式化有不同的converter，还可以自定义我们自己的Converter

Validators 组件： 对已经绑定了请求消息的入参对象进行数据校验功能，确保数据的合法性，并生成BindingResult对象

BindingResult组件：负责保存以及解析数据绑定期间数据校验产生的结果

然后SpringMVC就抽取 BindingResult中的入参对象和校验的错误对象，将它们给处理方法的响应入参

自定义ViewSolver:

1:实现View接口，自定义 视图 对象
   MyView:

public class MyView implements View {
    /**
     *  返回给客户端的视图类型,html类型
     */
    @Override
    public String getContentType() {
        return "text/html";
    }

    /**
     * 渲染方法:
     * 这个 map 就是目标方法用于存储数据的map,类型可以是(Map,LinkedHashMap,Model,ModelMap)
     * 不明白的同学建议先把基础掌握好，几种传值方式，以及原理
     * request和response就不做解释了
     */
    @Override
    public void render(Map<String, ?> map, HttpServletRequest request,
                       HttpServletResponse response) throws Exception {

		//这一步就是从 map 中取出 key 对应的值来
        Object name=  map.get("name");
        Object age=  map.get("age");
        Object sex=  map.get("sex");
        /**
         * 设置编码和内容
         */
        response.setContentType("text/html;charset=UTF-8");
        response.getWriter().write("name: " + name +
                            "age: " + age +
                            "sex: " + sex);
    }
}

2:实现ViewSolver接口，自定义视图解析器:

Ordered 接口就是指定了，在SpringMVC解析 View 的时候，先后顺序，如果不指定，默认就是InternalResourceViewResolver
 最先解析，这样的话，就达不到我们的目的，因为，InternalResourceViewResolver 第一个解析的话，
 它是没有办法解析我们自定义的View的，就会报错，所以我们就需要实现这个接口来执行我们的自定义的ViewSolver是第一个解析的
 public class MyViewResolver implements ViewResolver, Ordered {
    /**
     * 指定 视图解析器的顺序，默认为 0
     */
    private Integer order = 0;
    /**
     * 解析视图，因为是测试，所以比较简陋
     * 这里是解析以 "my:'开头的view对象
     */
    @Override
    public View resolveViewName(String s, Locale locale) throws Exception {
        if(s.startsWith("my:")){
            return new MyView();
        }else{
            return null;
        }
    }

  //因为需要在 xml 文件中配置 order ，所以需要提供相应的 set 和 get 方法
    @Override
    public int getOrder() {
        return order;
    }
    public void setOrder(int order){
        this.order = order;
    }
}

3: xml文件配置:

<?xml version="1.0" encoding="UTF-8"?>
<!--suppress ALL-->
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd
     ">
    <!--配置扫描器-->
    <context:component-scan base-package="com.yg.myConversionService"></context:component-scan>
    
    <!--配置视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/"></property>
        <property name="suffix" value=".jsp"></property>
    </bean>
    
	<!--开启基于注解配置的控制模式-->
    <mvc:annotation-driven></mvc:annotation-driven>

    <!--在 ioc 容器里 添加自己 的视图解析器-->
    <bean class="com.yg.myViewResolver.MyViewResolver">
        <!--指定 视图解析器的 顺序，在 InternalViewResolver之前 解析-->
        <property name="order" value="1"></property>
    </bean>

测试:

Test:
@RequestMapping(path="/test")
@Controller("test")
public class Test {

	//使用了ModelMap传值
    @RequestMapping(path="/myViewResolver")
    public String myViewResolver(ModelMap modelMap){
        modelMap.addAttribute("name","杨小光");
        modelMap.addAttribute("age","19");
        modelMap.addAttribute("sex","男");
        //这里就是以 my 开头的 view ，所以自定义 ViewResolver 可以解析
        return "my:/success";
    }
}

自定义Convert:

1:测试javabean:

public class Student {
    private String name;
    private Integer age;
    private String gender;

    public Student(){}

    public Student(String name,Integer age,String gender){
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    @Override
    public String toString() {
        return "name：" + this.name + " " + "age: " + this.age + " gender: " + this.gender;
    }
}

2:实现 Converter 接口，实现自己的类型转换器
/**
 * 泛型: S : Source（源）  T : Target （目标）
 * 例: String --------------------->   Integer
 * 		S	------------------------------> T
*	此处 将 String 转为 Student 对象，所以指定泛型为String , Student
 */
public class MyConversionService implements Converter<String,Student> {
    @Override
    public Student convert(String s) {
	//因为测试，所以代码逻辑不够完善
        if(s.contains("-")){
            /**
             * 以 - 分割
             */
            String[] temp = s.split("-");
            //将 以 - 分割 的每个字符串，作为参数构造 Student
             Student student = new Student(temp[0],Integer.valueOf(temp[1]),temp[2]);
            return student;
        }
        return null;
    }
}

3: xml 文件配置
<?xml version="1.0" encoding="UTF-8"?>
<!--suppress ALL-->
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd
     ">
    <!--配置扫描器-->
    <context:component-scan base-package="com.yg.myConversionService"></context:component-scan>

	<!--开启基于注解的配置模式，添加类型转换组件-->
    <mvc:annotation-driven conversion-service="conversionService"></mvc:annotation-driven>
    
    <!--配置自己的 类型转换器-->
    <bean id="conversionService" class="org.springframework.context.support.ConversionServiceFactoryBean">
        <property name="converters">
            <set>
                <bean class="com.yg.myConversionService.MyConversionService"></bean>
            </set>
        </property>
    </bean>

测试:

前端请求: 

<a href="testMyConversionService/myConversionService?student=杨小光-19-男">测试自己的类型转换器</a>

Test:

@RequestMapping("/testMyConversionService")
@Controller("test2")
public class Test {

    /**
     * 这里本来不能将 String 转为 Student 的， 但是我自定义了一个类型转换器，所以
     * springmvc就用我自定义的类型转换器
     */
    @RequestMapping("/myConversionService")
    public String myConversionService(@RequestParam("student")Student student){
        System.out.println("参数封装成的学生为 : " + student);
        return "redirect:/success.jsp";
    }
}

需要注意的一点是当你自定义了自己的 Convert之后，SpringMVC并不会 不用其它的Converter，
而是把你自定义的Convert加入到ConversionService中

下面是我调试的结果:
找到这个类，在如图 红色标记的地方打断点：

执行完第一个断点之后的结果如下图:

可以看到，我们的类型转换器是已经在ConversionConvert中的，并且，别的Convert也在其中.