程序中的耦合及用工厂模式进行解耦 （Spring IOC 思想）

什么是程序的耦合

耦合性(Coupling)，也叫耦合度，是对模块间关联程度的度量。耦合的强弱取决于模块间接口的复杂性、调用模块的方式以及通过界面传送数据的多少。模块间的耦合度是指模块之间的依赖关系，包括控制关系、调用关系、数据传递关系。模块间联系越多，其耦合性越强，同时表明其独立性越差（降低耦合性，可以提高其独立性）。耦合性存在于各个领域，而非软件设计中独有的，但是我们只讨论软件工程中的耦合。

总结：在软件工程中，耦合指的就是指对象之间的依赖关系。对象之间的依赖程度越高，耦合度就越高。对象之间的耦合越高，维护成本越高。因此对象的设计应使类和构件之间的耦合最小。

降低程序之间的依赖程度，即降低程序之间的耦合度的过程就叫做解耦。

案例举例：

早期的Jdbc操作中，在注册数据库驱动时，为什么采用的是Class.forName的方式，而不是采用DriverManager.registerDriver的方式?

public class TestJdbc {
  public static void main(String[] args) throws Exception {
    //1.注册数据库驱动
    // DriverManager.registerDriver( new Driver() );
    Class.forName("com.mysql.jdbc.Driver");
    //2.获取数据库连接
    //3.获取传输器
    //4.发送sql到服务器执行并返回执行结果
    //5.处理结果
    //6.释放资源
  }
}

除了DriverManager.registerDriver会导致驱动注册两次外，更重要的是，如果使用这种方式，JDBC程序就会依赖于数据库的驱动类（MySQL的Driver类），如果后期程序因数据量和性能原因升级到Oracle数据库，就需要修改程序源代码——重新导入新的驱动类，这会增加很多不必要的麻烦！

而是用Class.forName方式注册驱动，这样的好处是Jdbc程序不再依赖具体的驱动类，即使删除（或不导入）mysql驱动包，程序依然可以编译（当然不可能运行，因为运行时肯定需要依赖驱动）。

此时类中仅仅是将mysql驱动类的全限定类名写死在程序中（只是一个字符串），可以将这个字符串提取到配置文件中，后期可以通过修改配置文件（而不用修改程序代码）轻松的替换数据库产品。

工厂模式解耦介绍

在实际开发中可以将三层（表现层、业务层、持久层）的对象都使用配置文件配置起来，当启动服务器加载应用时，可以通过工厂读取配置文件，根据配置文件中的配置将这些对象创建出来，在接下来使用的时候，直接拿过来使用即可。

那么，这个负责读取配置文件，根据配置文件创建并返回这些对象的类就是工厂。

可以通过【工厂+接口+配置文件】的方式解除程序中的耦合。

问题引入

首先我们创建一个maven工程：
1、创建持久层接口和接口实现类

com.qiu.dao.WorkerDao （接口）

com.qiu.dao.WorkerDaoImpl （实现类）

2、创建业务层接口和接口实现类

com.qiu.service.WorkerService （接口）

com.qiu.service.WorkerServiceImpl （实现类）

3、创建表现层测试程序（com.qiu.controller.WorkerController）并运行测试程序:

详细代码如下：
1、创建持久层接口（com.qiu.dao.WokerDao）

package com.qiu.dao;
/**
 * 员工模块的Dao(持久层)接口
 */
public interface WorkerDao {
	/**添加员工信息*/
	public void addWorker();
}

2.创建持久层接口实现类（com.qiu.dao.WorkerDaoImpl）

package com.qiu.dao;

public class WorkerDaoImpl implements WorkerDao{
	@Override
	public void addWorker() {
		System.out.println("Dao层的Worker()方法执行了.."
				+ "成功保存了一条员工信息..");
	}
}

3、创建业务层接口（com.qiu.service.WorkerService）

package com.qiu.Service;
/**
 * 员工模块的service(业务层)接口
 */
public interface WorkerService {
	/** 添加员工信息 */
	public void addWorker();
}

4、创建业务层接口实现类（com.qiu.service.WorkerServiceImpl）

package com.qiu.Service;

import com.qiu.dao.WorkerDao;
import com.qiu.dao.WorkerDaoImpl;

/**
 * 员工模块的service(业务层)接口实现类
 * service层 ---> dao层
 */
public class WorkerServiceImpl implements WorkerService{
	private WorkerDao workerDao=new WorkerDaoImpl();
	@Override
	public void addWorker() {
		System.out.println("调用dao层的方法添加员工信息...");
		workerDao.addWorker();
	}
}

5、创建表现层测试类（com.qiu.controller.WorkerController）

package com.qiu.controller;

import org.junit.Test;

import com.qiu.Service.WorkerService;
import com.qiu.Service.WorkerServiceImpl;

/**
 * 模拟表现层 
 * controller --> service --> dao
 */
public class WorkerController {
	/* 获取Service接口的子类实例
	 * ——这里使用new对象的方式造成了程序之间的耦合性提升 */
	private WorkerService service = new WorkerServiceImpl();
	
	@Test
	public void testAddEmp() {
		System.out.println("调用service层的方法添加员工信息...");
		service.addWorker();
	}
}

在上面的程序中，WorkerController中要调用Service层的方法，所以通过new对象的形式获取了WokerService接口子类的实例，代码如下：

private WorkerService service = new WorkerServiceImpl();

在WorkerService的实现类中要调用Dao层的方法，所以通过new对象的形式获取了WorkerDao接口子类的实例，代码如下：

private WorkerDao dao = new WorkerDaoImpl();

如果在上面的程序中将WorkerDaoImpl或者WorkerServiceImpl移除，会导致其他类中的代码编译错误。此时表现层和业务层，及业务层和持久层之间的依赖程度过高，如果将来替换某一层，很可能会造成其他层无法运行，只能通过修改程序代码保证程序运行，这样依赖就会提高维护成本以及造成不必要的麻烦。
而在程序中new对象的方式造成了这种程序之间的依赖程度提升，即提升了程序之间的耦合性。

解决办法：

我们可以通过工厂模式+配置文件+接口方式来解决这一问题：
1、通过工程+配置文件+接口（已有）方式解耦

(1)创建工厂类（com.qiu.factory.BeanFactory）并实现

(2)提供配置文件，将service接口和dao接口的实现类的全限定类名编写到配置文件中。

2、使用工厂获取service接口和dao接口的实例，替换使用new的方式获取接口的实例。

使用工厂+配置文件+接口解耦代码如下：
1、创建com.tedu.factory.BeanFactory类，用于创建各个层所需要的对象。

package com.qiu.factory;

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

public class BeanFactory {
	//声明一个Properties对象，在静态代码块中对其进行初始化
		private static Properties prop;
		static {
			try {
				//为prop进行实例化
				prop = new Properties();
				//获取配置文件的流对象
				InputStream in = BeanFactory.class.getClassLoader()
						.getResourceAsStream("config.properties");
				//将配置文件中的内容读取到Properties对象中
				prop.load( in );
			} catch (Exception e) {
				e.printStackTrace();
				throw new RuntimeException("初始化Properties对象失败!");
			}
		}
		
		/**
		 * 根据config.xml文件中的key获取对应class类的实例
		 * @param key 
		 * @return
		 */
		public static Object getBean(String key) {
			Object bean = null;
			try {
				String className = prop.getProperty( key );
				bean = Class.forName(className).newInstance();
			} catch (Exception e) {
				e.printStackTrace();
			}
			return bean;
		}
	}	

2、在源码目录下创建一个config.properties文件，文件内容配置如下：

EmpService=com.qiu.service.WorkerServiceImpl
EmpDao=com.qiu.dao.WorkerDaoImpl

3.将WorkerController类中通过 “new对象的形式获取了WokerService接口子类的实例” 以及在WorkerServiceImpl类中通过 “new对象的形式获取了WorkerDao接口子类的实例” 改为使用BeanFactory工厂获取Service和Dao层的实例。如下：

/* 获取Service接口的子类实例
 * ——这里使用new对象的方式造成了程序之间的耦合性提升 */
//private WorkerService service = new WorkerServiceImpl();
private WorkerService service = (WorkerService)BeanFactory.getBean("WorkerService");

/* 获取Dao接口的子类实例 * ——这里使用new对象的方式造成了程序之间的耦合性提升 */
//private WorkerDao dao = new WorkerDaoImpl();
private WorkerDao dao = (WorkerDao)BeanFactory.getBean( "WorkerDao" );