BeanFactory 解决程序间的耦合

1. 什么是程序的耦合 

耦合性(Coupling)，也叫耦合度，是对模块间关联程度的度量。耦合的强弱取决于模块间接口的复杂性、调 用模块的方式以及通过界面传送数据的多少。模块间的耦合度是指模块之间的依赖关系，包括控制关系、调用关
系、数据传递关系。模块间联系越多，其耦合性越强，同时表明其独立性越差( 降低耦合性，可以提高其独立 性)。耦合性存在于各个领域，而非软件设计中独有的，但是我们只讨论软件工程中的耦合。 在软件工程中，耦合指的就是就是对象之间的依赖性。对象之间的耦合越高，维护成本越高。因此对象的设计
应使类和构件之间的耦合最小。软件设计中通常用耦合度和内聚度作为衡量模块独立程度的标准。划分模块的一个 准则就是高内聚低耦合

     分类:

（1） 内容耦合。当一个模块直接修改或操作另一个模块的数据时，或一个模块不通过正常入口而转入另 一个模块时，这样的耦合被称为内容耦合。内容耦合是最高程度的耦合，应该避免使用之。

 （2） 公共耦合。两个或两个以上的模块共同引用一个全局数据项，这种耦合被称为公共耦合。在具有大 量公共耦合的结构中，确定究竟是哪个模块给全局变量赋了一个特定的值是十分困难的。

 （3） 外部耦合 。一组模块都访问同一全局简单变量而不是同一全局数据结构，而且不是通过参数表传 递该全局变量的信息，则称之为外部耦合。  

 （4） 控制耦合 。一个模块通过接口向另一个模块传递一个控制信号，接受信号的模块根据信号值而进 行适当的动作，这种耦合被称为控制耦合。  

 （5） 标记耦合 。若一个模块 A 通过接口向两个模块 B 和 C 传递一个公共参数，那么称模块 B 和 C 之间 存在一个标记耦合。

 （6） 数据耦合。模块之间通过参数来传递数据，那么被称为数据耦合。数据耦合是最低的一种耦合形 式，系统中一般都存在这种类型的耦合，因为为了完成一些有意义的功能，往往需要将某些模块的输出数据作为另
一些模块的输入数据。

 （7） 非直接耦合 。两个模块之间没有直接关系，它们之间的联系完全是通过主模块的控制和调用来实 现的。

2. 解决耦合的思路( 开发中 有些依赖关系是必须的  有些关系可以通过代码优化来解决)

//通过new来注册驱动  =>  通过反射来注册驱动的： 
DriverManager.registerDriver(new com.mysql.jdbc.Driver()) =>Class.forName("com.mysql.jdbc.Driver")

 此时的好处是，我们的类中不再依赖具体的驱动类，此时就算删除 mysql 的驱动 jar 包，依然可以编译。但是也产生了一个新的问题，mysql 驱动的全限定类名字符串是在 java 类中写死的，一旦要改还是要修改 源码。 解决这个问题可以，使用配置文件配置。 

3. 工厂模式解耦

     在实际开发中我们可以把三层的对象都使用配置文件配置起来，当启动服务器应用加载的时候，让一个类中的
方法通过读取配置文件，把这些对象创建出来并存起来。在接下来的使用的时候，直接拿过来用就好了。 那么，这个读取配置文件，创建和获取三层对象的类就是工厂。 

package com.zsw.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 Devin
 * @version 1.0
 * @date 2019/7/16 0:27
 * 一个创建Bean对象的工厂
 
 *   我的配置文件可以是xml也可以是properties
 */
public class BeanFactory {
    private static Properties props;
    //自定义Map 存放bean对象
    private static Map<String,Object> beans;
    static {
       try {
           props = new Properties();
           InputStream in = BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties");
           props.load(in);
           beans = new HashMap<String, Object>();
           //获取配文件中所有的key
           Enumeration<Object> keys = props.keys();
           while(keys.hasMoreElements()){
               String key = keys.nextElement().toString();
               //根据key 获取value
               String beanPath = props.getProperty(key);
               try {
                   Object o = Class.forName(beanPath).newInstance();
                   beans.put(key,o);
               } catch (ClassNotFoundException e) {
                   e.printStackTrace();
               } catch (IllegalAccessException e) {
                   e.printStackTrace();
               } catch (InstantiationException e) {
                   e.printStackTrace();
               }

           }

       } catch (IOException e) {
            e.printStackTrace();
            throw new ExceptionInInitializerError("properties初始化失败");
        }

    }

    /**
     * 根据bean名车获取bean对象
     * @param beanName
     * @return
     */
//    public static Object getBean(String beanName)  {
//        Object bean = null;
//        try {
//            String beanPath = props.getProperty(beanName);
//            System.out.println(beanPath);
//            bean = Class.forName(beanPath).newInstance();
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//        return bean;
//    }

    public static Object getBean(String beanName)  {
        Object bean = beans.get(beanName);
        return bean;
    }


}

bean.xml

   创建出来的对象存在哪?  ==> 在应用加载时，创建一个 Map，用于存放三层对象。    我们把这个 map 称之为容器。 

   什么是工厂 ==> 工厂就是负责给我们从容器中获取指定对象的类。这时候我们获取对象的方式发生了改变 一开始我们获取对象采用new的方式 是主动的 ,现在 我们获取对象时，同时跟工厂要，有工厂为我们查找或者创建对象。是被动的。