默写流年
默写流年

设计模式初探-创建型模式之单例模式

上一篇文章从NIO原理到性能优化中，我 们引入了性能调优的相关话题，着重了谈了一下互联网架构的演变之路。这篇文章，我们将会开启一个老生常谈的新专题-设计模式。
提剑跨骑挥鬼雨，白骨如山鸟惊飞。尘世如潮人如水，只叹江湖几人回！
如果将代码比作江湖，那么语法就是一招一式，而设计模式则是神秘莫测的内功心法，将其融会贯通之日，便是立于不败之时。本文分为如下部分：

  1. 前言
  2. 设计模式分类
  3. 单例
    3.1 使用场景
    3.2 单例的5种实现
    3.3 饿汉单例
    3.3.1 破坏单例
    3.3.2 序例化和反序例化的实现机制
    3.3.3 通过readResolve 来改善单例
    3.4 懒汉单例
    3.4.1 破坏单例
    3.5 双重锁单例
    3.5.1 破坏单例
    3.6 内部类单例
    3.6.1 破坏单例
    3.7 枚举单例
    3.7.1 破坏单例
    3.8 几种单例的比对
    3.9 基于单例编写文件加载
  4. 总结

1. 前言

在说设计模式之前我们先思考几个问题。

  1. 什么是设计模式？
  2. 什么情况下要用到设计模式？
    那么带着这些问题，我们推开设计模式的大门

2. 设计模式分类

所谓设计模式指的是在某些特定情境下，针对某些特定问题的某种解决方案。它不是语法规定，而是一套解决方案，使用设计模式帮助我们提高代码的复用性、可维护性、健壮性以及安全性。同时更方便和清晰的通过代码传递我们coding时的设计思路，毕竟好的代码自己就是注释。设计模式按照意图可以分为以下几类：

意图分类 解释 模式
创建型 创建型模式涉及到对象的实例化，这类模式提供一个方法，将客户从对象的创建种解耦 工厂方法、抽象工厂、单例、建造者、原型
行为型 涉及到类和对象如何交互及分配职责 模板方法、命令、迭代器、观察者、策略、状态、职责链、中介者、访问者、备忘者、解释器
结构型 结构型模式可以让你把类或对象组合到更大的结构中去 适配器、装饰器、代理、组合、门面、桥接、享元

值得注意的是：

  1. 设计模式职期间并不是毫无关联的，常常一种模式里会包含另一种模式（如用工工厂方法实现抽象工厂）。
  2. 设计模式并不是一尘不变的，常常为了实现需求而做不同的改变（比如spring的bean是单例，但却不是我们常用的单例模式，而是注册表单例）。
  3. 不要滥用设计模式，采用最简单直观的方式解决问题才是最好的选择，不要过分设计。

3. 单例

所谓单例即确保一个类只有一个实例并提供一个全局的访问点。

3.1 使用场景

从单例模式的定义中我们就可以看出单例的使用场景，即只需要一个对象的时候。那么什么时候只需要一个对象呢？即当对象的创建和销毁代价比较高的时候。如配置文件的加载，如spring bean的创建。

3.2 单例模式的5种实现方式

单例模式一般有如下实现方式

  • 饿汉
  • 懒汉
  • 双重锁
  • 内部类
  • 枚举

3.3 饿汉单例

所谓饿汉，即类初始化的时候就实例化一个不可变的静态对象。代码如下

public class Singleton implements Serializable {
    private static final Singleton INSTANCE=new Singleton();
    private Singleton(){

    }

    public static Singleton getInstance(){
        return INSTANCE;
    }
}

3.3.1 破坏单例

上面的单例看起来有点薄弱，那么它能实现我们要的单利效果吗？让我们来测一下，毕竟不想当测试的程序员不是一个好UI。

  • 单线程模式
    /**
     * 单线程调用
     */
    public void testWithOneThread() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Singleton.getInstance());
        }
    }
   public static void main(String[] args) {
        SingletonTest singletonTest=new SingletonTest();
        singletonTest.testWithOneThread();
    }

输出结果如下：

com.designPatterns.singleton.eager.Singleton@610455d6
com.designPatterns.singleton.eager.Singleton@610455d6
com.designPatterns.singleton.eager.Singleton@610455d6
com.designPatterns.singleton.eager.Singleton@610455d6
com.designPatterns.singleton.eager.Singleton@610455d6
com.designPatterns.singleton.eager.Singleton@610455d6
com.designPatterns.singleton.eager.Singleton@610455d6
com.designPatterns.singleton.eager.Singleton@610455d6
com.designPatterns.singleton.eager.Singleton@610455d6
com.designPatterns.singleton.eager.Singleton@610455d6

看起来运行的很完美，但是这样就完了吗？

设计模式初探-创建型模式之单例模式_第1张图片

我们尝试从以下几方面尝试来打破单例
1. 多线程
2. 反射
3. 序列化和反序列化
ps：由于我们的类未考虑要实现Cloneable接口，故clone 的单利破坏不在讨论范围之内

  • 多线程
 /**
     * 多线程调用
     */
    public void testWithMultiThread() {
        ExecutorService pool = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++) {
            pool.submit(() -> {
                System.out.println(Singleton.getInstance());
            });
        }
    }
 public static void main(String[] args) {
        SingletonTest singletonTest=new SingletonTest();
        singletonTest.testWithMultiThread();
    }

运行结果如下：

com.designPatterns.singleton.eager.Singleton@68674054
com.designPatterns.singleton.eager.Singleton@68674054
com.designPatterns.singleton.eager.Singleton@68674054
com.designPatterns.singleton.eager.Singleton@68674054
com.designPatterns.singleton.eager.Singleton@68674054
com.designPatterns.singleton.eager.Singleton@68674054
com.designPatterns.singleton.eager.Singleton@68674054
com.designPatterns.singleton.eager.Singleton@68674054
com.designPatterns.singleton.eager.Singleton@68674054
com.designPatterns.singleton.eager.Singleton@68674054

我们可以看到饿汉模式实现的单利，在多线程情况下运行良好，static 对象只在初始化的时候被加载一次，这点是由JVM保证的

  • 反射
 /**
     * 反射调用
     * @throws Exception
     */
    public void testWithReflect() throws Exception{
        Constructor[] constructors = Singleton.class.getDeclaredConstructors();
        Constructor defaultConstructor = constructors[0];
        defaultConstructor.setAccessible(true);
        Singleton    singleton = (Singleton) defaultConstructor.newInstance(null);
        System.out.println(Singleton.getInstance());
        System.out.println(singleton);
    }

    public static void main(String[] args) throws Exception{
        SingletonTest singletonTest=new SingletonTest();
        singletonTest.testWithReflect();
    }

com.designPatterns.singleton.eager.Singleton@610455d6
com.designPatterns.singleton.eager.Singleton@511d50c0

我们可以看到，通过反射调用构造方法，可以得到两个不同的对象，饿汉单利在反射情况下不能良好运行

  • 序列化和反序列化
  /**
     * 序列化反序列化调用
     *
     * @throws Exception
     */
    public void testWithStream() throws Exception {
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("\\singleton"));
             ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("\\singleton")));) {
            oos.writeObject(Singleton.getInstance());
            Singleton singleton = (Singleton) ois.readObject();
            System.out.println(Singleton.getInstance());
            System.out.println(singleton);
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    public static void main(String[] args) throws Exception {
        SingletonTest singletonTest = new SingletonTest();
        singletonTest.testWithStream();
    }

com.designPatterns.singleton.eager.Singleton@266474c2
com.designPatterns.singleton.eager.Singleton@2f4d3709

我们看到通过序列化和反序列化，我们也成功的打破了饿汉单利。

通过上面的实例，我们看到，饿汉模式在单线程及多线程环境下可以良好运行。在反射、序列化和反序列化的情况下无法良好运行。

设计模式初探-创建型模式之单例模式_第2张图片

3.3.2 序列化和反序列化的实现机制

当我们将一个对象在磁盘上存储，或者网上传输的时候，需要将其转换成byte[]，这个过程称之为序列化，其相反的过程为反序列化。实现序列化的方式有两种，实现Serializable\Externalizable 接口，下面为其异同

类目 是否要public constructor 实例化的方式 自定义逻辑的方式
Serializable no 查找最近父类，调用父类的无参构造器来实例化，逐个属性赋值 定义私有readObject\writeObject\readResolve
Externalizable yes 调用当前类的无参public constructor 实例化，调用readExternal为属性赋 重写writeExternal/readExternal 方法

下面以Serializable为例来做个示范

public class Student implements Serializable{
    private String name;
    private int age;
    private transient String addr;

    private Student(){
        System.out.println("构造方法被调用了");
    }


    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getAddr() {
        return addr;
    }

    public void setAddr(String addr) {
        this.addr = addr;
    }


    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", addr='" + addr + '\'' +
                '}';
    }

    /**
     *  定制序列化
     * @param oos
     * @throws Exception
     */
    private void writeObject(ObjectOutputStream oos)throws Exception{
        System.out.println("writeObject 调用了");
        oos.defaultWriteObject();
        oos.writeObject((addr+"test"));
    }

    /**
     * 定制反序列化
     * @param ois
     * @throws Exception
     */
    private void readObject(ObjectInputStream ois)throws Exception{
        System.out.println("readObject 调用了");
        ois.defaultReadObject();
        addr=(String) ois.readObject();

    }

    /**
     * 替换readObject后的值
     * @return
     */
    private Object readResolve(){
        System.out.println("readResolve 调用了");
        return this;
    }
    private static Student initStudent(){
        Student student=new Student();
        student.setAddr("上海市");
        student.setAge(20);
        student.setName("zhangsan");
        System.out.println("init student:"+student);
        return student;
    }

    public static void main(String[] args) throws Exception{
        Student student=initStudent();
        ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("\\sitx"));
        //将对象转为byte[] 输出
        oos.writeObject(student);
        ObjectInputStream ois=new ObjectInputStream(new FileInputStream(new File("\\sitx")));
        //从byte[] 中读取对象
        Student std= (Student)ois.readObject();
        System.out.println("readStudent:"+std);
    }
}

输出结果：

构造方法被调用了
init student:Student{name='zhangsan', age=20, addr='上海市'}
writeObject 调用了
readObject 调用了
readResolve 调用了
readStudent:Student{name='zhangsan', age=20, addr='上海市test'}

我们可以看到readObject 实例化的时候，并没有调用我们私有的构造器。同时readObject的调用顺序要先于readResolve。同时我们发现了一个有趣的现象，Student类中的三个方法readObject\writeObject\readResolve均为私有方法，是怎么被外部调用的呢？

疑问.jpg

原来ObjectOutputStream.writeObject和ObjectInputStream.readObject的过程中，会通过先按照默认的方式序列化/反序列化所有的非transient属性，然后再利用反射调用类中的私有writeObject/readObject/readReSolve方法。
源码如下：

  • 在ObjectStreamClass实例化的时候，通过反射查找并初始化上面的几个私有方法
if (serializable) {
            AccessController.doPrivileged(new PrivilegedAction() {
                public Void run() {
                    if (isEnum) {
                        suid = Long.valueOf(0);
                        fields = NO_FIELDS;
                        return null;
                    }
                    if (cl.isArray()) {
                        fields = NO_FIELDS;
                        return null;
                    }

                    suid = getDeclaredSUID(cl);
                    try {
                        fields = getSerialFields(cl);
                        computeFieldOffsets();
                    } catch (InvalidClassException e) {
                        serializeEx = deserializeEx =
                            new ExceptionInfo(e.classname, e.getMessage());
                        fields = NO_FIELDS;
                    }

                    if (externalizable) {
                        cons = getExternalizableConstructor(cl);
                    } else {
                        cons = getSerializableConstructor(cl);
                        writeObjectMethod = getPrivateMethod(cl, "writeObject",
                            new Class[] { ObjectOutputStream.class },
                            Void.TYPE);
                        readObjectMethod = getPrivateMethod(cl, "readObject",
                            new Class[] { ObjectInputStream.class },
                            Void.TYPE);
                        readObjectNoDataMethod = getPrivateMethod(
                            cl, "readObjectNoData", null, Void.TYPE);
                        hasWriteObjectData = (writeObjectMethod != null);
                    }
                    domains = getProtectionDomains(cons, cl);
                    writeReplaceMethod = getInheritableMethod(
                        cl, "writeReplace", null, Object.class);
                    readResolveMethod = getInheritableMethod(
                        cl, "readResolve", null, Object.class);
                    return null;
                }
            });
        }
  • 在ObjectOutputStream 中 invokeMethod
 private void writeSerialData(Object obj, ObjectStreamClass desc)
        throws IOException
    {
        ObjectStreamClass.ClassDataSlot[] slots = desc.getClassDataLayout();
        for (int i = 0; i < slots.length; i++) {
            ObjectStreamClass slotDesc = slots[i].desc;
            if (slotDesc.hasWriteObjectMethod()) {
                PutFieldImpl oldPut = curPut;
                curPut = null;
                SerialCallbackContext oldContext = curContext;

                if (extendedDebugInfo) {
                    debugInfoStack.push(
                        "custom writeObject data (class \"" +
                        slotDesc.getName() + "\")");
                }
                try {
                    curContext = new SerialCallbackContext(obj, slotDesc);
                    bout.setBlockDataMode(true);
                    slotDesc.invokeWriteObject(obj, this);
                    bout.setBlockDataMode(false);
                    bout.writeByte(TC_ENDBLOCKDATA);
                } finally {
                    curContext.setUsed();
                    curContext = oldContext;
                    if (extendedDebugInfo) {
                        debugInfoStack.pop();
                    }
                }

                curPut = oldPut;
            } else {
                defaultWriteFields(obj, slotDesc);
            }
        }
    }
void invokeWriteObject(Object obj, ObjectOutputStream out)
        throws IOException, UnsupportedOperationException
    {
        requireInitialized();
        if (writeObjectMethod != null) {
            try {
                writeObjectMethod.invoke(obj, new Object[]{ out });
            } catch (InvocationTargetException ex) {
                Throwable th = ex.getTargetException();
                if (th instanceof IOException) {
                    throw (IOException) th;
                } else {
                    throwMiscException(th);
                }
            } catch (IllegalAccessException ex) {
                // should not occur, as access checks have been suppressed
                throw new InternalError(ex);
            }
        } else {
            throw new UnsupportedOperationException();
        }
    }

3.3.3 通过readResolve 来改善单例

通过上面的介绍，大致可以了解readResolve的用法。下面我们用其来完善饿汉单例。

public class Singleton implements Serializable {
    private static final Singleton INSTANCE=new Singleton();
    private Singleton(){

    }

    public static Singleton getInstance(){
        return INSTANCE;
    }

    private Object readResolve(){
        return INSTANCE;
    }
}
  • 序列化和反序列化测试
   /**
     * 序列化反序列化调用
     *
     * @throws Exception
     */
    public void testWithStream() {
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("\\singleton"));
             ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("\\singleton")));) {
            oos.writeObject(Singleton.getInstance());
            Singleton singleton = (Singleton) ois.readObject();
            System.out.println(Singleton.getInstance());
            System.out.println(singleton);
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    public static void main(String[] args) throws Exception {
        SingletonTest singletonTest = new SingletonTest();
        singletonTest.testWithStream();
    }

结果如下：

com.designPatterns.singleton.eager.Singleton@b4c966a
com.designPatterns.singleton.eager.Singleton@b4c966a

成功的防止了在序列化和反序列化情况下单利破坏。

3.4 懒汉单例

懒汉单利，即用到的时候才实例化的单例。这里的懒指的是懒加载。

public class Singleton implements Serializable {
    private static Singleton INSTANCE = null;

    private Singleton() {

    }

    public static Singleton getInstance() {
        if (INSTANCE == null) {
            INSTANCE = new Singleton();
        }
        return INSTANCE;
    }

}

3.4.1 破坏单例

我们分别在单线程环境、多线程环境、反射、序列化和反序列化的情况下获取单例。
由于代码与3.3.1 中相同，故只贴出运行结果

  • 单线程
com.designPatterns.singleton.lazy.Singleton@610455d6
com.designPatterns.singleton.lazy.Singleton@610455d6
com.designPatterns.singleton.lazy.Singleton@610455d6
com.designPatterns.singleton.lazy.Singleton@610455d6
com.designPatterns.singleton.lazy.Singleton@610455d6
com.designPatterns.singleton.lazy.Singleton@610455d6
com.designPatterns.singleton.lazy.Singleton@610455d6
com.designPatterns.singleton.lazy.Singleton@610455d6
com.designPatterns.singleton.lazy.Singleton@610455d6
com.designPatterns.singleton.lazy.Singleton@610455d6
  • 多线程
com.designPatterns.singleton.lazy.Singleton@49fe0fd2
com.designPatterns.singleton.lazy.Singleton@49fe0fd2
com.designPatterns.singleton.lazy.Singleton@7c837e63
com.designPatterns.singleton.lazy.Singleton@49fe0fd2
com.designPatterns.singleton.lazy.Singleton@49fe0fd2
com.designPatterns.singleton.lazy.Singleton@358b5609
com.designPatterns.singleton.lazy.Singleton@49fe0fd2
com.designPatterns.singleton.lazy.Singleton@49fe0fd2
com.designPatterns.singleton.lazy.Singleton@49fe0fd2
com.designPatterns.singleton.lazy.Singleton@5bbb3bd2
  • 反射
com.designPatterns.singleton.lazy.Singleton@610455d6
com.designPatterns.singleton.lazy.Singleton@511d50c0
  • 序列化和反序列化
com.designPatterns.singleton.lazy.Singleton@b4c966a
com.designPatterns.singleton.lazy.Singleton@2f4d3709

可以看到，懒汉模式只有在单线程环境下能良好运行。在多线程、反射、序列化和反序列化环境下均无法保证单例。
当然我们同样可以通过定义readResolve方法来让其在序列化和反序列的情况下正常运行。由于与3.3.3 的代码完全一致，此处不做演示。
值得注意的是，懒汉模式实现了懒加载，这点是饿汉无法实现的

3.5 双重锁单利

既然饿汉模式实现了懒加载但是无法保证线程安全，那么有没有一种即能实现懒加载，又能保证线程安全的单利模式呢？双重锁单利（double-check-singleton）就是这种单利。
所谓双重锁单利，即通过对代码加锁（可以是语言层面的synchronzied,也可以是jdk层面的 Lock）和双重非空判断的方式来实现单利。通过这种方式实现的单利，兼具线程安全及懒加载及性能。以下为代码实现

   private static volatile Singleton INSTANCE = null;

    private Singleton() {

    }

    public static Singleton getInstance() {
        if (INSTANCE == null) {
            synchronized (Singleton.class) {
                if (INSTANCE == null) {
                    INSTANCE = new Singleton();
                }
            }

        }
        return INSTANCE;
    }

}

有两点值得注意的地方

  1. synchronized 加锁的位置是出于性能的考虑（不加在方法上是为了保证互斥的最小性）
  2. volatile关键字是为了禁止指令的重排序及保证可见性（防止多线程环境下，拿到已分配内存但未初始化的对象）
    上面的第二点主要是因为new Singleton() 这个步骤，是一个非原子性操作。通过javap -c Singleton 查看字节码：
public static com.designPatterns.singleton.doubleCheck.Singleton getInstance();
    Code:
       0: getstatic     #2                  // Field INSTANCE:Lcom/designPatterns/singleton/doubleCheck/Singleton;
       3: ifnonnull     37
       6: ldc           #3                  // class com/designPatterns/singleton/doubleCheck/Singleton
       8: dup
       9: astore_0
      10: monitorenter
      11: getstatic     #2                  // Field INSTANCE:Lcom/designPatterns/singleton/doubleCheck/Singleton;
      14: ifnonnull     27
      17: new           #3                  // class com/designPatterns/singleton/doubleCheck/Singleton
      20: dup
      21: invokespecial #4                  // Method "":()V
      24: putstatic     #2                  // Field INSTANCE:Lcom/designPatterns/singleton/doubleCheck/Singleton;
      27: aload_0
      28: monitorexit
      29: goto          37
      32: astore_1
      33: aload_0
      34: monitorexit
      35: aload_1
      36: athrow
      37: getstatic     #2                  // Field INSTANCE:Lcom/designPatterns/singleton/doubleCheck/Singleton;
      40: areturn

我们可以看到 instance=new Singleton 分为几步

  1. 开辟对象空间-new
  2. 调用构造函数初始化-invokespecial
  3. 为引用赋值-putstatic
    步骤2和3 可能会发生指令的重排序，导致多线程环境下拿到未初始化的实例。

3.5.1 破坏单例

我们分别在单线程环境、多线程环境、反射、序列化和反序列化的情况下获取单例。
由于代码与3.3.1 中相同，故只贴出运行结果

  • 单线程
com.designPatterns.singleton.doubleCheck.Singleton@610455d6
com.designPatterns.singleton.doubleCheck.Singleton@610455d6
com.designPatterns.singleton.doubleCheck.Singleton@610455d6
com.designPatterns.singleton.doubleCheck.Singleton@610455d6
com.designPatterns.singleton.doubleCheck.Singleton@610455d6
com.designPatterns.singleton.doubleCheck.Singleton@610455d6
com.designPatterns.singleton.doubleCheck.Singleton@610455d6
com.designPatterns.singleton.doubleCheck.Singleton@610455d6
com.designPatterns.singleton.doubleCheck.Singleton@610455d6
com.designPatterns.singleton.doubleCheck.Singleton@610455d6
  • 多线程
com.designPatterns.singleton.doubleCheck.Singleton@3480e44e
com.designPatterns.singleton.doubleCheck.Singleton@3480e44e
com.designPatterns.singleton.doubleCheck.Singleton@3480e44e
com.designPatterns.singleton.doubleCheck.Singleton@3480e44e
com.designPatterns.singleton.doubleCheck.Singleton@3480e44e
com.designPatterns.singleton.doubleCheck.Singleton@3480e44e
com.designPatterns.singleton.doubleCheck.Singleton@3480e44e
com.designPatterns.singleton.doubleCheck.Singleton@3480e44e
com.designPatterns.singleton.doubleCheck.Singleton@3480e44e
com.designPatterns.singleton.doubleCheck.Singleton@3480e44e
  • 反射
com.designPatterns.singleton.doubleCheck.Singleton@610455d6
com.designPatterns.singleton.doubleCheck.Singleton@511d50c0
  • 序列化和反序列化
com.designPatterns.singleton.doubleCheck.Singleton@b4c966a
com.designPatterns.singleton.doubleCheck.Singleton@2f4d3709

可以看到，双重锁单例在单线程及多线程环境下均能很好的工作，但是在反射及序列化反序列化的情况下均无法正常工作。

3.6 内部类单例

所谓内部类单例，即通过内部类的方式来提供懒加载的单例。

public class Singleton {
    private Singleton() {

    }

    private static class Holder {
        private static Singleton singleton = new Singleton();
    }

    public static Singleton getInstance() {
        return Holder.singleton;
    }

}

值得注意的是：

  1. 实现了懒加载的单例
  2. 不用加锁
  3. 外部类可以访问内部类的私有变量（TODO）

3.6.1 破坏单例

我们分别在单线程环境、多线程环境、反射、序列化和反序列化的情况下获取单例。
由于代码与3.3.1 中相同，故只贴出运行结果

  • 单线程
com.designPatterns.singleton.holder.Singleton@610455d6
com.designPatterns.singleton.holder.Singleton@610455d6
com.designPatterns.singleton.holder.Singleton@610455d6
com.designPatterns.singleton.holder.Singleton@610455d6
com.designPatterns.singleton.holder.Singleton@610455d6
com.designPatterns.singleton.holder.Singleton@610455d6
com.designPatterns.singleton.holder.Singleton@610455d6
com.designPatterns.singleton.holder.Singleton@610455d6
com.designPatterns.singleton.holder.Singleton@610455d6
com.designPatterns.singleton.holder.Singleton@610455d6
  • 多线程
com.designPatterns.singleton.holder.Singleton@3480e44e
com.designPatterns.singleton.holder.Singleton@3480e44e
com.designPatterns.singleton.holder.Singleton@3480e44e
com.designPatterns.singleton.holder.Singleton@3480e44e
com.designPatterns.singleton.holder.Singleton@3480e44e
com.designPatterns.singleton.holder.Singleton@3480e44e
com.designPatterns.singleton.holder.Singleton@3480e44e
com.designPatterns.singleton.holder.Singleton@3480e44e
com.designPatterns.singleton.holder.Singleton@3480e44e
com.designPatterns.singleton.holder.Singleton@3480e44e
  • 反射
com.designPatterns.singleton.holder.Singleton@610455d6
com.designPatterns.singleton.holder.Singleton@511d50c0
  • 序列化和反序列化
com.designPatterns.singleton.holder.Singleton@b4c966a
com.designPatterns.singleton.holder.Singleton@2f4d3709

我们可以看到内部类单例在单线程及多线程环境下均能很好的运行，但是在反射和序列化反序列化的情况下无法保证单例。

3.7 枚举单例

上面的几种单例模式，不能同时满足 懒加载、线程安全、序列化反序列、反射的情况下单例。那么就没有一种同时满足以上几种情况的单例吗？
枚举单例既能保证线程安全，又能保证序列化和反序列化单例，也能保证反射单例。但是无法懒加载。

public enum Singleton {
    INSTANCE;
    public static Singleton getInstance(){
        return INSTANCE;
    }
}
吃惊.jpg

是不是特别简单，值得注意的是：

  1. jvm 会保证enum 构造器的私有，故此处不用写私有构造方法

3.7.1 破坏单例

我们分别在单线程环境、多线程环境、反射、序列化和反序列化的情况下获取单例。
由于代码与3.3.1 中相同，故只贴出运行结果

  • 单线程
INSTANCE
INSTANCE
INSTANCE
INSTANCE
INSTANCE/
INSTANCE
INSTANCE
INSTANCE
INSTANCE
INSTANCE
  • 多线程
INSTANCE
INSTANCE
INSTANCE
INSTANCE
INSTANCE
INSTANCE
INSTANCE
INSTANCE
INSTANCE
INSTANCE
  • 反射
Exception in thread "main" java.lang.IllegalArgumentException: Cannot reflectively create enum objects
    at java.lang.reflect.Constructor.newInstance(Constructor.java:417)
    at com.designPatterns.singleton.SingletonTest.testWithReflect(SingletonTest.java:48)
    at com.designPatterns.singleton.SingletonTest.main(SingletonTest.java:74)
  • 序列化和反序列化
INSTANCE
INSTANCE

可以看到，我们无法通过反射调用枚举类型的构造方法。枚举单利，在单线程、多线程、反射、序列化反序列化的情况下均能很好的工作。无需加锁，实现简单，是首推的实现单例的方式。

3.8 几种单例的比对

单例类型 能否懒加载 是否线程安全 是否加锁 能否通过反射获取新的实例 能否通过序列化和反序列化获取新的实例
饿汉模式 非懒加载 线程安全 不加锁 是 否
懒汉模式 懒加载 线程不安全 不加锁 是 否
双重锁单例 非懒加载 线程安全 加锁 是 否
内部类单例 懒加载 线程安全 不加锁 是 否
枚举单例 非懒加载 线程安全 不加锁 否 否

可以看到枚举单例是我们实现起来最简单，也是最高效的单例，不用去考虑私有构造器，不用去考虑定制反序列化readResolve方法。

3.9 基于单例编写文件加载

假设有个需求需要加载资源文件，这种资源文件的加载是比较耗时的，我们肯定只希望加载一次，尝试用枚举单例解决这个问题。

public enum PropertiesConfig {
    //实例
    CONFIG;
    //配置文件存储集合
    private ConcurrentHashMap sources = new ConcurrentHashMap();

    PropertiesConfig() {
        Properties properties = new Properties();
        try {
            properties.load(PropertiesConfig.class.getResourceAsStream("application.properties"));
        } catch (IOException e) {
            e.printStackTrace();
        }
        properties.entrySet().forEach(p -> sources.put(p.getKey(), p.getValue()));
    }

    private static PropertiesConfig getInstance() {
        return CONFIG;
    }

    private Object getPropertiesByKey(String key) {
        return sources.get(key);
    }


    public static void main(String[] args) {
        ExecutorService pool = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++) {
            pool.submit(() -> {
                System.out.println(PropertiesConfig.getInstance().getPropertiesByKey("url"));
            });
        }
    }
}

4.总结

本文开始，我们开启了新的话题-设计模式。我们先是总结了设计模式的分类，然后着重剖析了单例模式，分析了单例模式的实现。but 本文的重点不是单例模式的实现，而是单例模式的破坏，以及小tips-序列化和反序列自定义。希望通本文，大家都能对单例的种种有些许新的感悟。

由于技术水平所限，文章难免有不足之处，欢迎大家指出。希望每位读者都能有新的收获，我们下一篇文章-设计模式初探-创建型模式之工厂模式 见
.....

参考文章

  • head first 设计模式

你可能感兴趣的:(设计模式初探-创建型模式之单例模式)

  • 《昼颜》里的日本女人：相遇要万种风情，分手要残忍绝情 迷影咖啡
    作者：迷之菌子神奇菇迷影咖啡：一本正经做烘焙，胡说八道聊电影漫天萤火虫消散之时良宵就将过去，人们也说含苞待放的花蕾总会开了又谢，因紧紧相拥而面红耳赤的躯体，便是我们经历过这热爱的证明。夫妻关系介绍《昼颜》是2014年电视剧《昼颜：工作日下午三点的恋人们》的续集，故事发在电视剧情节结束的三年后，讲述了已经恢复独身的纱和偶然与曾经的出轨对象北野重逢后再次陷入感情漩涡的故事。《昼颜》制作灵感源自利佳子在
  • 迎接2019 唯有杜康1994
    告别2018这一年是机遇与挑战，痛苦与喜悦，失去与收获的一年一月:收获了第一份爱情，开始真正想去了解一个人三月:对工作有了更深入的认识，靠自己的力量完成晋升五月:搬家，住进了自己理想的公寓，一间属于自己的屋子。满地的书六月:外调广州，升经理，有了自己的第一个团队。七月:怀着自我否定，第一次完成了部门任务八月:第一个员工流失，痛哭不已明白无不散之筵席九月:员工陆续离开，经济是一切的根本。十月:陪员工
  • 亲子日记之祝姑姥姥生日快乐（282） 冰心雨露_d504
    2021年7月18日，周日，晴周日上班的不上班，上学的不上学，全家都属于休息状态，洗衣做饭是上午的主要任务，中午休息一会儿，下午比较晚了出去给梦怡买了二年级上册的口算题卡，然后去参加姑姑的生日聚餐，本来姑姑应该是周一生日，因为周一都要上班，就提前到周日过了，说是过生日其实就是想借此机会一家人聚聚，毕竟平常都忙，没有时间聚在一起，梦怡还给姑姥姥做了生日贺卡，虽然长相一般，重在心意。生日快乐
  • android 自定义曲线图,Android自定义View——贝赛尔曲线 weixin_39767513 android自定义曲线图
    个人博客：haichenyi.com。感谢关注本文针对有一定自定义View的童鞋，最好对贝赛尔曲线有辣么一丢丢了解，不了解也没关系。花5分钟看一下GcsSloop的安卓自定义View进阶-Path之贝塞尔曲线。本文的最终效果图：最终效果图.gif思路首先他是一个只有上半部分的正弦形状的水波纹，很规则。其次，他这个正弦图左右在移动。然后，就是它这个自定义View，上下也在移动，是慢慢增加的最后，优化
  • 信任 饮冰伊乔
    随着社会的发展，微信和支付宝交易给人们带来了极大的方便，越来越多的人出门都只选择拿一部手机即可，方便安全，可昨天我就遇到了一件比较尴尬的事。昨天傍晚，我从公司出来，感觉有点饿，决定索性吃了饭再回去，来到去过几次的一个店里，如往常一样叫了餐，当时店里吃饭的不多，老板麻利的先去做了，正要扫微信付账的时候发现手机没电了，迷之尴尬，我只好跟老板说不用做了，手机没电了，我身上又没现金，付不了帐了。老板娘很热
  • Django之Debug篇 菜鸟之编程 Djangodjangopython后端
    一、DebugToolBar基本使用1.1、概述Django框架的调试工具栏使用django-debug-toolbar库，是一组可配置的面板，显示有关当前请求/响应的各种调试信息，点击时，显示有关面板内容的更多详细信息。官方文档：DjangoDebugToolbar—DjangoDebugToolbar4.3.0documentation1.2、安装pipinstalldjango-debug-
  • 以高质量调查研究助力组织工作提质增效 木同木同
    近日，中共中央办公厅印发了《关于在全党大兴调查研究的工作方案》(后简称《方案》），要求各地区各部门结合实际认真贯彻落实。调查研究是我们党的传家宝，是谋事之基、成事之道。组织部门作为党管干部的核心部门，肩负着管党员、管干部、管人才的重要职责，调查研究更是把握组织工作规律、破解组织工作难题的重要办法。要用好调查研究这一法宝，把准政治方向，贯穿问题导向，坚持实事求是，以高质量调查研究助力组织工作提质增效
  • 地低为海人低为王 缘梦草
    地低为海，人低为王。低，高之基，高，低之顶。谦虚才能收益，咄咄逼人会招损。高粱熟了，头会低下。受益反而会深藏不露。捧人之术，把人捧高，然后控制。受控之人，大都是虚荣心作祟。活成别人想象中的样子，像别人想象中那么有面子的活着是悲哀的。穷不可怕，怕的是虚荣心。当你好面子，你就会被控制。一旦受虚荣心控制，你不得不谨小慎微的维护面子，付出多余的能量，希望得到别人的一句赞。面子就是金子打造的牢笼，让你在赞美
  • 计划比盲目做重要 一祉微笑
    坚持分享第99天。一次次会议提醒着老师们假期余额不足，马上面临停机状态。50多天掐指而过，想想放假时的计划，对照如今的完成情况，感觉差太远。想着好好看书，如今50多天过去了第6本还处在未完待续状态；想着假期好好陪陪孩子，在玩中学一些知识，如今想想，孩子学的真不多；想着暑假坚持跑步，有时还是容易给自己找借口，休息三两天。给这个假期一个综合评价，只能说只完成了计划的百分之五六十。想想为什么临近开学没达
  • 081天 约柜失而复得 宁宁2018
    撒迦利亚书4:6他对我说：“这是耶和华指示所罗巴伯的。万军之耶和华说：‘不是倚靠势力，不是倚靠才能，乃是倚靠我的灵方能成事。’
  • 《金文成〈正蒙〉日记124。2020-11-9》 金吾生
    《金文成〈正蒙〉日记124。2020-11-9》今天是庚子丁亥丙子，九月廿四，2020年11月9日星期一。作者篇7【舜之孝，汤、武之武，虽顺逆不同，其为不幸均矣。】船山讲解说，顺，指的是舜的父亲最终受到感化，转变了态度，结局圆满之事；逆，指的是＂桀放、纣诛＂，即，商汤放桀，周武诛纣，都是采用暴力，不是感化方式，所以是逆。顺与逆，都是为了解决弊政，然其差异之大如此，然而，无论圆满还是遗憾，其实他们都
  • 如何把大象装进冰箱的思考 210624 大丁_初心生活
    央视春晚曾有个小品，宋丹丹问赵本山，如何把大象装进冰箱。赵本山说不知道。宋丹丹得意地说，第一步，把冰箱门打开。第二步，把大象装进去。第三步，把冰箱门关上。我相信很多人看了都是一笑了之，我们也从潜意识上给出了否定的答案。樊登老师给出了不一样的解读，他认为这其实是解决问题的经典方法。“把大象装冰箱”，目标十分明确，宋丹丹给出的执行步骤也十分清晰。可赵本山却不会？难道赵本山不知道这三个步骤吗？肯定知道。
  • 道德经第三十四章 套马地汉纸
    道德经第三十四章原文：大道泛兮，其可左右！万物恃之而生，而不辞，功成不名有。爱养万物而不为主，常无欲，可名于小；万物归焉而不为主，可名为大。是以圣人终不为大，故能成其大。译文：大道广泛流行，无所不到。万物依赖它生长而不推辞，有所成就而不自以为有功。养育万物而不自以为主，永远没有私欲，可以说是渺小得很，所以可称它为“小”；物归附于它而它不自以为主宰，可以说极其伟大，所以可称它为“大”。由于它不自以为
  • Linux学习系列之vim编辑器（一） llibertyll linux学习
    vi编辑器的操作模式输入模式—aio等—>命令模式<—：键—末行模式从输入/末行模式切换到命令模式都是需要按ESC键注:a光标后输入，i光标前输入，o直接向下加一行输入，O向上加一行输入在vi编辑器中光标的移动（命令行模式下）键组合（命令）光标的移动$光标移动到当前行的结尾0（零）光标移动到当前行的开始GG光标移动到最后一行gg光标移动到第一行在命令行模式下删除与复制的操作键组合（命令）含义dd删
  • 6/21 最后的编织之观后感 ChereAlicia
    今天看了7分钟震撼人心之短篇有种当局者迷旁观者清的感觉在外人眼里看来已经足够但自有人深陷其中无法自拔而那个人很有可能是自己超脱物质寻求自己真正想要的方能得到内心的平息和安宁图片发自App
  • 每天学点成语 余子烨
    1、口诀：功败垂成未成功，不以为然不赞同；火中取栗被利用，罚不当罪处罚重；2、解释：功败垂成：事情接近成功的时候却遭到了失败。出自：《三国志·杨阜传》：“弃垂成之功，陷不义之名，阜以死守之。”不以为然：不认为是对的。表示不同意或否定。出自：宋·苏轼《再乞罢详定役法状》：“右臣先曾奏论前衙一役，只当招募，不当定差，执政不以为然。”火中取栗：一只猴子和一只猫看见炉火中烤着栗子，猴子叫猫去偷，猫用爪子从
  • C语言演示多线程编程条件下自旋锁和屏障的使用 嫦娥妹妹等等我 开发语言c语言开源
    主线故事:有4个人玩游戏输了,惩罚:1分别使用4台不同的ATM机给我存钱2必须一块一块的存3存完还得在ATM上看一下我的余额设计模式:1每个人使用一条单独的线程,再准备一个计时线程用来输出时间2存钱涉及到对共享资源的读写,是原子操作需要用锁保护这里使用自旋锁3都存完钱后需要等待在各自的ATM上回显余额这里使用屏障技术4如果在主线程中回显对应他们给我打电话告诉我存完了我自己看一下则不需要使用屏障因为
  • 2023-11-07 碎碎念念的每一天
    忽然开始自卑了，感觉自己无论各个方面都太平平，读书不多，家务做不好，体重控制的不好，早起也困难，起来又不知道该做什么，没有一个可以为之奋斗的目标，也没有很好的交际圈，感觉自己就像一只在笼子里的鸟，想飞也飞不高……我想改变这样的现状，可该如何呢？其实都是我不够努力，没有争分夺秒，没有自律，这些都是我未来跟人拉开差距的原因，所以，我不应该只是自卑，自卑过头会变成焦虑，我应该努力去改变，哪怕改变一小点，
  • stm32之GPIO寄存器 luofengmacheng 嵌入式stm32嵌入式硬件单片机
    文章目录1背景2GPIO寄存器的类型2.1端口配置寄存器2.2设置/清除寄存器和位清除寄存器3总结1背景C51单片机在进行数据的输入输出时，是直接操作与外部引脚关联的内部寄存器，例如，当设置P2_1为0时，就是将外部引脚的P21引脚设置为低电平，当读取P2_1时，就是读取P21的电平。与之类似，stm32芯片内部也有很多用于输入输出的寄存器，这些寄存器也是用于操作外部引脚，但是比C51单片机复杂很
  • 《老子》笔记19 2018-10-28 海上明月共
    第二十二章[原文]曲则全，枉则直，洼则盈，敝则新，少则得，多则惑。是以圣人抱一为天下式。不自见，故明；不自是，故彰，不自伐，故有功；不自矜，故长。夫唯不争，故天下莫能与之争。古之所谓"曲则全"者，岂虚言哉？诚全而归之。[译文]委曲便会保全，屈枉便会直伸；低洼便会充盈，陈旧便会更新；少取便会获得，贪多便会迷惑。所以有道的人坚守这一原则作为天下事理的范式，不自我表扬，反能显明；不自以为是，反能是非彰明
  • 爱心账户之存钱日记11.20 静_d595
    新沙发终于到了，满心欢喜，可旧沙发的处理又是个头疼的问题，免费送都没有人要。临时想起来公司那个收垃圾的，看看付费能不能拉走。对方说随便给点都行，我又拿不准，于是就想说88把。对方说给两包烟就行了，我说还是给钱吧，也不想欠人情。如果请专门搬东西的估计得200加了，还算是比较顺利，刚好想到他。选了12元存进我的爱心账户！
  • 【二】【设计模式】建造者模式 妖精七七_ 设计模式设计模式建造者模式
    建造者模式的引入//C10_1.cpp#include#include"SystemConfig.h"intmain(){SystemConfigconfig("mysql://127.0.0.1/","xiaomu","xiaomumemeda","redis://127.0.0.1/","xiaomuredis","xiaomuredispw","kafka://127.0.0.1","xia
  • 大话设计模式之工厂模式 码农客栈 设计模式开发语言
    工厂模式（FactoryPattern）是一种创建型设计模式，它提供了一种创建对象的最佳方式，而无需指定将要创建的对象的确切类。通过使用工厂模式，我们可以将对象的创建和使用分离，从而使代码更具灵活性和可维护性。在工厂模式中，通常会有三种角色：工厂接口（FactoryInterface）：声明了一个用于创建对象的接口，这样所有具体工厂类都必须实现该接口。具体工厂（ConcreteFactory）：实
  • 《外观模式（极简c++）》 Bovinitwo 设计模式（极简c++版）c++开发语言
    本文章属于专栏-概述-《设计模式（极简c++版）》-CSDN博客模式说明方案：外观模式提供了一个统一的接口，简化了一组复杂子系统的访问方式。优点：将客户端与子系统解耦，降低了复杂性。提高了代码的灵活性和可维护性。缺点：可能导致外观类过于庞大，承担了过多的责任。增加了系统的抽象层，有时会影响性能。本质思想：外观模式的本质思想是为一组复杂的子系统提供一个简单的接口，隐藏其复杂性，使得客户端可以更轻松地
  • 大话设计模式之代理模式 码农客栈 设计模式代理模式
    代理模式（ProxyPattern）是一种结构型设计模式，它允许通过代理对象控制对另一个对象的访问。代理对象充当客户端和实际对象之间的中介，客户端通过代理对象间接访问实际对象，从而可以在访问控制、缓存、延迟加载等方面提供额外的功能。在代理模式中，通常会有三种角色：Subject（抽象主题）：声明了真实对象和代理对象的共同接口，这样在任何使用真实对象的地方都可以使用代理对象。RealSubject（
  • 【1.1 编程基础之输入输出】09. 字符菱形 青少年编程小助手_Python Openjudge题目解析算法青少年编程电子学会等级考试gesp
    09:字符菱形总时间限制:1000ms内存限制:65536kB描述给定一个字符，用它构造一个对角线长5个字符，倾斜放置的菱形。输入输入只有一行，包含一个字符。输出该字符构成的菱形。样例输入*样例输出*************参考程序（1）C语言#includeintmain(){charc;scanf("%c",&c);printf("%c\n",c);printf("%c%c%c\n",c,c,
  • C#学习笔记 2301_79022588 学习笔记
    一、事件派发器在C#中，事件派发器通常是指事件委托和事件处理程序的组合，用于实现一种观察者设计模式。它允许对象在状态发生变化时通知其他对象，从而实现对象之间的解耦。事件派发器的基本组成部分：事件委托（EventDelegate）：事件委托是一种特殊的委托，用于封装可以被调用的方法。它定义了事件的签名，即指定了事件处理程序方法的参数和返回类型。通常，事件委托声明在事件派发器类的外部，并且使用dele
  • 剩28天19年12月3日星期二 晴朗 岁月流转足迹可循
    图片发自App图片发自App图片发自App图片发自App昨天升完旗，去操场上走走，才发现霜是如此之重，脚踩上去，都有凝粒！天是越来越冷了！不过晴空净爽，空气清冽，一呼一吸之间很是舒服！中午写了几个大字，童爸说笔画还有些软，一语中的。需用心提升，贵在坚持坚持吧！下午做了张丽华的顺车，捎我到陈仓元，再坐了3路到西关，费时50分钟！晚上吃完饭送童去学校，到八点半下楼运动半小时，跳了500个绳，弯弯腰！感
  • 很久以前的故事 138 余间上古
    偶遇机械人大公子镇静下来继续说：“你可知所谓的拍卖会是要杀掉一些人，某些人斗不过一个映山城，天下虽大，从此后恐无容身之地。”他语气一缓：“如果你肯联手，我不但不计较你今日之举，杀手阁随时恭候大驾光临，从此多了一个方便之门。”“我只是寻找路彦而已......”薛莹笑道直呼其名：“剑二，用尽心思糊弄别人，独行者经常内斗再正常不过！你不过是一个道修，踏入神明之境而已，理解不到独行者的真谛……”薛莹言尽意
  • 因你 秋之枫520
    空气中，咖啡味弥散那是，一种我爱的香醇与你分别后，我的咖啡再没加过冰糖粉与牛奶品着苦涩，如同我生命的味道你若来了，倒给你半杯加糖加奶，空气多了两份香甜若你走了，我又会是一满杯一切如初，黑夜依旧宁静只有醇香陪着，久久不散因你，咖啡才会有苦有甜因你，我的小诗才有了主角因你，黑夜冲了杯喝不尽的咖啡因你，黑夜有了写不完的零碎小诗因你，我爱上了黑夜的这份宁静秋之枫。（原作）
  • 如何用ruby来写hadoop的mapreduce并生成jar包 wudixiaotie mapreduce
    ruby来写hadoop的mapreduce，我用的方法是rubydoop。怎么配置环境呢： 1.安装rvm：     不说了 网上有 2.安装ruby：     由于我以前是做ruby的，所以习惯性的先安装了ruby，起码调试起来比jruby快多了。 3.安装jruby：     rvm install jruby然后等待安
  • java编程思想 -- 访问控制权限 百合不是茶 java访问控制权限单例模式
    访问权限是java中一个比较中要的知识点,它规定者什么方法可以访问,什么不可以访问   一:包访问权限;   自定义包: package com.wj.control; //包 public class Demo { //定义一个无参的方法 public void DemoPackage(){ System.out.println("调用
  • [生物与医学]请审慎食用小龙虾 comsci 生物
         现在的餐馆里面出售的小龙虾,有一些是在野外捕捉的,这些小龙虾身体里面可能带有某些病毒和细菌,人食用以后可能会导致一些疾病,严重的甚至会死亡.....      所以,参加聚餐的时候,最好不要点小龙虾...就吃养殖的猪肉,牛肉,羊肉和鱼,等动物蛋白质     
  • org.apache.jasper.JasperException: Unable to compile class for JSP: 商人shang maven2.2jdk1.8
    环境： jdk1.8    maven  tomcat7-maven-plugin  2.0 原因： tomcat7-maven-plugin  2.0 不知吃 jdk 1.8，换成 tomcat7-maven-plugin  2.2就行，即     <plugin>
  • 你的垃圾你处理掉了吗?GC oloz GC
    前序:本人菜鸟，此文研究学习来自网络，各位牛牛多指教　 1.垃圾收集算法的核心思想 　　Java语言建立了垃圾收集机制，用以跟踪正在使用的对象和发现并回收不再使用(引用)的对象。该机制可以有效防范动态内存分配中可能发生的两个危险：因内存垃圾过多而引发的内存耗尽，以及不恰当的内存释放所造成的内存非法引用。 　　垃圾收集算法的核心思想是：对虚拟机可用内存空间，即堆空间中的对象进行识别
  • shiro 和 SESSSION 杨白白 shiro
    shiro 在web项目里默认使用的是web容器提供的session，也就是说shiro使用的session是web容器产生的，并不是自己产生的，在用于非web环境时可用其他来源代替。在web工程启动的时候它就和容器绑定在了一起，这是通过web.xml里面的shiroFilter实现的。通过session.getSession()方法会在浏览器cokkice产生JESSIONID，当关闭浏览器，此
  • 移动互联网终端 淘宝客如何实现盈利 小桔子 移動客戶端淘客淘寶App
           2012年淘宝联盟平台为站长和淘宝客带来的分成收入突破30亿元，同比增长100%。而来自移动端的分成达1亿元，其中美丽说、蘑菇街、果库、口袋购物等App运营商分成近5000万元。 可以看出，虽然目前阶段PC端对于淘客而言仍旧是盈利的大头，但移动端已经呈现出爆发之势。而且这个势头将随着智能终端(手机，平板)的加速普及而更加迅猛
  • wordpress小工具制作 aichenglong wordpress小工具
    wordpress 使用侧边栏的小工具，很方便调整页面结构 小工具的制作过程 1 在自己的主题文件中新建一个文件夹(如widget)，在文件夹中创建一个php(AWP_posts-category.php) 小工具是一个类,想侧边栏一样，还得使用代码注册，他才可以再后台使用，基本的代码一层不变 <?php class AWP_Post_Category extends WP_Wi
  • JS微信分享 AILIKES js
    // 所有功能必须包含在 WeixinApi.ready 中进行    WeixinApi.ready(function(Api) {        // 微信分享的数据            var wxData = {       &nb
  • 封装探讨 百合不是茶 JAVA面向对象 封装
    //封装   属性 方法 将某些东西包装在一起，通过创建对象或使用静态的方法来调用，称为封装；封装其实就是有选择性地公开或隐藏某些信息，它解决了数据的安全性问题，增加代码的可读性和可维护性   在 Aname类中申明三个属性，将其封装在一个类中：通过对象来调用   例如   1： //属性 将其设为私有 姓名 name 可以公开
  • jquery radio/checkbox change事件不能触发的问题 bijian1013 JavaScriptjquery
    我想让radio来控制当前我选择的是机动车还是特种车，如下所示：  <html> <head> <script src="http://ajax.googleapis.com/ajax/libs/jquery/1.7.1/jquery.min.js" type="text/javascript"><
  • AngularJS中安全性措施 bijian1013 JavaScriptAngularJS安全性XSRFJSON漏洞
            在使用web应用中，安全性是应该首要考虑的一个问题。AngularJS提供了一些辅助机制，用来防护来自两个常见攻击方向的网络攻击。 一.JSON漏洞         当使用一个GET请求获取JSON数组信息的时候（尤其是当这一信息非常敏感，
  • [Maven学习笔记九]Maven发布web项目 bit1129 maven
    基于Maven的web项目的标准项目结构 user-project     user-core     user-service     user-web        src      
  • 【Hive七】Hive用户自定义聚合函数(UDAF) bit1129 hive
    用户自定义聚合函数，用户提供的多个入参通过聚合计算(求和、求最大值、求最小值)得到一个聚合计算结果的函数。 问题：UDF也可以提供输入多个参数然后输出一个结果的运算，比如加法运算add(3，5)，add这个UDF需要实现UDF的evaluate方法,那么UDF和UDAF的实质分别究竟是什么？   Double evaluate(Double a, Double b)  
  • 通过 nginx-lua 给 Nginx 增加 OAuth 支持 ronin47
    前言：我们使用Nginx的Lua中间件建立了OAuth2认证和授权层。如果你也有此打算，阅读下面的文档，实现自动化并获得收益。SeatGeek 在过去几年中取得了发展，我们已经积累了不少针对各种任务的不同管理接口。我们通常为新的展示需求创建新模块，比如我们自己的博客、图表等。我们还定期开发内部工具来处理诸如部署、可视化操作及事件处理等事务。在处理这些事务中，我们使用了几个不同的接口来认证： &n
  • 利用tomcat-redis-session-manager做session同步时自定义类对象属性保存不上的解决方法 bsr1983 session
    在利用tomcat-redis-session-manager做session同步时，遇到了在session保存一个自定义对象时，修改该对象中的某个属性，session未进行序列化，属性没有被存储到redis中。 在 tomcat-redis-session-manager的github上有如下说明： Session Change Tracking As noted in the &qu
  • 《代码大全》表驱动法-Table Driven Approach-1 bylijinnan java算法
    关于Table Driven Approach的一篇非常好的文章： http://www.codeproject.com/Articles/42732/Table-driven-Approach package com.ljn.base; import java.util.Random; public class TableDriven { public
  • Sybase封锁原理 chicony Sybase
           昨天在操作Sybase IQ12.7时意外操作造成了数据库表锁定，不能删除被锁定表数据也不能往其中写入数据。由于着急往该表抽入数据，因此立马着手解决该表的解锁问题。     无奈此前没有接触过Sybase IQ12.7这套数据库产品，加之当时已属于下班时间无法求助于支持人员支持，因此只有借助搜索引擎强大的
  • java异常处理机制 CrazyMizzz java
    java异常关键字有以下几个，分别为 try catch final throw throws 他们的定义分别为 try：    Opening exception-handling statement. catch：  Captures the exception. finally： Runs its code before terminating
  • hive 数据插入DML语法汇总 daizj hiveDML数据插入
    Hive的数据插入DML语法汇总1、Loading files into tables语法：1) LOAD DATA [LOCAL] INPATH 'filepath' [OVERWRITE] INTO TABLE tablename [PARTITION (partcol1=val1, partcol2=val2 ...)]解释：1)、上面命令执行环境为hive客户端环境下： hive>l
  • 工厂设计模式 dcj3sjt126com 设计模式
      使用设计模式是促进最佳实践和良好设计的好办法。设计模式可以提供针对常见的编程问题的灵活的解决方案。 工厂模式 工厂模式（Factory）允许你在代码执行时实例化对象。它之所以被称为工厂模式是因为它负责“生产”对象。工厂方法的参数是你要生成的对象对应的类名称。 Example #1 调用工厂方法（带参数） <?phpclass Example{ 
  • mysql字符串查找函数 dcj3sjt126com mysql
      FIND_IN_SET(str,strlist) 假如字符串str 在由N 子链组成的字符串列表strlist 中，则返回值的范围在1到 N 之间。一个字符串列表就是一个由一些被‘,’符号分开的自链组成的字符串。如果第一个参数是一个常数字符串，而第二个是type SET列，则   FIND_IN_SET() 函数被优化，使用比特计算。如果str不在strlist 或st
  • jvm内存管理 easterfly jvm
    一、JVM堆内存的划分 分为年轻代和年老代。年轻代又分为三部分：一个eden,两个survivor。 工作过程是这样的：e区空间满了后，执行minor gc，存活下来的对象放入s0, 对s0仍会进行minor gc，存活下来的的对象放入s1中，对s1同样执行minor gc，依旧存活的对象就放入年老代中； 年老代满了之后会执行major gc，这个是stop the word模式，执行
  • CentOS-6.3安装配置JDK-8 gengzg centos
    JAVA_HOME=/usr/java/jdk1.8.0_45 JRE_HOME=/usr/java/jdk1.8.0_45/jre PATH=$PATH:$JAVA_HOME/bin:$JRE_HOME/bin CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar:$JRE_HOME/lib export JAVA_HOME
  • 【转】关于web路径的获取方法 huangyc1210 Web路径
    假定你的web application 名称为news,你在浏览器中输入请求路径：  http://localhost:8080/news/main/list.jsp  则执行下面向行代码后打印出如下结果：  1、 System.out.println(request.getContextPath()); //可返回站点的根路径。也就是项
  • php里获取第一个中文首字母并排序 远去的渡口 数据结构PHP
    很久没来更新博客了，还是觉得工作需要多总结的好。今天来更新一个自己认为比较有成就的问题吧。 最近在做储值结算，需求里结算首页需要按门店的首字母A-Z排序。我的数据结构原本是这样的： Array ( [0] => Array ( [sid] => 2885842 [recetcstoredpay] =&g
  • java内部类 hm4123660 java内部类匿名内部类成员内部类方法内部类
         　在Java中，可以将一个类定义在另一个类里面或者一个方法里面，这样的类称为内部类。内部类仍然是一个独立的类，在编译之后内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号。内部类可以间接解决多继承问题,可以使用内部类继承一个类，外部类继承一个类，实现多继承。      &nb
  • Caused by: java.lang.IncompatibleClassChangeError: class org.hibernate.cfg.Exten zhb8015
    maven pom.xml关于hibernate的配置和异常信息如下，查了好多资料，问题还是没有解决。只知道是包冲突，就是不知道是哪个包....遇到这个问题的分享下是怎么解决的。。   maven pom:   <dependency> <groupId>org.hibernate</groupId> <ar
  • Spark 性能相关参数配置详解－任务调度篇 Stark_Summer sparkcachecpu任务调度yarn
    随着Spark的逐渐成熟完善, 越来越多的可配置参数被添加到Spark中来, 本文试图通过阐述这其中部分参数的工作原理和配置思路, 和大家一起探讨一下如何根据实际场合对Spark进行配置优化。   由于篇幅较长，所以在这里分篇组织，如果要看最新完整的网页版内容，可以戳这里：http://spark-config.readthedocs.org/，主要是便
  • css3滤镜 wangkeheng htmlcss
    经常看到一些网站的底部有一些灰色的图标，鼠标移入的时候会变亮，开始以为是js操作src或者bg呢，搜索了一下，发现了一个更好的方法：通过css3的滤镜方法。 html代码： <a href='' class='icon'><img src='utv.jpg' /></a> css代码： .icon{-webkit-filter: graysc
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他