分析程序耦合与解耦思路

男娘i 2022-10-25 01:30 176阅读 0赞

程序间耦合是指程序之间的依赖关系。我们开发的程序如果耦合度太高就会导致独立性太差，所以软件开发应该遵循高内聚，低耦合的设计标准。依赖一般分为类之间的依赖和方法之间的依赖。那么如何降低程序间的依赖呢？在开发中，应该做到程序在编译的时候不依赖，在运行的时候才依赖，我们可以通过两个步骤来分析实现。

*  第一：使用反射来创建对象，避免使用new关键字创建；
 *  第二：通过配置文件来获取要创建对象的全限定类名。通过以上两步即可做到完美解耦。

### 1、程序耦合 ###

案例：

我们做一个模拟保存用户的例子，在有解耦意识之前，我们的代码是这样的：

package cn.com.gjw.dao;
     
    //用户持久层接口
    public interface UserDao {
        
    	void saveUser();
    }

package cn.com.gjw.dao.impl;
     
    import cn.com.gjw.dao.UserDao;
    //用户持久层接口实现类
    public class UserDaoImpl implements UserDao {
        
     
    	@Override
    	public void saveUser() {
        
    		System.out.println("模拟保存用户信息。。。");
    	}
     
    }

package cn.com.gjw.service;
    //用户业务层接口
    public interface UserService {
        
     
    	void saveUser();
    }

package cn.com.gjw.service.impl;
     
    import cn.com.gjw.dao.UserDao;
    import cn.com.gjw.dao.impl.UserDaoImpl;
    import cn.com.gjw.service.UserService;
     
    public class UserServiceImpl implements UserService {
        
     
    	private UserDao dao = new UserDaoImpl();
    	@Override
    	public void saveUser() {
        
    		dao.saveUser();
    	}
     
    }

package cn.com.gjw.test;
     
    import cn.com.gjw.service.UserService;
    import cn.com.gjw.service.impl.UserServiceImpl;
     
    public class Test2 {
        
     
    	public static void main(String[] args) {
        
    		UserService service = new UserServiceImpl();
    		service.saveUser();
    	}
    }

main函数依赖UserServiceImpl类才能编译成功，同样，UserServiceImplement类依赖UserDaoImpl才能编译成功，足以看出耦合度很高。

### 2、解耦 ###

那么接下来我们通过解耦来提高程序的独立性：

首先创建一个属性文件（`beans.properties`），以键值对的形式存放以下内容：

userService=cn.com.gjw.service.impl.UserServiceImpl
    userDao=cn.com.gjw.dao.impl.UserDaoImpl

其次再创建一个**Bean工厂**，由工厂代替new关键字为我们创建对象：

/**
     * 一个创建Bean对象的工程
     *
     *  Bean：在计算机英语中，有可重用组件的含义
     *  JavaBean：用java语言编写的可重用组件。
     *      javaBean > 实体类
     *
     *  它就是用来创建service和dao对象的。
     *
     *  第一个：需要一个配置文件配置我们的service和dao
     *          配置内容：唯一标识符=全限定类名（key = value）
     *  第二个：通过读取配置文件中配置的内容，反射创建对象
     *
     *  配置文件可以是xml也可以是properties
     */
    public class BeanFactory {
        
        //定义Properties对象
        private static Properties props;
    
        //使用静态代码块为Properties赋值
        static{
        
            try {
        
                //1.实例化对象
                props = new Properties();
                //2.获取properties文件的流对象
                InputStream in = BeanFactory.class.getClassLoader().getResourceAsStream("beans.properties");
                props.load(in);
    
            } catch (Exception 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);
                System.out.println(beanPath);
                bean = Class.forName(beanPath).newInstance();
            } catch (Exception e) {
        
                e.printStackTrace();
            }
            return bean;
        }
    }

此时，我们创建对象时，只需要调用BeanFactory类的getBean()方法即可。同时，我们对依赖的类也要做调整：

package cn.com.gjw.test;
     
    import cn.com.gjw.factory.BeanFactory;
    import cn.com.gjw.service.UserService;
     
    public class Test2 {
        
     
    	public static void main(String[] args) {
        
    		//UserService service = new UserServiceImpl();
    		UserService service = (UserService) BeanFactory.getBean("userService");
    		service.saveUser();
    	}
    }

package cn.com.gjw.service.impl;
     
    import cn.com.gjw.dao.UserDao;
    import cn.com.gjw.factory.BeanFactory;
    import cn.com.gjw.service.UserService;
     
    public class UserServiceImpl implements UserService {
        
     
    	//private UserDao dao = new UserDaoImpl();
    	private UserDao dao = (UserDao) BeanFactory.getBean("userDao");
    	
    	@Override
    	public void saveUser() {
        
    		dao.saveUser(); 
    	}
     
    }

至此，我们已完成程序间解耦，此时，不管程序中缺少UserServiceImpl类还是缺少UserDaoImpl类，程序都能编译通过。

#### 1.1 多例模式转单例 ####

但是我们的Bean现在是`多例模式`，例如：

public static void main(String[] args) {
        
    		//UserService service = new UserServiceImpl();
    		for(int i = 0; i < 5; i++) {
        
    			UserService service = (UserService) BeanFactory.getBean("userService");
    			System.out.println(service);
    		}
    		//service.saveUser();
    	}

打印结果为：  
![在这里插入图片描述][20210130161355642.png]  
从打印结果可以看出，我们循环了5次，创建了5次service对象，这会影响我们程序的性能，最好使用单例模式，同样也要注意单例模式带来的多线程问题，因此在使用单例模式时，我们尽量把普通变量定义到方法内部，形成局部变量，对工厂类进行改进：

package cn.com.gjw.factory;
    //bean工厂
     
    import java.io.IOException;
    import java.io.InputStream;
    import java.util.Enumeration;
    import java.util.HashMap;
    import java.util.Map;
    import java.util.Properties;
     
    public class BeanFactory {
        
     
    	private static Properties props;
    	
    	//程序启动时，将所有的对象创建好，并存入map集合中，使用的时候直接从集合中拿，不需要再创建
    	private static Map<String, Object> beans = new HashMap<String, Object>();
    	
    	//静态代码块，只在程序启动时执行一次
    	static {
        
    		try {
        
    			props = new Properties();
    			//通过流的方式加载属性文件
    			InputStream in = BeanFactory.class.getClassLoader().getResourceAsStream("beans.properties");
    			props.load(in);
    			//从属性对象props中获取所有的键，是一个枚举类型的集合
    			Enumeration<Object> keys = props.keys();
    			//遍历
    			while(keys.hasMoreElements()) {
        
    				String key = keys.nextElement().toString();
    				String pathName = props.getProperty(key);
    				try {
        
    					Object value = Class.forName(pathName).newInstance();
    					beans.put(key, value);
    				} catch (Exception e) {
        
    					e.printStackTrace();
    				}
    			}
    		} catch (IOException e) {
        
    			e.printStackTrace();
    		}
    	}
    	
    	public static Object getBean(String beanName) {
        
    		return beans.get(beanName);
    	}
    	//通过bean的名称获取对象
    /*	public static Object getBean(String beanName) {
    		//bean的全限定类名
    		String beanPath = props.getProperty(beanName);
    		Object bean = null;
    		try {
    			bean = Class.forName(beanPath).newInstance();
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    		return bean;
    	}*/
    }

打印结果为：

com.study.iocbase.service.UserServiceImpl@61bbe9ba
    com.study.iocbase.service.UserServiceImpl@61bbe9ba
    com.study.iocbase.service.UserServiceImpl@61bbe9ba
    com.study.iocbase.service.UserServiceImpl@61bbe9ba
    com.study.iocbase.service.UserServiceImpl@61bbe9ba

此刻，已实现单例模式，并且成功完成解耦。

[20210130161355642.png]: /images/20221024/cc136549c7a348f88619f31760b3a88d.png