关于java:设计模式二工厂模式

大家在开发中应该都应用过或者看到过 SqlSessionFactory 或者 BeanFactory，这就是应用工厂模式来生产对象。工厂模式用于封装和治理对象的创立，拆散对象的创建者和调用者，实现与对象解耦的目标。

工厂模式能够分为：

简略工厂
工厂办法
形象工厂

简略工厂通过接管的参数的不同来返回不同的对象实例，波及到的角色有：

形象产品
具体产品
具体工厂
调用者

代码如下：

// 形象产品
public interface Car {void run();
}

// 具体产品 1
public class Audi implements Car {
    @Override
    public void run() {System.out.println("audi run");
    }
}

// 具体产品 2
public class Benz implements Car{
    @Override
    public void run() {System.out.println("benz run");
    }
}

// 具体工厂，用于生成产品
public class SimpleFactory {
    // 形式 1，依据传入的参数生成对应的产品对象
    public static Car getCar(String type){if ("audi".equals(type)){return new Audi();
        } else if ("benz".equals(type)){return new Benz();
        } else {return null;}
    }

    // 形式 2，间接调用生成对应的产品对象的办法
    public static Car getAudi(){return new Audi();
    }

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

// 调用者
public class SimpleFactoryTest {public static void main(String[] args) {
        // 没有应用简略工厂，那么客户端就须要和接口 Car 以及其实现类打交道
//        Car audi = new Audi();
//        Car benz = new Benz();
//        audi.run();
//        benz.run();

        // 应用简略工厂，形式 1
        Car audi = SimpleFactory.getCar("audi");
        Car benz = SimpleFactory.getCar("benz");
        audi.run();
        benz.run();
        System.out.println("============");

        // 应用简略工厂，形式 2
        Car audi1 = SimpleFactory.getAudi();
        Car benz1 = SimpleFactory.getBenz();
        audi1.run();
        benz1.run();}
}

类图如下：

能够看到，如果再减少一种产品，则须要批改工厂类，故这种工厂模式实用于产品对象较少，且产品固定的需要。其实咱们在个别的我的项目中应用简略工厂就足够了。

为了防止简略工厂不满足开闭准则的毛病，减少产品而不须要去批改工厂类，能够应用工厂办法模式，减少产品的同时通过减少一个对应的工厂类来生产对应的产品，波及的角色有：

形象产品
具体产品
形象工厂
具体工厂
调用者

代码如下：

// 形象产品
public interface Car {void run();
}

// 具体产品 1
public class Audi implements Car {
    @Override
    public void run() {System.out.println("audi run");
    }
}

// 具体产品 2
public class Benz implements Car {
    @Override
    public void run() {System.out.println("benz run");
    }
}

// 形象工厂
public interface CarFactory {Car createCar();
}

// 具体工厂 1
public class AudiFactory implements CarFactory {
    @Override
    public Car createCar() {return new Audi();
    }
}

// 具体工厂 2
public class BenzFactory implements CarFactory {
    @Override
    public Car createCar() {return new Benz();
    }
}

// 调用者
public class FactoryMethodTest {public static void main(String[] args) {Car audi = new AudiFactory().createCar();
        Car benz = new BenzFactory().createCar();
        audi.run();
        benz.run();}
}

类图如下：

能够看到，如果新减少一种具体产品，就须要为其减少一个具体工厂类用于生产该产品。

形象工厂用于生产一族产品。波及的角色有：

形象产品
具体产品
形象工厂
具体工厂
调用者

代码如下：

// 形象产品 A
public interface Engine {void autoStart();
}

// 具体产品 A1
public class HighEngine implements Engine {
    @Override
    public void autoStart() {System.out.println("高端发动机有主动启停性能");
    }
}

// 具体产品 A2
public class LowEngine implements Engine {
    @Override
    public void autoStart() {System.out.println("低端发动机没有主动启停性能");
    }
}

// 形象产品 B
public interface Tyre {void monitor();
}

// 具体产品 B1
public class HighTyre implements Tyre {
    @Override
    public void monitor() {System.out.println("高端轮胎有胎压监控性能");
    }
}

// 具体产品 B2
public class LowTyre implements Tyre {
    @Override
    public void monitor() {System.out.println("低端轮胎无监控胎压性能");
    }
}

// 形象工厂
public interface CarFactory {Engine createEngine();
    Tyre createTyre();}

// 具体工厂 A1B1
public class HighCarFactory implements CarFactory {
    @Override
    public HighEngine createEngine() {return new HighEngine();
    }

    @Override
    public HighTyre createTyre() {return new HighTyre();
    }
}

// 具体工厂 A2B2
public class LowCarFactory implements CarFactory {
    @Override
    public LowEngine createEngine() {return new LowEngine();
    }

    @Override
    public LowTyre createTyre() {return new LowTyre();
    }
}

// 调用者
public class AbstractFactoryTest {public static void main(String[] args) {CarFactory highCar = new HighCarFactory();
        highCar.createEngine().autoStart();
        highCar.createTyre().monitor();
    }
}

类图如下：

能够看到通过具体工厂 A1B1 和 A2B2 能够生产出不同的产品族，在产品固定的状况下，能够通过新增具体工厂类，来组合生成不同的产品族，比方 A1B2 或者 A2B1。然而如果要减少新的产品的话，比方减少产品 C，那就须要去批改形象工厂和具体工厂，就不适宜了。

欢送关注我的公众号，一起学习技术。

关于java:设计模式二工厂模式

什么是工厂模式

实现形式

简略工厂

工厂办法

形象工厂