使用 spring 的 IOC 解決程序耦合

工廠模式解耦

在實際開發中咱們能夠把三層的對象都使用配置文件配置起來，當啓動服務器應用加載的時候，讓一個類中的方法經過讀取配置文件，把這些對象建立出來並存起來。在接下來的使用的時候，直接拿過來用就行了。

那麼，這個讀取配置文件，建立和獲取三層對象的類就是工廠。

簡單工廠模式(Simple Factory Pattern)：又稱爲靜態工廠方法(Static Factory Method)模式，它屬於類建立型模式。在簡單工廠模式中，能夠根據參數的不一樣返回不一樣類的實例。簡單工廠模式專門定義一個類來負責建立其餘類的實例，被建立的實例一般都具備共同的父類。簡單點說就是用來建立具備相同基類的對象

簡單工廠模式最大的優勢在於實現對象的建立和對象的使用分離，將對象的建立交給專門的工廠類負責，可是其最大的缺點在於工廠類不夠靈活，增長新的具體產品須要修改工廠類的判斷邏輯代碼，並且產品較多時，工廠方法代碼將會很是複雜。

簡單工廠模式適用狀況包括：客戶端只知道傳入工廠類的參數，對於如何建立對象不關心；工廠類負責建立的對象比較少。

 

1、程序的耦合

（劃分模塊的一個準則就是高內聚低耦合）

耦合性(Coupling)，也叫耦合度，是對模塊間關聯程度的度量。耦合的強弱取決於模塊間接口的複雜性、調用模塊的方式以及經過界面傳送數據的多少。

模塊間的耦合度是指模塊之間的依賴關係，包括控制關係、調用關係、數據傳遞關係。模塊間聯繫越多，其耦合性越強，同時代表其獨立性越差( 下降耦合性，能夠提升其獨立性)。耦合性存在於各個領域，而非軟件設計中獨有的，可是咱們只討論軟件工程中的耦合。

在軟件工程中，耦合指的就是就是對象之間的依賴性。對象之間的耦合越高，維護成本越高。所以對象的設計應使類和構件之間的耦合最小。

軟件設計中一般用耦合度和內聚度做爲衡量模塊獨立程度的標準。

 

耦合是影響軟件複雜程度和設計質量的一個重要因素，在設計上咱們應採用如下原則：若是模塊間必須存在耦合，就儘可能使用數據耦合，少用控制耦合，限制公共耦合的範圍，儘可能避免使用內容耦合。

 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4     xsi:schemaLocation="http://www.springframework.org/schema/beans
 5     http://www.springframework.org/schema/beans/spring-beans-3.1.xsd ">
 6     
 7     <!-- 定義userDaoImpl對象,並指定id爲userDaoImpl -->
 8     <bean id="userDaoImpl" class="cn.bdqn.biz.dao.impl.UserDaoImpl" />
 9     <!-- 定義User對象,並指定id爲user -->
10     <bean id="user" class="cn.bdqn.biz.pojo.User" />
11     
12     <!-- 定義UserServiceImpl對象,並指定id爲userServiceImpl -->
13     <bean id="userServiceImpl" class="cn.bdqn.biz.service.impl.UserServiceImpl">
14         <!--爲userServiceImpl的userDao屬性賦值,須要注意的是,這裏要調用setUserDao()方法 -->
15         <property name="userDao">
16             <!-- 引用id爲userDao的對象爲userServiceImpl的userDao屬性賦值 -->
17             <ref bean="userDaoImpl" />
18         </property>
19     </bean>
20     
21 </beans>

 

二、解決程序耦合的思路

一、當是咱們講解 jdbc 時，是經過反射來註冊驅動的，代碼以下：Class.forName("com.mysql.jdbc.Driver");//此處只是一個字符串

二、此時的好處是，咱們的類中再也不依賴具體的驅動類，此時就算刪除 mysql 的驅動 jar 包，依然能夠編譯（運行就不要想了，沒有驅動不可能運行成功的）。同時，也產生了一個新的問題，mysql 驅動的全限定類名字符串是在 java 類中寫死的，一旦要改仍是要修改源碼。解決這個問題也很簡單，使用配置文件配置。

三、代碼實現：持久層，業務層，變現層

 

當咱們講解jdbc時，是經過反射來註冊驅動的，代碼以下：　Class.forName("com.mysql.jdbc.Driver");

這時的好處是，咱們的類中再也不依賴具體的驅動類，此時就算刪除mysql的驅動jar包，依然能夠編譯。可是由於沒有驅動類，因此不能運行。

不過，此處也有個問題，就是咱們反射類對象的全限定類名字符串是在java類中寫死的，一旦要改仍是要修改源碼。

解決這個問題也很簡單，使用配置文件配置。

 

在實際開發中咱們能夠把全部的dao和service和action對象使用配置文件配置起來，當啓動服務器應用加載的時候，經過讀取配置文件，把這些對象建立出來並存起來。在接下來的使用的時候，直接拿過來用就行了。

 

package com.ioc.spring.util;

import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import java.net.JarURLConnection;
import java.net.URL;
import java.net.URLDecoder;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;

/**
 * 獲取某個包下面的全部類信息
 */
public class Util {

   /**
    * 取得某個接口下全部實現這個接口的類
    */
   public static List<Class> getAllClassByInterface(Class c) {
      List<Class> returnClassList = null;

      if (c.isInterface()) {
         // 獲取當前的包名
         String packageName = c.getPackage().getName();
         // 獲取當前包下以及子包下因此的類
         List<Class<?>> allClass = getClasses(packageName);
         if (allClass != null) {
            returnClassList = new ArrayList<Class>();
            for (Class classes : allClass) {
               // 判斷是不是同一個接口
               if (c.isAssignableFrom(classes)) {
                  // 自己不加入進去
                  if (!c.equals(classes)) {
                     returnClassList.add(classes);
                  }
               }
            }
         }
      }

      return ClassList;
   }

   /*
    * 取得某一類所在包的全部類名 不含迭代
    */
   public static String[] getPackageAllClassName(String classLocation, String packageName) {
      // 將packageName分解
      String[] packagePathSplit = packageName.split("[.]");
      String realClassLocation = classLocation;
      int packageLength = packagePathSplit.length;
      for (int i = 0; i < packageLength; i++) {
         realClassLocation = realClassLocation + File.separator + packagePathSplit[i];
      }
      File packeageDir = new File(realClassLocation);
      if (packeageDir.isDirectory()) {
         String[] allClassName = packeageDir.list();
         return allClassName;
      }
      return null;
   }

   /**
    * 從包package中獲取全部的Class
    * @param packageName
    * @return
    */
   public static List<Class<?>> getClasses(String packageName) {

      // 第一個class類的集合
      List<Class<?>> classes = new ArrayList<Class<?>>();
      // 是否循環迭代
      boolean recursive = true;
      // 獲取包的名字 並進行替換
      String packageDirName = packageName.replace('.', '/');
      // 定義一個枚舉的集合 並進行循環來處理這個目錄下的things
      Enumeration<URL> dirs;
      try {
         dirs = Thread.currentThread().getContextClassLoader().getResources(packageDirName);
         // 循環迭代下去
         while (dirs.hasMoreElements()) {
            // 獲取下一個元素
            URL url = dirs.nextElement();
            // 獲得協議的名稱
            String protocol = url.getProtocol();
            // 若是是以文件的形式保存在服務器上
            if ("file".equals(protocol)) {
               // 獲取包的物理路徑
               String filePath = URLDecoder.decode(url.getFile(), "UTF-8");
               // 以文件的方式掃描整個包下的文件 並添加到集合中
               findAndAddClassesInPackageByFile(packageName, filePath, recursive, classes);
            } else if ("jar".equals(protocol)) {
               // 若是是jar包文件
               // 定義一個JarFile
               JarFile jar;
               try {
                  // 獲取jar
                  jar = ((JarURLConnection) url.openConnection()).getJarFile();
                  // 今後jar包 獲得一個枚舉類
                  Enumeration<JarEntry> entries = jar.entries();
                  // 一樣的進行循環迭代
                  while (entries.hasMoreElements()) {
                     // 獲取jar裏的一個實體 能夠是目錄 和一些jar包裏的其餘文件 如META-INF等文件
                     JarEntry entry = entries.nextElement();
                     String name = entry.getName();
                     // 若是是以/開頭的
                     if (name.charAt(0) == '/') {
                        // 獲取後面的字符串
                        name = name.substring(1);
                     }
                     // 若是前半部分和定義的包名相同
                     if (name.startsWith(packageDirName)) {
                        int idx = name.lastIndexOf('/');
                        // 若是以"/"結尾 是一個包
                        if (idx != -1) {
                           // 獲取包名 把"/"替換成"."
                           packageName = name.substring(0, idx).replace('/', '.');
                        }
                        // 若是能夠迭代下去 而且是一個包
                        if ((idx != -1) || recursive) {
                           // 若是是一個.class文件 並且不是目錄
                           if (name.endsWith(".class") && !entry.isDirectory()) {
                              // 去掉後面的".class" 獲取真正的類名
                              String className = name.substring(packageName.length() + 1, name.length() - 6);
                              try {
                                 // 添加到classes
                                 classes.add(Class.forName(packageName + '.' + className));
                              } catch (ClassNotFoundException e) {
                                 e.printStackTrace();
                              }
                           }
                        }
                     }
                  }
               } catch (IOException e) {
                  e.printStackTrace();
               }
            }
         }
      } catch (IOException e) {
         e.printStackTrace();
      }

      return classes;
   }

   /**
    * 以文件的形式來獲取包下的全部Class
    * 
    * @param packageName
    * @param packagePath
    * @param recursive
    * @param classes
    */
   public static void findAndAddClassesInPackageByFile(String packageName, String packagePath, final boolean recursive,
         List<Class<?>> classes) {
      // 獲取此包的目錄 創建一個File
      File dir = new File(packagePath);
      // 若是不存在或者 也不是目錄就直接返回
      if (!dir.exists() || !dir.isDirectory()) {
         return;
      }
      // 若是存在 就獲取包下的全部文件 包括目錄
      File[] dirfiles = dir.listFiles(new FileFilter() {
         // 自定義過濾規則 若是能夠循環(包含子目錄) 或則是以.class結尾的文件(編譯好的java類文件)
         public boolean accept(File file) {
            return (recursive && file.isDirectory()) || (file.getName().endsWith(".class"));
         }
      });
      // 循環全部文件
      for (File file : dirfiles) {
         // 若是是目錄 則繼續掃描
         if (file.isDirectory()) {
            findAndAddClassesInPackageByFile(packageName + "." + file.getName(), file.getAbsolutePath(), recursive,
                  classes);
         } else {
            // 若是是java類文件 去掉後面的.class 只留下類名
            String className = file.getName().substring(0, file.getName().length() - 6);
            try {
               // 添加到集合中去
               classes.add(Class.forName(packageName + '.' + className));
            } catch (ClassNotFoundException e) {
               e.printStackTrace();
            }
         }
      }
   }
}

 

上面解耦的思路有2個問題：

一、存哪去？

分析：因爲咱們是不少對象，確定要找個集合來存。這時候有Map和List供選擇。到底選Map仍是List就看咱們有沒有查找需求。有查找需求，選Map。

因此咱們的答案就是：

在應用加載時，建立一個Map，用於存放action，Service和dao對象。咱們把這個map稱之爲容器。

 

二、仍是沒解釋什麼是工廠？

工廠就是負責給咱們從容器中獲取指定對象的類。這時候咱們獲取對象的方式發生了改變。

原來，咱們在獲取對象時，都是採用new的方式。是主動的。如今：咱們獲取對象時，同時跟工廠要，有工廠爲咱們查找或者建立對象是被動的。

這種被動接收的方式獲取對象的思想就是控制反轉，它是spring框架的核心之一。它的做用只有一個：削減計算機程序的耦合。