前言
曾经有两个人,一个是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();
}
}
后记
我会一直以这样通俗易懂的自己能想到的例子,讲解设计模式,最大的启发是来源于《大话设计模式》。非常感觉这本书的作者程杰先生。