【设计模式】工厂模式

工厂模式是一种创建型设计模式。

开闭原则

开闭原则是设计模式原则之一，倡导实体应当对扩展开发，对修改关闭。
意思是说，你想要扩展或者修改已写好代码的功能，可以往里面加入新的代码，但不允许修改修改以前已经写好的代码。
高耦合将会导致，拓展功能时，不得不修改以前的代码。
比如

public class Service {
    Dao dao = new JpaDao(); 
    void service(){
    	//使用dao进行一系列持久层操作
    }
}

起初我们使用JPA作为ORM，将数据库操作都封装在JpaDao里面，通过new来创建JpaDao实例。如果要把JPA改成Mybatis，就需要逐个去修改用到JpaDao的Service类。这就是Service和Dao的紧耦合导致违反开闭原则。
为什么会紧耦合？是因为Service中直接new了一个非常具体的对象。

new操作本身就是一个耦合操作

引入工厂类

想要解耦，就得去掉new，但是要创建对象就必须得new。所以我们将new换个地方，创建一个工厂类。

public class DaoFactory {
    public static Dao getDao() {
        return new JpaDao(); 
    }
}

public class Service {
    Dao dao = DaoFactory.getDao(); 
    void service(){
    //使用dao进行一系列持久层操作
    }
}

这样的好处就是，后续不管更换什么持久层框架，只需要改工厂类里的代码一个地方就好。
但是根本问题还是没解决，还是违反了开闭原则。因为到时候还是得改DaoFactory的代码。
如何才能不改代码修改实现方法？可以将类名写在配置文件，通过反射创建对象。这样就把耦合从代码提到了配置文件。

dao=com.example.demo.pattern.factory.JpaDao

public class DaoFactory {
    public static Dao getDao() {
    	Properties properties = new Properties();
    	properties.load(DaoFactory.class.getClassLoader().getResourceAsStream(“config.properties”));
    	Class<?> dao = Class.forName((String) properties.get("dao"));
    	return (Dao) dao.newInstance();
    }
}

简单工厂模式

简单工厂模式，又叫静态工厂模式。顾名思义，就是通过静态方法获取实例。

public class Factory {
    public static <R,P> R getInstance(P type){
        //根据传入的type不同做if else判断返回不同类型的对象。
    }
}

public class Factory {
    public static <R,P> R getInstance01(){
        //创建一种类型的对象
    }
  	public static <R,P> R getInstance02(){
        //创建另一种类型的对象
    }
}

也可以不定义为静态方法

public class Factory {
    public <R,P> R getInstance(P type){
        //根据传入的type不同做if else判断返回不同类型的对象。
    }
}

这种方式又叫实例工厂模式。去静态工厂模式区别在于，静态方法的调用不用创建实例对象。但是静态方法可以继承，但是不能重写，没有重写就不能实现多态的特性。所以静态工厂模式无法通过继承动态改变创建对象的行为。

优缺点

• 优点：一定程度上实现解耦，这种解耦的特点是，将对象的创建和使用解耦。其实所有创建型的设计模式都有这个特点。
• 缺点：不符合开闭原则。静态工厂模式的本质在于，通过各种方式（方法名，入参）传入一个参数，做if判断，达到返回不同对象的目的。因此，要加入新的类型，就不得不修改原来的代码，违反开闭原则。上面说的反射+配置文件的方法，也没有从根本解决问题。
  或许就是这个原因，静态工厂模式不属于GOF23体系。

工厂方法模式

静态工厂模式之所以违反开闭原则，是因为它把所有相关对象的创建都集中在一个工厂类了。所以没新增一个对象都要修改这个工厂类。
如果给每个对象写一个自己的工厂类呢？
工厂方法模式，是在静态工厂模式的基础上，进一步抽象，将工厂类设计为抽象类或者接口，不同产品实现自己的工厂实体类。创建对象时，只需要提供对应的产品类和该产品的工厂类即可，不需要知道内部过程。

interface DaoFactory{
    Dao getDao();
}

class JpaDaoFactory implements DaoFactory{
    public Dao getDao() {
        return new JpaDao();
    }
}

class MybatisDaoFactory implements DaoFactory{
    public Dao getDao() {
        return new MybatisDao();
    }
}

然后创建Service类时，将具体的工厂类传入，利用多态就可以实现不同的持久层的切换。

public class Service {
	private Dao dao;
	public Service(DaoFactory daoFactory) {
		dao = DaoFactory.getDao();
	}
	void service() {
		//使用dao进行一系列持久层操作
	}
}

优缺点

• 优点：符合开闭原则。当有新的持久层实现时，只需要实现DaoFactory接口的getDao()方法即可，不改动原有代码。
• 优点2：符合依赖倒置原则。

依赖倒置原则
依赖倒置原则倡导我们面向接口编程，不要面向现实编程。比如上面例子中，和业务类Service耦合的是最高层接口DaoFactory，而底层实现是用的时候才决定的。

• 缺点：如果产品的类型非常多，并且这些产品联系紧密，完全可以一起创建，但是你还是得给每一个产品写一个工厂类，非常繁琐。
  比如要创建一个手枪产品，同时又得创建子弹产品。如果用工厂方法模式，得写一个手枪和子弹的公共工厂接口，两个工厂实现类，如果有其他配套，还得写新的实现类，如果要生产另一种手枪B，工厂实现类会成倍增长。
  

抽象工厂模式

抽象工厂模式和工厂方法模式在GOF23中是单独的模式。抽象工厂模式的出现，就是为了解决上述工厂方法的问题。
工厂方法模式创建的对象，归根结底都是同一类对象。
上面的JpaDao是一类对象，MybatisDao是一类对象。而在手枪的例子中，手枪A、手枪B各自的一系列产品，是一类对象，叫产品族。抽象工厂模式就是为了创建一系列以产品族为单位的对象。
我们将一种武器的手枪、子弹等包装为一个工厂类，就能大大减少工厂类的数量。

public interface Weapen {}

interface Gun extends Weapen{}

interface Bullet textends Weapen {}

public class GunA implements Gun {}

public class BulletA implements Bulle {}

public class GunB implements Gun {}

public class BulletB implements Bulle {}

//顶层武器工厂
public interface WeapenFactory{
	Gun getGun() ;
	Bullet getBullet();
}

//武器A实现类
public class WeapanAFactoryImpl implements WeapenFactory {
	public GunA getGun() {
		return new GunA();
	}
	public BulletA getBullet() {
		return new BulletA();
	}
}

//武器B实现类
public class WeapanBFactoryImpl implements WeapenFactory {
	public GunB getGun() {
		return new GunB();
	}
	public BulletB getBullet() {
		return new BulletB();
	}
}

抽象工厂与工厂方法

抽象工厂模式是工厂方法模式的升级。如果不涉及子弹，不涉及产品族，抽象工厂与工厂方法一模一样。

工厂模式的应用

工厂模式应用很广泛。

• JDK的Calendar，构造器是protected的，获取对象需要通过getInstance()方法，这个方法就采用了静态工厂模式，通过调用createCalendar()方法，传入的两个参数TimeZone（时区）和Local（区域），创建需要的对象。

private static Calendar createCalendar(TimeZone zone, Locale aLocale) {
  			//省略大量无关代码
        Calendar cal = null;
        if (aLocale.hasExtensions()) {
            String caltype = aLocale.getUnicodeLocaleType("ca");
            if (caltype != null) {
                switch (caltype) {
                    case "buddhist":
                        cal = new BuddhistCalendar(zone, aLocale);
                        break;
                    case "japanese":
                        cal = new JapaneseImperialCalendar(zone, aLocale);
                        break;
                    case "gregory":
                        cal = new GregorianCalendar(zone, aLocale);
                        break;
                }
            }
        }
        if (cal == null) {
            if (aLocale.getLanguage() == "th" && aLocale.getCountry() == "TH") {
                cal = new BuddhistCalendar(zone, aLocale);
            } else if (aLocale.getVariant() == "JP" && aLocale.getLanguage() == "ja"
                    && aLocale.getCountry() == "JP") {
                cal = new JapaneseImperialCalendar(zone, aLocale);
            } else {
                cal = new GregorianCalendar(zone, aLocale);
            }
        }
        return cal;
    }

• Spring中有个FactoryBean接口，用来指定其实现类为一个具体的工厂类，以创建特定类型的对象。
  比如ThreadPoolExecutorFactoryBean就是创建返回一个线程池对象；ProxyFactoryBean用来创建一个代理对象，就是典型的工厂方法模式的实现。

public class ThreadPoolExecutorFactoryBean extends ExecutorConfigurationSupport
		implements FactoryBean<ExecutorService>, InitializingBean, DisposableBean {
	//...
	@Override
	protected ExecutorService initializeExecutor(
			ThreadFactory threadFactory, RejectedExecutionHandler rejectedExecutionHandler) {

		BlockingQueue<Runnable> queue = createQueue(this.queueCapacity);
		ThreadPoolExecutor executor  = createExecutor(this.corePoolSize, this.maxPoolSize,
				this.keepAliveSeconds, queue, threadFactory, rejectedExecutionHandler);
		if (this.allowCoreThreadTimeOut) {
			executor.allowCoreThreadTimeOut(true);
		}

		// Wrap executor with an unconfigurable decorator.
		this.exposedExecutor = (this.exposeUnconfigurableExecutor ?
				Executors.unconfigurableExecutorService(executor) : executor);

		return executor;
	}
	
	protected ThreadPoolExecutor createExecutor(
			int corePoolSize, int maxPoolSize, int keepAliveSeconds, BlockingQueue<Runnable> queue,
			ThreadFactory threadFactory, RejectedExecutionHandler rejectedExecutionHandler) {

		return new ThreadPoolExecutor(corePoolSize, maxPoolSize,
				keepAliveSeconds, TimeUnit.SECONDS, queue, threadFactory, rejectedExecutionHandler);
	}
}	

• Mybaties的SqlSessionFactory。