blocks|key|1528791|text|只包含静态方法和字段的类是可能的吗？我不确定你的情况到底是什么，但可能值得一查。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1528792|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Is a class that contains only static methods and fields possible? I'm not sure of exactly what your situation is, but it might be worth looking into.

blocks|key|227201|text|最好的方法是使用工厂模式。当您构造类的新实例(在工厂中)时，您可以将“全局”数据插入到新构造的对象中，作为对单个实例(存储在工厂类中)的引用，或者通过将相关数据复制到新对象中。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|227202|然后，您的所有对象都将包含过去存在于单例中的数据。我不认为总体上有太大的区别，但它可以使您的代码更容易阅读。|227203|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

The best way is to use a Factory pattern instead. When you construct a new instance of your class (in the factory) you can insert the 'global' data into the newly constructed object, either as a reference to a single instance (which you store in the factory class) or by copying the relevant data into the new object.

All your objects will then contain the data that used to live in the singleton. I don't think there's much of a difference overall, but it can make your code easier to read.

blocks|key|1526937|text|我可能在这里陈述了一个显而易见的事实，但是你有什么理由不能使用Spring或Guice这样的依赖注入框架吗？(我相信Spring现在也可以用于.NET+)。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1526938|这样，框架可以保存配置对象的单个副本，并且您的bean(服务、DAO等)不必担心查找它。|1526939|这是我通常采用的方法！|1526940|entityMap|0|LINK|mutability|MUTABLE|url|http://www.springframework.org/|1|http://code.google.com/p/google-guice/^0|V|6|0|12|5|1|0|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@$A|S|B|T|1|U]|$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|Z|8|@]|9|@]|C|$]]|$1|H|3|-4|5|6|7|10|8|@]|9|@]|C|$]]]|I|$J|$5|K|L|M|C|$N|O]]|P|$5|K|L|M|C|$N|Q]]]]

I might be stating the obvious here, but is there a reason why you can't use a dependency-injection framework such as <a href="http://www.springframework.org" rel="nofollow noreferrer">Spring</a> or <a href="http://code.google.com/p/google-guice/" rel="nofollow noreferrer">Guice</a>? (I believe Spring also is available for .NET as well now).

That way, the framework can hold a single copy of the configuration objects, and your beans (services, DAOs, whatever) don't have to worry about looking it up.

This is the approach I usually take!

blocks|key|227243|text|可能也不是很干净，但是您可以将想要更改的信息位传递给创建单例的方法--而不是使用|type|unstyled|depth|inlineStyleRanges|entityRanges|data|227244|public+static+Singleton+getInstance()+{
++++if(singleton+!=+null)
++++++++createSingleton();
++++++++return+singleton;
++++}
}|code-block|syntax|javascript|227245|您可以在应用程序启动时(以及在单元测试的设置方法中)直接调用createSingleton(Information+info)。|offset|length|style|CODE|227246|entityMap^0|0|0|U|X|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Maybe not very clean either, but you could maybe pass the information bits you want to have changed to the method that creates the singleton -- instead of using

<pre><code>public static Singleton getInstance() {
 if(singleton != null)
 createSingleton();
 return singleton;
 }
}
</code></pre>

you could call <code>createSingleton(Information info)</code> directly on application startup (and in the setUp-Methods of the unit tests).

blocks|key|227509|text|如果您使用Spring+Framework，则可以只创建一个常规bean。默认情况下(或者如果显式设置了scope="singleton")，只创建bean的一个实例，并且每次在依赖项中使用该bean或通过getBean()检索该bean时，都会返回该实例。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|227510|您可以获得单个实例的优势，而无需耦合Singleton模式。|227511|entityMap|0|LINK|mutability|MUTABLE|url|http://www.springsource.org/^0|1G|H|2V|9|5|G|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@$9|Q|A|R|B|C]|$9|S|A|T|B|C]]|D|@$9|U|A|V|1|W]]|E|$]]|$1|F|3|G|5|6|7|X|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|Y|8|@]|D|@]|E|$]]]|I|$J|$5|K|L|M|E|$N|O]]]]

If you use <a href="http://www.springsource.org/" rel="nofollow noreferrer">Spring Framework</a>, you can just create a regular bean. By default (or if you explicitly set <code>scope="singleton"</code>) only one instance of the bean is created and that instance is returned every time the bean is used in a dependency or retrieved via <code>getBean()</code>.

You get the advantage of the single instance, without the coupling of the Singleton pattern.

blocks|key|1528902|text|Google+Testing+blog有一系列关于避免单例的条目(为了创建可测试的代码)。也许这对你有帮助：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1528903|1528904|Using+dependency+injection+to+avoid+singletons|unordered-list-item|1528905|Singletons+are+Pathological+Liars|1528906|Root+Cause+of+Singletons|1528907|Where+have+all+the+Singletons+Gone?|1528908|1528909|上一篇文章详细解释了如何将新对象的创建转移到工厂中，这样您就可以避免使用单例。当然值得一读。|1528910|1528911|简而言之，我们将所有的新操作符都转移到一个工厂。我们将生命周期相似的所有对象组合到一个工厂中。|blockquote|1528912|1528913|entityMap|0|LINK|mutability|MUTABLE|url|http://googletesting.blogspot.com/|1|http://googletesting.blogspot.com/2008/05/tott-using-dependancy-injection-to.html|2|http://googletesting.blogspot.com/2008/08/by-miko-hevery-so-you-join-new-project.html|3|http://googletesting.blogspot.com/2008/08/root-cause-of-singletons.html|4|http://googletesting.blogspot.com/2008/08/where-have-all-singletons-gone.html^0|0|J|0|0|0|0|1A|1|0|0|X|2|0|0|O|3|0|0|Z|4|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1B|8|@]|9|@$A|1C|B|1D|1|1E]]|C|$]]|$1|D|3|-4|5|6|7|1F|8|@]|9|@]|C|$]]|$1|E|3|F|5|G|7|1G|8|@]|9|@$A|1H|B|1I|1|1J]]|C|$]]|$1|H|3|I|5|G|7|1K|8|@]|9|@$A|1L|B|1M|1|1N]]|C|$]]|$1|J|3|K|5|G|7|1O|8|@]|9|@$A|1P|B|1Q|1|1R]]|C|$]]|$1|L|3|M|5|G|7|1S|8|@]|9|@$A|1T|B|1U|1|1V]]|C|$]]|$1|N|3|-4|5|6|7|1W|8|@]|9|@]|C|$]]|$1|O|3|P|5|6|7|1X|8|@]|9|@]|C|$]]|$1|Q|3|-4|5|6|7|1Y|8|@]|9|@]|C|$]]|$1|R|3|S|5|T|7|1Z|8|@]|9|@]|C|$]]|$1|U|3|-4|5|6|7|20|8|@]|9|@]|C|$]]|$1|V|3|-4|5|6|7|21|8|@]|9|@]|C|$]]]|W|$X|$5|Y|Z|10|C|$11|12]]|13|$5|Y|Z|10|C|$11|14]]|15|$5|Y|Z|10|C|$11|16]]|17|$5|Y|Z|10|C|$11|18]]|19|$5|Y|Z|10|C|$11|1A]]]]

The <a href="http://googletesting.blogspot.com" rel="noreferrer">Google Testing blog</a> has a series of entries about avoiding Singleton (in order to create testable code). Maybe this can help you:

<ul>
<li><a href="http://googletesting.blogspot.com/2008/05/tott-using-dependancy-injection-to.html" rel="noreferrer">Using dependency injection to avoid singletons</a></li>
<li><a href="http://googletesting.blogspot.com/2008/08/by-miko-hevery-so-you-join-new-project.html" rel="noreferrer">Singletons are Pathological Liars</a></li>
<li><a href="http://googletesting.blogspot.com/2008/08/root-cause-of-singletons.html" rel="noreferrer">Root Cause of Singletons</a></li>
<li><a href="http://googletesting.blogspot.com/2008/08/where-have-all-singletons-gone.html" rel="noreferrer">Where have all the Singletons Gone?</a></li>
</ul>

The last article explains in detail how to move the creation of new objects into a factory, so you can avoid using singletons. Worth reading for sure.

<blockquote>
 In short we move all of the new operators to a factory.
 We group all of the objects of similar lifetime into a single factory.
</blockquote>

blocks|key|227306|text|这取决于什么工具/框架等。正被使用。使用依赖注入/ioc工具，人们通常仍然可以通过让di/ioc容器对所需的类(如IConfigSettings接口)使用单例行为来获得单例性能/优化，只需创建类的一个实例。这仍然可以用来替代测试|type|unstyled|depth|inlineStyleRanges|entityRanges|data|227307|或者，您可以使用工厂来创建类，并在每次请求时返回相同的实例-但为了测试，它可以返回存根/模拟版本|227308|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Depends on what tooling/frameworks etc.. are being used. 
With dependency injection/ioc tools one can often still get singleton performance/optimizations by having the di/ioc container use singleton behaviour for the class required - (such as a IConfigSettings interface) by only ever creating one instance of the class. This could be still substituted out for testing

Alternately one could use a factory to create the class and return the same instance each time you request it - but for testing it could return a stubbed/mocked version

blocks|key|4544038|text|另一种选择是传入你需要的东西，而不是向对象请求东西。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4544039|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

The alternative is passing in what you need instead of asking an object for things.

blocks|key|4544058|text|评估配置为回调接口的可能性。因此，您的配置敏感代码将如下所示：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4544059|MyReuseCode.Configure(IConfiguration)|code-block|syntax|javascript|4544060|系统初始化代码将如下所示：|4544061|Library.init(MyIConfigurationImpl)|4544062|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Review possibility to make configuration as callback interface. 
So your configuration sensitive code will look:

<pre><code>MyReuseCode.Configure(IConfiguration)
</code></pre>

System-init code will look: 

<pre><code>Library.init(MyIConfigurationImpl)
</code></pre>

blocks|key|1528982|text|不会累积对单个配置对象的责任，因为它将以一个既难以理解又脆弱的非常大的对象结束。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|1528983|例如，如果您需要一个特定类的另一个参数，您可以更改Configuration对象，然后重新编译使用它的所有类。这有点问题。|CODE|1528984|尝试重构您的代码，以避免通用的、全局的和大的Configuration对象。仅将必需的参数传递给客户端类：|1528985|class+Server+{

++++int+port;

++++Server(Configuration+config)+{
++++++++this.port+=+config.getServerPort();
++++}+

}|code-block|syntax|javascript|1528986|应该重构为：|1528987|+class+Server+{

++++public+Server(int+port)+{
+++++++this.port+=+port;
++++}
+}|1528988|一个依赖注入框架在这里会有很大帮助，但它不是严格要求。|1528989|entityMap^0|0|B|0|P|D|0|M|D|0|0|0|0|2|6|0^^$0|@$1|2|3|4|5|6|7|X|8|@$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|10|8|@$9|11|A|12|B|H]]|D|@]|E|$]]|$1|I|3|J|5|6|7|13|8|@$9|14|A|15|B|H]]|D|@]|E|$]]|$1|K|3|L|5|M|7|16|8|@]|D|@]|E|$N|O]]|$1|P|3|Q|5|6|7|17|8|@]|D|@]|E|$]]|$1|R|3|S|5|M|7|18|8|@]|D|@]|E|$N|O]]|$1|T|3|U|5|6|7|19|8|@$9|1A|A|1B|B|C]]|D|@]|E|$]]|$1|V|3|-4|5|6|7|1C|8|@]|D|@]|E|$]]]|W|$]]

don't accumulate responsibilites to a single configuration object since it will ends in a very big object that is both difficult to understand and fragile. 

For example if you need another parameter to a particular class you change the <code>Configuration</code> object, then recompile all the classes that uses it. This is somewhat problematic.

Try refactoring your code to avoid a common, global and big <code>Configuration</code> object. Pass only required parameters to client classes:

<pre><code>class Server {

 int port;

 Server(Configuration config) {
 this.port = config.getServerPort();
 } 

}
</code></pre>

should be refactored to:

<pre><code> class Server {

 public Server(int port) {
 this.port = port;
 }
 }
</code></pre>

a dependency injection framework will help a lot here, but it isn't stricly required.

blocks|key|4544146|text|您可以使用依赖注入框架来减轻传递configuration对象的痛苦。一个不错的选择是ninject，它的优点是使用代码而不是xml。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|4544147|entityMap|0|LINK|mutability|MUTABLE|url|http://ninject.org/^0|17|7|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

You could use a dependency injection framework to ease the pain of passing in the configuration object. A decent one is <a href="http://ninject.org" rel="nofollow noreferrer">ninject</a> which has the advantage of using code rather than xml.

blocks|key|227642|text|您可以通过使用静态方法来实现单例的相同行为。Steve+yegge在this帖子中很好地解释了这一点。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|227643|entityMap|0|LINK|mutability|MUTABLE|url|http://steve.yegge.googlepages.com/singleton-considered-stupid^0|Y|4|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

You can accomplish the same behavior of singleton by using static methods. Steve yegge explains it very well in <a href="http://steve.yegge.googlepages.com/singleton-considered-stupid" rel="nofollow noreferrer">this</a> post.

blocks|key|1527141|text|单例不是邪恶的，但设计模式是有缺陷的。我有一个类，我只想在运行时创建它的单个实例，但希望在单元测试期间创建多个隔离实例，以确保确定性结果。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1527142|DI使用Spring等，是一个非常好的选择，但不是唯一的选择。|1527143|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Singletons are not evil but the design pattern is flawed. I have a class that I only want to create a single instance of it during runtime but want to create multiple isolated instances during unit testing to ensure deterministic results.

DI using Spring, etc, is a very good option but not the only option.

We have a class that holds configuration information for the application. It used to be a singleton. After some architectural review, we were told to remove the singleton. We did see some benefits of not using singleton in the unit testing because we can test different configurations all at once.

Without singleton, we have to pass the instance around everywhere in our code. It's getting so messy so we wrote a singleton wrapper. Now we are porting the same code to PHP and .NET, I am wondering if there is a better pattern we can use for the configuration object.

What's Alternative to Singleton

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我们有一个保存应用程序配置信息的类。它曾经是一个单例。在一些架构审查之后，我们被告知要删除单例。我们确实看到了单元测试中不使用单例的一些好处，因为我们可以一次测试所有不同的配置。如果没有单例，我们必须在代码中到处传递实例。它变得如此混乱，所以我们写了一个单例包装器。现在我们正在将相同的代码移植到PHP和.NET，我想知...

问Singleton的替代方案是什么
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Singleton的替代方案是什么EN