Android开发之深入理解工厂(Factory)模式

2017-08-04 15:27 阅读 627 次 评论 0 条
版权声明:本文著作权归TeachCourse所有,未经许可禁止转载,谢谢支持!
转载请注明出处:http://teachcourse.cn/2459.html

摘要:

你是否明白什么是工厂模式,什么时候使用工厂模式,使用工厂模式包含哪几种方式?这篇文章将带你深入理解工厂(Factory)模式,文章以线程池创建线程为例子,线程池以缓存线程池,即Executors.newCachedThreadPool()为代表,一个APP项目中可能需要多个线程,多则几十个,如果使用new逐一创建,会显得有点繁琐、麻烦,这个时候可以考虑工厂模式。

一、工厂模式应用于线程池实例

Android多线程开发中,线程池在TeachCourse的印象中包含四个方面:1.执行器,2.工作任务,3.线程池,4.线程,它们之间的关系是:执行器从线程池已有的线程中取出一条线程执行已提交的工作任务,它们的UML类图如下:

线程池

该实例涉及到的类包括:ExecutorExecutorsRunnableThreadFactoryThread等,Executor是一个接口,还包含其实现类及其子类,Executors是对Executor及其子类的封装,Runnable表示需要执行的工作任务,ThreadFactory表示创建线程的工厂,Thread表示线程,具体的用法如下:

public class DefaultConfigurationFactory {
    /**创建执行器对象*/
    public static Executor createTaskDistributor() {
        return Executors.newCachedThreadPool(createThreadFactory(Thread.NORM_PRIORITY, "uil-pool-d-"));
    }
    /**创建线程工厂对象*/
    private static ThreadFactory createThreadFactory(int threadPriority, String threadNamePrefix) {
        return new DefaultConfigurationFactory.DefaultThreadFactory(threadPriority, threadNamePrefix);
    }
    /**重写线程工厂*/
    private static class DefaultThreadFactory implements ThreadFactory {

        private static final AtomicInteger poolNumber = new AtomicInteger(1);

        private final ThreadGroup group;
        private final AtomicInteger threadNumber = new AtomicInteger(1);
        private final String namePrefix;
        private final int threadPriority;

        DefaultThreadFactory(int threadPriority, String threadNamePrefix) {
            this.threadPriority = threadPriority;
            SecurityManager s = System.getSecurityManager();
            group = (s != null) ? s.getThreadGroup() : Thread.currentThread().getThreadGroup();
            namePrefix = threadNamePrefix + poolNumber.getAndIncrement() + "-thread-";
        }

        @Override
        public Thread newThread(Runnable r) {
            Thread t = new Thread(group, r, namePrefix + threadNumber.getAndIncrement(), 0);
            if (t.isDaemon()) t.setDaemon(false);
            t.setPriority(threadPriority);
            return t;
        }
    }
}

在上面的代码中,有两个地方使用到工厂模式,第一个地方是调用newThread()返回Thread对象,第二个地方是调用createThreadFactory()返回ThreadFactory对象,接下来我们可以使用创建的执行器Executor执行提交的工作任务Runnable,具体的用法如下:

       DefaultConfigurationFactory.createTaskDistributor().execute(new LoadTask(textView,handler));

在一个APP项目中会出现多个工作任务,使用线程池后不要担心创建线程的问题,只需要将工作任务按照上述的方法提交给Executor执行器即可,比如:TeachCourse创建一个加载和显示图片的工作任务LoadAndDisplayImageTask,在需要的地方,执行如下代码:

       DefaultConfigurationFactory.createTaskDistributor().execute(new LoadAndDisplayImageTask(imageView,handler));

到这里,我们学习了工厂模式在线程池中的使用,通过线程池减少线程对象创建、销毁的开销,工厂模式的一个特点:将创建相同对象的过程封装成方法,调用同一个方法完成相同对象的创建

二、什么是工厂模式?

通过工厂模式应用于线程池的例子的学习,首先让读者对工厂模式有一个大概的认识,对上面的例子不是很理解,不影响你对后面工厂模式的学习,毕竟工厂模式应用于线程池的例子涉及的知识点包括多线程、消息队列,这些知识在本篇文章中不做过多介绍,需要读者具备一定的基础,而本篇文章重点学习工厂模式。

工厂模式的特点:将创建相同对象的过程封装成方法,调用同一个方法完成相同对象的创建

现实中的工厂,负责生产厂品,工厂模式的工厂负责创建对象,创建一个对象会为对象分配一块独立的内存,创建对象的过程就是不断分配内存的过程。生活的农村TeachCourse对工厂印象深刻,以前村里没有工厂生产棉衣,家里人会买一些毛衣的回来,家人更多时候手工织毛衣,织一件毛衣可能需要有两个月甚至更长,大部分是满足家庭所需;但过了有段时间后,一些领导干部决定带动村里经济发展,着手发展一些第三产业,开始招商引资,吸引了商家创建在村周边创办了一些工厂,让工厂负责生产日常所需的毛衣,同时将多余的产品销售全国各地,原本有两个月完成一件的毛衣,现在可以一天生产几十、几百甚至上千。从这个例子体现出工厂的高效率。

手动生产毛衣的过程,如下图:

工厂模式

在面向对象的编程语言中,将织毛衣转化成Sweater类,代码如下:

public class Sweater {
    private String size;
    private String style;
    private String material;

    public Sweater(String size, String style, String material) {
        this.size = size;
        this.style = style;
        this.material = material;
    }

    public void makeSweater() {
        System.out.println("当前生产的毛衣:");
        System.out.println("尺寸:" + size);
        System.out.println("样式:" + style);
        System.out.println("材料:" + material);
    }
}

工厂生产毛衣的过程,准备好毛衣的尺寸、材料、样式等基本信息,制作成一份模板,然后开始批量生产,所以工厂生产出来某批量的毛衣在尺寸、材料和样式上没有很大的差异。

工厂生产毛衣的过程,如下图:

工厂模式

将毛衣工厂转化成SweaterFactory类,类里面包含对应的属性、方法,代码如下:

public class SweaterFactory {

    public static Sweater createSweater(String size,String style,String material){
           return new Sweater(size,style,material);
    }
}

总结:工厂模式是将创建相同对象的过程封装成方法,调用同一个方法完成相同对象的创建。

三、 什么时候使用工厂模式?

如果你想要生产相同尺寸、样式和材料没有差异的一批毛衣,就应该考虑通过工厂进行生产;如果你只想织一两件日常所需的毛衣,暂时就不用考虑工厂模式。在上面线程池的例子中,因为考虑线程池可能不止一两条线程,所以考虑通过线程工厂负责创建线程,可以满足线程池需要多少创建多少的要求。

总结:在考虑创建一批没有很大差异性的对象时,可以考虑使用工厂模式

四、工厂模式的几种方式

我们生产的毛衣款式按年龄段划分可以有:童装、成人装、老年装;不同年龄段有分为男装、女装,按照上面所述代码,每次创建对象都需要输入:毛衣的尺寸、样式和材质,能不能将每一种款式封装成一份模板,每次只需要定义调用createSweater()方法,而不用关心传入的参数呢?

开始对上面的代码,进行重构,首先声明一个产品的接口Product,代码如下:

public interface Product {
    void makeSweater();
}

根据毛衣款式的不同,分别实行Product接口,童装具体类,代码如下:

public class ChildrenSweater implements Product {
    @Override
    public void makeSweater() {
        System.out.println("当前生产的毛衣:");
        System.out.println("尺寸:" + "童装大小");
        System.out.println("样式:" + "松绿色");
        System.out.println("材料:" + "纯棉体恤");
    }
}

成人装具体类,代码如下:

public class AdultSweater implements Product {
    @Override
    public void makeSweater() {
        System.out.println("当前生产的毛衣:");
        System.out.println("尺寸:" + "成人大小");
        System.out.println("样式:" + "夏装男士圆领净色纯色短T男装");
        System.out.println("材料:" + "纯棉体恤");
    }
}

老年装具体类,代码如下:

public class OldSweater implements Product {
    @Override
    public void makeSweater() {
        System.out.println("当前生产的毛衣:");
        System.out.println("尺寸:" + "老人大小");
        System.out.println("样式:" + "中老年男装夹克2017春季新款");
        System.out.println("材料:" + "锦纶");
    }
}

第一种方式:

工厂不能像上面一样只负责生产一种款式的毛衣,现在要根据生产的需求,工厂要能批量生产童装、成人装和老年装的产品,开始对SweaterFactory进行重构,代码如下:

public class SweaterFactory {

    public static <T extends Product> T createProduct(Class<T> clz){
        Product product=null;
        try {
            product=(Product) Class.forName(clz.getName()).newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return (T) product;

    }
}

接下来工厂就可以批量生产不同款式的毛衣,代码如下:

        /**批量生产童装*/
        Product product=SweaterFactory.createProduct(ChildrenSweater.class);
        product.makeSweater();
        /**批量生产成人装*/
        product=SweaterFactory.createProduct(AdultSweater.class);
        product.makeSweater();
        /**批量生产老年装*/
        product=SweaterFactory.createProduct(OldSweater.class);
        product.makeSweater();

这是一种动态批量生产对象的方式,需要哪一个类的对象传入那一个类,然后调用相同的makeSweater()方法,特点:使用反射知识,理解比较困难,但代码简洁

第二种方式:

不使用反射的知识,通过类型识别生产哪一款毛衣,创建对应毛衣对象,特点:简单明了,依赖性强,代码如下:

public class SweaterFactory {

    public static Product createProduct(String type) {
        Product product
        switch (type) {
            case "children":

                product = new ChildrenSweater();

                break;
            case "adult":

                product = new AdultSweater();

                break;
            case "old":

                product = new OldSweater();

                break;
            default:

                product = new ChildrenSweater();

                break;
        }
        return product;
    }
}

第三种方式:

根据程序的单一职责,一个工厂负责生产一种款式的毛衣,ChildrenFactory负责生产童装,AdultFactory负责生产成人装,OldFactory负责生产老年装,然后再进行细分,童装还可以划分成不同年龄段的男孩、女孩款式,成人装进一步划分高矮胖瘦的男人、女人款式,老年装划分不同年龄身高的男款、女款,多个工厂的特点:职责单一,方便扩展

重构SweaterFactory为抽象工厂,代码如下:

public abstract class SweaterFactory {

    public abstract Product createProduct();
}

负责生产童装的工厂,代码如下:

public class ChildrenFactory extends SweaterFactory {
    @Override
    public Product createProduct() {
        return new ChildrenSweater();
    }
}

负责生产成人装的工厂,代码如下:

public class AdultFactory extends SweaterFactory {
    @Override
    public Product createProduct() {
        return new AdultSweater();
    }
}

负责生产老年装的工厂,代码如下:

public class OldFactory extends SweaterFactory {
    @Override
    public Product createProduct() {
        return new OldSweater();
    }
}

第三种方式又叫做抽象工厂模式,属于一种特殊的工厂模式,同时复合工厂模式的特点,工厂模式的特点:将创建相同对象的过程封装成方法,调用同一个方法完成相同对象的创建

在实际的开发中,把握住了工厂模式的特点,然后进行重构,还会有其他的方式,创建相同对象的过程可以封装成实例方法或类方法,都是可以的,文章开头线程池的实例中就包含实例方法和类方法。

五、总结

本篇文章从什么是工厂模式、什么时候使用工厂模式以及工厂模式几种方式入手,认真分析了工厂模式的特点:将创建相同对象的过程封装成方法,调用同一个方法完成相同对象的创建,把符合该特点的设计模式称为工厂模式,最后列举几种工厂模式的方式,深入理解工厂模式。

关注公众号 扫一扫二维码,加我QQ

如果文章对你有帮助,欢迎点击上方按钮关注作者

来源:TeachCourse每周一次,深入学习Android教程,关注(QQ1589359239或公众号TeachCourse)
转载请注明出处:http://teachcourse.cn/2459.html

资源分享

下载源码
Android项目结构与分析源码,其中的秘密,你知道吗? Android项目结构与分析源码,其
浅谈dt.jar、tools.jar和rt.jar 浅谈dt.jar、tools.jar和rt.jar
你知道,哪些即时通信平台? 你知道,哪些即时通信平台?
Android开发之Genymotion安装第三方软件的“APP not installed”问题 Android开发之Genymotion安装第

发表评论

呲牙 憨笑 坏笑 偷笑 色 微笑 抓狂 睡觉 酷 流汗 鼓掌 大哭 可怜 疑问 晕 惊讶 得意 尴尬 发怒 奋斗 衰 骷髅 啤酒 吃饭 礼物 强 弱 握手 OK NO 勾引 拳头 差劲 爱你

表情