五 工厂方法模式【Factory Method Pattern】 来自CBF4LIFE 的设计模式

女娲补天的故事大家都听说过吧，今天不说这个，说女娲创造人的故事，可不是“造人”的工作，这
个词被现代人滥用了。这个故事是说，女娲在补了天后，下到凡间一看，哇塞，风景太优美了，天空是湛
蓝的，水是清澈的，空气是清新的，太美丽了，然后就待时间长了就有点寂寞了，没有动物，这些看的到
都是静态的东西呀，怎么办？
别忘了是神仙呀，没有办不到的事情，于是女娲就架起了八卦炉（技术术语：建立工厂）开始创建人，
具体过程是这样的：先是泥巴捏，然后放八卦炉里烤，再扔到地上成长，但是意外总是会产生的：
第一次烤泥人，兹兹兹兹~~，感觉应该熟了，往地上一扔，biu~，一个白人诞生了，没烤熟！
第二次烤泥人，兹兹兹兹兹兹兹兹~~，上次都没烤熟，这次多烤会儿，往地上一扔，嘿，熟过头了，
黑人哪！
第三次烤泥人，兹~兹~兹~，一边烤一边看着，嘿，正正好，Perfect！优品，黄色人类！【备注:RB 人
不属此列】
这个过程还是比较有意思的，先看看类图：（之前在论坛上有兄弟建议加类图和源文件，以后的模式都
会加上去，之前的会一个一个的补充，目的是让大家看着舒服，看着愉悦，看着就想要，就像是看色情小
说一样，目标，目标而已，能不能实现就看大家给我的信心了）
 

那这个过程我们就用程序来表现，首先定义一个人类的总称：

package FactoryMethod;

/**
 * @author lhb
 * @类名 IHuman
 * @描述 定义一个人类的统称
 * @时间 2022/6/15 14:53
 * @版本
 **/
public interface IHuman {
    //人是愉快的，会笑的，本来是想用smile表示，想了一下laugh更合适，好长时间没有大笑了；
     void laugh();
    //人类还会哭，代表痛苦
     void cry();
    //人类会说话
    void talk();

package FactoryMethod;

/**
 * @author lhb
 * @类名 BlackMan
 * @描述 黑色人类： 
 * @时间 2022/6/15 14:55
 * @版本
 **/
public class BlackMan implements IHuman {

    @Override
    public void laugh() {
        System.out.println("blackman can laugh");
    }

    @Override
    public void cry() {
        System.out.println("blackman can cry");
    }

    @Override
    public void talk() {
        System.out.println("blackman can talk");
    }
}

package FactoryMethod;

/**
 * @author lhb
 * @类名 WhiteMan
 * @描述白色人类： 
 * @时间 2022/6/15 14:57
 * @版本
 **/
public class WhiteMan implements  IHuman{
    @Override
    public void laugh() {
        System.out.println("WhiteMan can laugh");
    }

    @Override
    public void cry() {
        System.out.println("WhiteMan can cry");
    }

    @Override
    public void talk() {
        System.out.println("WhiteMan can talk");
    }
}

package FactoryMethod;

import java.lang.reflect.InvocationTargetException;

/**
 * @author lhb
 * @类名 HumanFactory
 * @描述 今天讲女娲造人的故事，这个故事梗概是这样的：
  * 很久很久以前，盘古开辟了天地，用身躯造出日月星辰、山川草木，天地一片繁华
  * One day，女娲下界走了一遭，哎！太寂寞，太孤独了，没个会笑的、会哭的、会说话的东东 
 * 那怎么办呢？不用愁，女娲，神仙呀，造出来呀，然后捏泥巴，放八卦炉（后来这个成了太白金星的宝 贝）中烤，于是就有了人：
  * 我们把这个生产人的过程用Java程序表现出来
 * @时间 2022/6/15 15:26
 * @版本
 **/
public class HumanFactory {
    //定一个烤箱，泥巴塞进去，人就出来，这个太先进了
    public static IHuman createHuman(Class c) {
        IHuman human = null;  //定义一个类型的人类
        try {
            human = (IHuman)Class.forName(c.getName()).getDeclaredConstructor().newInstance();   //产生一个 人类
        } catch (InstantiationException e) {
            System.out.println("必须指定人类的颜色");
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            System.out.println("人类定义错误！");
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            System.out.println("当找不到特定方法时抛出");
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            System.out.println("混蛋，你指定的人类找不到！");
            e.printStackTrace();
        }
        return human;
    }

}

package FactoryMethod;

/**
 * @author lhb
 * @类名 NvWa
 * @描述 首先定义女娲，这真是额的神呀 
 * @时间 2022/6/15 15:41
 * @版本
 **/
public class NvWa {
    public static void main(String[] args) {
        //女娲第一次造人，试验性质，少造点，火候不足，缺陷产品
        var whiteHuman = HumanFactory.createHuman(WhiteMan.class);
        whiteHuman.cry();
        //女娲第二次造人，火候加足点，然后又出了个次品，黑人
        var  blackHuman = HumanFactory.createHuman(BlackMan.class);
        blackHuman.laugh();
    }
}

这样这个世界就热闹起来了，人也有了，但是这样创建太累了，神仙也会累的，那怎么办？神仙就想
了：我塞进去一团泥巴，随机出来一群人，管他是黑人、白人，只要是人就成（你看看，神仙都偷
懒，何况是我们人），先修改类图：

然后看我们的程序修改，先修改 HumanFactory.java，增加了 createHuman()方法

package FactoryMethod;

import javax.swing.*;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.util.List;
import java.util.Random;
import java.util.Set;

/**
 * @author lhb
 * @类名 HumanFactory
 * @描述 今天讲女娲造人的故事，这个故事梗概是这样的：  * 很久很久以前，盘古开辟了天地，用身躯造出日月星辰、山川草木，天地一片繁华  * One day，女娲下界走了一遭，哎！太寂寞，太孤独了，没个会笑的、会哭的、会说话的东东  * 那怎么办呢？不用愁，女娲，神仙呀，造出来呀，然后捏泥巴，放八卦炉（后来这个成了太白金星的宝 贝）中烤，于是就有了人：  * 我们把这个生产人的过程用Java程序表现出来
 * @时间 2022/6/15 15:26
 * @版本
 **/
public class HumanFactory {

    //定义了多少人类
    public  static List<Class> concreteHumanList;

    static {
        try {
            concreteHumanList = ClassUtils.getAllClassByInterface(IHuman.class);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //定一个烤箱，泥巴塞进去，人就出来，这个太先进了
    public static IHuman createHuman(Class c) {
        IHuman human = null;  //定义一个类型的人类
        try {
            human = (IHuman)Class.forName(c.getName()).getDeclaredConstructor().newInstance();   //产生一个 人类
        } catch (InstantiationException e) {
            System.out.println("必须指定人类的颜色");
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            System.out.println("人类定义错误！");
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            System.out.println("当找不到特定方法时抛出");
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            System.out.println("混蛋，你指定的人类找不到！");
            e.printStackTrace();
        }
        return human;
    }

    public static IHuman createHuman(){
        IHuman human=null;  //定义一个类型的人类
        Random random = new Random();
        int rand = random.nextInt(concreteHumanList.size());
        return createHuman(concreteHumanList.get(rand));
    }

}

然后看女娲是如何做的：

package FactoryMethod;

/**
 * @author lhb
 * @类名 NvWa
 * @描述
 * @时间 2022/6/15 15:41
 * @版本
 **/
public class NvWa {
    public static void main(String[] args) {
        //女娲第一次造人，试验性质，少造点，火候不足，缺陷产品
        var whiteHuman = HumanFactory.createHuman(WhiteMan.class);
        whiteHuman.cry();
        //女娲第二次造人，火候加足点，然后又出了个次品，黑人
        var  blackHuman = HumanFactory.createHuman(BlackMan.class);
        blackHuman.laugh();

        for(int i = 0;i<100;++i){

            var human = HumanFactory.createHuman();
            human.talk();
        }
    }
}

哇，这个世界热闹了！，不过还没有完毕，这个程序你跑不起来，还要有这个工具类：

package FactoryMethod;

import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;

/**
 * @author lhb
 * @类名 ClassUtils
 * @描述
 * @时间 2022/6/16 11:13
 * @版本
 **/
public class ClassUtils {
    //给一个接口，返回这个接口的所有实现类
    public static List<Class> getAllClassByInterface(Class c) throws  ClassNotFoundException,IOException{
        List<Class> returnClassList = new ArrayList<Class>();  //返回结果
        //如果不是一个接口，则不做处理
        if(c.isInterface()){
            String packageName = c.getPackageName();
            String packageName1 = c.getPackage().getName();
            System.out.println(packageName);
            System.out.println(packageName1);
            List<Class>  allClass = getClasses(packageName);  //获得当前包下以 及子包下的所有类
            //判断是否是同一个接口
            for(int i =0;i<allClass.size();i++){
                if(c.isAssignableFrom(allClass.get(i))){//判断是不是一个接口
                    if(!c.equals(allClass.get(i))){ //本身不加进去
                        returnClassList.add(allClass.get(i));
                    }
                }
            }
        }

        return returnClassList;
    }

    private static List<Class> getClasses(String packageName)throws ClassNotFoundException, IOException {
        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
        String path = packageName.replace('.','/');
        List<File> dirs = new ArrayList<File>();
        Enumeration<URL> resources = classLoader.getResources(path);
        while (resources.hasMoreElements()){
            URL resource = resources.nextElement();
            dirs.add(new File(resource.getFile()));
        }
        ArrayList<Class> classes = new ArrayList<Class>();
        for(File directory:dirs){
            classes.addAll(findClassess(directory, packageName));
        }
        return  classes;
    }

    private static List<Class> findClassess(File directory, String packageName) throws ClassNotFoundException{
        List<Class> classes = new ArrayList<>();
        if(!directory.exists()){
            return  classes;
        }
        File[] files = directory.listFiles();
        for(File file : files){
            if(file.isDirectory()){
                assert !file.getName().contains(".");
                classes.addAll(findClassess(file,packageName+"."+file.getName()));
            }else if(file.getName().endsWith(".class")){
                classes.add(Class.forName(packageName+'.'+file.getName().substring(0,file.getName().length()-6)));
            }
        }

        return classes;
    }

}

告诉你了，这个 ClassUtils 可是个宝，用处可大了去了，可以由一个接口查找到所有的实现类，也可
以由父类查找到所有的子类，这个要自己修改一下，动脑筋想下，简单的很！完整的类图如下：
 

我们来总结一下，特别是增加了 createHuman()后，是不是这个工厂的扩展性更好了？你看你要再加一
个人类，只要你继续集成 IHuman 接口成了，然后啥都不用修改就可以生产了，具体产多少，那要八卦炉说
了算，简单工厂模式就是这么简单，那我们再引入一个问题：人是有性别的呀，有男有女，你这怎么没区
别，别急，这个且听下回分解！

工厂方法模式还有一个非常重要的应用，就是延迟始化(Lazy initiali zation)，什么是延迟始化呢？
一个对象初始化完毕后就不释放，等到再次用到得就不用再次初始化了，直接从内存过中拿到就可以了，
怎么实现呢，很简单，看例子：

package FactoryMethod;

import javax.swing.*;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.util.HashMap;
import java.util.List;
import java.util.Random;
import java.util.Set;

/**
 * @author lhb
 * @类名 HumanFactory
 * @描述 今天讲女娲造人的故事，这个故事梗概是这样的：  * 很久很久以前，盘古开辟了天地，用身躯造出日月星辰、山川草木，天地一片繁华  * One day，女娲下界走了一遭，哎！太寂寞，太孤独了，没个会笑的、会哭的、会说话的东东  * 那怎么办呢？不用愁，女娲，神仙呀，造出来呀，然后捏泥巴，放八卦炉（后来这个成了太白金星的宝 贝）中烤，于是就有了人：  * 我们把这个生产人的过程用Java程序表现出来
 * @时间 2022/6/15 15:26
 * @版本
 **/
public class HumanFactory {

    //定义了多少人类
    public  static List<Class> concreteHumanList;

    static {
        try {
            concreteHumanList = ClassUtils.getAllClassByInterface(IHuman.class);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static HashMap<String,IHuman> humans = new HashMap<>();

    //定一个烤箱，泥巴塞进去，人就出来，这个太先进了
    public static IHuman createHuman(Class c) {
        IHuman human = null;  //定义一个类型的人类
        try {
            if(humans.containsKey(c.getSimpleName())){
                human = humans.get(c.getSimpleName());
            }else {
                human = (IHuman)Class.forName(c.getName()).getDeclaredConstructor().newInstance();   //产生一个 人类
                humans.put(c.getSimpleName(),human);
            }
        } catch (InstantiationException e) {
            System.out.println("必须指定人类的颜色");
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            System.out.println("人类定义错误！");
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            System.out.println("当找不到特定方法时抛出");
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            System.out.println("混蛋，你指定的人类找不到！");
            e.printStackTrace();
        }
        return human;
    }

    public static IHuman createHuman(){
        IHuman human=null;  //定义一个类型的人类
        Random random = new Random();
        int rand = random.nextInt(concreteHumanList.size());
        return createHuman(concreteHumanList.get(rand));
    }

}

很简单，就加上了黄色那部分的代码，这个在类初始化很消耗资源的情况比较实用，比如你要连接硬
件 ，或 者 是 为 了 初 始 化 一 个 类 需 要 准 备 比 较 多 条 件（ 参 数 ），通 过 这 种 方 式 可 以 很 好 的 减 少 项 目 的 复 杂 程 度