Spring框架学习总结之IOC与DI

一.什么是spring?

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

优点

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

二. spring体系结构

先看一张图：

①核心依赖

• 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">
     <!--id名自取，class写注入的全限定类名-->
    <bean id="hello" class="bean.Hello">
         <!--name为要赋值的变量名，value写要赋的值-->
        <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文件：

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

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

六.bean的作用范围

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

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

七.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，且没有默认的构造方法。

 <bean id="hello" class="bean.Hello">
        <constructor-arg name="str" value="hello,spring"></constructor-arg>
 </bean>

2.set注入

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

<bean id="address" class="bean.Address"></bean>
   <bean id="name" class="bean.Student">
       <!--普通注入-->
       <property name="name" value="John"></property>
       <!--Bean的注入，也就是使用类进行注入-->
       <property name="address" ref="address"></property>
       <!--数组的注入-->
       <property name="books">
           <array>
               <value>水浒传</value>
               <value>西游记</value>
               <value>三国演义</value>
               <value>红楼梦</value>
           </array>
       </property>
       <!--list数据注入-->
       <property name="hobbys" >
           <list>
               <value>打球</value>
               <value>打网球</value>
               <value>打乒乓球</value>
           </list>
       </property>
       <!--map集合注入-->
       <property name="map">
           <map>
               <entry key="k1" value="v1"></entry>
               <entry key="k2" value="v2"></entry>
           </map>
       </property>
       <!--set集合注入-->
       <property name="games">
           <set>
               <value>LOL</value>
               <value>CS</value>
           </set>
       </property>
       <!--null注入-->
       <property name="wife">
         <null/>
       </property>
       <!--prop注入-->
       <property name="info">
           <props>
               <prop key="username">John</prop>
               <prop key="password">John</prop>
               <prop key="age">21</prop>
           </props>
       </property>
   </bean>

3.p命名空间的注入

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