设计帮助！枚举工厂变压器中的java泛型！

Question

我想知道我是否可以获得一些关于设计这个的好方法的意见。我将提出我的方法，但我认为有更好的解决方案（因此有问题:)）。

我想创建一个枚举（以明确选项并避免单例架构），它具有用于从另一个对象创建一个对象的访问器。但这些对象的内容非常灵活。

将其视为限制此转换的选项数量的一种方法。

让我简单介绍一下层次结构。如果我要从一组不同的对象变成这样的东西：

class Base {...}
class ValueA extends Base {...}
class ValueB extends Base {...}

我正在考虑做这样的事情：

public enum ValueTransformer{
  VALUE_A{

    @Override
    public <T> T createVo (Class<T> expectedRtn, Object obj) {
      ValueA retObj = null;

      if (expectedRtn == getReturnType ()) {
        if (obj != null && CanBeTranslatedToA.class == obj.getClass ()) {
          retObj = new ValueA ();
          /*...*/
        }
      }

      return retObj;
    }

    @Override
    public Class<ValueA> getReturnType () { return ValueA.class; }

  },
  VALUE_B {
    @Override
    public Class<ValueB> getReturnType () { return ValueB.class; }

    @Override
    public <T> T createVo (Class<T> expectedRtn, Object obj) {
      ValueB retObj = null;

      if (expectedRtn == getReturnType ()) {
        if (obj != null && CanBeTranslatedToB.class == obj.getClass ()) {
          retObj = new ValueB ();
          /*...*/
        }  else if (obj != null && AnotherClassForB.class = obj.getClass ()){
          retObj = new ValueB();
          /* ... */
        }
      }

      return retObj;
    }
  };

  public abstract <T> Class<T> getReturnType ();
  public abstract <T> T createVo (Class<T> expectedRtn, Object obj);
}

这是一个不错的设计吗？这个枚举可能会增长，并且可以创建的 ValueA 和 ValueB 可能会改变（随着系统的增长）。在所有这些情况下我都可以返回“Base”，但这需要演员表和检查。我宁愿没有那个。

我是否需要有expectedRtn参数？我应该使用泛型吗？我对 Java 相当陌生，所以我并不总是确定处理这种情况的最佳方法。

感谢您的任何提示！

Answer 1

这不是一个很好的设计，我什至不知道这个枚举想要完成什么。首先，您使用每个枚举值实现的通用方法，这意味着该方法的调用者可以决定他们希望T成为什么类型...但这不是您想要的，因为这些方法实际上对它们将返回的对象类型有自己的看法。

Class<String> foo = ValueTransformer.VALUE_B.getReturnType();
String string = ValueTransformer.VALUE_A.createVo(String.class, "");

考虑到您的代码，上述内容是完全合法的，但您的代码实际上并未处理此问题。通用方法并不像您想象的那样做。

我觉得您真正想要的只是一种将特定类型的对象转换为 ValueA 或 ValueB 类型的对象的简单方法。最简单的方法是让每个可以以这种方式转换的类提供一个在每个此类上执行此操作的方法：

public class CanBeTranslatedToB {
  ...

  public ValueB toValueB() {
    ValueB result = new ValueB();
    ...
    return result;
  }
}

然后，如果您有一个 CanBeTranslatedToB 实例，而不是这样做：

 CanBeTranslatedToB foo = ...
 ValueB b = ValueTransformer.VALUE_B.createVo(ValueB.class, foo);

你只需这样做：

CanBeTranslatedToB foo = ...
ValueB b = foo.toValueB();

这更清晰，并且不像枚举版本那样容易出错。

如有必要，您可以执行各种操作来简化此操作，例如创建一个定义 toValueA() 和 toValueB() 方法的接口，以及创建帮助程序类来提供任何常见的所有实现都需要使用的行为。我不认为像您所描述的那样有任何用处。

编辑：

如果您无法更改需要转换为ValueB等的类的代码，您有多种选择。最简单（在我看来可能是最好的）处理方法是向 ValueA 和 ValueB 添加工厂方法，例如：

// "from" would be another good name
public static ValueB valueOf(CanBeTranslatedToB source) {
  ...
}

public static ValueB valueOf(AnotherClassForB source) {
  ...
}

那么你可以这样写：

CanBeTranslatedToB foo = ...
ValueB b = ValueB.valueOf(foo);

如果你如果您不想在 ValueB 上使用这些方法，您可以将它们放在另一个类中，其方法名称类似于 newValueB(CanBeTranslatedToB)。

最后，另一种选择是使用 Guava 并创建一个 函数。这是最接近您的原始设计的，但它是类型安全的，并且可以与 Guava 提供的所有接受函数的实用程序配合良好。您可以根据需要在类中收集这些 Function 实现。下面是一个单例实现从 Foo 到 ValueB 转换的示例：

public static Function<Foo, ValueB> fooToValueB() {
  return FooToValueB.INSTANCE;
}

private enum FooToValueB implements Function<Foo, ValueB> {
  INSTANCE;

  @Override public ValueB apply(Foo input) {
    ...
  }
}

但是，我不会使用它作为执行此操作的唯一方法转换...如果您的应用程序需要转换整个对象集合，最好使用我上面提到的静态 valueOf 方法，并提供此类 Function 只是为了方便一下子很多。

Answer 2

关于泛型，Java 没有“真正的”泛型，在这种情况下这既有利又有害。当您在编译时不确切知道正在处理的对象类型时，使用泛型会很棘手。如果使用此信息的代码实际上知道它应该从对 ValueTransformer.ValueA.createVo 的调用中期望得到哪种类型的对象，那么它应该诚实地期望转换返回的值。我希望调用看起来更像这样：

MyTypeA myType = (MyTypeA)ValueTransformer.ValueA.createVo(sourceObject);

如果我从此方法中得到错误的类型，我宁愿在这一行（问题真正发生的地方）看到一个 Cast 异常，而不是稍后看到空指针异常。这是正确的“快速失败”做法。

如果您真的不喜欢显式转换，我看到了一个很酷的技巧，可以让您隐式转换这些内容。我认为它是这样的：

public abstract <T> T createVo (Object obj) {...}

MyTypeA myType = ValueTransformer.ValueA.createVo(sourceObject);

但是，我并不真正推荐这种方法，因为它仍然在运行时执行强制转换，但没有人会通过查看您的使用代码来怀疑这一点。

我可以看到您可能希望实现的一些目标：

1. 对于给定基类的所有对象，有一个单一的“事实来源”。
2. 允许在每次请求时创建给定对象的实例。
3. 具有类型安全并避免在运行时进行强制转换。

除非你有我没有想到的其他要求，否则工厂似乎会更好：

public class ValueFactory
{
    public ValueA getValueA(Object obj) {return new ValueA();} 
    public ValueB getValueB(Object obj) {return new ValueB();}
}

这满足了上述所有要求。此外，如果您知道生成 ValueA 对象需要什么类型的对象，则可以对输入值使用更明确的类型。

Answer 3

我花了一些时间，终于成功实现了基于枚举的工厂，看起来就像您正在寻找的那样。

这是我工厂的源代码：

import java.net.Socket;

public enum EFactory {
    THREAD(Thread.class) {
        protected <T> T createObjectImpl(Class<T> type) {
            return (T)new Thread();
        }
    },
    SOCKET(Socket.class) {
        protected <T> T createObjectImpl(Class<T> type) {
            return (T)new Socket();
        }
    },
    ;

    private Class<?> type;

    EFactory(Class<?> type) {
        this.type = type;
    }

    protected abstract <T> T createObjectImpl(Class<T> type);

    public <T> T createObject(Class<T> type) {
        return assertIfWrongType(type, createObjectImpl(type));
    }

    public <T> T assertIfWrongType(Class<T> type, T obj) {
        if (!type.isAssignableFrom(obj.getClass())) {
            throw new ClassCastException();
        }
        return obj;
    }
}

这是我如何使用它。

Thread t1 = EFactory.THREAD.createObject(Thread.class);
String s1 = EFactory.THREAD.createObject(String.class); // throws ClassCastException

我个人不太喜欢这个实现。 Enum 被定义为 Enum，因此不能在类级别进行参数化。这就是类参数（在我的示例中为 Thread 和 Socket）必须传递给工厂方法本身的原因。此外，工厂实现本身包含会产生警告的强制转换。但从另一方面来看，至少使用这个工厂的代码足够干净并且不会产生警告。