动态properties转换

ajoo

浏览: 453814 次

最近访客更多访客>>

san_yun

w931

97wgl

csm_qz

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

博客分类：

默认类别

单元测试 UI Apache IDE Bean

今天同事和我讨论他遇到的一个问题。具体要求是这样的，在运行时，我们会从模块G得到一个Map，这个Map里面都是一些字符串对，你可以理解成一个字典，有字符串的key和字符串的value。简短节说，就是

Map<String, String>

非常非常复杂深奥。

好，现在我们事先知道要从这个map里读取一些数据点，比如：id, name, sex等等。

对id，我们知道读出来的是int；对name，是string；对sex，应该对应一个叫Gender的enum类型。

这就涉及一个自动类型转换的问题。我们希望不用对每个数据点做手工类型转换。

另外一个需求，一些数据点是有缺省值的。比如name我们可以缺省为空字符串。
这样，如果map里面没有某个值，我们就看缺省值，如果有，就用这个缺省值，如果没有，就抛异常。

手工做的话，大概是这样：

String idValue = map.get("id");
if (idValue == null) {
  throw ...;
}
int id = Integer.parseInt(idValue);

String name = map.get("name");
if (name == null) {
  name = "";
}

String sexValue = map.get("sex");
if (sexValue == null) {
  throw ...;
}
Gender sex = Gender.valueOf(sexValue);
...

比较痛苦。于是做了一个动态代理：

public final class PropertyConverter<T> {
  private final Class<T> targetType;
  
  private PropertyConverter(Class<T> targetType) {...}

  public static <T> PropertyConverter<T> to(Class<T> targetType) {
    return new PropertyConverter<T>(targetType);
  }

  public T from(final Map<String, String> map) {
    return Proxy.newProxyInstance(
      new Class[]{targetType}, targetType.getClassLoader(), new InvocationHandler() {
        public Object invoke(Object proxy, Method method, Object[] args) {
          String value = map.get(method.getName());
          if (value == null) {
            Object defaultValue = method.getDefaultValue();
            if (defaultValue == null) {
              throw ...;
            }
            return defaultValue;
          }
          return convert(value, method.getReturnType());
        }
    });
  }
}

convert()函数是调用apache的ConvertUtilsBean做的，没什么说的。

那么，用法呢？

@interface Foo {
  int id();
  String name() default "";
  Gender sex();
}

Map<String, String> map = ...;
Foo foo = PropertyConverter.to(Foo.class).from(map);
foo.id();
foo.name();

这里面，对annotation的用法比较特别。不过不这么做，java也不提供一个简单并且类型安全的指定缺省值的方法。当然，如果你凑巧不需要缺省值，那么也不用annotation，直接用interface就好。

分享到：

getThis().getEvilAdvocate().setDead(getT ... | 怎样最有效地测试异常？

2008-05-07 06:06
浏览 7445
评论(52)
论坛回复 / 浏览 (50 / 32062)
分类:企业架构
查看更多

32 楼 ajoo 2008-05-10

引用

ajoo 写道

C++可以在编译时处理这种情况是因为它用扩展法。在编译的时候它知道T是String。而Java不知道。在getProperty()内部你要调用convert(targetType, value)的时候，你不知道targetType是什么。

明白了，type erasure 的泛型总是出乎我意料地弱 …… 那么，在泛型函数内取 T 对应的 class 对象行不行？这个只需要编译器给泛型函数加一个隐藏的额外参数，应该是可以做的吧？

有一些办法的。比如Neal Gafter的Type token（通过一个子类来绕出来这个T的class），或者传统地传一个String.class进去，或者新的Reified Generics（vaporware)。

引用

ajoo 写道

用proxy，字符串仅仅会在PropertyConverterTest一个类里面存在，而我会建立一些完全虚假的FooForTest接口和一些虚构的property，这些东西测试好了之后再也不会变了。
而客户代码因为直接依赖业务接口Foo，永远不会需要基于字符串进行测试。比如：

@interface Foo {
  int id();
  String name() default "foo";
  Gender sex() default UNKNOWN;
}
public class FooClient {
  private final Function

, Foo> converter;
  public void run(Map map) {
    Foo foo = converter.from(map);
    if (foo.id() == 1) {
       ...
    }
    if (foo.sex() == MALE) {
      ...
    }
  }
}

你看测试里我是不是再也不关心Map里面放的是什么了？反正直接mock一个Foo来用就是了。
用GetProperty的话，那么FooTest, BarTest, BazTest等等等等都要依赖字符串的。

这个 …… 一般的方案难道不是直接给 FooClient 传一个 Foo 进去么？就算沦落到直接用 Map ，也木有把 map.put(...) 这种东西直接放在 FooClient 里的道理呀？

我们谈的是测试代码呀兄弟。

当然也是传一个Foo进去。问题是这里的Foo不是接口，而是一个行为依赖于Map的内容的具体类。你要模拟一个id=0的情况，不得在Foo里面的那个Map上下功夫？
比如：

@Mock Foo foo;
public void testIdIsZero() {
  expect(foo.id()).andReturn(0); //表示foo.id()会被调用，我们对这个调用返回0.
  replay();
  assertEquals("expect to get this value", new FooClient(foo).run());
}

要是Foo是个行为依赖于Map的类的话，你怎么鼓捣？

引用

ajoo 写道

我已经逐渐学会用大家喜欢用的词来讨论问题了，即使它<script type="text/javascript" src="http://www.iteye.com/javascripts/tinymce/themes/advanced/langs/zh.js"></script><script type="text/javascript" src="http://www.iteye.com/javascripts/tinymce/plugins/javaeye/langs/zh.js"></script>们不够精确，或者说穿了就是狗屁。

你小子庸俗化了呀！当年那只特立独行的猪捏？猪肉涨价被人宰了吃了？

我管这叫“成熟”。

31 楼 ajoo 2008-05-10

引用

ajoo 写道

有一些办法的。比如Neal Gafter的Type token（就是通过一个子类来绕出来这个T的类型），或者传统地传一个String.class进去，或者新的Reified Generics（vaporware)。

引用

ajoo 写道

用proxy，字符串仅仅会在PropertyConverterTest一个类里面存在，而我会建立一些完全虚假的FooForTest接口和一些虚构的property，这些东西测试好了之后再也不会变了。

而客户代码因为直接依赖业务接口Foo，永远不会需要基于字符串进行测试。比如：

@interface Foo {
  int id();
  String name() default "foo";
  Gender sex() default UNKNOWN;
}

public class FooClient {
  private final Function<Map<String, String>, Foo> converter;

  public void run(Map<String, String> map) {
    Foo foo = converter.from(map);
    if (foo.id() == 1) {
       ...
    }
    if (foo.sex() == MALE) {
      ...
    }
  }
}

你看测试里我是不是再也不关心Map里面放的是什么了？反正直接mock一个Foo来用就是了。

用GetProperty的话，那么FooTest, BarTest, BazTest等等等等都要依赖字符串的。

这个 …… 一般的方案难道不是直接给 FooClient 传一个 Foo 进去么？就算沦落到直接用 Map ，也木有把 map.put(...) 这种东西直接放在 FooClient 里的道理呀？

当然也是传一个Foo进去。问题是这里的Foo不是接口，而是一个行为依赖于Map的内容的具体类。你要模拟一个id=0的情况，不得在Foo里面的那个Map上下功夫？

引用

ajoo 写道

我已经逐渐学会用大家喜欢用的词来讨论问题了，即使它们不够精确，或者说穿了就是狗屁。

你小子庸俗化了呀！当年那只特立独行的猪捏？猪肉涨价被人宰了吃了？

我管这叫“成熟”。

30 楼 pojo 2008-05-10

有一点不明白。你如何保证形式（interface Foo）与内容（Map)的类型一致？

29 楼 Elminster 2008-05-10

ajoo 写道

用proxy，字符串仅仅会在PropertyConverterTest一个类里面存在，而我会建立一些完全虚假的FooForTest接口和一些虚构的property，这些东西测试好了之后再也不会变了。

而客户代码因为直接依赖业务接口Foo，永远不会需要基于字符串进行测试。比如：

@interface Foo {
  int id();
  String name() default "foo";
  Gender sex() default UNKNOWN;
}

public class FooClient {
  private final Function<Map<String, String>, Foo> converter;

  public void run(Map<String, String> map) {
    Foo foo = converter.from(map);
    if (foo.id() == 1) {
       ...
    }
    if (foo.sex() == MALE) {
      ...
    }
  }
}

你看测试里我是不是再也不关心Map里面放的是什么了？反正直接mock一个Foo来用就是了。

用GetProperty的话，那么FooTest, BarTest, BazTest等等等等都要依赖字符串的。

这个 …… 一般的方案难道不是直接给 FooClient 传一个 Foo 进去么？就算沦落到直接用 Map ，也木有把 map.put(...) 这种东西直接放在 FooClient 里的道理呀？

ajoo 写道

我已经逐渐学会用大家喜欢用的词来讨论问题了，即使它们不够精确，或者说穿了就是狗屁。

你小子庸俗化了呀！当年那只特立独行的猪捏？猪肉涨价被人宰了吃了？

28 楼 ajoo 2008-05-10

引用

ajoo 写道

所有的类型都是。因为这里你需要的不是一个编译时类型，而是运行时的。

不明白你这里所说的“运行时的类型”是什么含义。这个 GetProperty<String>("name", ""); 是直接写在代码里的，编译时就可以知道，java 编译器应该很容易就可以处理。

引用

ajoo 写道

类型安全嘛，比如你写map.put("id", "0")，就隐含依赖于id是int这个事实，如果一旦id被重构成别的类型，或者改名，这里编译器和ide不会提醒不会报错。

不论用什么方案，map.put("id", "0") 或是类似的东西总是会在某个地方顽强地存在的。

用proxy，字符串仅仅会在PropertyConverterTest一个类里面存在，而我会建立一些完全虚假的FooForTest接口和一些虚构的property，这些东西测试好了之后再也不会变了。

而客户代码因为直接依赖业务接口Foo，永远不会需要基于字符串进行测试。比如：

@interface Foo {
  int id();
  String name() default "foo";
  Gender sex() default UNKNOWN;
}

public class FooClient {
  private final Function<Map<String, String>, Foo> converter;

  public void run(Map<String, String> map) {
    Foo foo = converter.from(map);
    if (foo.id() == 1) {
       ...
    }
    if (foo.sex() == MALE) {
      ...
    }
  }
}

你看测试里我是不是再也不关心Map里面放的是什么了？反正直接mock一个Foo来用就是了。

用GetProperty的话，那么FooTest, BarTest, BazTest等等等等都要依赖字符串的。

引用

ajoo 写道

我倒是觉得用继承比较费解，这里更象一个has-a而不是is-a。

我已经逐渐倾向于不用 has-a 、is-a 这种方式来考虑如何构造程序了 …… 算了，这个话题说起来要费太多口水，得空的时候再学习老庄写“敲响 is-a 的丧钟”吧，:D:D

我已经逐渐学会用大家喜欢用的词来讨论问题了，即使它们不够精确，或者说穿了就是狗屁。

27 楼 Elminster 2008-05-10

ajoo 写道

所有的类型都是。因为这里你需要的不是一个编译时类型，而是运行时的。

ajoo 写道

嗯，这是一个优势。

ajoo 写道

类型安全嘛，比如你写map.put("id", "0")，就隐含依赖于id是int这个事实，如果一旦id被重构成别的类型，或者改名，这里编译器和ide不会提醒不会报错。

不论用什么方案，map.put("id", "0") 或是类似的东西总是会在某个地方顽强地存在的。

ajoo 写道

我倒是觉得用继承比较费解，这里更象一个has-a而不是is-a。

26 楼 laiseeme 2008-05-09

有点像springmvc里面的binder

25 楼 ajoo 2008-05-09

引用

1. 木有想到 …… java 的泛型这么弱？是所有的泛型函数调用都要这样，还是 String 比较特殊？

所有的类型都是。因为这里你需要的不是一个编译时类型，而是运行时的。

引用

2. 原来你的方案，也要依赖你这个泛型类 PropertyConverter<T> 吧？这和依赖 Base 区别在哪里？而且我没有发现哪里损失了类型安全，说来听听？

不要。我会注射一个Function<Map, T>进去，（或者任何的一个从Map到T的接口）。PropertyConverter只在最外层的容器里面用。否则我干嘛PropertyConverter.to(Foo.class).from(map)这么麻烦？干啥不PropertyConverter.convert(map, Foo.class)？

类型安全嘛，比如你写map.put("id", "0")，就隐含依赖于id是int这个事实，如果一旦id被重构成别的类型，或者改名，这里编译器和ide不会提醒不会报错。

引用

3. 哪个面向对象语言里面都是组合优于继承，OO 原则么。不过我觉得这种地方用继承更直截了当，目前也看不见什么更复杂的东西。将来若是这里真的变复杂了，也可以重构。

我倒是觉得用继承比较费解，这里更象一个has-a而不是is-a。

24 楼 Elminster 2008-05-09

ajoo 写道

其实很多人还是更偏向你这个写法的。我的那个也不见得就比这个好。只不过它更“有趣”，更值得聊。

有几个考虑我来说一下哈：

1. Base.GetProperty<String>()是不行滴，因为erasure，你要写成getProperty(String.class, "name", "")，写起来不是那么爽快。
2. 这样客户代码要依赖Base这个具体类，而不是一个简单地接口。测试就不够方便了，类型安全没了，重构也比较麻烦了。比如你要测试id为0的情况，不能直接expect(foo.id()).andReturn(0)，而是要map.put("id", "0")。当然，你可以让Foo实现一个接口，不过这样就比较麻烦了，又要写类，又要写接口。
3。不是你这个方法的问题。在java里面，一般应该是组合而不是继承Base。

1. 木有想到 …… java 的泛型这么弱？是所有的泛型函数调用都要这样，还是 String 比较特殊？
2. 原来你的方案，也要依赖你这个泛型类 PropertyConverter<T> 吧？这和依赖 Base 区别在哪里？而且我没有发现哪里损失了类型安全，说来听听？
3. 哪个面向对象语言里面都是组合优于继承，OO 原则么。不过我觉得这种地方用继承更直截了当，目前也看不见什么更复杂的东西。将来若是这里真的变复杂了，也可以重构。

23 楼 quaff 2008-05-09

Elminster 写道

quaff 写道

这种代码差不多所有人都会写,还不如GetProperty做成静态方法然后引入,还去掉了必须继承Base这个限制

是啊，这种代码所有人都会写，这难道不好么？
GetProperty 做成静态方法也可以，这样每个 Foo 需要自己内部保存 map 的实例，多费一点功夫。在我看来，这个交换不太合算。

我的意思是大家都会的就没什么必要拿来讨论了,还有java不能多重继承,所以最好不要弄出个Base来

22 楼 ajoo 2008-05-09

Elminster 写道

quaff 写道

这种代码差不多所有人都会写,还不如GetProperty做成静态方法然后引入,还去掉了必须继承Base这个限制

静态方法不太好，最好是一个对象，只不过不是继承Base，而是包含一个MapConverter。

不过，问题还是一样，就是测试不方便，测试代码不够类型安全，也不容易重构。

21 楼 Elminster 2008-05-09

quaff 写道

这种代码差不多所有人都会写,还不如GetProperty做成静态方法然后引入,还去掉了必须继承Base这个限制

20 楼 ajoo 2008-05-09

Elminster 写道

ajoo 写道

主要是这个默认值，<script type="text/javascript" src="http://www.iteye.com/javascripts/tinymce/themes/advanced/langs/zh.js"></script><script type="text/javascript" src="http://www.iteye.com/javascripts/tinymce/plugins/javaeye/langs/zh.js"></script>除了annotation想不到别的好办法解决。

别的人也给了些建议，比如自己写一个Property<T>类，在这个类里面实现类型转换和默认值处理。不过都要求比较多的代码，而且用起来客户代码还要依赖于一个不是很容易mock的Property类。反而不如动态代理简单干净，侵入性基本没有。用起来可以注射进一个接口，而不是PropertyConverter类，这样最容易测试。

你要用随便啦。反正都贴在blog里了，随便拷贝。

我比较笨，想不出来为什么写一个类负责转换会要求更多的代码，如下（木有写过 java，语法错误莫怪）：

public abstract class Base
{
    private final Map<String, String> _map;
    public Base(Map<String, String> map) { _map = map; }
    public T GetProperty<T>(String key, T defaultValue)
    {
        String value = _map.get(key);
        if (value == null) {
            if (defaultValue == null) {
                throw ...;
            }
            return defaultValue;
        }
        return convert(value);
    }
}

public final class Foo : Base
{
    public Foo(Map<String, String> map) : base(map) {}

    public int id() { return Base.GetProperty<int>("id", null); }
    public String name() { return Base.GetProperty<String>("name", ""); }
    Gender sex() { return Base.GetProperty<Gender>("sex", null); }  
}
   
Map<String, String> map = ...;
Foo foo = new Foo(map);
foo.id();
foo.name();

当然啦，这个看起来木有你原来那个帅，不过相对而言要好懂一些吧？而且处理方法名和属性名不同的情况也不用额外多费手脚了。

其<script type="text/javascript" src="http://www.iteye.com/javascripts/tinymce/themes/advanced/langs/zh.js"></script><script type="text/javascript" src="http://www.iteye.com/javascripts/tinymce/plugins/javaeye/langs/zh.js"></script>实很多人还是更偏向你这个写法的。我的那个也不见得就比这个好。只不过它更“有趣”，更值得聊。

19 楼 ajoo 2008-05-09

<p>怎么回事？javaeye bug？删除</p>

18 楼 quaff 2008-05-09

Elminster 写道

ajoo 写道

主要是这个默认值，除了annotation想不到别的好办法解决。

别的人也给了些建议，比如自己写一个Property<T>类，在这个类里面实现类型转换和默认值处理。不过都要求比较多的代码，而且用起来客户代码还要依赖于一个不是很容易mock的Property类。反而不如动态代理简单干净，侵入性基本没有。用起来可以注射进一个接口，而不是PropertyConverter类，这样最容易测试。

你要用随便啦。反正都贴在blog里了，随便拷贝。

我比较笨，想不出来为什么写一个类负责转换会要求更多的代码，如下（木有写过 java，语法错误莫怪）：

public abstract class Base
{
    private final Map<String, String> _map;
    public Base(Map<String, String> map) { _map = map; }
    public T GetProperty<T>(String key, T defaultValue)
    {
        String value = _map.get(key);
        if (value == null) {
            if (defaultValue == null) {
                throw ...;
            }
            return defaultValue;
        }
        return convert(value);
    }
}

public final class Foo : Base
{
    public Foo(Map<String, String> map) : base(map) {}

    public int id() { return Base.GetProperty<int>("id", null); }
    public String name() { return Base.GetProperty<String>("name", ""); }
    Gender sex() { return Base.GetProperty<Gender>("sex", null); }  
}
   
Map<String, String> map = ...;
Foo foo = new Foo(map);
foo.id();
foo.name();

当然啦，这个看起来木有你原来那个帅，不过相对而言要好懂一些吧？而且处理方法名和属性名不同的情况也不用额外多费手脚了。

这种代码差不多所有人都会写,还不如GetProperty做成静态方法然后引入,还去掉了必须继承Base这个限制

17 楼 quaff 2008-05-09

ajoo 写道

quaff 写道

ajoo 写道

引用

很优雅,很有创意,改进了两点
1.能够自动为基本类型赋默认值,比如 int id();不用写成 int id() default 0,还有支持enum类型转化;

原始的需求是所有的域都是缺省强制的，如果map里面没有是要抛异常的。所以不能自动提供默认值。enum本来就是支持的，只要自己在converter bean里面注册一个enum converter就是了。ConvertUtils不能直接用，它对非法字符串保持沉默而不抛异常。所以要自己用ConvertUtilsBean。

引用

2.支持getter,方便jstl,ognl之类的表达式, name()和getName()是一样的

哦，在annotation里，没有getName()这个命名规范的。不用操心的吧？

其实，可以另外弄一个annotation来处理key的名字和方法名不匹配的情况：

@Rentention(RUNTIME)
@Target(METHOD)
@interface Property {
  String value();
}

@interface Foo {
  @Property("标识符")
  int id();
  String name() default "";
}

1.需要手动注册enum converter还不如直接写在这个里面,也就是两行代码
2.在annotation里面增加getName()是为了能够在EL里面可以用xxx.name

还有这个@Property("标识符")起什么作用?也不能用EL在UI上面显示出来.

怎么转换enum就是具体实现方法了。我是因为有一个单独可重用的ConvertUtilsBean负责转换所有类型，所以直接拿过来用了，你自己写也可以的。

至于@Property么，用来处理你的Map里面的key和方法名不能匹配的情况，比如例子里面Map的key是“老婆，出来看标识符”，你总不能把方法名字也写这么一大长串吧？（除非你是中文编程的扇子）。ui么，呵呵，俺不知道。这个ui不能被定制的么？

叫@Alias更好一些,我以为你把它当label显示在UI上面,UI上面一般都是用EL来获取值,如果你要在UI里面写java代码也没说不可以.

16 楼 Elminster 2008-05-09

ajoo 写道

我比较笨，想不出来为什么写一个类负责转换会要求更多的代码，如下（木有写过 java，语法错误莫怪）：

public abstract class Base
{
    private final Map<String, String> _map;
    public Base(Map<String, String> map) { _map = map; }
    public T GetProperty<T>(String key, T defaultValue)
    {
        String value = _map.get(key);
        if (value == null) {
            if (defaultValue == null) {
                throw ...;
            }
            return defaultValue;
        }
        return convert(value);
    }
}

public final class Foo : Base
{
    public Foo(Map<String, String> map) : base(map) {}

    public int id() { return Base.GetProperty<int>("id", null); }
    public String name() { return Base.GetProperty<String>("name", ""); }
    Gender sex() { return Base.GetProperty<Gender>("sex", null); }  
}
   
Map<String, String> map = ...;
Foo foo = new Foo(map);
foo.id();
foo.name();

当然啦，这个看起来木有你原来那个帅，不过相对而言要好懂一些吧？而且处理方法名和属性名不同的情况也不用额外多费手脚了。

15 楼 ajoo 2008-05-09

quaff 写道

ajoo 写道

引用

很优雅,很有创意,改进了两点
1.能够自动为基本类型赋默认值,比如 int id();不用写成 int id() default 0,还有支持enum类型转化;

引用

2.支持getter,方便jstl,ognl之类的表达式, name()和getName()是一样的

哦，在annotation里，没有getName()这个命名规范的。不用操心的吧？

其实，可以另外弄一个annotation来处理key的名字和方法名不匹配的情况：

@Rentention(RUNTIME)
@Target(METHOD)
@interface Property {
  String value();
}

@interface Foo {
  @Property("标识符")
  int id();
  String name() default "";
}

14 楼 quaff 2008-05-09

ajoo 写道

引用

很优雅,很有创意,改进了两点
1.能够自动为基本类型赋默认值,比如 int id();不用写成 int id() default 0,还有支持enum类型转化;

引用

2.支持getter,方便jstl,ognl之类的表达式, name()和getName()是一样的

哦，在annotation里，没有getName()这个命名规范的。不用操心的吧？

其实，可以另外弄一个annotation来处理key的名字和方法名不匹配的情况：

@Rentention(RUNTIME)
@Target(METHOD)
@interface Property {
  String value();
}

@interface Foo {
  @Property("标识符")
  int id();
  String name() default "";
}

13 楼 ajoo 2008-05-08

myyate 写道

armorking 写道

ajoo 写道

bottom 写道

BeanUtils.copyProperties(foo, map);

这个，不管在必须的property不存在的情况下报错吧？而且，BeanUtils是1.5以前的吧？管enum么？

BeanUtils与ConvertUtilsBean都是“org.apache.commons.beanutils ”提供的
而且BeanUtils.copyProperties方法正是用ConvertUtilsBean实现的类型转换
如果BeanUtils搞不定enum的话，ConvertUtilsBean就可以了么？

ConvertUtilsBean和enum或者jdk1.5没有任何关系的，不就是进行enum转换嘛，你写个EnumConverter注册到ConvertUtilsBean就行了。

convert()函数就是这么用的。问题是，BeanUtils.copyProperties()能自动使用我的enum converter么？还有报错怎么解决？

发表评论

您还没有登录,请您登录后再发表评论

最近访客更多访客>>

博主相关

文章分类

社区版块

存档分类

最新评论