在学习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

版权声明：本文为zjulanjian原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/zjulanjian/p/10929976.html