java设计模式（二）单例模式 建造者模式

（三）单例模式

单例模式应该是最常见的设计模式，作用是保证在JVM中，该对象只有一个实例存在。

优点：1、减少某些创建比较频繁的或者比较大型的对象的系统开销。

    2、省去了new操作符，降低系统内存使用频率，减轻GC压力。

    3、保证核心代码的唯一性，比如交易引擎。

单例模式看似是最简单的设计模式。

public class Singleton {
	//私有构造方法，防止实例化
	private Singleton(){
		
	}
	//创建类的实例的时候加载
	private static Factory factory = new Factory();
	//延迟加载
	private static Factory factory1;
	public static Factory getInstans(){
		if(factory1 == null){
			factory1 = new Factory();
		}
		return factory1;
	}
}

上面是比较常见的单例模式的写法，后一种延迟加载应该是实际应用中使用比较多的方式，但是这种加载方式如果在多线程模式下就有可能出现问题。对于多线程的处理，第一个想到的就是 synchronized 线程锁。

private static Factory factory;
	private static Object classlock = Singleton.class;
	public static Factory getInstances(){
		synchronized (classlock) {
			if(factory == null){
				factory = new Factory();
			}
			return factory;
		}
	}
	public static Factory getInstance(){
		if(factory == null){
			syncInit();
		}
		return factory;
	}
	private static synchronized void syncInit(){
		if(factory == null){
			factory = new Factory();
		}
	}

以上是两种线程锁的方法，第一种是对象锁，但是因为每次调用都需要加锁，性能会有部分损失。第二种是方法锁。但是实际上，无论 synchronized 关键字加在方法上还是对象上，它取得的锁都是对象，而不是吧一段代码或函数当作锁。

单例模式是为了保证类只有一个实例，并为类提供全局访问点，单例模式最富盛名，但是最容易误用，不要让它成为创建全局变量的花哨方法。类应该只需要知道与它协作的对象，不必了解创建它需要的限制。单例模式一定要记住隐藏构造函数，也就是在类里面写一个 private 的构造函数。
（四）建造者模式

建造者模式的意图是将类的构建逻辑转移到类的实例化外部。建造者模式比抽象工厂模式又复杂一点，抽象工厂有一个 Factory 现在多一个工厂的主管 Director 他来管理工厂的生产过程。

interface Builder { 
	void buildPartA(); 
	void buildPartB(); 
	void buildPartC(); 
	Product getResult(); 
} 
interface Product { }
interface Part { }
class Car implements Product{
	private String door;
	private String windows;
	public String getDoor() {
		return door;
	}
	public void setDoor(String door) {
		this.door = door;
	}
	public String getWindows() {
		return windows;
	}
	public void setWindows(String windows) {
		this.windows = windows;
	}
}
//具体建造工具
class ConcreteBuilder implements Builder { 
	Part partA, partB, partC; 
	private static Car product = new Car();
	public void buildPartA() {
		//这里是具体如何构建partA的代码
		product.setDoor("铁的");
	}; 
	public void buildPartB() { 
		//这里是具体如何构建partB的代码
		product.setWindows("玻璃的");
	}; 
	public void buildPartC() { 
		//这里是具体如何构建partB的代码
	}; 
	public Product getResult() {
		return product; 
		//返回最后组装成品结果
	}; 
}
//具体建造工具
class ConcreteBuilder2 implements Builder { 
	Part partA, partB, partC; 
	private static Car product = new Car();
	public void buildPartA() {
		//这里是具体如何构建partA的代码
		product.setDoor("木头的");
	}; 
	public void buildPartB() { 
		//这里是具体如何构建partB的代码
		product.setWindows("玻璃的");
	}; 
	public void buildPartC() { 
		//这里是具体如何构建partB的代码
	}; 
	public Product getResult() {
		return product; 
		//返回最后组装成品结果
	}; 
}
//建造者
class Director {
	private Builder builder; 
	public Director( Builder builder ) { 
		this.builder = builder; 
	} 
	public void construct() { 
		builder.buildPartA();
		builder.buildPartB();
		builder.buildPartC(); 
	} 
} 
public class BuilderPattern {
	public static void main(String[] args){
		//获得具体的工厂
		ConcreteBuilder2 builder = new ConcreteBuilder2();
		//将工厂给管理者
		Director director = new Director( builder ); 
		//管理者构造出产品
		director.construct();
		//在工厂取得产品
		Car product = (Car) builder.getResult();
		System.out.println(product.getDoor());
	}
}

不同的工厂就会生产出不同的产品，但是生产什么产品是管理者决定的，假如管理者的

construct

不生产门了，那么最终的产品也就没有门了。

建造者模式可以控制中间的生产过程，比如读取 xml 时候用来判断某个值是否有数据。或者拼装 sql 语句的时候

SqlString sql = new SqlString();
        if(forUpdate) {
            sql.selectForUpdate(db);
        } else {
            sql.select(db);
        }
        sql.from(db).where().eq(db);