我有senderA和senderB，它们都实现了sender和两个单态，我有一个SenderWrapper(可能实现ISenderWrapper(类，我想把SenderA和SenderB表示为某种静态常数。
我正在运行时使用Guice获取实例senderA和senderB。
我正在运行时创建SenderWrapper类的许多实例(每个请求一个(，我想在这些类中以某种方式表示senderA和senderB。我将在SenderWrapper中定义的一些方法中使用它们。
我有几个解决方案：
-
我有两个非静态字段
senderA和senderB，我从构造函数传递它们。(也许我也可以注射，但我担心性能( -
我可以为
senderA和senderB设置静态字段，并在运行时在Guice模块中设置它们。但问题是，这些字段不会是常量，并且会发送错误的消息，即它可能在运行时更改。
public class SenderWrapper implements ISenderWrapper {
public static Sender senderA = null;
public static Sender senderB = null;
public void dummyMethod() {
senderA.send(); senderB.send();
}
}
//in Guice module
@Provides
public providesSenderA(){
Sender senderA = new SenderA();
SenderWrapper.senderA = senderA;
return senderA;
}
- 我当前的解决方案是使用
Enum类来表示senderA和senderB。类似于
enum Senders {
senderA, senderB
}
我有一种感觉，这与第2点中提到的解决方案类似，至少在功能上是这样。我只是讨厌使用枚举。
对于这种情况，最好、最优雅的方法是什么？我不介意重构，用某种程度的间接方法来解决这个问题。
为什么不有一个Enum(稍微重命名了一下，这样我们就知道它是一个枚举，而不是一个类(，如下所示：
enum SenderType {
SENDER_A, SENDER_B
}
然后让你的课像这样：
public abstract class SenderBase {
public final SenderType myType;
public SenderBase(SenderType pType) {
myType = pType;
}
// optional getter
public SenderType getType() {
return myType;
}
public void send() {
// here, send myType to socket.
// best is to send myType.name(), because ordinal WILL change when you re-order the enums in their enum class.
// or, if you have different send() implementations for A and B, make this method abstract (and empty, remove body) so you FORCE A and B to implement it.
}
}
你的类实现是这样的：
class SenderA extends SenderBase {
public SenderA () {
super(SenderType.SENDER_A);
}
}
class SenderB extends SenderBase {
public SenderB () {
super(SenderType.SENDER_B);
}
}
并通过构建
SenderA senderA = new SenderA();
SenderB senderB = new SenderB();
和你的包装：
public abstract class SenderWrapper {
public final SenderA mySenderA;
public final SenderB mySenderB;
public SenderWrapper() {
mySenderA = new SenderA();
mySenderB = new SenderB();
}
public void send() {
mySenderA.send();
mySenderB.send();
}
}
实际上，现在我考虑一下Wrapper，它甚至可能有一个(数组(列表，您可以在其中添加所有实现，并在send()中对它们进行迭代。
答案是匿名类。
在我的Guice模块中，我这样做：
//in Guice module
@Provides
public providesSenderWrapper(final SenderA senderA, final SenderA, senderB){
return new ISenderWrapper {
@Override
public Send() {
senderA.send(); senderB.send();
}
}
}
在类中使用有效常量的巧妙方法。