Java程序设计之静态方法和单例模式
2013年08月04日


一、问题的引出


目的:设计一个加密的工具类。


写法一:【单例模式】

public class CipherUtils {
    private List key;
    private static CipherUtils instance;
    private CipherUtils(String... args){
        // TODO 比较复杂的初始化KEY的过程
    } 
    public static boolean initInstance(String... args){
        instance = new CipherUtils(args);
        return true;
    }
    public static CipherUtils getInstance(){
        return instance;
    }
     
    // 正在用到的加密方法
    public String doCipher(String... args){
        // TODO
        Map map = new HashMap();
        map.put("key", key);
        return null;
    }
}

》》调用方法:

CipherUtils cu= CipherUtils.getInstance();

                  cu.doCipher(...);


写法二:【静态方法模式】  

public class CipherUtils {
    private static List key;
    // 正在用到的加密方法
    public static String doCipher(String... args){
        // TODO
        Map map = new HashMap();
        map.put("key", key);
        return null;
    }
    // 比较复杂的初始化KEY的过程
    public static void initKey(String... args){
        // TODO
    }
}

》》调用方法:CipherUtils.doCipher(...);


注意以上例子,只是一个模拟,真实情况 类的属性可能不止一个,可能有三个以上属性


写法一的特点:

1、使用时调的方法都是非static的(doCipher等等)

2、类的属性都是非static的。

3、拥有单例模式的所有优点。


写法二的优点:

1、属性和方法都是static的。

2、static是全局共享的,所以也拥有单例模式的核心优点。


另外,还注意到一点,单例模式 有一个比 静态方法模式 更好的地方:

    它可以被继承,方法可以被子类重载,所以扩展性更强。


例如一个子类SubCipher重载了doCipher方法,那么调用方式如下:

CipherUtils cu= SubCipher.getInstance();

                   cu.doCipher(...);

注意到,调用处(第二行)是无需修改代码的。但是如果是静态方法的话,只能重命名一个方法了,而且调用出还要改代码,比如:

CipherUtils.doCipher_02(...);


二、问题的研究


  这一部分主要参考了网上3、4篇关于类似问题的讨论

  比如:

http://www.blogjava.net/ITdavid/archive/2008/01/22/176939.html

http://wenku.baidu.com/view/f08eb06125c52cc58bd6befe.html


  具体分析见第三节-总结。


三、总结


1、搞清楚单例模式的缺点和优势,不要乱用。

一般我不用单例模式,因为这样增加了代码管理成本。但是以下几个场景最好用单例模式


1)场景一:类可能会有继承、方法可能需要重载。(Spring里面有些东西就是这样设计的)


2)场景二:类的所有属性需要保持一致性,(要么都改变,要么都不改变)且这个类的非private方法较多(5个以上)单例模式实现这个功能就比较方便,直接把原来缓存的static实例对象整体替换掉,重新new一个就可以了,


但是如果用静态方法来实现,则在更新属性时,需要停止所有的static方法被调用,也就意味着,要在所有的方法中加上synchronized关键字,即:单例模式只需要同步getInstance这个方法就可以,而静态方法模式,需要同步所有的方法


如果类的实例方法不多,在5个以内,那其实给每个方法都加上synchronized关键字那也无所谓,反正效率上讲,静态方法还稍微高一些,但是如果方法多了,则还是采用单例模式吧。


2、就我上面,那个问题而言,最好是采用静态方法模式,因为只有一个doCipher方法,不符合场景二,而且本身是个工具类,无需类的继承,所以也不符合场景一


PS:参考Struts的源码,我们其实可以对同步静态方法进行适当改造。单例模式有一个缺点是,无论你做什么操作,都需要同步,性能上稍微低了一点点静态方法则可以采用一种“读写锁”的模式,当有“写操作”时,则不允许其他操作,当只有“读操作时”,则不允许“写操作”但是允许其他读操作。其实现可以参考如下struts的源码

    com.opensymphony.xwork2.util.logging.LoggerFactory;

    java.util.concurrent.locks.ReadWriteLock;

    java.util.concurrent.locks.ReentrantReadWriteLock;



PS:在Effective Java一书中,作者提到了一种单例模式的方法,我觉得有些繁琐,仅供参考:

    java程序还有被称为类型安全枚举的模式:定义一类来代表枚举类型的单个元素,并且不提供任何公有的构造函数,相反提供公有的静态final域,使枚举类型的每一个常量都对应一个域。如:

//the typesafe enum pattern
public class Suit{
    private final String name;
    private Suit(String name){this.name=name;}
    public String toString(){return name;}
    public static final Suit CLUBS =new Suit("Clubs");
    public static final Suit DIAMANDS=new Suit("Diamands");
    public static final Suit HEARTS =new Suit("Hearts");
    public static final Suit SPADES =new Suit("Spades");
}

  即使这个类没有声明为final,客户也没法创建这个类的对象,也无法扩展这个类,因而除了通过这些公有的静态final域导出的Suit对象之外,永远不会有其它的对象存在。

 好处: 

       提供了编译的类型安全性 

      多个“类型安全枚举”可以包含相同名字的枚举常量,因为每个类都有自己的命名空间。 

      新的常量加入到一个类型安全枚举类中,无需重新编译客户代码,因为常量并没有被编译到客户代码中。 

      可以通过改写toString来允许其值转化为可打印字符串。 

因为任何方法都可以被加到类型安全枚举中类中,所以它们可以实现任何接口。如Comparable:

//ordinal-based typesafe enum
public class Suit implements Comparable{
    private final String name;
    private static int nextOrdinal=0;
    private final int ordinal = nextOrdinal++;
    private Suit(String name){this.name=name;}
    public String toString(){return name;}
    public int compareTo(Object o){
    return ordinal-((Suit)o).ordinal;
    }
    public static final Suit CLUBS =new Suit("Clubs");
    public static final Suit DIAMANDS=new Suit("Diamands");
    public static final Suit HEARTS =new Suit("Hearts");
    public static final Suit SPADES =new Suit("Spades");
}

因为类型安全枚举类型的常量是对象,所以你可以把这些常量放到集合中。如:

    private static final Suit[] PRIVATE_VALUES={CLUBS, DIAMAONDS, HEARTS, SPADES};

    public static final List VALUES=Collection.unmodifiableList(Array.asList(PRIVATE_VALUES)); 

基于序数形式的类型安全枚举模式,在声明中增加implements Serializable,然后提供一一个readResolve方法,即可支持序列化。

    private Object readResolve() throws ObjectStreamException{

        return PRIVATE_VALUES[ordinal];

    } 

类型安全枚举类在性能可与int枚举常量相比美,因为可以使用“引用的同一性比较”来检查逻辑上的相关等关系。

使得一个类型安全枚举类可以扩展,只需要提供一个受保护的构造函数即可。 

对客户没有用的方法,应声明为prtotected,对客户隐藏,允许子类修改。且如果没有合理的默认实现,应声明为abstract,

改写equals和hashCode,使他们成为final,以保证该枚举类。