耦合度分析,振动的耦合与解耦

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

首先，使用反射创建对象，但不要使用new关键字。 第二，获取从配置文件中创建对象的完全限定类名。 以上2个阶段可以完美地解除结合。 1、程序结合案例：

让我们看一下模拟保存用户的示例。 在意识到去耦之前，我们的代码是这样的：

package cn.com.gjw.dao； //用户持久层界面publicinterfaceuserdao { voidsaveuser (； } package cn.com.gjw.dao.impl； import cn.com.gjw.dao.UserDao； //用户持久层接口实现类publicclassuserdaoimplimplementsuserdao { @ overridepublicvoidsaveuser () } { system.out.println (伪。 请参阅。 )； } } package cn.com.gjw.service； //用户业务层界面publicinterfaceuserservice { voidsaveuser (； } package cn.com.gjw.service.impl； import cn.com.gjw.dao.UserDao； import cn.com.gjw.Dao.impl.userdao impl； import cn.com.gjw.service.userservice； publicclassuserserviceimplimplementsuserservice { privateuserdaodao=newuserdaoimpl (； @Overridepublic 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{ publicstaticvoidmain (string [ ] args ) userserviceservice=newuserserviceimpl }； service.saveUser (； } }可以看到，}} main函数依赖于UserServiceImpl类成功编译，同样，UserServiceImplement类依赖于UserDaoImpl成功编译，耦合度高。

2、解除耦合后，接下来通过解除耦合来提高程序的独立性。

首先，创建属性文件" beans.properties "，并将以下内容存储为键值对：

在userservice=cn.com.gjw.service.impl.userserviceimpluserdao=cn.com.gjw.Dao.impl.userdao impl之后添加3358wwwl

创建* * Bean对象的工程* * Bean :在计算机英语中，它的意思是可复用组件。 * JavaBean :用Java语言编写的可重用组件。 * javaBean实体类* *它用于创建服务和dao对象。 *第一：需要配置服务和dao *配置文件。 唯一标识符=完全限定类名(key=value )第二个：通过读取配置文件中配置的内容创建反射对象* *配置文件为xml或properties */public class beanfaction //使用静态代码块将static{ try { //1.实例化对象props=new Properties (； 获取//2.properties文件的流对象inputstream in=beanfactory.class.getclass loader (.getresourceasstream (' beans.beans ) ) }catch(exceptione ) thrownewexceptioninitializererror (' properties初始化失败！' )； 从}/***Bean的名称中获取bean对象* @param beanName * @return */publ

ic 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");@Overridepublic 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();}

打印结果为：

从打印结果可以看出，我们循环了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@61bbe9bacom.study.iocbase.service.UserServiceImpl@61bbe9bacom.study.iocbase.service.UserServiceImpl@61bbe9bacom.study.iocbase.service.UserServiceImpl@61bbe9bacom.study.iocbase.service.UserServiceImpl@61bbe9ba

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