因心造境 风云由我

即使是简单的脚本语言，应用良好的模式可以得到非常“优美”的代码和较高的效率。
尤其是对于交互要求较高的B/S系统，非常有必要用设计模式来优化代码。

单件模式（Singleton Pattern）是一种非常基本和重要的创建型模式。
“单件”的职责是保证一个类有且只有一个实例，并提供一个访问它的全局访问点。
在程序设计过程中，有很多情况下需要确保一个类只能有一个实例。

传统的编程语言中为了使一个类只有一个实例，最容易的方法是在类中嵌入静态变量，并在第一个实例中设置该变量，而且每次进入构造函数都要做检查，不管类有多少个实例，静态变量只能有一个实例。为了防止类被多次初始化，要把构造函数声明为私有的，这样只能在静态方法里创建一个实例。

在javascript中，虽然我们仍然可以指定静态方法来构造对象，但由于我们不能利用构造函数的“私有”来禁止多个实例的生成，因此要完全实现Singleton并没有想象中那么简单。

请看下面的例子：

[code]
<script>
function SingletonObject()
{
 SingletonObject.prototype.methodA = function()
 {
  alert('methodA');
 }
 SingletonObject.prototype.methodB = function()
 {
  alert('methodB');
 }
 SingletonObject.instance = this;
}
SingletonFactory = new Object();
SingletonFactory.getInstance = function()
{
 if(SingletonObject.instance == null)
  return new SingletonObject();
 else
  return SingletonObject.instance;
}

var instA = SingletonFactory.getInstance();
var instB = SingletonFactory.getInstance();
instA.methodA();
instB.methodA();
alert(instA == instB); //成功
var instC = new SingletonObject();
instC.methodA();
alert(instA == instC); //失败
</script>
[/code]
上面的例子试图通过传统的方式来实现Singleton模式，而通过调用SingletonTest.getInstance()来获得对象确实可以保证“唯一实例”，然而，这个例子的失败之处在于它并没有有效地禁止Singleton对象的构造，因此如果我们在程序代码中人工加入new SingletonObject()，仍然可以获得到多个对象而导致模式失败。

一个改进的替代方案如下：
[code]
<script>
function SingletonObject()
{
 if(SingletonObject.instance != null)
 {
  alert("不能创建多个singleton实例!");
  throw new Error();
 }
 SingletonObject.prototype.methodA = function()
 {
  alert('methodA');
 }
 SingletonObject.prototype.methodB = function()
 {
  alert('methodB');
 }
 SingletonObject.instance = this;
}
SingletonFactory = new Object();
SingletonFactory.getInstance = function()
{
 if(SingletonObject.instance == null)
  return new SingletonObject();
 else
  return SingletonObject.instance;
}

var instA = SingletonFactory.getInstance();
var instB = SingletonFactory.getInstance();
instA.methodA();
instB.methodA();
alert(instA == instB); //成功
try
{var instC = new SingletonObject(); }//抛出异常
catch(e)
{alert('系统成功抛出了异常，阻止了instC的构造!');}
</script>
[/code]
这样当用户试图自己创建多个对象的时候，通过人工抛出异常来阻止。不过这么做还是有一点点违反了"初衷"，即没有满足“必须通过静态方法来构造唯一实例”这个基本条件。因为用户可以在最开始的时候还是可以采用new操作符来构造对象，比如在一开始写var instA = new SingletonObject()来构造instA并不会导致抛出异常，这不能不说是这种方法的一个缺陷。

于是我们进一步思考，得到了下面第三种方法，这种方法巧妙利用了“匿名”函数的特征来禁止对SingletonObject类构造函数的访问，可以说比较好的模拟了私有构造函数的特性，从而比较完美地解决了用javascript实现Singleton Pattern的问题。

[code]
<script>
(function(){
 //instance declared
 //SingletonFactory Interface
 SingletonFactory = {
  getInstance : getInstance
 }

 //private classes
 function SingletonObject()
 {
  SingletonObject.prototype.methodA = function()
  {
   alert('methodA');
  }
  SingletonObject.prototype.methodB = function()
  {
   alert('methodB');
  }
  SingletonObject.instance = this;
 }
 
 //SingletonFactory implementions
 function getInstance()
 {
  if(SingletonObject.instance == null)
   return new SingletonObject();
   
  else
   return SingletonObject.instance;
 }

})();

var instA = null;
try
{
alert("试图通过new SingletonObject()构造实例！");
instA = new SingletonObject();
}
catch(e){alert("SingletonObject构造函数不能从外部访问，系统抛出了异常！");}

instA = SingletonFactory.getInstance();  //通过Factory上定义的静态方法获得
var instB = SingletonFactory.getInstance();
instA.methodA();
instB.methodA();

alert(instA == instB); //成功

var instC = null;
try
{
alert("试图通过new SingletonObject()构造实例！");
instC = new SingletonObject();
}
catch(e){alert("SingletonObject构造函数不能从外部访问，系统抛出了异常！");}
</script>
[/code]

Singleton Pattern

Partly from : http://en.wikipedia.org/wiki/Singleton_pattern the singleton pattern is a design pattern that is used to restrict instantiation of a class to one object. This is useful when exactly one object is needed to coordinate actions across the system. Sometimes it is generalized to systems that operate more efficiently when only one or a few objects exist. Make sure both default constructor and copy constructor are private.

public class Singleton {  private final static Singleton instance = new Singleton();  // Private constructor suppresses generation of a (public) default constructor  private Singleton() {}  public static Singleton getInstance() {  return instance;  }  }

public class Singleton {  private static Singleton instance;  // Private constructor suppresses generation of a (public) default constructor  private Singleton() {}  public static synchronized Singleton getInstance() {  if(instance == null) {  instance = new Singleton();  }  return instance;  }  }

public class Singleton {  // Private constructor suppresses generation of a (public) default constructor  private Singleton() {}  private static class SingletonHolder {  private static Singleton instance = new Singleton();  }  public static Singleton getInstance() {  return SingletonHolder.instance;  }  }

public class Singleton {  private volatile static Singleton instance;  // Private constructor suppresses generation of a (public) default constructor  private Singleton() {}  public static Singleton getInstance() {  if(instance == null) {  synchronized(Singleton.class) {  if(instance == null) {  instance = new Singleton();  }  }  }  return instance;  }  }

编者按：程序中经常有这样的要求，整个程序运行时只有一个实例被使用。比如：数据库连接池，系统参数配置，Java API 中的 Runtime, Calendar ...如何实现这种需求成为一个值得讨论的问题。让我们来看看本文的例子。
　　 
　　A.常见的例子
　　以往的做法，是在程序的某个类里面（比如是 GlobalObject ）建立一个这个此种类的实例，然后规定所有需要用到此类的，都从 GlobalObject 那里获得，看下面的例子：
public class ConnectionPoolManager {
public ConnectionPoolManager {
// do some initialize work
}
public Connection getConnection(){
....
}
}

public class GlobalObject {
private ConnectionPoolManager connectionPoolManager;
public GlobalObject () {
connectionPoolManager = new ConnectionPoolManager();
...
}
public void getConnectionPoolManager() {
return connectionPoolManager;
}
}

public class QueryFunctions {
public static Collection findStudentByName(String name){
ConnectionPoolManager = globalObject.getConnectionPoolManager();
Connection connection = connectionPoolManager.getConnection();
// query database
}
}

　　但这样做有如下缺点：
　　其他人可能 调用 ConnectionPoolManager 的构造函数自己建立一个 数据库连接池，导致程序中存在多个 ConnectionPoolManager，人为的规定往往得不到好的实施。
　　GlobalObject 其实就是一个 C 语言中的全局变量，与面向对象的方法相冲突。
新的方法实践过程 
　　B.使用新的方法
　　因此，可以使用 设计模式 中的 Singleton （单件）模式来完成以上的需求：
　　Java API 中的 Runtime 等等用的就是这种方法。
　　代码如下：

public class ConnectionPoolManager {
private static instance = null;
private ConnectionPoolManager() {
// do some initialize work
}
public static void getInstance() {
if (instance == null){
instance = new ConnectionPoolManager();
}
return instance;
}
public Connection getConnection(){
}
}

　　ConnectionPoolManager 的使用

public class QueryFunctions {
public static Collection findStudentByName(String name){
ConnectPoolManager connectionPoolManager = ConnectionPoolManager.getInstance();
Connection conn = connectionPoolManager.getConnection();
// query database
}
}

　　1.instance 是私有的，开始时赋值为 null，外部只有通过 getInstance 方法才能获得他。
　　2.构造方法是私有的，这点很重要，保证只有这个类自己才能够调用，其他的类无法调用此构造函数。
　　3.getInstance 方法中：if 语句，保证只有一个 instance 存在
　　唯一的一个 ConnectionPoolManager 在第一次调用的时候被建立。
C.另一个特殊实例
　　下面是另一个例子： java.lang.Runtime
　　我刚看了 Runtime 的实现如下：
public class Runtime {
private static Runtime currentRuntime = new Runtime();
public static Runtime getRuntime() {
return currentRuntime;
}
/** Don‘t let anyone else instantiate this class */
// 够狠
private Runtime() {}
}
　　它在定义变量时创建 唯一的 Runtime 实例。
　　Java语言在设计的时候就使用了很多 设计模式的思想，像 Collection 中的 Iterator 模式，
Event 中的 Observer 模式，Applet 中的 Templete 模式，对象创建时的 Factory 模式，这些
模式大多可以从 Java 的类的命名中体现出来，希望大家在学习 Java 时多注意对 设计模式 的学习。
　　参考：
　　设计模式：可复用面向对象软件的基础 (Gang of Four 的 Design Pattern 经典)
　　Thinking in Pattern : http://www.mindview.net/Books/TIPatterns/ 还是 Bruce Eckel 写的。
　　Design Pattern Java : ftp://cinc.dns2go.com/pub/doc/pattern/java
在java中singleton是什么模式？
 悬赏分：0 - 解决时间：2007-11-17 23:27
在java中singleton是什么模式？我书上写的不是很详细！只是说singleton模式被用来限制对象的创建，不能有子类，构造函数是私有的，而且一般提供一个静态方法getInstance（）来得到一个实例！
提问者： paopao0611 - 经理 四级 
最佳答案
单例模式，不管你事例化多少个这个类的对象， 
其实都只存在一个对象。 

构造函数私有，就是屏蔽了构造方法，不能由构造方法来产生对象。 
因此你可以自己写个getInstance()..由此，就可以控制整个系统中，只存在一个此类的对象。
单子模式又叫单例模式。 应用该模式时,实例化对象的类必须只有一个实例存在。主要应用在整个系统只需要一个全局对象,有利于协调系统的整体行为。 
你可以上网搜一搜有关单子模式的内容 
单例模式的好处就是：类只实例化一次，省资源，节省开销，提高速度
下边写的是什么还没怎么看懂，再提高提高再回过头来看吧，先存在这
Java Singleton 模式用来保证在运行的应用程序中，一个Class只是实例化一次，也就是只有一个相应的对象存在。在 web 程序中我们会用一个核心的分配功能的Servlet程序，在这里我们就可以运用这种设计模式了。 
一般Singleton模式通常有几种种形式: 
第一种形式: 
定义一个类，它的构造函数为private的，它有一个static的private的该类变量，在类初始化时实例话，通过一个public的getInstance方法获取对它的引用,继而调用其中的方法。
Java代码 
public class Singleton {    
private Singleton(){}