关于java：用于强制执行一致性的接口上的静态方法的替代方法


Alternatives to static methods on interfaces for enforcing consistency

在爪哇，我希望能够定义标记接口，强制实现提供静态方法。例如，对于简单的文本序列化/反序列化，我希望能够定义如下所示的接口：

1
2
3
4
5
public interface TextTransformable<T>{

  public static T fromText(String text);

  public String toText();

因为Java中的接口不能包含静态方法(如在许多其他的帖子/线程中所指出的：这里，这里，这里，这个代码不起作用)。

然而，我要寻找的是一些合理的范例来表达相同的意图，即对称方法，其中一个是静态的，由编译器强制执行。现在我们能想到的最好的方法是某种静态工厂对象或通用工厂，这两者都不是真正令人满意的。

注意：在我们的例子中，我们的主要用例是我们有许多，许多"值对象"类型——枚举，或者其他具有有限值的对象，通常不带超出其值的状态，我们每秒解析/反解析数千次，所以实际上关心重用实例(如float、integer等)及其对内存使用的影响。MPEE/G.C.

有什么想法吗？

Edit1：为了消除一些混乱，我们有许多不同的对象适合这个模式，实际上我们正试图为具有两种语义的调用者提供一些优雅的东西：

  • 作为合同的接口-访问的统一性(例如，可作为功能进行文本转换)
  • 需要通过子类/实现实现实现(例如强制它们实现自己的转换)

就我们对轻量级的想法而言，工厂——它们都是我们考虑过的选择，实际上，我们正在尝试寻找一种比依赖JavaDoc说的"实现工厂并委托调用它，或者通过约定在XXX位置公开它"更优雅的东西。

这非常适合飞锤。这基本上就是你想要用静力学来完成的。关于如何服务于飞锤物体，使你不创造数千个，这里有一些想法。

一个是工厂，你陈述了你的想法和拒绝，虽然你没有陈述原因(所以其他的想法可能会遇到同样的问题)，所以我不会进入它。

另一种方法是让值类型具有一个可以为其转换器服务的方法。像这样：

1
2
3
 public class ValueType {
       public static final TextTransformable<ValueType> CONVERT = ....
 }

然后像这样使用：

1
2
3
 ValueType value = ValueType.CONVERT.fromText(text);

 String text = ValueType.CONVERT.toText(value);

现在，这并不能强制所有的ValueType通过相同的机制提供它们的转换器，因为我认为您需要某种类型的工厂。

编辑：我想我不知道你在工厂里发现了什么不雅的地方，但我认为你关注的是打电话的人，所以这对你来说是什么感觉：

1
  ValueType value = getTransformer(ValueType.class).fromText(text);

上述操作可以通过工厂的静态导入和具有如下签名的方法完成：

1
2
3
   public static <T> TextTransformable<T> getTransformer(Class<T> type) {
         ...
   }

找到合适的转换器的代码并不一定是最漂亮的，但从调用者的角度来看，一切都很好地呈现出来。

编辑2：再进一步考虑，我看到你想要控制对象构造。你不能真的那样做。换句话说，在Java中，不能强制实现者使用或不使用工厂来创建对象。它们始终可以公开公共构造函数。我认为你的问题是你对强制施工的机制不满意。如果这种理解是正确的，那么可以使用以下模式。

创建的对象只包含包装值类型的私有构造函数。对象可以有一个泛型类型参数来了解它包装的值类型。这个对象是用一个静态的工厂方法实例化的，该方法使用一个工厂接口来创建"real"值对象。所有使用该对象的框架代码只将该对象作为参数。它不直接接受值类型，如果没有值类型的工厂，则无法实例化该对象。

这种方法的问题在于它是非常有限的。只有一种方法可以创建对象(工厂接口支持的对象)，并且使用值对象的能力有限，因为代码处理这些文本元素仅通过该对象进行有限的交互。

我想他们说没有一个软件问题不能通过一个额外的间接层来解决，但这可能是一个桥梁太远了。至少它是思考的食物。

相关讨论

只需考虑一个想法：您可以将转换逻辑与对象本身分离开来，然后拥有一组固定的转换器，实现以下接口：

1
2
3
4
5
6
public interface Transformer<T>{

  public T fromText(String text);

  public String toText(T obj);
}

实际的数据类可以有一个getTransformer()方法，该方法为它们返回正确的转换器。

相关讨论

一个完全不同的方法(以及一个丑陋的黑客方法)是让接口有一个返回方法的方法。

1
2
3
public interface MyInterface{
    Method getConvertMethod();
}

现在您的客户机代码可以

1
yourInterface.getConvertMethod().invoke(objectToBeConverted);

这是非常强大，但非常糟糕的API设计

肖恩

相关讨论

只是一个不同的想法。不适用于所有情况，但可以帮助其他人。

您可以使用abstract class作为您的interface和concrete classes之间的桥梁。抽象类允许静态方法以及收缩方法定义。例如，您可以查看collection api，其中sun实现了几个抽象类，而不是从零开始的所有具体类的强力编码。

在某些情况下，您可以用抽象类替换接口。

如果运行在Java 5或更高版本中，可以使用EnUM类型——所有这些都是按定义定义的。所以你可以这样做：

1
2
3
4
5
6
7
8
9
10
public enum MyEnumType {
    Type1,
    Type2,
    //....
    TypeN;

    //you can do whatever you want down here
    //including implementing interfaces that the enum conforms to.

}

这样，内存问题就消失了，您可以实现单个行为实例。

编辑：如果您没有访问枚举(1.4或更早版本)的权限，或者由于其他原因，它们对您不起作用，那么我建议您使用flyweight模式实现。

相关讨论

似乎您需要将工厂从创建的对象中分离出来。

1
2
3
4
public interface TextTransformer<T> {
    public T fromText(String text);
    public String toText(T source);
}

您可以根据需要注册TextTransformer类：

1
2
3
4
public class FooTextTransformer implements TextTransformer<Foo> {
    public Foo fromText(String text) { return ...; }
    public String toText(Foo source) { return ...; }
}

如果您希望footerxtTransformer是单例的，那么可以使用类似spring的容器来实现这一点。Google已经启动了一个项目，从代码库中删除所有手动强制的单例，但是如果你想做一个老式的单例，你可以使用一个实用程序类：

1
2
3
4
5
public class TextTransformers {
    public static final FooTextTransformer FOO = new FooTextTransformer();
    ...
    public static final BarTextTransformer BAR = new BarTextTransformer();
}

在客户代码中：

1
2
3
4
5
Foo foo = TextTransformers.FOO.fromText(...);
...
foo.setSomething(...);
...
String text = TextTransformers.FOO.toText(foo);

这只是我头顶上的一个方法。

正如@aperkins所说，您应该使用枚举。

枚举基类enum提供将字符串转换为实例的方法的valueof。

1
2
3
4
5
enum MyEnum { A, B, C; }
// Here's your toText
String strVal = MyEnum.A.getName();
// and here's your fromText
MyEnum value = MyEnum.valueOf(MyEnum.class, strVal);

更新：对于那些是枚举的，这可能会满足您的需要。它使用反射，因此您只需要在必须处理遗留值的枚举上实现EnumHelper。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
/** Enums can implement this to provide a method for resolving a string
  * to a proper enum name.
  */
public interface EnumHelp
{
    // Resolve s to a proper enum name that can be processed by Enum.valueOf
    String resolve(String s);
}

/** EnumParser provides methods for resolving symbolic names to enum instances.
  * If the enum in question implements EnumHelp, then the resolve method is
  * called to resolve the token to a proper enum name before calling valueOf.
  */
public class EnumParser
{
    public static <T extends Enum<T>> T fromText(Class<T> cl, String s) {
        if (EnumHelp.class.isAssignableFrom(cl)) {
            try {
                Method resolve = cl.getMethod("resolve", String.class);
                s = (String) resolve.invoke(null, s);
            }
            catch (NoSuchMethodException ex) {}
            catch (SecurityException ex) {}
            catch(IllegalAccessException ex) {}
            catch(IllegalArgumentException ex) {}
            catch(InvocationTargetException ex) {}
        }
        return T.valueOf(cl, s);
    }

    public <T extends Enum<T>> String toText(T value)
    {
        return value.name();
    }
}
相关讨论