将 Class 名称 + 字符串值的解析器创建为类型值

Question

我正在尝试编写一个方法，该方法可以接受一个字符串类名和一个字符串值，以及 return 表示为该字符串的值。

示例输入：

parse("java.lang.String", "abc") -> String "ABC"
parse("java.lang.Boolean", "FALSE") -> Boolean FALSE
parse("java.lang.Integer", "123") -> Integer 123
parse("com.me.Color", "RED") -> enum Color.RED

我发现如果我使用包含 assignableFrom 调用的 if 块，我可以实现这一点。但是更愿意编写更具可扩展性的东西，这样明天添加一个新的解析器就不那么困难了。

这是我现在拥有的：

    String stringClassName = //stringified full class name
    String value = //value to parse
    Class<?> fieldType = Class.forName(stringClassName)
    if (fieldType.isAssignableFrom(String.class)) {
      return value;
    } else if (fieldType.isAssignableFrom(Boolean.class)) {
      return Util.toBoolean(value);
    } else if (fieldType.isEnum()) {
      return Util.toEnum(fieldType, value);
    } else {
      // throw exception
    }

Answer 1

有多种方法可以做到这一点。例如：

您可以有一个名为 Parser

的界面

package example;

public interface Parser {

    boolean canParse(String fullQualifiedClassName);
    Object parse(String fullQualifiedClassName, String value) throws ParseException;

    class ParseException extends Exception {

        public ParseException(String msg) {
            super(msg);
        }

        public ParseException(Exception cause) {
            super(cause);
        }
    }
}

以及您在枚举中或以另一种方式静态定义的所有默认实现：

package example;

public enum DefaultParser implements Parser {

    STRING {
        @Override
        public boolean canParse(String fullQualifiedClassName) {
            return isClassAssignableFromClassName(fullQualifiedClassName, String.class);
        }

        @Override
        public Object parse(String fullQualifiedClassName, String value) throws ParseException {
            return value;
        }
    },
    ENUM {
        @Override
        public boolean canParse(String fullQualifiedClassName) {
            return isClassAssignableFromClassName(fullQualifiedClassName, Enum.class);
        }

        @Override
        public Object parse(String fullQualifiedClassName, String value) throws ParseException {
            final Class<? extends Enum> clazz;
            try {
                clazz = (Class<? extends Enum>) Class.forName(fullQualifiedClassName);
            } catch (ClassNotFoundException e) {
                throw new ParseException(e);
            }

            return Enum.valueOf(clazz, value);
        }
    },
    BOOLEAN {
        @Override
        public boolean canParse(String fullQualifiedClassName) {
            return isClassAssignableFromClassName(fullQualifiedClassName, Boolean.class);
        }

        @Override
        public Object parse(String fullQualifiedClassName, String value) throws ParseException {
            return value.toLowerCase().equals("true");
        }
    };

    private static boolean isClassAssignableFromClassName(String fullQualifiedClassName, Class<?> clazz) {
        try {
            return clazz.isAssignableFrom(Class.forName(fullQualifiedClassName));
        } catch (ClassNotFoundException e) {
            return false;
        }
    }
}

还有一个 ParentParser 将多个解析器合并为一个的实现：

package example;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;

public class ParentParser implements Parser {

    private final List<Parser> parsers;

    public ParentParser() {
        this.parsers = new ArrayList<>();
        this.parsers.addAll(Arrays.asList(DefaultParser.values()));
    }

    public void register(Parser parser) {
        this.parsers.add(parser);
    }

    @Override
    public boolean canParse(String fullQualifiedClassName) {
        return findParser(fullQualifiedClassName).isPresent();
    }

    @Override
    public Object parse(String fullQualifiedClassName, String value) throws ParseException {
        return findParser(fullQualifiedClassName)
              .orElseThrow(() -> new ParseException("no registered parser found for class=" + fullQualifiedClassName))
              .parse(fullQualifiedClassName, value);
    }

    private Optional<Parser> findParser(String fullQualifiedClassName) {
        return this.parsers.stream().filter(parser -> parser.canParse(fullQualifiedClassName)).findAny();
    }
}

然后你可以像这样使用：

package example;

import example.Parser.ParseException;

public class Example {

    public static void main(String[] args) throws ParseException {
        final ParentParser parser = new ParentParser();

        System.out.println(parser.parse("java.lang.String", "hello world"));
        System.out.println(parser.parse("java.lang.Boolean", "true"));
        System.out.println(parser.parse("java.time.DayOfWeek", "TUESDAY"));
    }
}

您还可以添加更多解析器，例如使用 Jackson (JSON) 的解析器：

package example;

import com.fasterxml.jackson.databind.ObjectMapper;
import example.Parser.ParseException;

import java.io.IOException;

public class Example {

    public static void main(String[] args) throws ParseException {
        final ParentParser parser = new ParentParser();

        System.out.println(parser.parse("java.lang.String", "hello world"));
        System.out.println(parser.parse("java.lang.Boolean", "true"));
        System.out.println(parser.parse("java.time.DayOfWeek", "TUESDAY"));

        parser.register(new JacksonParser());

        System.out.println(parser.parse("java.util.Map", "{\"key\":\"value\"}"));
    }

    private static class JacksonParser implements Parser {

        private static final ObjectMapper MAPPER = new ObjectMapper();

        @Override
        public boolean canParse(String fullQualifiedClassName) {
            final Class<?> clazz;
            try {
                clazz = Class.forName(fullQualifiedClassName);
            } catch (ClassNotFoundException e) {
                return false;
            }

            return MAPPER.canDeserialize(MAPPER.constructType(clazz));
        }

        @Override
        public Object parse(String fullQualifiedClassName, String value) throws ParseException {
            try {
                return MAPPER.readValue(value, Class.forName(fullQualifiedClassName));
            } catch (ClassNotFoundException | IOException e) {
                throw new ParseException(e);
            }
        }
    }
}

请注意，这当然可以根据您的需要进行优化。如果您的解析器实现只能解析静态类型列表并且每个 Class 只有一个解析器实现，您应该将 List<Parser> 更改为 Map<Class<?>, Parser> 并将寄存器方法更改为register(Class<?> clazz, Parser parser) 例如

Answer 2

您可以在 java 中使用反射 API 编写通用解决方案。这将减少大量代码并且更具可扩展性。枚举类型也不需要单独处理。我已经在下面显示的代码中介绍了基本情况。

public static void main(String[] args) throws NoSuchMethodException, ClassNotFoundException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Object instance1 = parse("java.lang.String", "abc", false);
        Object instance2 = parse("java.lang.Boolean", "FALSE", false);
        Object instance3 = parse("java.lang.Integer", "123", false);
        Object instance4 = parse("com.me.Color", "RED", true);
    }

    private static Object parse(String className, String argument, boolean isEnum) throws NoSuchMethodException, ClassNotFoundException, IllegalAccessException, InstantiationException, InvocationTargetException {
        if (isEnum) {
            Object value = Enum.valueOf((Class<? extends Enum>) Class.forName(className), argument);
            //System.out.println(value);
            return value;
        } else {
            return parse(className, new Object[]{argument}, isEnum);
        }
    }

    private static Object parse(String className, Object[] arguments, boolean isEnum) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Class<?> clazz = Class.forName(className);
        Constructor<?> ctor = clazz.getConstructor(String.class);
        Object object = ctor.newInstance(arguments);
        //System.out.println(object);
        return object;
    }

将 Class 名称 + 字符串值的解析器创建为类型值

Creating a parser of Class name + String value to a typed value

java

generics

design-patterns

functional-programming

functional-interface