工厂模式解耦升级版

今天在写工厂模式的小demo中，对之前代码的问题做了比较全面的排查，其中最大的问题就是耦合性太高，从一开始的接口实现类直接new下一层的对象，到使用工厂模式的多例对象创建，再到单例对象创建，其中学习到了很多知识，我觉得有必要记录一下，下面先给出demo的结构图（maven）：

其中的视图层我用ui代替，就是一个用户入口，然后dao层、service层就是普通的mvc架构。重点是factory这个包，先给factory包中的代码：

package com.xu.factory;

import java.io.IOException;
import java.io.InputStream;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;

/**
 * @author HaibiaoXu
 * @date Create in 14:30 2019/10/6
 * @modified By
 */
public class BeanFactory {
    private static Properties pros;
    //定义map，用于存放要创建的对象，称作容器
    private static Map<String, Object> beans;
    
    static {
        try {
            pros = new Properties();
            InputStream as = BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties");
            pros.load(as);
            
            beans = new HashMap<String, Object>();
            Enumeration<Object> keys = pros.keys();
            while (keys.hasMoreElements()) {
                String key = keys.nextElement().toString();
                String beanPath = pros.getProperty(key);
                Object value = Class.forName(beanPath).newInstance();
                beans.put(key, value);
            }
        } catch (Exception e) {
            throw new ExceptionInInitializerError("初始化错误");
        }
    }

    /**
     * 根据类名称获取对象，单例
     * @param beanName
     * @return
     */
    public static Object getBean(String beanName){
        return beans.get(beanName);
    }
    
    /**
     * 根据类名称获取对象，多例
     * @param beanName
     * @return
     */
    /*public static Object getBean(String beanName) {
        Object bean = null;
        try {
            String beanPath = pros.getProperty(beanName);
            bean = Class.forName(beanPath).newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        return bean;
    }*/
}

大致思路是这样的：

1. 读取配置文件（这里用的properties，Spring里都是xml）
2. 如果是创建多例对象，那直接定义通过类名用反射来创建新对象的方法；
3. 如果是创建单例对象，需要再静态代码块中先创建一个对象放入一个容器中，由于需要存放的是类名+对象这样的形式，想到用map来当这个容器（实质上Spring底层也是用map来当容器的）。定义通过类名找到map中的对象的方法；

单例和多例的区别移步 https://blog.csdn.net/feicongcong/article/details/78121900

通过循环创建多个对象来对单例和多例进行测试，入口函数代码：

package com.xu.ui;

import com.xu.factory.BeanFactory;
import com.xu.service.impl.AccountServiceImpl;

/**
 * @author HaibiaoXu
 * @date Create in 14:27 2019/10/6
 * @modified By
 */
public class Client {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            AccountServiceImpl as = (AccountServiceImpl)BeanFactory.getBean("AccountServiceImpl");
            System.out.println(as);
            as.saveAccount();
        }
    }


}

service层接口实现：

package com.xu.service.impl;

import com.xu.dao.impl.AccountDaoImpl;
import com.xu.factory.BeanFactory;
import com.xu.service.IAccountService;

/**
 * @author HaibiaoXu
 * @date Create in 14:20 2019/10/6
 * @modified By
 */
public class AccountServiceImpl implements IAccountService {
    private AccountDaoImpl dao;
    private int i = 1;
    public void saveAccount() {
        dao = (AccountDaoImpl) BeanFactory.getBean("AccountDaoImpl");
        dao.saveAccount();
        System.out.println(i);
        i++;
    }
}

数据访问层接口实现：

package com.xu.dao.impl;

import com.xu.dao.IAccountDao;

/**
 * @author HaibiaoXu
 * @date Create in 14:23 2019/10/6
 * @modified By
 */
public class AccountDaoImpl implements IAccountDao {
    public void saveAccount() {
        System.out.println("保存账户");
    }
}

打印结果比较：
单例：

多例：

期间遇到了一个小bug，就是在实现多例的过程中报了空指针异常，找了很久发现是service层dao对象的创建在方法外，把他移到方法内就解决了。我猜想是因为单例化后类不会被新创建导致原来的dao对象被垃圾回收了，但也仅仅是猜想，没有深入研究，等会再去考察考察哈哈，溜！