对一程序员来说，只要你的实力够牛，没什么公司进不去的，学历、年龄都不是问题，本文是一个刚刚入职阿里的一个专科生学习时整理出来的spring笔记，接下来笔者会分别通过IOC和DI两个方面来对spring中的概念进行分享！

什么是Spring

Spring在经典三层中的位置，各个层都有体现

Spring是一个一站式/full-stack（全栈）的框架

不仅可以用Spring开发web层，也可以开发service层，还有dao层，归根结底，它是一个对象的容器，它能够处理请求是因为这个容器中有能够处理请求的对象，能够操作数据库，是因为这个容器中有能够操作数据库的对象

根本上，就是一个对象的容器（Map）

l Spring的发展历程

了解讲义

l Spring的优势

了解讲义

l Spring的框架结构

注意：Spring是一个模块化的框架，它的功能很强大，但是并不要求你完全都得用，图中每一个圆角矩形都代表一个jar，使用哪些模块引入哪些模块即可

[理解]IOC的概念和作用

说明：

Spring所使用的两大思想IOC和AOP，都不是Spring提出的，之前更倾向于理论化，Spring框架把这两大思想在技术上做了非常好的实现。

l IOC的概念

IOC：Interverse of control （控制反转/反转控制）。原来我们在类中需要其他类时我们自己new对象，有了Spring之后，不需要我们自己new，框架已经准备好了对象，等待我们使用，我们只需要问框架要对象即可

我们丧失了一个权利（创建对象），得到了一个福利（不用管什么时候创建对象，以及对象什么时候销毁）

l IOC的作用

解决的是程序耦合问题

l 关于程序耦合(有一个认识即可)

耦合：耦合度，为了完成一定的功能，一个类调用了另外一个类，所产生的影响，影响大小代表耦合度的高低。

注意：耦合不能够绝对避免，耦合只能降低

“高内聚、低耦合”，麻烦自己，方便别人，你修改时候，别人对你的调用就不用变动

[理解]自定义IOC实现程序解耦合

需求：开发dao层和service层模拟保存账户（Account），不具体操作数据库

l service层调用dao层存在耦合，解耦合分析过程

l 需要实例化的类的全限定类名配置在xml中，便于工厂使用反射技术实例化对象

l 使用工厂模式解耦合，分析并完成工厂内的两大任务

package com.spring.factory;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import java.io.InputStream;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 产生对象的工厂
 * 任务一：读取解析xml，根据配置信息实例化对象，放入map集合（对象容器），等待使用
 * 任务二：提供一个从map中获取对象的方法（根据id获取对象）
 */
public class BeanFactory {

    // map集合（对象容器，存储对象的）
    private static Map<String,Object> map = new HashMap<>();


    //任务一：读取解析xml，根据配置信息实例化对象，放入map集合（对象容器），等待使用
    static {
        // 读取解析xml
        InputStream inputStream = BeanFactory.class.getClassLoader().getResourceAsStream("beans.xml");
        SAXReader saxReader = new SAXReader();
        try {
            Document document = saxReader.read(inputStream);
            Element rootElement = document.getRootElement();
            List<Element> selectNodes = rootElement.selectNodes("//bean");
            if(selectNodes != null && selectNodes.size() > 0) {
                for (int i = 0; i < selectNodes.size(); i++) {
                    Element element =  selectNodes.get(i);
                    String id = element.attributeValue("id");
                    String clazz = element.attributeValue("class");
                    Class aClass = Class.forName(clazz);
                    Object o = aClass.newInstance();
                    // 把反射生成的对象放入对象容器待用
                    map.put(id,o);
                }
            }
        } catch (DocumentException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        }
    }



    //任务二：提供一个从map中获取对象的方法（根据id获取对象）
    public static Object getBean(String id) {
        return map.get(id);
    }

}

[掌握]使用SpringIOC实现程序解耦合

l 从IOC容器获取对象相比原有方式对比

l 引入jar坐标

<!--引入spring容器坐标-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.0.2.RELEASE</version>
</dependency>

l service层和dao层的业务代码完善

l 实例化service和dao代码，把它们的信息写在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 http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="accountDao" class="com.spring.dao.AccountDaoImpl"/>
    <bean id="accountService" class="com.spring.service.AccountServiceImpl"/>
</beans>

l 启动容器，通过容器获取对象

import com.spring.dao.AccountDao;
import com.spring.service.AccountService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainTest {

    /**
     * 测试用例：使用SpringIOC获取对象
     */
    @Test
    public void testSpringIoc() {
        // 启动对象容器
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        // getBean
        AccountService accountService = (AccountService) applicationContext.getBean("accountService");
        AccountDao accountDao = (AccountDao) applicationContext.getBean("accountDao");
        //AccountService accountService1 = applicationContext.getBean(AccountServiceImpl.class);
        //AccountService accountService1 = applicationContext.getBean(AccountService.class);
        //applicationContext.getBean("accountService",AccountService.class);

        System.out.println(accountService);
        System.out.println(accountDao);
    }
}

[掌握]SpringIOC的一些细节知识

ApplicationContext和BeanFactory

ApplicationContext在启动SpringIOC容器的时候，会立即创建对象放入map中（*不存在影响性能的问题*）

BeanFactory在启动SpringIOC容器的时候，不会立即创建对象，getBean使用对象的时候，Spring才去创建对象（类似于懒加载）

Bean标签

l id：标识符，定位对象的。id不能重复，没有mybatis中namespace之说了

class ：所创建对象的全限定类名，类似于：com.spring.dao.AccountDaoImpl，不能配置为接口，因为接口不能实例化

l scope ：对象的作用范围，单例和多例，单例：内存中这个类只有这一个对象，创建之后一直使用这一个；多例：当你getBean的时候，每getBean一次都给你创建一个新的对象

singleton：单例/单个的意思，默认bean的scope都是单例

prototype：多例的意思，每getBean一次就new一个新的对象返回

request：在web应用的一个request请求内有效，下个请求内就重新new一个对象

session：在web应用的一个session会话内有效，下个会话重新new一个对象

l 生命周期属性

bean即对象，对象就有生命周期，生命周期就有开始和结束，有时候希望在对象创建之后立马做点啥，或者销毁之前做事情

l 对象创建的三种方式

通过配置class全限定类名框架底层使用反射技术来创建对象(经常使用，推荐)

静态方法自己new对象，然后加入到Spring的对象容器中管理）

package com.spring.factory;

import com.spring.service.AccountService;
import com.spring.service.AccountServiceImpl;

public class StaticFactory {

   public static AccountService createAccountService() {
       return new AccountServiceImpl();
   }
}

动态实例化方法（自己new对象，然后加入到Spring的对象容器中管理）（需要首先定义工厂的bean，然后通过工厂bean对象调用里面的方法返回具体对象）

package com.spring.factory;

import com.spring.service.AccountService;
import com.spring.service.AccountServiceImpl;

public class InstanceFactory {

   public AccountService createAccountService() {
       return new AccountServiceImpl();
   }
}

下篇文章会更新DI依赖注入的概念！如果文章对你有帮助，别忘了点个关注，支持下作者，感谢！