spring的設計思想

在學習Spring框架的時候, 第一件事情就是分析Spring的設計思想

在學習Spring的時候, 需要先了解耦合和解耦的概念

耦合: 簡單來說, 在軟件工程當中, 耦合是指對象之間的相互依賴

耦合的壞處: 耦合提升了代碼的復雜度, 不利於開發和維護, 低耦合是軟件系統架構設計的原則之一

為什么需要Spring?

Spring能夠統一的管理bean對象, 當需要什么對象, 我們就去從Spring中獲取對應的對象, 而不再需要去new新建出來, 大大的簡化了對象的管理(創建, 調用和配置文件的讀取)等工作! 

Spring解決了耦合問題, 降低了對象之間的相互依賴關系

Spring解決了什么問題?

簡單來說，就是處理對象的創建的、以及對象的依賴關系！

Spring的基本實現思路是什么樣的? 

1.第一步, 最原始的, 使用new()方法來創建對象

   不足: 這導致了程序的高耦合性, 如果需要新建的對象還沒有被實現, 那么就會報錯, 不能進行后續的開發, 同時程序在編譯時會報錯. 有悖於軟件架構設計的低耦合原則, 和單一功能原則. 

  // 1. 程序有強耦合關系: 使用mysql驅動的時候, 使用Driver類的對象
    @Test
    public void test1() {
        try {
            // 創建了一個Driver對象
            // 使用registerDriver來添加mysql驅動到驅動管理器中
            Driver driver = new com.mysql.jdbc.Driver();
            DriverManager.registerDriver(driver);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

 

2. 第二步, 反射 例如: Class.ForName("com.mysql.jdbc.Driver").newInstance()

　 通過反射機制, 在程序運行的時候, 來將需要的類進行加載並創建類的對象

   // 2. 把代碼中的強關系, 轉換為了弱關系
        String driver = "com.mysql.jdbc.Driver";
        try {
            Class.forName(driver);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

 

3. 第三步, 配置 例如: db.properties和web.xml

　通過配置文件, 在程序運行的時候, 讀取配置文件中的內容, 通過配置文件來加載類, 並創建類的實例

 /**
     * 通過配置文件來實現解耦
     */
    @Test
    public void test3() {
        // db.properties文件位置在src下
        // 編譯完成后, src目錄下的配置文件會拷貝一份到classes目錄
        ClassLoader classLoader = TestMySQL.class.getClassLoader();
        InputStream resourceAsStream = classLoader.getResourceAsStream("db.properties");
        Properties properties = new Properties();
        try {
            properties.load(resourceAsStream);
            System.out.println(properties.get("driver"));
            String driver = (String)properties.get("driver");
            Class.forName(driver);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

4. 第四步, 通過Bundle來加載配置文件,簡化配置文件的加載過程, 然后創建出對象

  // 使用bundle
    @Test
    public void test4() {
        // ResourceBundle是專門用來讀取配置文件的工具類
        // bundle只能讀取properties類型的文件, 讀取的時候只需要文件名, 不需要后綴
        // bundle還提供了迭代的方法讀取所有配置
        ResourceBundle db = ResourceBundle.getBundle("db");
        db.getString("driver");
        Enumeration<String> keys = db.getKeys();
        while(keys.hasMoreElements()) {
            String key = keys.nextElement();
            System.out.println(key +": " + db.getString(key));
        }
    }

5. 第五步, 通過Bean工廠來管理所有的類的對象的管理, 直接從Bean工廠中獲取對象

public class BeanFactory {

    // 在bean的工廠中准備一個容器,將bean都反射后添加進來,隨用隨取
    private static Map<String,Object> beanMap = null;
    static {
        beanMap = new HashMap<>();
        ResourceBundle bean = ResourceBundle.getBundle("bean");
        Enumeration<String> keys = bean.getKeys();
        while(keys.hasMoreElements()) {
            String key = keys.nextElement();
            String classPath = bean.getString(key);
            try {
                Object object = Class.forName(classPath).newInstance();
                beanMap.put(key,object);
            } catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
    }
    /**
     * 使用Object的基礎類來接受獲取的對象
     * @param key
     * @return
     */
    public static Object getBean(String key) {
        Object o = null;
        ResourceBundle bean = ResourceBundle.getBundle("bean");
        String classPath = bean.getString(key);
        try {
            o = Class.forName(classPath).newInstance();
        } catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
            e.printStackTrace();
        }
        return o;
    }

 /**
     * 使用泛型方法來獲取對象(推薦)
     * @param key
     * @param clazz
     * @param <T>
     * @return
     */
    public static<T> T getBean(String key, Class<T> clazz) {
      return (T) beanMap.get(key);
    }

那么再程序中對新建對象的調用就變成了如下的代碼

        UserService userService = BeanFactory.getBean("userService", UserService.class);
        userService.register(user);

Spring的核心思想:

　　就是通過一個BeanFactory的工廠來統一管理所有的對象

在bean的工廠中准備一個容器,將bean都反射后添加進來,隨用隨取

參考文章: https://www.cnblogs.com/hello-liyb/p/8252029.html

https://blog.csdn.net/weixin_37243717/article/details/79673502

https://www.cnblogs.com/poilk/p/7015929.html

https://www.ibm.com/developerworks/cn/java/j-lo-spring-principle/

https://www.cnblogs.com/wade-luffy/p/6000277.html