Spring框架学习总结之IOC与DI

小鱼儿 2023-02-18 14:09 19阅读 0赞

### 目录 ###

*   *   *  一.什么是spring?
         *  二. spring体系结构
         *  三. 程序的耦合和解耦
         *  四.控制反转和依赖注入
         *   *  案例理解spring
         *  五.IOC创建对象bean三种方式
         *   *  1.使用默认的构造函数创建
             *  2.使用普通工厂的方法创建对象
             *  3.使用工厂中的静态方法创建对象
         *  六.bean的作用范围
         *  七.bean的生命周期
         *  八.依赖注入的三种方式
         *   *  1.构造方法注入
             *  2.set注入
             *  3.p命名空间的注入

### 一.什么是spring? ###

spring是以IOC(控制反转)和AOP（面向切面编程）为内核的轻量级开源框架，可以看作是一个容器通过集成其它框架技术来完成对JavaEE企业级的开发，同时还提供了表现层和持久层以及业务层的事务管理等技术。

**优点**

*  方便解耦，简化开发
 *  支持事务，整合框架
 *  控制反转，切面编程

### 二. spring体系结构 ###

先看一张图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxODU3OTU1_size_16_color_FFFFFF_t_70]  
**①核心依赖**

*  `spring-beans`:对bean的支持,负责配置文件，创建和管理bean，同时支持依赖注入和控制反转的操作
 *  `spring-core`:其它模块的核心基础，包含一些核心的工具类
 *  `spring-context`:提供上下文的支持，最关键的就是ApplicationContext。
 *  `spring-expression`:spring表达式语言，帮助spring运行时查询和操作对象，获取对象的属性和方法的调用。
 *

**②AOP模块：功能与代码分离**

*  `spring-aop`:对于代理AOP的支持
 *  `spring-Aspects`:对于Aspect的AOP支持

**③Web模块**

*  `spring-web`:提供基础的web功能，在Web项目中提供Spring的容器
 *  `spring-webmvc`:提供基于Servlet的SpringMvc
 *  `spring-WebSocket`:提供WebSocket功能
 *  `spring-webmvc-portlet`:提供portlet支持

**④数据库模块**

*  `spring-jdbc`:提供jdbc访问数据库的支持
 *  `spring-tx`：提供对事物的支持的支持
 *  `spring-oxm`：提供对象xml的支持
 *  `spring-jms`:提供对java消息服务的支持

### 三. 程序的耦合和解耦 ###

/** * @author jektong * @Date 2020/6/18-12:38 */
    public class JdbcTemplate { 
        public static void main(String[] args) throws SQLException { 
            Connection conn=null;
            PreparedStatement ps = null;
            ResultSet rs = null;
            try { 
                //注册驱动
                Class.forName("com.mysql.cj.jdbc.Driver");
                //建立连接
                conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/bookmanage?useUnicode=true&characterEncoding=utf-8&serverTimezone=GMT%2B8",
                                                   "jektong",
                                                   "123456");
                //获取数据库连接的预处理对象
                ps = conn.prepareStatement("select * from book");
                //执行sql，得到结果集
                rs = ps.executeQuery();
                //遍历结果集
               while (rs.next()){ 
                       System.out.println(rs.getString("bname"));
                       System.out.println(rs.getString("author"));
               }
            } catch (ClassNotFoundException | SQLException e) { 
                e.printStackTrace();
            }finally { 
                //释放资源
                if (rs != null) { 
                    rs.close();
                }
                if (ps != null) { 
                    ps.close();
                }
                if (conn != null) { 
                    conn.close();
                }
            }
        }
    }

**耦合**

这段代码是最初我们连接数据库的代码，当然运行此代码的时候,就必须加入mysql驱动包，不加就不会运行，这样就可以理解成程序间的耦合，也就是程序间的存在的依赖关系。依赖关系包括类之间的依赖和方法间的依赖。.

**解耦**

降低依赖关系：

*  用反射来创建对象，避免用new这个关键字
 *  使用配置文件来获取到创建对象的全限定类名

### 四.控制反转和依赖注入 ###

`依赖注入（Dependency Inhection）`是一种开发的设计思想，在没有提出这个思想之前，我们就需要硬编码的方式去创建对象，然后在赋值给其他的对象，更要命的是还要用代码去管理他们的生命周期，DI提出后直接用框架来去管理这些杂七杂八的东西的，我们唯一要做的就是将对象组织封装起来，调用它们的业务方法。

Spring框架出来后，实例对象不需手动创建，由Spring容器来自动创建，控制权直接由代码转给容器，发生了反转，就叫做`控制反转(Inversion of Control)`。再从Spring容器的角度来看，Spring负责被依赖的对象赋值给调用者的成员变量，相当于为调用者注入它依赖的实例，就是Spring的依赖注入。  
IOC（控制反转）Spring的核心，就是由Spring容器来负责控制对象的生命周期和对象之间的关系。  
Spring所倡导的就是所有的类都会在Spring容器中进行登记，你需要什么东西的时候，它会交给你什么东西，类的创建和销毁由Spring控制，也就是说控制对象的生命周期的不是引用的对象而是Spring。简单来说，以前都是它来控制对象，现在所有的对象都交给Spring来控制（IOC）。

#### 案例理解spring ####

`Hello.java`:包含一个str的变量

/** * @author jektong * @Date 2020/6/18-22:34 */
    public class Hello { 
        private String str;
        public String getStr() { 
            return str;
        }
        public void setStr(String str) { 
            this.str = str;
        }
        @Override
        public String toString() { 
            return "Hello{" +
                    "str='" + str + '\'' +
                    '}';
        }
    }

`beans.xml`:相当于将对象交给spring托管的容器,放在类路径下

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd">
         
        <bean id="hello" class="bean.Hello">
             
            <property name="str" value="hello,spring"></property>
        </bean>
    </beans>

`HelloTest.java`

/** * @author jektong * @Date 2020/6/18-22:45 */
    public class HelloTest { 
        public static void main(String[] args) { 
        	//加载beans.xml文件
            ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
            //从容器中获取bean
            Hello hello = (Hello) context.getBean("hello");
            System.out.println(hello.getStr());
        }
    }

`ApplicationContext`当加载配置文件的时候会将所管理的类进行实例化  
它有两个实现类：  
`ClassPathXmlApplicationContext`:加载类路径下的xml配置文件  
`FileSystemXmlApplicationContext`加载文件系统(磁盘)下的配置文件

### 五.IOC创建对象bean三种方式 ###

#### 1.使用默认的构造函数创建 ####

上述的代码案例的方式就是通过默认的构造函数创建的，如果没有这个默认的构造函数，对象就会无法创建  
`<bean id="hello" class="bean.Hello"/>`

#### 2.使用普通工厂的方法创建对象 ####

改造上面的案例：  
建造一个普通的工厂`InstanceFactory.java`使用`getHello()`这个方法来创建对象  
`InstanceFactory.java`这个工厂类可能存在jar包中，不允许修改的

/** * @author jektong * @Date 2020/6/19-14:11 */
    public class InstanceFactory { 
        public Hello getHello(){ 
            return new Hello();
        }
    }

在`beans.xml`文件中改造

<bean id="instanceFactory" class="bean.InstanceFactory"></bean>
    <bean id="hello" factory-bean="instanceFactory" factory-method="getHello">
    	<property name="str" value="hello,spring"></property>
     </bean>

#### 3.使用工厂中的静态方法创建对象 ####

如果将上述的工厂中方法加入`static`关键字后，普通工厂创建对象就会无效，此时应修改`beans.xml文件`：

上述输出的代码结果都是 hello，spring

### 六.bean的作用范围 ###

spring中bean对象的作用范围通过修改scope属性的值来进行指定的，有以下两种：

*  `singleton`:单例，也是默认值，怎么get都只有一个对象
 *  `prototype`:多例对象，每一次从容器中get时都会产生一个对象

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxODU3OTU1_size_16_color_FFFFFF_t_70 1]

### 七.bean的生命周期 ###

**单例对象**

出生：容器创建，对象创建  
活着：容器在，对象就在  
死亡：容器销毁，对象消失

> 当容器被创建的时候此对象就会产生，只要这个容器存在，则这个对象就会存在，容器消失，对象也就会消失。

**多例对象**

出生：使用时，容器创建对象  
活着：对象使用就一直存在  
死亡：对象长时间不用时，且没有其他对象的调用，交个GC回收

> 使用对象的时候，spring就会为我们创建，只要被使用了就会一直存在，当对象长时间不用的时候，并且有没有别的对象进行引用的时候Java的垃圾回收机制就会来回收这些对象。

### 八.依赖注入的三种方式 ###

准备一个Student类,相关属性如下：

/** * @author jektong * @Date 2020/6/19-19:44 */
    public class Student { 
        private String name;
        private Address address;
        private String[] books;
        private List<String> hobbys;
        private Map<String, String> map;
        private Set<String> games;
        private String wife;
        private Properties info;
    }
    //略去toString方法和setter，getter方法

#### 1.构造方法注入 ####

上面的案例一开始就是用了默认的构造方法注入，若类中带有参数的构造方法时，`beans.xml`应改为：  
构造方法有多少参数就要注入多少`<constructor-arg>`,这里构造方法参数只有一个name，且没有默认的构造方法。

#### 2.set注入 ####

现在使用Student这个类，Spring容器中注入各种数据

#### 3.p命名空间的注入 ####

这里将name以p命名空间进行注入：  
`<bean id="name" class="bean.Student" p:name="John"/>`  
输出的结果就是John

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxODU3OTU1_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200618103509686.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxODU3OTU1,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxODU3OTU1_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200619171533270.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxODU3OTU1,size_16,color_FFFFFF,t_70