工厂模式讲解, 引入Spring IOC

目录
  • 引入
  • 简单工厂
  • 抽象工厂
  • Spring的bean工厂
  • 模拟Spring工厂实现
    • 模拟IOC

引入

  • 假设有一个司机, 需要到某个城市, 于是我们给他一辆汽车
public class Demo {
    public static void main(String[] args) {
        Car car = new Car();
        car.run();
    }
}

public class Car {
    public void run(){
        System.out.println("汽车正在向前跑...");
    }
}
  • 如果我们希望给到这个司机的始终是一辆车, 应该怎么做? (单例)
  • 首先我们不能让司机自己通过new产生一辆汽车, 而是应该通过调用Car类中的某个方法对外提供车.
public class Car {
    private static Car car = new Car();//用于提供给外界, 始终是同一辆车

    private Car(){};//私有构造方法, 在类之外不能通过new获得本类对象了, 保证了单例

    public Car getInstance(){
        return car;
    }

    public void run(){
        System.out.println("汽车正在向前跑...");
    }
}

public static void main(String[] args) {
    Car car = Car.getInstance();
    car.run();
}

简单工厂

  • 下面考虑, 如果我们不希望只有汽车这种交通工具, 我们希望可以定制交通工具, 并定制生产交通工具的流程, 应该怎么做?
  • 一旦产生由汽车到交通工具这样的概念, 就应该想到多态. 我们可以定义一个Moveable接口, 在接口中声明run()方法, 所有的交通工具类都实现该接口.
  • 对于定制生产流程, 我们可以通过一个工厂进行生产对应的交通工具.
public interface Moveable {
    void run();
}

public class Car implements Moveable{

    public Car(){};//私有构造方法, 在类之外不能通过new获得本类对象了, 保证了单例

    public void run(){
        System.out.println("汽车正在向前跑...");
    }
}

public abstract class VehicleFactory {
    public abstract Moveable create();
}

public class CarFactory extends VehicleFactory {
    @Override
    public Moveable create() {
        return new Car();
    }
}

//Test
public static void main(String[] args) {
    VehicleFactory factory = new CarFactory();
    Moveable m = factory.create();
    m.run();
}

抽象工厂

  • 下面把简单工厂的画面从脑海中清空, 讲述另一种工厂实现.
  • 我们假设开头的司机不是一个普通的司机, 他除了需要一种交通工具以到达某个城市外, 他还需要一把AK47, 并且还需要一个苹果以备路上不时之需.
  • 所以我们需要给他一个工厂来制造这一系列产品.
  • 为了提高可扩展性, 我们还希望不同的工厂可以制作不同系列的产品, 比如上面说的A工厂制造的是汽车, AK47, 苹果; 而B工厂制造的是飞机, 火箭炮, 旺仔小馒头.
//test
public static void main(String[] args) {
    AbstractFactory factory = new Factory1();
    Vehiche v = factory.createVehiche();
    Weapon w = factory.createWeapon();
    Food f = factory.createFood();

    v.run();
    w.fire();
    f.eat();
}

public abstract class Vehiche {//交通工具的抽象类
    public abstract void run();
}

public abstract class Weapon {//武器的抽象类
    public abstract void fire();
}

public abstract class Food {//食物的抽象类
    public abstract void eat();
}

public class Car extends Vehiche{一种具体的交通工具
    @Override
    public void run() {
        System.out.println("小汽车启动...");
    }
}

public class AK47 extends Weapon {//一种具体的武器
    @Override
    public void fire() {
        System.out.println("哒哒哒...");
    }
}

public class Apple extends Food{//一种具体的食物
    @Override
    public void eat() {
        System.out.println("大口吃苹果...");
    }
}

//抽象工厂
public abstract class AbstractFactory {
    public abstract Vehiche createVehiche();
    public abstract Weapon createWeapon();
    public abstract Food createFood();
}

//抽象工厂的实现1
public class Factory1 extends AbstractFactory {
    @Override
    public Vehiche createVehiche() {
        return new Car();
    }

    @Override
    public Weapon createWeapon() {
        return new AK47();
    }

    @Override
    public Food createFood() {
        return new Apple();
    }
}
  • 总结一下, 抽象工厂和简单工厂各有什么优劣?
  • 抽象工厂能够生产一系列产品, 也能方便地替换掉一系列产品, 但是如果想要在产品系列中添加多一个品种将会非常麻烦. 比如说在上面的系列产品中添加一个盔甲抽象类, 那么抽象工厂以及对应的实现都要修改源码了.
  • 而简单工厂能够灵活的生产但一个品种的产品, 但是如果生产的品种较多, 会出现工厂泛滥的问题.
  • 两者优劣互补, 那么有没有可以兼容两者优点的工厂实现呢? 下面看spring的工厂实现, 它给出了一种解决方案.

Spring的bean工厂

  • 我们再次考虑最原始的情况, 有一个Moveable接口, 里面有run方法, Car小汽车类实现了该接口.
public static void main(String[] args) {
    Moveable m = new Car();
    m.run();
}

public interface Moveable {
    void run();
}

public class Car implements Moveable{
    @Override
    public void run() {
        System.out.println("小汽车往前跑...");
    }
}
  • 在Spring的bean工厂中, 新对象不是通过new关键字获取的, 而是通过配置文件获取的.
  • 具体的过程是: 先读取配置文件获得该类的class对象, 然后通过class对象创建具体的实例对象.
public static void main(String[] args) throws Exception {
    //获取配置文件
    Properties props = new Properties();
    props.load(Test.class.getClassLoader().getResourceAsStream("spring.properties"));
    //获取配置文件中配置的类
    String vehicheTypeName = props.getProperty("vehicheTypeName");
    //反射生成对应的对象
    Moveable m = (Moveable) Class.forName(vehicheTypeName).newInstance();
    m.run();
}

//spring.properties
vehicheTypeName=designPattern.factory.springFactory.Car
  • 上面是对spring中bean工厂使用的模拟, 下面我们使用真实的spring来生成Car对象, 对比一下.
public static void main(String[] args) throws Exception {
    BeanFactory bf = new ClassPathXmlApplicationContext("applicationContext.xml");
    Vehiche v = (Vehiche)bf.getBean("v");
    v.run();
}

//配置文件
<bean id="v" class="designPattern.factory.Car">
</bean>
  • 经过对比我们发现我们自己写的简单工厂和spring的bean工厂在使用上没有什么区别, 确实spring使用起来就是这么简单, 下面我们模拟一下spring的bean工厂实现.

模拟Spring工厂实现

模拟IOC

  • 都说spring是个bean容器, 以下的代码将展示它是如何生成bean, 并把bean放入容器中供用户获取的.
  • 思路比较简单:
  1. 创建BeanFactory工厂接口, 添加方法getBean().
  2. 创建BeanFactory的实现类ClassPathXmlApplicationContext. 将在该实现类中展示IOC的具体实现.
  3. ClassPathXmlApplicationContext需要一个container容器存放创建的bean对象, 这里使用HashMap实现.
  4. 在ClassPathXmlApplicationContext的构造方法中读取spring的配置文件, 这里使用到了dom4j. 读取配置文件后根据bean的class属性使用反射创建出bean对象. 然后把id和bean对象分别作为key和value添加到容器中.
  5. 当工厂被调用getBean()方法时, 从容器中找到对应的bean并返回.
public static void main(String[] args) throws Exception {
    BeanFactory bf = new ClassPathXmlApplicationContext("applicationContext.xml");
    Vehiche v = (Vehiche) bf.getBean("v");
    v.run();
}

//BeanFactory的实现类
public class ClassPathXmlApplicationContext implements BeanFactory {

    private Map<String, Object> container = new HashMap<>();//用于存放bean对象的容器

    //在构造方法中读取xml配置文件, 把bean对象都创建好并放入容器中
    public ClassPathXmlApplicationContext(String propAddr) throws Exception {
        SAXReader reader = new SAXReader();
        File file = new File(this.getClass().getClassLoader().getResource(propAddr).toURI());
        Document document = reader.read(file);
        Element root = document.getRootElement();
        List<Element> childElements = root.elements();

        for (Element child : childElements) {
            Object bean = Class.forName(child.attributeValue("class")).newInstance();
            container.put(child.attributeValue("id"), bean);
        }
    }

    @Override
    public Object getBean(String beanId) {
        return container.containsKey(beanId) ? container.get(beanId) : null;
    }
}

//极简BeanFactory
public interface BeanFactory {
    Object getBean(String beanId);
}

//xml中配置的bean
<bean id="v" class="designPattern.factory.Car">
</bean>
赞 (0)

相关推荐

  • 为什么java会默认提供无参构造方法

    小话题:大神勿喷 众所周知,如果一个类中没有为其定义构造方法,那么它会默认提供一个无参构造方法,而你定义了有参构造方法以后,无参构造方法就没了? //定义一个Car类 public class Car ...

  • 通过模拟JDK中的动态代理,由浅入深讲解动态代理思想.

    目录 场景引入 动态代理引入 动态代理进阶 总结 个人认为动态代理在设计模式中算是比较难的, 本篇文章将从无到有, 从一个简单代码示例开始迭代, 逐步深入讲解动态代理思想. 场景引入 假设现在有一个坦 ...

  • 设计模式----------工厂(Factory)模式

    作用 实现了创建者和调用者分离. 工厂模式核心/本质: 实例化对象不在使用new,而是用工厂方法代替. 将选择实现类,创建对象统一管理和控制,从而实现调用者和我们实现类解耦 工厂模式详细分类 1.简单 ...

  • 【铁升定律】技术模式讲解

    [铁升定律]与[铁跌定律]的技术模式讲解: [铁升定律]的技术交易模式讲解: 一.[铁升定律]的技术交易模式的三个组成部分: 1.上升三部曲走势形态的确定: 2.价格走势的回调波段: 3.第三波主升浪 ...

  • 死磕Spring之IoC篇 - 深入了解Spring IoC（面试题）

    该系列文章是本人在学习 Spring 的过程中总结下来的,里面涉及到相关源码,可能对读者不太友好,请结合我的源码注释 Spring 源码分析 GitHub 地址 进行阅读 Spring 版本:5.1. ...

  • 【中国的植物工厂模式】未来的城市周边种菜...

    [中国的植物工厂模式]未来的城市周边种菜模式可能是这样的,植物工厂根据城市需求来种菜,告别对天气.对阳光.对土壤的依赖,一年四季都可以种出各种蔬菜.1.种植方式是模块化种植,数字化管理:2.种植的工厂 ...

  • 敖丙所在的电商公司都是怎么用工厂模式的

    前言 不知道随着大家工作年限的增长,有没有一种危机感,害怕自己的技术深度开始没有提升,所以经常会去看一点框架的源码,或者报一些网课去提升自己. 最近我有一个老东家的同事跟我聊起来这个问题,说最近刚换公 ...

  • 【6/25】使用简单工厂模式（Simple Factory Pattern）改写Page基类

    这是<小游戏从0到1设计模式重构>系列内容第6篇,所有源码及资料在"程序员LIYI"公号回复"小游戏从0到1"获取. 工厂模式有三个姐妹:简单工厂模 ...

  • 【8/25】使用抽象工厂模式（Abstract Factory Pattern） 封装页面对象的创建过程

    这是<小游戏从0到1设计模式重构>系列内容第8篇,所有源码及资料在"程序员LIYI"公号回复"小游戏从0到1"获取. 看完了三姐妹中的大姐.二姐,最 ...

  • 21年新高考，院校 专业组模式讲解，这些问题不注意容易被退档！

    21年新高考，院校 专业组模式讲解，这些问题不注意容易被退档！

  • PHP设计模式之简单工厂模式

    PHP设计模式之简单工厂模式 先从简单工厂入门,不管是面试还是被他人面试,在问到设计模式的时候,大多数人都会提到工厂模式.毫无疑问,工厂相关的几种模式在设计模式中是最出名的也是应用比较广泛的一种模式. ...

  • PHP设计模式之抽象工厂模式

    PHP设计模式之抽象工厂模式 工厂模式系列中的重头戏来了,没错,那正是传闻中的抽象工厂模式.初次听到这个名字的时候你有什么感觉?反正我是感觉这货应该是非常高大上的,毕竟包含着"抽象" ...