给女友讲讲设计模式——单例模式（JAVA实例）2

版权声明：个人版权所有 https://blog.csdn.net/iAmSoLucky_/article/details/82558734

前言

曾经有两个人，一个是A，一个是B，他们俩都是这个世界上独立的个体，每个人都是这个世界上独一无二的。这个A呢，在一出生的时候，别人就会把他需要的食物全部给他，然后等到他饿了的时候，就可以直接拿过来吃，但是在他不饿的时候，天天被在身上确是一种负担，人们都管他叫做饿汉。B呢，则是在出生的时候，并没有任何食物给他，但是在他饿的时候，他连伸手都不用，只需要张嘴喊一嗓子，便有人给他送来了食物，就因为他这么懒，所以被叫做懒汉。为什么要讲这个故事呢，接下来你就会明白了。

单例模式

在web开发中，我们经常碰到这样一种情况，我们在整个项目的上下文中，有且只有一个实例，所有线程操纵的都是它，例如说Mybatis中的SqlSessionFactory。如果说只存在一个实例，那么他绝对是不可以new出来，所以他的构造方法一定是私有的。
单例模式从方式上分为懒汉模式，和饿汉模式，这就像是咱们刚刚提到故事里的B和A一样，具体代码如下：

package singleton;

/**
 * 这是懒汉模式，但是对于多线程的情况下是不安全的
 * 
 * @author luckyharry
 *
 */
public class SingletonLazyNotSafe {
    private SingletonLazyNotSafe() {
        System.out.println("单例懒汉模式，无锁，实例化--");
    }

    private static SingletonLazyNotSafe singletonLazyNotSafe;

    public static SingletonLazyNotSafe getInstance() {
        if (singletonLazyNotSafe == null) {
            singletonLazyNotSafe = new SingletonLazyNotSafe();
        }
        return singletonLazyNotSafe;
    }
}

这是懒汉模式，但是我们会发现getInstance（）方法，多个线程可能会共同竞争，将会导致数据的不统一性，那么我们需要给它添加一个锁，关键字synchronized。

package singleton;

/**
 * 这是懒汉模式，对于多线程的情况下是安全的 但是因为加了锁，所以效率比较低
 * 
 * @author luckyharry
 *
 */
public class SingletonLazySafe {
    private SingletonLazySafe() {
        System.out.println("懒汉模式 有锁 实例化--");
    }

    private static SingletonLazySafe singletonLazySafe;

    public static synchronized SingletonLazySafe getInstance() {
        if (singletonLazySafe == null) {
            singletonLazySafe = new SingletonLazySafe();
        }
        return singletonLazySafe;
    }
}

懒汉模式，他是在当需要获得的时候才实例化，就像是刚刚所说的B那个人一样，实现了懒加载。但是加了锁之后，效率比较低下。

package singleton;

public class SingletonHunger {

    private static SingletonHunger singletonHunger=new SingletonHunger();
    // 构造器为私有的，不可以通过new实力化
    private SingletonHunger() {
        System.out.println("初始化 Singleton 饿汉方式--");
    }


    public static SingletonHunger getInstance() {
        return singletonHunger;
    }
}

饿汉模式我们不再去考虑多线程的问题，但是它却是在类加载的时候便会实例化单例本身，并未实现懒加载。这就像是刚刚说的A一样，在一出生的时候，该实例化的已经被实例化放在那了。

package singleton;

public class SingletonInnerClass {

    // 构造器为私有的，不可以通过new实力化
    private SingletonInnerClass() {
        System.out.println("初始化 Singleton 内部类方式--");
    }

    private static class SingletonCreate {
        private static SingletonInnerClass singleton = new SingletonInnerClass();
    }

    public static SingletonInnerClass getInstance() {
        return SingletonCreate.singleton;
    }
}

这种内部类的形式，既解决了锁的问题，又实现了懒加载，是一种懒汉模式的变种。
接下来就是测试类了。

package singleton;

/**
 * 懒汉模式以及饿汉模式的本质区别在于
 * 单例的类的初始化的位置，如果我们是在类刚开始初始化的时候就初始化了的化，那么是饿汉加载
 * 如果我们是在获取实例的那个方法初始化的化（实现了懒加载），那就是懒汉模式。
 * @author luckyharry
 *
 */
public class MainTest {

    public static void main(String[] args) {

        //获得单例中的实例
        SingletonInnerClass.getInstance();

        SingletonLazyNotSafe.getInstance();

        SingletonLazySafe.getInstance();

        SingletonHunger.getInstance();

    }
}

前言

小的时候，我特别喜欢四驱车，我就不停的攒零花钱，等攒到足够买的起一辆车的时候，就会那所有的钱去买这辆车，但是很快我发现，组装好的车一般都是要比一个一个部件组装贵多了。发现这个秘密之后，我就会去买各种零部件，然后回来组装。
我想通过这个故事引出我们今天的主角，建造者模式。

建造者模式

package builder;

/**
 * 四驱车类，是一个entity
 * @author luckyharry
 *
 */
public class FourWheelDrive {
    private Motor motor;
    private Shell shell;
    private Tire tire;
    public Motor getMotor() {
        return motor;
    }

    public void setMotor(Motor motor) {
        this.motor = motor;
    }
    public Shell getShell() {
        return shell;
    }
    public void setShell(Shell shell) {
        this.shell = shell;
    }
    public Tire getTire() {
        return tire;
    }
    public void setTire(Tire tire) {
        this.tire = tire;
    }
    @Override
    public String toString() {
        return "FourWheelDrive [motor=" + motor + ", shell=" + shell + ", tire=" + tire + "]";
    }


}

我们首先定义了一个四驱车类，里面包含了马达，轮胎，外壳（我们暂且认为四驱车是由这三个零件组成的）。

package builder;

/**
 * 马达类，作为四驱车的一个零部件
 * @author luckyharry
 *
 */
public class Motor {

    private String engine;
    private String housePower;
    public String getEngine() {
        return engine;
    }
    public void setEngine(String engine) {
        this.engine = engine;
    }
    public String getHousePower() {
        return housePower;
    }
    public void setHousePower(String housePower) {
        this.housePower = housePower;
    }
    @Override
    public String toString() {
        return "Motor [engine=" + engine + ", housePower=" + housePower + "]";
    }


}

马达这个类，具有引擎以及马力这两个属性。

package builder;

/**
 * 外壳类，作为四驱车的一个零部件
 * @author luckyharry
 *
 */
public class Shell {

    private String color;
    private Double length;
    private Double width;
    public String getColor() {
        return color;
    }
    public void setColor(String color) {
        this.color = color;
    }
    public Double getLength() {
        return length;
    }
    public void setLength(Double length) {
        this.length = length;
    }
    public Double getWidth() {
        return width;
    }
    public void setWidth(Double width) {
        this.width = width;
    }
    @Override
    public String toString() {
        return "Shell [color=" + color + ", length=" + length + ", width=" + width + "]";
    }


}

外壳类，具有颜色，长度，宽度，三个属性。

package builder;

/**
 * 轮胎类，作为四驱车的一个零部件。
 * @author luckyharry
 *
 */
public class Tire {

    private String resistance;
    private String size;
    public String getResistance() {
        return resistance;
    }
    public void setResistance(String resistance) {
        this.resistance = resistance;
    }
    public String getSize() {
        return size;
    }
    public void setSize(String size) {
        this.size = size;
    }
    @Override
    public String toString() {
        return "Tire [resistance=" + resistance + ", size=" + size + "]";
    }


}

轮胎类，具有摩擦力，以及轮胎尺寸两个属性。

package builder;

public interface Builder {

    public void buildMotor(Motor motor);

    public void buildShell(Shell shell);

    public void builTire(Tire tire);

    public FourWheelDrive getCar();

}

这是建造者模式的一个中枢，是通过这个类，封装了一个个零部件的。但是需要注意的是，Builder只是把生成马达，外壳，以及轮胎的方法写好了，但是他并没有进行组装。

package builder;

public class BuilderImpl implements Builder {

    private FourWheelDrive fourWheelDrive=new FourWheelDrive();

    @Override
    public void buildMotor(Motor motor) {
        fourWheelDrive.setMotor(motor);
    }

    @Override
    public void buildShell(Shell shell) {
        fourWheelDrive.setShell(shell);
    }

    @Override
    public void builTire(Tire tire) {
        fourWheelDrive.setTire(tire);
    }

    @Override
    public FourWheelDrive getCar() {
        System.out.println(fourWheelDrive);
        return fourWheelDrive;
    }
}

实现了Builder接口，真正赋予Builder的各个部件，但是这也不是一个组装的类。

package builder;

public class Director {

    private Builder builder;

    public Director(Builder builder) {
        this.builder = builder;
    }

    public void create(Motor motor,Shell shell,Tire tire) {
        builder.buildMotor(motor);
        builder.buildShell(shell);
        builder.builTire(tire);
    }

}

真正组装的类在这呢，那么我们为什么需要Director（导演）这个类呢，因为四驱车一定得需要马达，外壳，轮胎，但是他们的具体属性有可能会不同，所以我们把builder中的各个部件组装在这，调用的人，只需要知道自己想要什么样的四驱车就行，这种操作简直太爽了。

package builder;

public class MainTest {

    public static void main(String[] args) {
        Motor motor=new Motor();
        Shell shell =new Shell();
        Tire tire = new Tire();
        FourWheelDrive car =new FourWheelDrive();
        motor.setEngine("高速引擎");
        motor.setHousePower("大马力");
        shell.setColor("蓝色");
        shell.setLength(80.00);
        shell.setWidth(35.66);
        tire.setResistance("60N");
        tire.setSize("30*30");
        car.setMotor(motor);
        car.setShell(shell);
        car.setTire(tire);
        Builder builder=new BuilderImpl();
        Director director=new Director(builder);
        director.create(motor, shell, tire);
        builder.getCar();
    }

}

后记

我会一直以这样通俗易懂的自己能想到的例子，讲解设计模式，最大的启发是来源于《大话设计模式》。非常感觉这本书的作者程杰先生。