Java设计模式（八） 之创建型模式（工厂方法模式）

一、工厂方法模式概念

工厂方法(Factory Method)模式：定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中。核心工厂类不再负责产品的创建，这样核心类成为一个抽象工厂角色，仅负责具体工厂子类必须实现的接口，这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。

二、角色结构

• 抽象工厂(Creator)角色：是工厂方法模式的核心，与应用程序无关。任何在模式中创建的对象的工厂类必须实现这个接口。
• 具体工厂(Concrete Creator)角色：这是实现抽象工厂接口的具体工厂类，包含与应用程序密切相关的逻辑，并且受到应用程序调用以创建产品对象。在上图中有两个这样的角色：BulbCreator与TubeCreator。
• 抽象产品(Product)角色：工厂方法模式所创建的对象的超类型，也就是产品对象的共同父类或共同拥有的接口。在上图中，这个角色是Light。
• 具体产品(Concrete Product)角色：这个角色实现了抽象产品角色所定义的接口。某具体产品有专门的具体工厂创建，它们之间往往一一对应。

三、场景展示（女娲造人）

先看类图：

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

package com.ssy.wlj.factorymethod;

/**
 * 定义一个人类的统称
 * @author Administrator
 * @since 2019/05/25
 *
 */
public interface Human {

    // 首先定义什么是人类
    // 人会笑，表达愉快
    void laugh();
    // 人会哭，表达悲伤
    void cry();
    // 人会说话
    void talk();
}

然后定义具体的人种：

白种人：

package com.ssy.wlj.factorymethod;

public class WhiteHuman implements Human {

    @Override
    public void laugh() {
        System.out.println("白种人会笑...");
    }

    @Override
    public void cry() {
         System.out.println("白种人会哭...");
    }

    @Override
    public void talk() {
        System.out.println("白种人说话，一般都是单字节...");
    }

}

黑种人：

package com.ssy.wlj.factorymethod;

public class BlackHuman implements Human {

    @Override
    public void laugh() {
        System.out.println("黑种人会笑...");
    }

    @Override
    public void cry() {
        System.out.println("黑种人会哭...");
    }

    @Override
    public void talk() {
        System.out.println("黑种人说话，一般都听不懂...");
    }

}

黄种人：

package com.ssy.wlj.factorymethod;

public class YellowHuman implements Human {

    @Override
    public void laugh() {
        System.out.println("黄种人会笑...");
    }

    @Override
    public void cry() {
        System.out.println("黄种人会哭...");
    }

    @Override
    public void talk() {
        System.out.println("黄种人说话，一般说的都是双字节...");
    }

}

工厂类：

package com.ssy.wlj.factorymethod;

/**
 * 八卦炉，创造Human的工厂
 * @author Administrator
 * @since 2019/05/25
 *
 */
public class HumanFactory {
     // 定义一个烤箱，泥巴塞进去，人就出来，这个太先进了
    public static Human createHuman(Class c) {
        Human human = null;
        
        try {
            // 产生一个人种
            human = (Human) Class.forName(c.getName()).newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
            // 你要是不说个人种颜色的话，没法烤，要白的黑的，你说话了才好烤
            System.out.println("必须指定人种的颜色!"); 
        } catch (IllegalAccessException e) {
            e.printStackTrace();
             // 定义的人种有问题，那就烤不出来了
            System.out.println("人种定义错误！"); 
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
            // 你随便说个人种，我到哪里给你制造去？！
            System.out.println("混蛋，你指定的人种找不到！"); 
        }
        
        return human;
    }
}

最后创建客户端类：

package com.ssy.wlj.factorymethod;

public class NvWaClient {
    
    public static void main(String[] args) {
        // 女娲第一次造人，试验性质，少造点，火候不足，缺陷产品
        System.out.println("第一批人：白种人-----------------");
        Human whiteHuman = HumanFactory.createHuman(WhiteHuman.class);
        whiteHuman.cry();
        whiteHuman.laugh();
        whiteHuman.talk();
        
        // 女娲第二次造人，火候加足点，然后又出了个次品，黑人
        System.out.println("第二批人：黑种人-----------------");
        Human blackHuman = HumanFactory.createHuman(BlackHuman.class);
        blackHuman.cry();
        blackHuman.laugh();
        blackHuman.talk(); 
        
        //第三批人了，这次火候掌握的正好，黄种人
        System.out.println("第三批人：黄种人-----------------");
        Human yellowHuman = HumanFactory.createHuman(YellowHuman.class);
        yellowHuman.cry();
        yellowHuman.laugh();
        yellowHuman.talk();
    }

}

 *********************************************************************************************************************************************************************************************

需求变更：

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

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

package com.ssy.wlj.factorymethod;

import java.util.List;
import java.util.Random;

/**
 * 八卦炉，创造Human的工厂
 * @author Administrator
 * @since 2019/05/25
 *
 */
public class HumanFactory {
     // 定义一个烤箱，泥巴塞进去，人就出来，这个太先进了
    public static Human createHuman(Class c) {
        Human human = null;
        
        try {
            // 产生一个人种
            human = (Human) Class.forName(c.getName()).newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
            // 你要是不说个人种颜色的话，没法烤，要白的黑的，你说话了才好烤
            System.out.println("必须指定人种的颜色!"); 
        } catch (IllegalAccessException e) {
            e.printStackTrace();
             // 定义的人种有问题，那就烤不出来了
            System.out.println("人种定义错误！"); 
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
            // 你随便说个人种，我到哪里给你制造去？！
            System.out.println("混蛋，你指定的人种找不到！"); 
        }
        
        return human;
    }
    
 // 女娲生气了，把一团泥巴塞到八卦炉，哎产生啥人种就啥人种
    public static Human createHuman() {
        
        // 定义一个类型的人类
        Human human = null; 

        // 首先是获得有多少个实现类，多少个人种
        List<Class> concreteHumanList = ClassUtil.getAllClassByInterface(Human.class); //定义了多少人种
        // 八卦炉自己开始想烧出什么人就什么人
        Random random = new Random();
        int rand = random.nextInt(concreteHumanList.size());

        human = createHuman(concreteHumanList.get(rand));

        return human;
    }
}

客户端程序修改为：

package com.ssy.wlj.factorymethod;

public class NvWaClient {
    
    public static void main(String[] args) {
         for(int i = 0; i < 10; i++) {
                System.out.println("随机产生人种了...");
                Human human = HumanFactory.createHuman();
                human.cry();
                human.laugh();
                human.talk();
            }
    }

}

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

package com.ssy.wlj.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;

public class ClassUtil {
    
    // 给一个接口，返回这个接口的所有实现类
    public static List<Class> getAllClassByInterface(Class c) {
        
        // 返回结果
        List<Class> returnClassList = new ArrayList<Class>();
        
        // 如果不是一个接口，则不做处理
        if(c.isInterface()) {
            // 获得类的包名
            String packageName = c.getPackage().getName();
            // 获得当前包以下以及子包下的所有类
            try {
                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));
                        }
                    }
                }
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        
        return returnClassList;
        
    }
    
    /*
     * 从一个包中查找出所有的类，在jar包中不能查找
     */
    private static List<Class> getClasses(String packageName) throws IOException, ClassNotFoundException {
        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
        String path = packageName.replace('.', '/');
        Enumeration<URL> resources = classLoader.getResources(path);
        List<File> dirs = new ArrayList<File>();
        while(resources.hasMoreElements()) {
            URL resource = resources.nextElement();
            dirs.add(new File(resource.getFile()));
        }
        List<Class> classes = new ArrayList<Class>();
        for(File directory : dirs) {
            classes.addAll(findClasses(directory, packageName));
        }
        return classes;
    }
    
    private static List<Class> findClasses(File directory, String packageName) throws ClassNotFoundException {
        List<Class> classes = new ArrayList<Class>();
        if(!directory.exists()) {
            return classes;
        }
        File[] files = directory.listFiles();
        for(File file : files) {
            if(file.isDirectory()) {
                assert !file.getName().contains(".");
                classes.addAll(findClasses(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;
    }

}

一个对象初始化完毕后就不释放，等到再次用到就不用再次初始化了，直接从内存过中拿到就可以了，怎么实现呢，很简单，看例子：

package com.ssy.wlj.factorymethod;

public class LazyHumanFactory {
    // 定义一个map，初始化过的Human对象都放在这里
    private static Map<String, Human> humans = new HashMap<>();
    
    // 定义一个烤箱，泥巴塞进去，人就出来，这个太先进了
    public static Human createHuman(Class c) {
        Human human = null;
        
        try {
            if(humans.containsKey(c.getSimpleName())) {
                human = humans.get(c.getSimpleName());
            }else {
                human = (Human) Class.forName(c.getName()).newInstance();
                // 放到map中
                humans.put(c.getSimpleName(), human);
            }
            
        } catch (InstantiationException e) {
            e.printStackTrace();
            System.out.println("必须指定人种的颜色!"); 
        } catch (IllegalAccessException e) {
            e.printStackTrace();
            System.out.println("人种定义错误！"); 
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
            System.out.println("混蛋，你指定的人种找不到！"); 
        }
        
        return human;
    }
}