0

我想知道这种设计是对是错还是两者兼而有之。
我有一个包含多个组件（对象）的应用程序，每个组件都有一个配置（标志、功能等）。在任何时候，我都想从对象中检索配置。
为此，我这样做了：

class ConfigRetriever {
    public String getConfigString() {
        String configString = "";   
        configString += "component 1 flag : "+component1.getFlag()+"\n";
        configString += "component 2 flag : "+component2.getFlag()+"\n";
        // ...
        return( configString );
    }
}

在其他地方，当需要配置时：

class SomeClass {
    public void someMethod() {
        ConfigRetriever configRetriever = new ConfigRetriever(); 
        String configString = configRetriever.getConfigString();
            // Do some stuff with configString...
    }
}

我是对象编程的新手，为一个特定的操作创建一个对象（ConfigRetriever）仍然感觉很奇怪（即使该对象能够做其他事情）。
我也考虑过单例模式，有这样的事情： 

String configString = ConfigRetriever.getInstance().getConfigString();

这是一条简洁的线，但是由于对象一直保留在内存中直到应用程序结束，我真的不知道什么是对的，什么是错的。

我的设计可以更好吗？如何 ？为什么 ？

更新
感谢您的回答。我认为我的问题有点混乱，我错过了我所要求的重点。
整个配置和组件的故事在这里作为我正在处理的那种情况的一个例子。这是快速而肮脏的代码，我应该警告你。真正的问题是：“只创建一次（或有时）创建一个对象以访问其方法之一是否很好？” 好吧，阅读您的答案并再次考虑它，似乎正确的答案是“这取决于您的目标、课程、职责等......”
我想将信息存储在我的对象中吗？不能是静态方法。
使用永久记忆的单身人士是否有问题？大多数时候是这样，因为我认为您必须有充分的理由在内存中维护具有全局状态的对象。所以，大多数时候：没有单例。

最后，创建一个用于实例化对象的类是否有问题？不是，加油！:-)

4

3 回答 3

1

我认为这里不需要单身。

为单个操作创建对象并不奇怪，但如果您经常调用该方法可能效率不高。我认为你能做的最好的就是使用依赖注入：

class SomeClass {
    private final ConfigRetriever retriever;
    public SomeClass(ConfigRetriever retriever) {
        this.retriever = retriever;
    }
    public void someMethod() {
        // use this.retriever here
    }
}
于 2012-09-28T17:22:55.497 回答
1

还没有人提到static方法。一个典型的 Java 模式是使用一个静态方法，您可以在没有类实例的情况下对其进行分类。就像是：

class ConfigRetriever {
   public static String getConfigString() {
      StringBuilder sb = new StringBuilder();
      sb.append("component 1 flag : ").append(component1.getFlag()).append('\n');
      sb.append("component 2 flag : ").append(component2.getFlag()).append('\n');
      // ...
      return sb.toString();
   }
}

因此，这允许您执行以下操作：

// call the static method on the class, not on an instance
String configString = ConfigRetriever.getConfigString();

由于您没有实例，因此您无法将状态存储在ConfigRetriever. 我不确定component1和component2对象是从哪里来的。

请注意，我将您的getConfigString()方法转换为使用比在内部实际使用多个StringBuilder()类的方法更有效的类。+= StringBuilder

于 2012-09-28T18:42:40.987 回答
0

几个问题 -
A. 您的原始代码有一个返回名为 getConfigString 的 void 的方法 - 这应该被修复。
B. 另外，在 ConfigRetriever 类中，组件提供给什么地方也不清楚。
C. 您可以选择一些选项：

1. 有 ConfigProvider 类层次结构，它将与您的组件层次结构相匹配 -
如果您有名为 ComputerComponent 的类，您将有一个匹配的 ComptuerConfigProider。
您可以考虑在 Component 类中使用 ConfigProider getConfigProvider 方法。

public abstract class Component {
   public abstract ConfigProvider getConfigProvider()'
}

然后一个具体的类可能看起来像：

public class ComputerComponent extends Component {
   public ConfigProvider getConfigProvider() { 
       return new ComputerConfigProvider(this);
   }
}




2. 与第一个类似的解决方案，但只有一个 ConfigProvider 类，上面有添加配置组件的方法。
例如，假设 ConfigurationProvider 仅包含键和值的映射。
在这种情况下，您的代码可能如下所示：

public class ConfigProvider {

    private Map<String,String> internalMap = new HashMap<String,String>();
    public String getConfigProvider() {
      //Return a string representation of the internal map
    }

    public ConfigProvider addConfigElement(String key,String value) {
        map.put(key,value); 
        return this;
    }
}

public class ComputerComponent extends Component {
    private int memory;
    private String cpu;
    public ConfigProvider getConfigProvider() {
       ConfigProvider configProvider = new ConfigProvider();
       return configProvider.addConfigElement("memory",Integer.toString(memory)).
       addConfigElement("cpu",cpu);
    } }




3. 如果你仍然想使用单调
——因为你的配置依赖于组件状态，所以有一个配置提供者单调是错误的，除非你把 getConfigProvider 变成一个“无状态”的方法——

String getConfigString(Component component)

但在这种情况下，您可能会考虑不使用单调，而只是使用静态方法，代码将如下所示：

public class ConfigurationProvider {
   public static String getConfigString(Component component) {
     StringBuilder sb = new StringBuilder();
     //Append the component values to the string builder
     return sb.toString();
   }
}
于 2012-09-28T17:32:20.270 回答