(2)spring常用模式--------工厂模式

在看spring常用的设计模式之前，如果对设计模式不太了解，可以先看看我之前写的设计模式相关的文章，建议重前面章节开始看，链接如下：
设计模式

1.工厂模式的分类

简单工厂模式（ simple Factory）
又叫做静态工厂方法（StaticFactory Method）模式，但不属于 23 种设计模式之一。
简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类。
工厂方法模式（Factory Method）
通常由应用程序直接使用 new 创建新的对象，为了将对象的创建和使用相分离，采用工厂方法模式方法,即应用程序将对象的创建及初始化职责交给工厂对象
抽象工厂模式（abstract Factory）
主要创建一个产品族，不同工厂继承父类的抽象工厂创建不同的产品族

2.简单工厂模式实例

有一个为car的接口，有三种不同类型的车分别为奥迪车、奔驰车、宝马车，为了根据传入不同的参数，就可以得到不同car对象

代码如下:

接口类car

/**
 * @Project: spring
 * @description:  实现车子的接口
 * @author: sunkang
 * @create: 2018-08-29 23:06
 * @ModificationHistory who      when       What
 **/
public interface Car {
    String getName();
}

有三个具体的实现类如下：

/**
 * @Project: spring
 * @description:  奥迪车
 * @author: sunkang
 * @create: 2018-08-29 23:07
 * @ModificationHistory who      when       What
 **/
public class Audi implements Car {
    @Override
    public String getName() {
        return "audi";
    }
}

/**
 * @Project: spring
 * @description:奔驰车
 * @author: sunkang
 * @create: 2018-08-29 23:08
 * @ModificationHistory who      when       What
 **/
public class Benz implements Car {
    @Override
    public String getName() {
        return "benz";
    }
}

/**
 * @Project: spring
 * @description: 宝马车
 * @author: sunkang
 * @create: 2018-08-29 23:08
 * @ModificationHistory who      when       What
 **/
public class Bmw implements Car {
    @Override
    public String getName() {
        return "bmw";
    }
}

简单工厂的方法如下：

/**
 * @Project: spring
 * @description: 简单工厂 根据传入不同的参数得到不同对象
 * @author: sunkang
 * @create: 2018-08-29 23:10
 * @ModificationHistory who      when       What
 **/
public class SimpleFactory  {
    public Car getCar(String name){
        if("BMW".equalsIgnoreCase(name)){
            return new Bmw();
        }else if("Benz".equalsIgnoreCase(name)){
            return new Benz();
        }else if("Audi".equalsIgnoreCase(name)){
            return new Audi();
        }else{
            System.out.println("这个产品产不出来");
            return null;
        }
    }
}

3.工厂方法模式实例

为了创建不同的类型的车，需要三个不同的工厂去创建，把创建的任务交给工厂去完成，于是代码就进行下面的演变

先引入一张简单工厂的uml图帮助大家理解：

简单工厂模式.png
下面为具体的代码

/**
 * @Project: spring 
 * @description:  造车工厂的接口
 * @author: sunkang
 * @create: 2018-08-30 22:33
 * @ModificationHistory who      when       What
 **/
public interface Factory {
     Car getCar();
}

/**
 *生产奥迪的工厂
 */
public class AudiFactory implements Factory {
    @Override
    public Car getCar() {
        return new Audi();
    }
}

/**
 *生产奔驰的工厂
 */
public class BenzFactory implements Factory {
    @Override
    public Car getCar() {
        return new Benz();
    }
}

/**
 * 生产宝马的工厂
 */
public class BmwFactory implements Factory {
    @Override
    public Car getCar() {
        return new Bmw();
    }
}

下面是工厂方法的测试类

/**
 * 工厂方法的测试类
 */
public class FactoryTest {
    public static void main(String[] args) {
        //1.首先先创建一个奥迪工厂出来
        Factory factory = new AudiFactory();
        //2.然后根据工厂得到奥迪车，具体的造车工厂交给工厂来完成
        System.out.println(factory.getCar());
        factory = new BmwFactory();
        System.out.println(factory.getCar());
    }
}

4.抽象工厂模式实例

假设奥迪和奔驰和宝马属于一个产品族的，那么可以根据抽象工厂即可创建一些的不同的车，此时的造车的接口工厂需要发生改变，需要支持多个产品族的创建

先引入一张抽象工厂的uml图帮助大家理解：

抽象工厂.png
下面给出具体的代码实现：

抽象工厂

public abstract class AbstractFactory {
  /**
   * 得到奥迪的车
   * @return
   */
  public abstract     Car getAudiCar();
  /**
   * 得到奔驰的车
   * @return
   */
  public abstract     Car getBenzCar();
  /**
   * 得到宝马的车
   * @return
   */
  public abstract     Car getBmwCar();
}

抽象工厂的具体实现

/**
 * @Project: spring
 * @description:  抽象工厂的具体实现
 * @author: sunkang
 * @create: 2018-09-01 19:37
 * @ModificationHistory who      when       What
 **/
public class CarFactory extends  AbstractFactory {
    @Override
    public Car getAudiCar() {
        return new Audi();
    }
    @Override
    public Car getBenzCar() {
        return new Benz();
    }
    @Override
    public Car getBmwCar() {
        return new Bmw();
    }
}

抽象工厂的测试类

public class AbstractFactoryTest {
    public static void main(String[] args) {
        //1.先创建具体抽象工厂
        AbstractFactory abstractFactory = new CarFactory();
        //2.根据具体的抽象工厂得到车
        Car audi  = abstractFactory.getAudiCar();
        System.out.println(audi.getName());
    }
}

5.工厂模式在spring 中的体现

Spring Bean 的创建是典型的工厂模式，这一系列的 Bean 工厂，也即 IOC 容器为开发者管理对象间的依赖关系提供了很多便利和基础服务，在 Spring 中有许多的 IOC 容器的实现供用户选择和使用，其相互关系如下：

工厂模式的体现springBean.png