通过工厂类对程序进行解耦

业务层和持久层的耦合

模拟一个业务层：

package com.ethan.service;

/*
账户业务层的接口
 */
public interface AccountService {
    /*
    模拟保存账户
     */
    void saveAccount();
}

package com.ethan.service.impl;

import com.ethan.service.AccountService;
import com.ethan.dao.AccountDao;
import com.ethan.dao.impl.AccountDaoImpl;
/*
账户的业务层实现类
 */
public class AccountServiceImpl implements AccountService {
    private AccountDao accountDAO = new AccountDaoImpl();
    public void saveAccount() {
        accountDAO.saveAccount();
    }
}

模拟持久层：

package com.ethan.dao;

/*
账户的持久层接口
 */
public interface AccountDao {
    /*
    模拟保存账户
     */
    void saveAccount();
}

package com.ethan.dao.impl;

import com.ethan.dao.AccountDao;

public class AccountDaoImpl implements AccountDao {

    public void saveAccount() {
        System.out.println("保存了账户");
    }
}

项目结构如下：

由于业务层直接用new AccountDaoImpl()持有一个持久层对象，业务层和持久层产生了耦合，如果持久层AccountDao的实现类不存在，业务层代码将不能通过编译：

package com.ethan.service.impl;

import com.ethan.service.AccountService;
import com.ethan.dao.AccountDao;
import com.ethan.dao.impl.AccountDaoImpl;
/*
账户的业务层实现类
 */
public class AccountServiceImpl implements AccountService {
    private AccountDao accountDAO = new AccountDaoImpl();   //产生耦合，如果实现类不存在，将产生编译期错误
    public void saveAccount() {
        accountDAO.saveAccount();
    }
}

表现层和业务层的依赖

创建一个表现层：

package com.ethan.ui;

import com.ethan.service.AccountService;
import com.ethan.service.impl.AccountServiceImpl;

/*
模拟一个表现层，用于调用业务层
 */
public class Client {
    public static void main(String[] args) {
        AccountService as = new AccountServiceImpl();
        as.saveAccount();
    }
}

表现层存在同样的问题：表现层和业务层产生耦合。

package com.ethan.ui;

import com.ethan.service.AccountService;
import com.ethan.service.impl.AccountServiceImpl;

/*
模拟一个表现层，用于调用业务层
 */
public class Client {
    public static void main(String[] args) {
        AccountService as = new AccountServiceImpl();   //表现层调用业务层同样产生耦合
        as.saveAccount();
    }
}

如果表现层、业务层、持久层三者中的一个的实现类缺失，代码将不能通过编译。解决方案如下：

1. 创建Bean（可重用组件）对象的工厂

JavaBean：用java语言编写的可重用组件

我们用这个工厂保存这些对象（AccountService实现类对象和AccountDao实现类对象）。对于需要这些对象的类，不采用new的方式声明对象，而让它们向这个工厂申请所需要的对象。

2. 需要一个配置文件来配置我们的service和dao

   配置的内容：唯一标识 = 全限定类名 (key = value)

3. 工厂通过读取配置文件中配置的内容，反射创建对象

在resources下创建file如下：

该配置文件的内容如下：

accountService = com.ethan.service.impl.AccountServiceImpl
accountDao = com.ethan.dao.impl.AccountDaoImpl

在包下创建factory.BeanFactory

package com.ethan.factory;

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

public class BeanFactory {
    //定义一个Properties对象
    private static Properties props;
    //使用静态代码块加载配置文件
    static {
        //实例化对象
        props = new Properties();
        //获取Properties文件的流对象
        InputStream is = BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties");	//注意不要直接用路径创建InputStream，否则文件路径改变将加载不到配置文件
        try {
            props.load(is);
        } catch (IOException e) {
            throw new ExceptionInInitializerError("初始化properties失败");
        }
    }

    /**
     * 根据Bean的名称获取Bean对象
     * @param beanName
     * @return
     */
    public static Object getBean(String beanName) {
        Object bean = null;
        try{
            String beanPath = props.getProperty(beanName);	//从bean.properties获取全限定类名
            bean = Class.forName(beanPath).newInstance();	//反射创建对象
        } catch(Exception e) {
            e.printStackTrace();
        }
        return bean;
    }
}

这时业务层和表现层作相应变动，通过getBean()方法从工厂中获取对象：

package com.ethan.service.impl;

import com.ethan.factory.BeanFactory;
import com.ethan.service.AccountService;
import com.ethan.dao.AccountDao;
/*
账户的业务层实现类
 */
public class AccountServiceImpl implements AccountService {
    AccountDao accountDao = (AccountDao) BeanFactory.getBean("accountDao");	//实际得到一个accountDaoImpl对象
    public void saveAccount() {
        accountDao.saveAccount();
    }
}

package com.ethan.ui;

import com.ethan.factory.BeanFactory;
import com.ethan.service.AccountService;

/*
模拟一个表现层，用于调用业务层
 */
public class Client {
    public static void main(String[] args) {
        AccountService as = (AccountService) BeanFactory.getBean("accountService");
        as.saveAccount();
    }
}

这时即使业务层的实现类缺失、或者持久层的实现类缺失，程序在编译时也不会产生错误。但是上述代码的accountServiceImpl对象在被申请时创建，对于每一个申请，工厂都新创建一个对象，这时工厂是多例的。

单例模式

每次表现层的代码执行，BeanFactory中将创建新的对象，即这时工厂类是多例的。而如果从始至终只使用一个对象，那么我们称这个类是单例的，这时类成员只被创建一次，从而类成员只会被初始化一次。

单例模式最初的定义出现于《设计模式》（艾迪生维斯理, 1994）：“保证一个类仅有一个实例，并提供一个访问它的全局访问点。”
Java中单例模式定义：“一个类有且仅有一个实例，并且自行实例化向整个系统提供。”

我们可以用静态代码块根据配置文件创建对象，并将这些对象保存在容器中。每当表现层请求对象，我们就从容器中取出对象，这时表现层使用的均是同一个对象。
工厂类：

package com.ethan.factory;

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

/**
 * @author Ethan
 * @date 2020/1/18 - 12:16
 */

public class BeanFactory {
    private static Properties props;

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

    //使用静态代码块为Properties对象赋值
    static {
        try {
            props = new Properties();
            //获取Properties文件的流对象
            InputStream is = BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties");
            props.load(is);
            //实例化容器
            beans = new HashMap<String, Object>();
            //取出配置文件中所有的key
            Enumeration keys = props.keys();
            while(keys.hasMoreElements()){
                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的名称获取对象
    public static Object getBean(String beanName){
        return beans.get(beanName);
    }

}

表现层：

package com.ethan.ui;

import com.ethan.factory.BeanFactory;
import com.ethan.service.AccountService;

/*
模拟一个表现层，用于调用业务层
 */
public class Client {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            AccountService as = (AccountService) BeanFactory.getBean("accountService"); //每次都得到同一个对象
            System.out.println(as);
            as.saveAccount();
        }
    }
}

总结

• 用工厂模式提供对象，实现了类之间的解耦，只需将创建对象的工作交给工厂；
• 如果创建一个对象比较复杂，需要许多参数时，使用工厂类则可以屏蔽创建这个对象的细节；
• 工厂可以将可重用对象保存在容器中，需要时直接分配对象；
• 工厂可以隐藏提供对象的真实类型，如提供抽象类的一个继承类的对象；
• 可能需要的对象之间有复杂的依赖关系，把创建对象工作交给工厂更为方便；
• 工厂可以更好地把握创建对象的时机；
• 实际生产中，是否选用工厂模式需要考虑业务的变化和成本。