自己写一个java的mvc框架吧（三）

自己写一个mvc框架吧（三）

根据Method获取参数并转换参数类型

上一篇我们将url与Method的映射创建完毕，并成功的将映射关系创建起来了。这一篇我们将根据Method的入参参数名称、参数类型来获取参数，并转换参数类型，使其能够符合Method的定义。

事先说明

因为这里只是一个mvc框架的简单实现，仅仅只做到了基本数据类型和基本数据类型包装类的转换，没有做到spring那样的很复杂的数据绑定功能。所以我在代码上面加了比较强的校验。

现在开始写吧

我们从一次http请求中获取参数的时候，一般需要知道参数的名称，参数名称我们可以用方法的入参名称。这一步我们已经做好了（可以看上一篇：https://www.cnblogs.com/hebaibai/p/10340884.html ）。

在这里我们需要定义一个方法，用来从请求中的String类型的参数转换成为我们定义的Method的入参类型。至于为啥请求中获取的参数是String类型的可以查看一下ServletRequest.java中的方法定义。这里就不讲啦～。所以我们这个方法可以是这样的：

/**
 * 获取方法的入参
 *
 * @param valueTypes
 * @param valueNames
 * @param valueSource
 * @return
 */
public Object[] getMethodValue(Class[] valueTypes, String[] valueNames, Map<String, String[]> valueSource){
    。。。
}

这里接受三个参数

1：valueTypes 这个是Method的入参类型

2：valueNames 这个是Method的入参参数名称

3：valueSource 这个是一次请求中所有的参数。这个参数是一个Map。value的泛型是一个String数组，这里用数组的原因是因为在一次请求中，名称相同的参数可能会有多个。可以查看ServletRequest.java中的方法：

public String[] getParameterValues(String name);

说明一下

这里我依然不写Servlet，因为还不到时候，我们可以在整个代码的架子都写起来之后，每一部分都经过单元测试之后，最后再写这个入口。就像搭积木一样，先把每一块都准备好，最后将所有的拼起来就好了。

继续

现在这个获取方法请求入参的方法定义完了，接下来怎么样根据参数类型将String类型的参数转换出来是一个麻烦的事情，这里要写好多if else的代码。我们一步一步的写，先写一个基本数据类型转换的。

数据类型转换

这里定义一个接口 ValueConverter.java，里面只有一个方法，用于做数据转换

<T> T converter(String[] value, Class<T> valueClass);

有同学要问了，这里为啥要定义成一个接口呢？为啥不直接写一个Class，里面直接写实现代码呢？

因为我这里还有一个工厂类要用来获取ValueConverter.java的实现呀！工厂类的代码张这个样子

/**
 * 数据转换器工厂类
 */
public class ValueConverterFactory {

    /**
     * 根据目标类型获取转换器
     *
     * @param valueClass
     * @return
     */
    public static ValueConverter getValueConverter(Class valueClass) {
        if(...){
            return ValueConverter;
        }
        throw new UnsupportedOperationException("数据类型：" + valueClass.getName() + " 不支持转换！");
    }
}

为啥要写这个工厂类呢？还要从接口 ValueConverter.java说起，java中的接口（interface）并不是为了在开发中写一个service或者写一个DAO让代码好看而定义的，而是让我们定义标准的。规定在这个标准中每个方法的入参、出参、异常信息、方法名称以及这个方法是用来做什么的。只要是这个接口的实现类，就必须要遵守这个标准。调用者在调用的时候也不需要知道它调用的是哪一个实现类，只要按照接口标准进行传参，就可以拿到想要的出参。

所以我们在使用这一段代码的时候只需要给ValueConverterFactory传如一个Class，工厂类返回一个可以转换这个Class的实现就好了。

将上面的 getMethodValue 补充完毕就是这个样子：

/**
 * 获取方法的入参
 *
 * @param valueTypes
 * @param valueNames
 * @param valueSource
 * @return
 */
public Object[] getMethodValue(Class[] valueTypes, String[] valueNames, Map<String, String[]> valueSource) {
    Assert.notNull(valueTypes);
    Assert.notNull(valueNames);
    Assert.notNull(valueSource);
    Assert.isTrue(valueNames.length == valueTypes.length,
            "getMethodValue() 参数长度不一致！");
    int length = valueNames.length;
    Object[] values = new Object[length];
    for (int i = 0; i < values.length; i++) {
        Class valueType = valueTypes[i];
        String valueName = valueNames[i];
        String[] strValues = valueSource.get(valueName);
        //来源参数中 key不存在或者key的值不存在，设置值为null
        if (strValues == null) {
            values[i] = null;
            continue;
        }
        ValueConverter valueConverter = ValueConverterFactory.getValueConverter(valueType);
        Object converter = valueConverter.converter(strValues, valueType);
        values[i] = converter;
    }
    return values;
}

在这里就可以看到，我们在调用工厂类的getValueConverter方法，工厂类就会给我们一个转换器 ValueConverter ，我们只需要用它来进行转换就好了，不需要知道是怎么转换的。

但是我们还是要先写几个转换器，因为现在并没有真正可用的转换器，有的只是标准。现在我们先写一个基本数据类型的转换器。

基本数据类型的转换

在这里，我们先要通过Class判断一下它是不是一个基本类型，注意：

这里我说的基本数据类型是指 java中的 基本数据类型 和 它们的包装类 以及 String

先写一个工具类：

public class ClassUtils {

    /**
     * java 基本类型
     */
    public static List<Class> JAVA_BASE_TYPE_LIST = new ArrayList<>();

    public final static Class INT_CLASS = int.class;
    public final static Class LONG_CLASS = long.class;
    public final static Class FLOAT_CLASS = float.class;
    public final static Class DOUBLE_CLASS = double.class;
    public final static Class SHORT_CLASS = short.class;
    public final static Class BYTE_CLASS = byte.class;
    public final static Class BOOLEAN_CLASS = boolean.class;
    public final static Class CHAR_CLASS = char.class;
    public final static Class STRING_CLASS = String.class;
    public final static Class INT_WRAP_CLASS = Integer.class;
    public final static Class LONG_WRAP_CLASS = Long.class;
    public final static Class FLOAT_WRAP_CLASS = Float.class;
    public final static Class DOUBLE_WRAP_CLASS = Double.class;
    public final static Class SHORT_WRAP_CLASS = Short.class;
    public final static Class BOOLEAN_WRAP_CLASS = Boolean.class;
    public final static Class BYTE_WRAP_CLASS = Byte.class;
    public final static Class CHAR_WRAP_CLASS = Character.class;

    static {
        //基本数据类型
        JAVA_BASE_TYPE_LIST.add(INT_CLASS);
        JAVA_BASE_TYPE_LIST.add(LONG_CLASS);
        JAVA_BASE_TYPE_LIST.add(FLOAT_CLASS);
        JAVA_BASE_TYPE_LIST.add(DOUBLE_CLASS);
        JAVA_BASE_TYPE_LIST.add(SHORT_CLASS);
        JAVA_BASE_TYPE_LIST.add(BYTE_CLASS);
        JAVA_BASE_TYPE_LIST.add(BOOLEAN_CLASS);
        JAVA_BASE_TYPE_LIST.add(CHAR_CLASS);
        //基本数据类型（对象）
        JAVA_BASE_TYPE_LIST.add(STRING_CLASS);
        JAVA_BASE_TYPE_LIST.add(INT_WRAP_CLASS);
        JAVA_BASE_TYPE_LIST.add(LONG_WRAP_CLASS);
        JAVA_BASE_TYPE_LIST.add(FLOAT_WRAP_CLASS);
        JAVA_BASE_TYPE_LIST.add(DOUBLE_WRAP_CLASS);
        JAVA_BASE_TYPE_LIST.add(SHORT_WRAP_CLASS);
        JAVA_BASE_TYPE_LIST.add(BOOLEAN_WRAP_CLASS);
        JAVA_BASE_TYPE_LIST.add(BYTE_WRAP_CLASS);
        JAVA_BASE_TYPE_LIST.add(CHAR_WRAP_CLASS);
    }

    /**
     * 检查是否是基本数据类型（包括基本数据类型的包装类）
     *
     * @param aClass
     * @return
     */
    public static boolean isBaseClass(Class aClass) {
        int indexOf = JAVA_BASE_TYPE_LIST.indexOf(aClass);
        return indexOf != -1;
    }   

    。。。

}

这样只需要判断这个Class 在不在 JAVA_BASE_TYPE_LIST 中就好了。

接下来我们开始写数据转换的，因为基本类型的包装类基本上都有直接转换的方法，我们一一调用就好了，代码是这样的：


/**
 * 基本数据类型的转换
 *
 * @author hjx
 */
public class BaseTypeValueConverter implements ValueConverter {

    /**
     * 非数组类型，取出数组中的第一个参数
     *
     * @param value
     * @param valueClass
     * @param <T>
     * @return
     */
    @Override
    public <T> T converter(String[] value, Class<T> valueClass) {
        Assert.notNull(value);
        Assert.isTrue(!valueClass.isArray(), "valueClass 不能是数组类型！");
        String val = value[0];
        Assert.notNull(val);
        if (valueClass.equals(ClassUtils.INT_CLASS) || valueClass.equals(ClassUtils.INT_WRAP_CLASS)) {
            Object object = Integer.parseInt(val);
            return (T) object;
        }
        if (valueClass.equals(ClassUtils.LONG_CLASS) || valueClass.equals(ClassUtils.LONG_WRAP_CLASS)) {
            Object object = Long.parseLong(val);
            return (T) object;
        }
        if (valueClass.equals(ClassUtils.FLOAT_CLASS) || valueClass.equals(ClassUtils.FLOAT_WRAP_CLASS)) {
            Object object = Float.parseFloat(val);
            return (T) object;
        }
        if (valueClass.equals(ClassUtils.DOUBLE_CLASS) || valueClass.equals(ClassUtils.DOUBLE_WRAP_CLASS)) {
            Object object = Double.parseDouble(val);
            return (T) object;
        }
        if (valueClass.equals(ClassUtils.SHORT_CLASS) || valueClass.equals(ClassUtils.SHORT_WRAP_CLASS)) {
            Object object = Short.parseShort(val);
            return (T) object;
        }
        if (valueClass.equals(ClassUtils.BYTE_CLASS) || valueClass.equals(ClassUtils.BYTE_WRAP_CLASS)) {
            Object object = Byte.parseByte(val);
            return (T) object;
        } else if (valueClass.equals(ClassUtils.BOOLEAN_CLASS) || valueClass.equals(ClassUtils.BOOLEAN_WRAP_CLASS)) {
            Object object = Boolean.parseBoolean(val);
            return (T) object;
        }
        if (valueClass.equals(ClassUtils.CHAR_CLASS) || valueClass.equals(ClassUtils.CHAR_WRAP_CLASS)) {
            Assert.isTrue(val.length() == 1, "参数长度异常，无法转换char类型！");
            Object object = val.charAt(0);
            return (T) object;
        }
        if (valueClass.equals(ClassUtils.STRING_CLASS)) {
            Object object = val;
            return (T) object;
        }
        throw new UnsupportedOperationException("类型异常，非基本数据类型！");
    }
}

这里基本数据类型的转换就写好了。接下来就是处理数组了，因为事先声明了，只做基本数据类型的转换，所以数组也只能是基本数据类型的。

基本数据类型数组的转换

那么怎么判断一个Class是不是数组呢？上网搜了搜java的Class的api发现其中有两个方法

//判断是不是一个数组
public native boolean isArray();

//在Class是一个数组的情况下，返回数组中元素的Class
//Class不是数组的情况下返回null
public native Class<?> getComponentType();

接下来就可以写代码了


import com.hebaibai.amvc.utils.Assert;

/**
 * 基本数据类型的转换
 *
 * @author hjx
 */
public class BaseTypeArrayValueConverter extends BaseTypeValueConverter implements ValueConverter {

    @Override
    public <T> T converter(String[] value, Class<T> valueClass) {
        Assert.notNull(value);
        Assert.notNull(valueClass);
        Assert.isTrue(valueClass.isArray(), "valueClass 必须是数组类型！");
        Class componentType = valueClass.getComponentType();
        Assert.isTrue(!componentType.isArray(), "valueClass 不支持多元数组！");
        Object[] object = new Object[value.length];
        for (int i = 0; i < value.length; i++) {
            object[i] = super.converter(new String[]{value[i]}, componentType);
        }
        return (T) object;
    }
}

这样这两个转换器就写完了。

BUT

现在只有转换器，工厂类中根据什么样的逻辑获取什么样的转换器还没写，现在给补上


import com.hebaibai.amvc.utils.ClassUtils;

/**
 * 数据转换器工厂类
 */
public class ValueConverterFactory {

    /**
     * 基本数据类型的数据转换
     */
    private static final ValueConverter BASE_TYPE_VALUE_CONVERTER = new BaseTypeValueConverter();
    /**
     * 基本类型数组的数据转换
     */
    private static final ValueConverter BASE_TYPE_ARRAY_VALUE_CONVERTER = new BaseTypeArrayValueConverter();

    /**
     * 根据目标类型获取转换器
     *
     * @param valueClass
     * @return
     */
    public static ValueConverter getValueConverter(Class valueClass) {
        boolean baseClass = ClassUtils.isBaseClass(valueClass);
        if (baseClass) {
            return BASE_TYPE_VALUE_CONVERTER;
        }
        if (valueClass.isArray()) {
            return BASE_TYPE_ARRAY_VALUE_CONVERTER;
        }
        throw new UnsupportedOperationException("数据类型：" + valueClass.getName() + " 不支持转换！");
    }
}

这样就万事大吉了～～～

再说点啥

之后想要添加其他的类型转换的话，只需要新写几个实现类，然后修改一下工厂代码就好了，比较好扩展。这也是写工厂类的原因。

写段代码测试一下吧

MethodValueGetter methodValueGetter = new MethodValueGetter();
//拼装测试数据
Map<String, String[]> value = new HashMap<>();
value.put("name", new String[]{"何白白"});
value.put("age", new String[]{"20"});
value.put("children", new String[]{"何大白1", "何大白2", "何大白3", "何大白4"});
//执行方法
Object[] methodValue = methodValueGetter.getMethodValue(
        new Class[]{String.class, int.class, String[].class},//入参中的参数类型
        new String[]{"name", "age", "children"},//入参的参数名称
        value//请求中的参数
);
//打印结果
for (int i = 0; i < methodValue.length; i++) {
    Object obj = methodValue[i];
    if (obj == null) {
        System.out.println("null");
        continue;
    }
    Class<?> objClass = obj.getClass();
    if (objClass.isArray()) {
        Object[] objects = (Object[]) obj;
        for (Object object : objects) {
            System.out.println(object + "===" + object.getClass());
        }
    } else {
        System.out.println(obj + "===" + obj.getClass());
    }
}

结果：

何白白===class java.lang.String
20===class java.lang.Integer
何大白1===class java.lang.String
何大白2===class java.lang.String
何大白3===class java.lang.String
何大白4===class java.lang.String

测试成功～～～

最后

现在通过反射执行Method的参数我们也已经拿到了，接下来就是执行了，下一篇在写吧

拜拜

对了，代码同步更新在我的github上 https://github.com/hjx601496320/aMvc 欢迎来看～

完

原文地址：https://www.cnblogs.com/hebaibai/p/10346162.html

时间： 2024-08-24 14:24:27

自己写一个java的mvc框架吧（三）的相关文章

自己动手写一个简单的MVC框架（第二版）

一.ASP.NET MVC核心机制回顾 在ASP.NET MVC中,最核心的当属“路由系统”,而路由系统的核心则源于一个强大的System.Web.Routing.dll组件. 在这个System.Web.Routing.dll中,有一个最重要的类叫做UrlRoutingModule,它是一个实现了IHttpModule接口的类,在请求处理管道中专门针对ASP.NET MVC请求进行处理.首先,我们要了解一下UrlRoutingModule是如何起作用的. (1)IIS网站的配置可以分为两个块:

AsMVC:一个简单的MVC框架的Java实现

当初看了<从零开始写一个Java Web框架>,也跟着写了一遍,但当时学艺不精,真正进脑子里的并不是很多,作者将依赖注入框架和MVC框架写在一起也给我造成了不小的困扰.最近刚好看了一遍springMVC的官方文档,对过去一段时间的使用做了一下总结,总结了一些MVC的使用需求,打算自己开坑写一个MVC框架,虽然是重复造轮子的过程,但也是学习提高的过程. 1.我们可能需要一个什么样的MVC框架 (1)用户一:我讨厌配置文件,最好能用注解的全用注解注解,能扫描直接扫描 (2)用户二:最好我导入一个j

来，咱们自己写一个Android的IOC框架！

到目前位置,afinal开发框架也是用了好几个月了,还记得第一次使用注释完成控件的初始化和事件绑定的时候,当时的心情是多么的兴奋- -代码竟然可以这样写!然后随着不断的学习,也慢慢的对IOC框架和注解反射等东西有了一点简单的了解,之前的一篇文章简单的介绍了一下Java的反射机制,今天的文章,就完成一个简单的,基于IOC的小Demo,让大家慢慢的对IOC有一点简单的了解. 首先,什么是IOC呢? 控制反转(Inversion of Control,英文缩写为IoC)是一个重要的面向对象编程的法则来

自己写一个java.lang.reflect.Proxy代理的实现

前言 Java设计模式9:代理模式一文中,讲到了动态代理,动态代理里面用到了一个类就是java.lang.reflect.Proxy,这个类是根据代理内容为传入的接口生成代理用的.本文就自己写一个Proxy类出来,功能和java.lang.reflect.Proxy一样,传入接口.代理内容,生成代理. 抛砖引玉吧,个人觉得自己写一些JDK里面的那些类挺好的,写一遍和看一遍真的是两个不同的概念,写一遍既加深了对于这些类的理解.提升了自己的写代码水平,也可以在写完之后对比一下自己的实现有哪些写得不好

软件测试第二次作业 - 写一个Java程序，用于分析一个字符串中各个单词出现的频率，并将单词和它出现的频率输出显示。

题目一: 1. 写一个Java程序,用于分析一个字符串中各个单词出现的频率,并将单词和它出现的频率输出显示.(单词之间用空格隔开,如“Hello World My First Unit Test”): 2. 编写单元测试进行测试: 3. 用ElcEmma查看代码覆盖率,要求覆盖率达到100%. Demo类: 1 import java.util.HashMap; 2 import java.util.Iterator; 3 import java.util.Map; 4 import java.

手把手写一个基于Spring Boot框架下的参数校验组件

手把手写一个基于Spring Boot框架下的参数校验组件(JSR-303) 前言 之前参与的新开放平台研发的过程中,由于不同的接口需要对不同的入参进行校验,这就涉及到通用参数的校验封装,如果不进行封装,那么写出来的校验代码将会风格不统一.校验工具类不一致.维护风险高等其它因素,于是我对其公共的校验做了一个封装,达到了通过注解的方式即可实现参数统一校验. 遇到的问题                    在封装的时候就发现了一个问题,我们是开放平台,返回的报文都必须是统一风格,也就是类似于{co

爬虫入门 手写一个Java爬虫

本文内容 涞源于  罗刚 老师的 书籍 << 自己动手写网络爬虫一书 >> ; 本文将介绍 1: 网络爬虫的是做什么的?  2: 手动写一个简单的网络爬虫; 1: 网络爬虫是做什么的?  他的主要工作就是 跟据指定的url地址 去发送请求,获得响应, 然后解析响应 , 一方面从响应中查找出想要查找的数据,另一方面从响应中解析出新的URL路径, 然后继续访问,继续解析;继续查找需要的数据和继续解析出新的URL路径  . 这就是网络爬虫主要干的工作.  下面是流程图: 通过上面的流程图

原来热加载如此简单，手动写一个 Java 热加载吧

1. 什么是热加载 热加载是指可以在不重启服务的情况下让更改的代码生效,热加载可以显著的提升开发以及调试的效率,它是基于 Java 的类加载器实现的,但是由于热加载的不安全性,一般不会用于正式的生产环境. 2. 热加载与热部署的区别 首先,不管是热加载还是热部署,都可以在不重启服务的情况下编译/部署项目,都是基于 Java 的类加载器实现的. 那么两者到底有什么区别呢? 在部署方式上: 热部署是在服务器运行时重新部署项目. 热加载是在运行时重新加载 class. 在实现原理上: 热部署是直接重新

【Android开发经验】来，咱们自己写一个Android的IOC框架！

到眼下位置.afinal开发框架也是用了好几个月了,还记得第一次使用凝视完毕控件的初始化和事件绑定的时候,当时的心情是多么的兴奋- -代码居然能够这样写!然后随着不断的学习,也慢慢的对IOC框架和注解反射等东西有了一点简单的了解.之前的一篇文章简单的介绍了一下Java的反射机制.今天的文章.就完毕一个简单的,基于IOC的小Demo.让大家慢慢的对IOC有一点简单的了解. 首先.什么是IOC呢? 控制反转(Inversion of Control,英文缩写为IoC)是一个重要的面向对象编程的法则来