设计模式(二):Android 源码中的工厂模式

之前的文章介绍了单例模式,单例模式非常简单,也很容易懂。本文介绍另外一种简单的创建型设计模式:工厂模式(Factory Pattern)。

什么是工厂模式?

工厂模式(Factory Pattern)在实际开发中非常常见,它可以由用户决定创建对象的类型。

因为工厂模式,我们无需向客户暴露我们的代码逻辑,只需要开放接口给客户,由客户指定要创建的对象的类型,便可以动态生成符合需求的类别对象。

什么场合用工厂模式?

需要根据实际情况才能决定创建何种类别对象的场景。

听起来挺悬乎的,其实很容易理解。

假设,你要从广州到深圳,你就需要交通工具。

选择可就多了,有大巴,有火车,有高铁,有动车,未来还有地铁和城轨。

你在不同时刻有不同的选择。

比较,你是土豪,你还可以坐飞机。

你不想转车,可能直接大巴。

你要便宜点,你可以坐火车。

干净舒适时,你可以选择高铁。

下面,实例讲解。

工厂模式的实现手段

交通工具可以是一个抽奖类,也可以是一个接口。

所以,我们定义一个接口代表交通工具,之后把大巴、火车、飞机实现这个接口,UML 图如下。

我们再编写工厂类。
在这里插入图片描述

我们通过 TransportationFactory 这个类中的 getTransportation() 方法就可以创建类了。

下面是 Java 代码示意:

Transportation.java


public interface Transportation {
   void move(String dst);
}

再实现 Bus、Train、Plane

Bus.java

public class  Bus  implements Transportation{

    @Override
    public void move(String dst) {
        // TODO Auto-generated method stub
        System.out.println("Take a bus to "+dst);
    }
}

Train.java

public class  Train  implements Transportation{

    @Override
    public void move(String dst) {
        // TODO Auto-generated method stub
        System.out.println("Take a train to "+dst);
    }
}

Plane.java

public class  Plane  implements Transportation{

    @Override
    public void move(String dst) {
        // TODO Auto-generated method stub
        System.out.println("Take a plane to "+dst);
    }
}

然后,我们实现工厂类

Transportation.java


public class TranportationFactory {

    public Transportation getTransportation(String type){
        if(type == null){
            return null;
        }        
        if(type.equalsIgnoreCase("TRAIN")){
            return new Train();
        } else if(type.equalsIgnoreCase("BUS")){
            return new Bus();
        } else if(type.equalsIgnoreCase("PLANE")){
            return new Plane();
        }
        return null;
    }
    
}

可以看到,工厂类根据 type 的不同,选择创建不同的类别对象。

最后,编写测试代码。
FactoryDemo.java


public class FactoryDemo {

    public static void main(String[] args) {

        TranportationFactory factory = new TranportationFactory();

        //Transportation transportation = factory.getTransportation("bus");
         Transportation transportation = factory.getTransportation("train");
        // Transportation transportation = factory.getTransportation("plane");

        transportation.move("深圳");
    }

}

最终,打印结果如下:

Take a train to 深圳

我们可以看到,通过简单的例子,我们掌握了工厂模式的基础方法,下面通过实际的源码例子加深理解。

Android 源码中的工厂模式

xref: /packages/apps/Camera2/src/com/android/camera/debug/Logger.java

public interface Logger {

    ......

    /**
     * Provides a Logger instance from a given Log tag.
     */
    public interface Factory {
        public Logger create(Tag tag);
    }
}

这是 Android 系统应用相机的一份代码,主要是记录 Log 的,但它是一个接口,说明这个应用中有不同的 Logger,并且里面还有一个接口 Factory,通过传入 Tag 可以生成不同的 Logger。

经查询 Logger 有 2 种实现类,TagLogger 和 NoOpLogger,它们的代码在 Loggers.java 中。

因为篇幅所限,这里只讨论 TagLogger。

xref: /packages/apps/Camera2/src/com/android/camera/debug/Loggers.java

public class Loggers {


    /**
     * This creates a factory that will use the standard android static log
     * methods.
     */
    public static Logger.Factory tagFactory() {
        return TagLoggerFactory.instance();
    }

    /**
     * Creates a logger factory which always returns the given logger.
     */
    public static Logger.Factory factoryFor(final Logger logger) {
        return new Logger.Factory() {
            @Override
            public Logger create(Tag tag) {
                return logger;
            }
        };
    }



    /**
     * Creates loggers that use tag objects to write to standard android log
     * output.
     */
    private static class TagLoggerFactory implements Logger.Factory {
        private static class Singleton {
            private static final TagLoggerFactory INSTANCE = new TagLoggerFactory();
        }

        public static TagLoggerFactory instance() {
            return Singleton.INSTANCE;
        }

        @Override
        public Logger create(Tag tag) {
            return new TagLogger(tag);
        }
    }

  
    /**
     * TagLogger logger writes to the standard static log output with the given
     * tag object.
     */
    private static class TagLogger implements Logger {
        private final Log.Tag mTag;

        public TagLogger(Log.Tag tag) {
            mTag = tag;
        }
        ...
    
    }
}

很惊喜的是,这个例子也可以用来解释单例模式。

TagLogger.Factory 中的 create 方法可以创建 TaggLogger。

所以,从入口方法 factoryFor()就可以决定不同的 Factory,不同的 Factory 就创建了不同的 Logger。

这显然是工厂模式。

总结

  1. 工厂模式非常简单,它符合里氏替换原则。
  2. 工厂模式的本质是将对象的类型确定延迟到子类,由子类自主决定。
frank909 CSDN认证博客专家 CV(computer vision)
爱阅读的程序员,专注于技术思考和分享。关注架构设计、Android 开发、AI、数学、自动驾驶领域,个人公号:Frankcall
©️2020 CSDN 皮肤主题: 编程工作室 设计师:CSDN官方博客 返回首页
实付 19.90元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值