工厂模式

工厂模式

工厂模式(Factory Pattern)

属于创建型模式中的一种常用的软件设计模式，它提供了一种创建对象的最佳方式。

在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

常见的应用

• JDBC中Connection对象的获取
• spring框架中IOC容器创建管理bean对象
• 反射中Class对象的newInstance()
• mybatis框架中的SessionFactory创建session
• Calendar类的getInstance()
• LoggerFactory 获取 Logger 对象

优点

实现了创建者和调用者的分离，实例化对象用工厂方法代替new操作，将选择实现类、创建对象统一管理和控制。从而将调用者跟我们的实现类解耦，增强系统的扩展性。相比于普通的直接实例化，工厂模式更符合面向对象设计的六大基本原则。

工厂模式的三种方式

• 简单工厂模式（又名静态工厂模式）
• 工厂方法模式
• 抽象工厂模式

简单工厂模式

简单工厂模式也叫静态工厂模式，将对象的创建交给专门的工厂负责，工厂类一般使用静态方法，通过接收参数的不同来返回不同的对象实例。虽然在某种程度上不符合设计原则，但是在实际中使用最多。

接口Car

public interface Car {	
    void run();
}

实现类Audi

public class Audi implements Car{

    @Override
    public void run() {
	System.out.println("奥迪启动了！！！");		
    }
}

实现类Benz

public class Benz implements Car{

    @Override
    public void run() {
	System.out.println("奔驰启动了！！！");		
    }
}

简单工厂类CarFactory

public class CarFactory {

    public static Car createCar(String type) {
	if ("奥迪".equals(type)) {
		return new Audi();
	}else if ("奔驰".equals(type)) {
		return new Benz();
	}else {
		return null;
	}
    }
}

另一种方式静态工厂模式CarFactory2

public class CarFactory2 {
	
    public static Car createAudi() {
	return new Audi();
    }

    public static Car createBenz() {
	return new Benz();
    }
}

在没有使用工厂模式下创建对象

public class Client01 {
  
    public static void main(String[] args) {
	Car c1 = new Benz();
	Car c2 = new Audi();
	
	c1.run();
	c2.run();	
    }
}

使用工厂模式创建对象

public class Client02 {
    public static void main(String[] args) {
   
	//简单工厂模式
	Car c1 = CarFactory.createCar("奥迪");
	Car c2 = CarFactory.createCar("奔驰");
	
	//静态工厂模式
	Car c3 = CarFactory2.createAudi();
	Car c4 = CarFactory2.createBenz();
	
	c1.run();
	c2.run();	
	c3.run();	
	c4.run();	
    }
}

工厂方法模式

在不修改已有类的情况下，通过增加新的工厂类来实现扩展。

接口CarFactory

public interface CarFactory {
    Car createCar();
}

奥迪工厂实现类AudiFactory

public class AudiFactory implements CarFactory{

    @Override
    public Car createCar() {		
	return new Audi();
    }
}

奔驰工厂实现类BenzFactory

public class BenzFactory implements CarFactory{

    @Override
    public Car createCar() {
	return new Benz(); 
    }
}

使用工厂方法模式创建对象

public class Client {
    public static void main(String[] args) {
	Car c1 = new AudiFactory().createCar();
	Car c2 = new BenzFactory().createCar();
	
	c1.run();
	c2.run();
    }
}

抽象工厂模式

定义一个抽象工厂，其定义了产品的生产接口，但不负责具体的产品，将生产任务交给不同的派生类工厂。这样不用通过指定类型来创建对象了。

与工厂方法模式不同的是，工厂方法模式中的工厂只生产单一的产品，而抽象工厂模式中的派生类工厂生产多个产品

抽象工厂接口AbstractCarFactory

public interface AbstractCarFactory {
    Engine createEngine();
    Glass createGlass();
    Seat createSeat();
}

豪华汽车工厂LuxuryCarFactory

public class LuxuryCarFactory implements AbstractCarFactory{

    @Override
    public Engine createEngine() {
	return new LuxuryEngine();
    }

    @Override
    public Glass createGlass() {
	return new LuxuryGlass();
    }

    @Override
    public Seat createSeat() {
	return new LuxurySeat();
    }
}

低端汽车工厂LowCarFactory

public class LowCarFactory implements AbstractCarFactory {

    @Override
    public Engine createEngine() {
	return new LowEngine();
    }

    @Override
    public Glass createGlass() {
	return new LowGlass();
    }

    @Override
    public Seat createSeat() {
	return new LowSeat();
    }
}

接口座椅Seat以及实现类豪华座椅LuxurySeat、低端座椅LowSeat

public interface Seat {
    void soft();
}

class LuxurySeat implements Seat{

    @Override
    public void soft() {
	System.out.println("非常柔软舒适");
    }
}

class LowSeat implements Seat{

    @Override
    public void soft() {
	System.out.println("一般柔软舒适");
    }
}

接口玻璃Seat以及实现类豪华玻璃LuxuryGlass、低端玻璃LowGlass

public interface Glass {
    void stiffness();
}

class LuxuryGlass implements Glass{

    @Override
    public void stiffness() {
	System.out.println("钢化玻璃");
    }	
}

class LowGlass implements Glass{

    @Override
    public void stiffness() {
	System.out.println("普通玻璃");
    }	
}

接口发动机Engine以及实现类豪华发动机LuxuryEngine、低端发动机LowEngine

public interface Engine {
    void run();
}

class LuxuryEngine implements Engine{

    @Override
    public void run() {
	System.out.println("启动快");
    }	
}

class LowEngine implements Engine{

    @Override
    public void run() {
	System.out.println("启动慢");
    }
}

使用抽象工厂模式创建对象

public class Client {
    public static void main(String[] args) {
        //豪华
	CarFactory factory = new LuxuryCarFactory();
	Engine engine = factory.createEngine();
	Glass glass = factory.createGlass();
	Seat seat = factory.createSeat();
	engine.run();
	glass.stiffness();
	seat.soft();
   
	System.out.println("--------------");
	//低端
	CarFactory factory2 = new LowCarFactory();
	Engine engine2 = factory2.createEngine();
	Glass glass2 = factory2.createGlass();
	Seat seat2 = factory2.createSeat();
	engine2.run();
	glass2.stiffness();
	seat2.soft();
    }
}

三种工厂模式对比分析

• 结构复杂度：简单工厂模式 > 工厂方法模式

• 代码复杂度：工厂方法模式 > 简单工厂模式

• 管理复杂度：简单工厂模式 > 工厂方法模式

• 客户端编程复杂度：简单工厂模式 > 工厂方法模式

• 设计原则符合程度：工厂方法模式 > 简单工厂模式

  抽象工厂模式与前两种模式不同，前两种模式只针对一类产品，而抽象工厂模式针对的是一个产品族。抽象工厂模式通过在AbstarctFactory中增加创建产品的接口方法，并在具体子工厂中实现新加产品的创建。

如何选用

以上三种工厂模式都有自己的应用场景，根据实际情况来使用，也不必完全的遵守面向对象设计原则，可适当变通。一般来说在针对一类产品情况下，简单工厂模式优于工厂方法模式。