简介
单例模式是设计模式中最简单的形式之一。这一模式的目的是使得类的一个对象成为系统中的唯一实例。要实现这一点,可以从客户端对其进行实例化开始。因此需要用一种只允许生成对象类的唯一实例的机制,“阻止”所有想要生成对象的访问。使用工厂方法来限制实例化过程。这个方法应该是静态方法(类方法),因为让类的实例去生成另一个唯一实例毫无意义。
要点
显然单例模式的要点有三个;一是某个类只能有一个实例;二是它必须自行创建这个实例;三是它必须自行向整个系统提供这个实例。
从具体实现角度来说,就是以下三点:一是单例模式的类只提供私有的构造函数,二是类定义中含有一个该类的静态私有对象,三是该类提供了
singleton
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
class ClassVariableTester @@class_count = 0 def initialize @instance_count = 0 end def increment @@class_count = @@class_count + 1 @instance_count = @instance_count + 1 end def to_s "class count :#{@@class_count} -- instance count :#{@instance_count}" end end cv1 = ClassVariableTester. new cv1.increment cv1.increment puts( "cv1:#{cv1}" ) cv2 = ClassVariableTester. new puts( "cv2:#{cv2}" ) #cv1:class count :2 -- instance count :2 #cv2:class count :2 -- instance count :0 |
当创建了第二个对象时,@@class_count 为2,二@instance_count为0,因为类变量被所有实例所共享,党cv1.increment调用了两次以后@@class_count为2,创建第二个ClassVariableTester对象cv2的时候,共享了@@class_count,所以此时的@@class_count仍为2。
而实例变量只能为当前对象服务,所以实例对象cv2的@@instance_count为0
类变量的这种特性是一种单例模式
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
class SimpleLogger @@instance = SimpleLogger. new def self .get_instance @@instance end private_class_method :new end sl1 = SimpleLogger.get_instance sl2 = SimpleLogger.get_instance puts sl1 == sl2 |
结果为:true 。
采用一个类变量来保存仅有的一个类的实例,同时需要一个类方法返回这个单例实例。
但是通过SimpleLogger.new还是可以创建另一个实例对象,因此需要把着个new方法设为私有的。
1
2
3
4
5
6
7
8
9
10
11
12
13
|
sl3 = SimpleLogger. new private method ` new ' called for SimpleLogger: Class (NoMethodError) require 'singleton' class SimpleLogger include Singleton end #puts SimpleLogger.new sl1 = SimpleLogger.instance sl2 = SimpleLogger.instance puts sl1 == sl2 |
结果为:true
Ruby类库中提供了singleton,来简化单例类的创建。
混入Singleton,就省略了创建类变量,初始化单例实例,创建类级别的instance方法,以及将new设为私有。
通过SimpleLogger.instance来获取日志器的单例。
但是两种方式还是又差异的。
第一种方式称之为“勤性单例(eager instantiation)”。
在确实需要之前就创建了实例对象。
第二种方式称之为“惰性单例(lazy instantiation)”
在调用instance时才会去创建 。
但是这个Singleton不能真正的阻止任何事情,可以用过public_class_method改变new方法的为公用的。
打开类,设置new方法为public之后,就可以用SimpleLogger.new来创建对象了。
1
2
3
4
5
|
class SimpleLogger public_class_method :new end puts SimpleLogger. new |
再来分两种情况:
(一)使用全局变量,尽量不要使用全局变量,因为全局变量是程序紧密的耦合在一起,
其实单例模式和全局变量的作用是一样的,
$logger = SimpleLogger.new
(二)使用类作为单例,
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
|
class SimpleLogger WARNING = 1 INFO = 2 def initialize(file) @@log = File .open(file, "w" ) @@level = WARNING end def self .warning(msg) puts @@level > WARNING @@log .puts(msg) if @@level > WARNING @@log .flush end def self .level @@level end def self .level=(new_level) @@level = new_level end end SimpleLogger. new ( "test.txt" ) puts SimpleLogger.level SimpleLogger.level = SimpleLogger:: INFO puts SimpleLogger.level SimpleLogger.warning( "warning" ) |
实例
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
require 'rubygems' require 'watir' require 'singleton' class AutoTest include Singleton def OpenUrl(url) @browser = Watir::Browser. new @browser .goto(url) @url =url end def set_textarea(text) @browser .text_field( :id , 'kw' ).set(text) end def click @browser .button( :id , 'su' ).click end end test,test2 = AutoTest.instance test.set_textarea( 'aslandhu' ) test.click |
这里虽然创建了两个AutoTest实例,但是第二个实例其实为nil,也就是说并没有创建成功。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
require 'rubygems' require 'watir' require 'singleton' require 'thread' class TestOneObj end class <<TestOneObj include Singleton def instance @browser = Watir::Browser. new self end def openurl(url) @browser .goto(url) end def set_textarea(text) @browser .text_field( :id , 'kw' ).set(text) end def click @browser .button( :id , 'su' ).click end end test = TestOneObj.instance test2 = TestOneObj.instance p test.inspect p test2.inspect test.openurl( 'www.baidu.com' ) test2.set_textarea( 'aslandhu' ) test.click |
上面这段代码试图创建两个Browser对象,但事实上创建的两个对象均为同一个。虽然打开了两个IE窗口,但是对象还是一个,即test与test2是同一个对象。