对初识Spring工厂模式的思考

Spring的基本理论知识

• 什么是Spring？

Spring 是分层的 Java SE/EE应用 full-stack 轻量级开源框架，以 IoC（Inverse Of Control：
反转控制）和 AOP（Aspect Oriented Programming：面向切面编程）为内核，提供了表现层 Spring
MVC 和持久层 Spring JDBC 以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多
著名的第三方框架和类库，逐渐成为使用最多的Java EE 企业应用开源框架。

• spring 的体系结构

• Spring的优势？

方便解耦，简化开发
AOP 编程的支持
声明式事务的支持（配置的方式）
方便程序的测试（好像集成了Junit）
方便集成各种优秀框架
降低 JavaEE API
Java 源码是经典学习范例

栗子

我们有这么一个场景，需要实现一个账户保存的功能。这个很简单，无非就是两个接口、两个实现类、再加一个测试类的事情。

创建账户持久层接口 IAccountDao，定义保存账户抽象方法

public interface IAccountDao {
    /**
     * 保存账户
     */
    void saveAccount();
}

实现账户持久层接口 AccountDaoImpl，并创建并实现 saveAccount 方法，输出保存信息。

public class AccountDaoImpl implements IAccountDao {
 @Override
    public void saveAccount() {
        System.out.println("已保存账户~！");
    }
}

定义账户业务层接口 IAccountService，并定义一个保存账户的方法

public interface IAccountService {
    /**
     * 保存账户
     */
    void saveAccount();
}

实现账户业务层接口 AccountServiceImpl，实现调用持久层 saveAccount 方法实现保存账号抽象方法。

public class AccountServiceImpl implements IAccountService {
  /**
     * 持久层对象
     */
    private IAccountDao accountDao = new AccountDaoImpl();

    @Override
    public void saveAccount() {
        accountDao.saveAccount();
    }
}

最后编写表现层 Test，测试下该用例是否能正常运行

public class Test{
    public static void main(String[] args) {
        IAccountService as = new AccountServiceImpl();
        as.saveAccount();
    }
}

// 以下为输出结果
已保存账户~！

分析：

1、首先要清楚一个概念：耦合

• 程序的耦合

耦合：程序间的依赖关系。包括 类之间的依赖、方法间的依赖。
解耦：降低程序间的依赖关系
实际开发中应该做到编译期不依赖，运行时才依赖。
解耦的思路：
第一步：使用反射来创建对象，而避免使用new关键字。
第二步：通过读取配置文件来获取要创建的对象全限定类名
在实际开发中，耦合是必然存在的，故只能尽量降低依赖，不能消除。

在上面的这几段代码中，耦合程度是很高的。为啥说高耦合呢，假若我们不小心删了 AccountDaoImpl ，整个程序都无法通过编译。那么这时候就需要改写代码，使用工厂模式解耦！！！

2、配置文件的使用

• 为什么要使用配置文件呢？？
  使用配置文件可以达到一个目的，就是我们可以将一些固定不变的内容抽取出来单独保存，通过调用的方式获取其实例。

首先需要一个配置文件来配置我们的service和dao。配置的内容：唯一标识=全限定类名（key=value)
其次通过读取配置文件中配置的内容，反射创建对象。

代码的改写

1、创建 bean.properties 文件，保存账户业务层实现类的路径 AccountServiceImpl 和账户持久层接口实现类 AccountDaoImpl 信息

accountService=service.AccountServiceImpl
accountDao=dao.AccountDaoImpl

2、创建Bean对象的工厂模式 BeanFactory 。Bean：在计算机英语中，有可重用组件的含义；
JavaBean：用java语言编写的可重用组件。它就是创建我们的service和dao对象的。

public class BeanFactory {

    /**
     * Properties 对象
     */
    private static Properties props;

    /**
     * 静态代码块为 Properties 对象赋值
     */
    static {
        try {
            // 实例化对象
            props = new Properties();
            // 使用类加载器获取配置文件位置，获取 properties 文件的流对象
            InputStream in = BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties");
            props.load(in);
        } catch (IOException e) {
            throw new ExceptionInInitializerError("初始化 properties 文件异常！");
        }
    }

    /**
     * 获取对象实例
     * @param beanName 对象实例名
     * @return {@link Object} 对象实例
     */
    public static Object getBean(String beanName) {
        Object bean = null;
        try {
            String beanPath = props.getProperty(beanName);
            //以反射的方式创建对象
            bean = Class.forName(beanPath).newInstance();
        }catch (Exception e) {
            e.printStackTrace();
        }
        return bean;
    }
}

此时，账户业务层实现类就可以这么写：

public class AccountServiceImpl implements IAccountService {
    // 通过工厂模式获取 AccountDaoImpl 的实例
    private IAccountDao accountDao = (IAccountDao) BeanFactory.getBean("accountDao");
    @Override
    public void saveAccount() {
        accountDao.saveAccount();
    }
}

表现层这么写：

public class Test {
    public static void main(String[] args) {
        IAccountService as = (AccountServiceImpl) BeanFactory.getBean("accountService");
        as.saveAccount();
    }
}

这时候相比之前耦合程度就大大降低了，这时候尽管删除持久层包下的实现类 AccountDaoImpl，编译是不会出错，但是没有该类是肯定运行不了。编译器会报 java.lang.ClassNotFoundException 异常，而不是 Error。
耦合只是相对而言，工厂模式也不是完美的，仍然存在很多可以优化的地方，但是可以减少部分耦合就是对程序性能的一个大幅度的提升。

代码的进一步改写

BeanFactory中有这么一句：bean = Class.forName(beanPath).newInstance();，这就使得每次都会调用默认构造函数创建对象，前提是我们的对象只能newInstance一次，由于创建对象后，不存起来，那么java的垃圾回收机制就会在长时间不用后将其回收，下次再用的时候肯定就没有了，所以这并不是一个单例的。
ps：多例相对于单例来说，对象被创建多次，执行效率没有单例对象高！newinstance()和new的区别?

改写BeanFactory：
思路：当newInstance创建对象后，需要将对象存起来。用什么存？Map！！！

public class BeanFactory {
    //定义一个Properties对象
    private static Properties props;

    //定义一个Map,用于存放我们要创建的对象。我们把它称之为容器
    private static Map<String,Object> beans;

    //使用静态代码块为Properties对象赋值
    static {
        try {
            //实例化对象
            props = new Properties();
            //获取properties文件的流对象
            InputStream in = BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties");
            props.load(in);
            //实例化容器
            beans = new HashMap<String,Object>();
            //取出配置文件中所有的Key
            Enumeration keys = props.keys();
            //遍历枚举
            while (keys.hasMoreElements()){
                //取出每个Key
                String key = keys.nextElement().toString();
                //根据key获取value
                String beanPath = props.getProperty(key);
                //反射创建对象
                Object value = Class.forName(beanPath).newInstance();
                //把key和value存入容器中
                beans.put(key,value);
            }
        }catch(Exception e){
            throw new ExceptionInInitializerError("初始化properties失败！");
        }
    }

    /**
     * 根据bean的名称获取对象
     * @param beanName
     * @return
     */
    public static Object getBean(String beanName){
        return beans.get(beanName);
    }

}