这份Sping IOC学习笔记你真得好好看看，阿里大牛花了三天整理出来的

Sping 的简介

Spring是一个轻量级控制反转(IoC)和面向切面(AOP)的容器框架。

Spring的特点

1.Spring是一个开源的免费框架（容器）
2.Spring是一个轻量级、非入侵式的框架
3.控制反转（IOC）面向切面编程（AOP）核心
4.支持事务的处理，对框架整合

使用Spring

我们在maven的项目中只需要导入spring-webmvc架包，maven会自动为我们导入其他的依赖架包

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.2.8.RELEASE</version>
    </dependency>

Sping的七大核心模块

核心容器（Spring Core）

核心容器提供Spring框架的基本功能。Spring以bean的方式组织和管理Java应用中的各个组件及其关系。Spring使用BeanFactory来产生和管理Bean，它是工厂模式的实现。BeanFactory使用控制反转(IoC)模式将应用的配置和依赖性规范与实际的应用程序代码分开。

应用上下文（Spring Context）

Spring上下文是一个配置文件，向Spring框架提供上下文信息。Spring上下文包括企业服务，如JNDI、EJB、电子邮件、国际化、校验和调度功能。

Spring面向切面编程（Spring AOP）

通过配置管理特性，Spring AOP 模块直接将面向方面的编程功能集成到了 Spring框架中。所以，可以很容易地使 Spring框架管理的任何对象支持 AOP。Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP，不用依赖 EJB 组件，就可以将声明性事务管理集成到应用程序中。

JDBC和DAO模块（Spring DAO）

JDBC、DAO的抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理，和不同数据库供应商所抛出的错误信息。异常层次结构简化了错误处理，并且极大的降低了需要编写的代码数量，比如打开和关闭链接。

对象实体映射（Spring ORM）

Spring框架插入了若干个ORM框架，从而提供了ORM对象的关系工具，其中包括了Hibernate、JDO和 IBatis SQL Map等，所有这些都遵从Spring的通用事物和DAO异常层次结构。

Web模块（Spring Web）

Web上下文模块建立在应用程序上下文模块之上，为基于web的应用程序提供了上下文。所以Spring框架支持与Struts集成，web模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。

MVC模块（Spring Web MVC）

MVC框架是一个全功能的构建Web应用程序的MVC实现。通过策略接口，MVC框架变成为高度可配置的。MVC容纳了大量视图技术，其中包括JSP、POI等，模型来有JavaBean来构成，存放于m当中，而视图是一个街口，负责实现模型，控制器表示逻辑代码，由c的事情。Spring框架的功能可以用在任何J2EE服务器当中，大多数功能也适用于不受管理的环境。Spring的核心要点就是支持不绑定到特定J2EE服务的可重用业务和数据的访问的对象，毫无疑问这样的对象可以在不同的J2EE环境，独立应用程序和测试环境之间重用。

Sping三大核心思想

DI(依赖注入) ：后台需要对象时，spring容器将给后台空对象以bean的方式注入对象
IOC(控制反转) ：后台对象由主动创建变被动接受，权限发生了转移
AOP(面向切面编程)：在整个系统中，动态横向添加新的功能，还不改变原来业务流程的编码。那么横向扩展怎么理解呢，我们在WEB项目开发中，通常都遵守三层原则：
包括控制层（Controller）->业务层（Service）->数据层（dao）,那么从这个结构下来的为纵向，它具体的某一层就是我们所说的横向。（AOP是OOP的补充）

IOC创建对象

创建Spring的xml配置applicationContext.xml
可以参考官方文档Sping官方文档

<?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="..." class="...">  
        <!-- collaborators and configuration for this bean go here -->
    </bean>

    <bean id="..." class="...">
        <!-- collaborators and configuration for this bean go here -->
    </bean>

    <!-- more bean definitions go here -->
</beans>

Hello.java

package com.zx.hello;

/**
 * @Author Tim
 * @Date 2020/7/22 22:43
 * @Version 1.0
 */
public class Hello {
    private String hello;


    public String getHello() {
        return hello;
    }
     //set方法在这里是什么关键的（由set方法来注入对象的），没有Set方法就会报错 
    public void setHello(String hello) {
        this.hello = hello;
    }

    @Override
    public String toString() {
        return "Hello{" +
                "hello='" + hello + '\'' +
                '}';
    }
}

以前创建对象：

Hello hello = new Hello();

现在在Sping配置文件中(前提是要保证Hello这个类必须存在)：
id = 变量名 – hello
class = new Hello();
bean = 对象
property = 对象属性值

<?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">

    <!--使用Spring来创建对象，在Spring中统一叫做Bean-->
    <!--    该id属性是标识单个bean定义的字符串。
            该class属性定义Bean的类型，并使用完全限定的类名。
            该id属性的值是指协作对象。在此示例中未显示用于引用协作对象的XML
     -->

    <!--
        bean = 对象
        Hello hello = new Hello();

        id = 变量名
        class =  new 的对象
        property  相当于给对象中的属性设值
    -->
        <bean id="hello" class="com.zx.hello.Hello">
            <!--给对象属性设值-->
            <property name="hello" value="spring"></property>
            <!-- collaborators and configuration for this bean go here -->
            <!--ref是引用Spring容器中创建好的对象-->
            <!--<property name="xx" ref="conversionService"></property>-->
        </bean>
   </beans>

然后便可以在Java实现类中调用对象（sping 容器一加载对象就创建了）

//获取Spring上下对象（获取Spring容器）
ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml");
//到此我们的对象就在Spring中管理了，我们要使用就直接去拿就好了。
Hello hello = (Hello) ac.getBean("hello");
Hello hello = ac.getBean("hello",Hello.class);

IOC创建对象的方式

使用无参构造创建对象（默认）
使用有参构造创建对象（如下）

    <bean id="user1" class="com.zx.user.Users">
        <!--index对象属性下标  下标赋值-->
        <constructor-arg index="0" value="李四"></constructor-arg>
    </bean>
     
    <!-- 不建议使用 当有多个相同类型就went  类型-->
    <bean id="user2" class="com.zx.user.Users">
        <constructor-arg type="java.lang.String" value="王五"></constructor-arg>
    </bean>

    <!-- 直接通过参数名-->
    <bean id="user3" class="com.zx.user.Users">
        <constructor-arg name="name" value="董彬"></constructor-arg>
    </bean>

DI(依赖注入)

依赖:bean对象的创建依赖于容器
注入:bean对象中的所有属性值由容器注入
1.构造器注入（前面）

2.set注入（重点）

 <?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="home" class="com.zx.Home">
        <property name="home" value="安徽宣城"></property>
    </bean>
    <bean id="student" class="com.zx.Student">
        <property name="name" value="黄杰"></property>
        <property name="home" ref="home"/>
        <property name="books">
          <array>
              <value>西游记</value>
              <value>水浒传</value>
              <value>三国演义</value>
              <value>红楼梦</value>
          </array>
        </property>
        <property name="hobbys">
            <list>
                <value>多人运动</value>
                <value>篮球</value>
            </list>
        </property>

        <property name="cards">
            <map>
                <entry key="身份证" value="111111111111"></entry>
                <entry key="银行卡" value="23456s"></entry>
            </map>
        </property>

        <property name="games">
            <set>
                <value>王者荣耀</value>
                <value>刺激战场</value>
            </set>
        </property>
        <property name="info">
            <props>
                <prop key="学号">16014420048</prop>
                <prop key="姓名">大黄</prop>
            </props>
        </property>
        <property name="wrok">
            <null></null>
        </property>
    </bean>
</beans>

3.其他注入

   <?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
       xmlns:c="http://www.springframework.org/schema/c"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--需要在USER类里添加无参构造器
       p命名空间对应就是set的属性注入property
    -->
    <bean id="user1" class="com.obj.User" p:name="张三" p:age="18" scope="prototype"></bean>

    <!--需要在USER类里添加有参构造器
      c命名空间对应就是构造器注入-->
    <bean id="user2" class="com.obj.User" c:name="李四" c:age="20"></bean>

    <!--p 和 c命名空间不可以直接使用，要导入XML约束-->
    <!--scope作用域，bean的作用域 默认是单例模式singleton  原型模式prototype
     其余的在Web开发使用request、session、application
     -->
</beans>

p 和 c命名空间不可以直接使用，要导入XML约束
<!--scope作用域，bean的作用域 默认是单例模式singleton  原型模式prototype
 其余的在Web开发使用request、session、application
-->

IOC的本质

IOC（控制反转），他是一中设计思想！IOC的本质就是获得依赖对象的方式反转了，使程序不要再去管理对象的创建，使得程序的耦合大大降低，可以将对象的创建交给第三方。
控制反转就是通过描述（xml配置文件、注解）通过第三方去产生或者获取到对象的方式，在Sping中IOC容器实现了控制反转,其实现的方法便是DI(依赖注入)。

补充（自动装配）

Bean的自动装配
自动装配是Spring是满足bean依赖的一种方式,Sping会在上下文中自动寻找，并自动给bean装配属性。spring中有三种装配方式:
1.xml中显示配置
2.在java中显示配置
3.隐式的自动装配（***）

方式一：

<?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="cat" class="com.zx.Cat">
        <property name="name" value="猫因"/>
    </bean>

    <bean id="dog" class="com.zx.Dog">
        <constructor-arg name="name" value="豆豆"/>
    </bean>

    <bean id="people" class="com.zx.People">
        <property name="name" value="大黄"/>
        <property name="cat" ref="cat"/>
        <property name="dog" ref="dog"/>
    </bean>

    <!--自动装配-->
    <!-- byName 会自动在容器中寻找和自己对象set方法后面的值对应的bean  id-->
    <bean id="people1" class="com.zx.People" autowire="byName">
        <property name="name" value="亚飞"/>
    </bean>

    <!-- byType 会自动在容器中寻找和自己对象类型相同的bean  id-->
    <bean id="people2" class="com.zx.People" autowire="byType">
        <property name="name" value="董小姐"/>
    </bean>

</beans>

import com.zx.People;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @Author Tim
 * @Date 2020/7/23 17:12
 * @Version 1.0
 */
public class Test6 {
    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml");
        People people = ac.getBean("people",People.class);
        people.getCat().show();
        people.getDog().show();
        System.out.println("这个人叫"+people.getName());


        People people1 = ac.getBean("people1",People.class);
        people1.getCat().show();
        people1.getDog().show();
        System.out.println("这个人叫"+people1.getName());


        People people2 = ac.getBean("people2",People.class);
        people2.getCat().show();
        people2.getDog().show();
        System.out.println("这个人叫"+people2.getName());


    }
}

方式二、

使用JAVA的方式来配置Spring
完全不用Spring的XML配置了
JavaConfig是Spring的一个子项目，在Spring4之后变为一个核心功能

@Configuration代表是一个配置``类，就和我们之前的bean.xml一样

@ComponentScan("com.zx")扫描包

@Bean//注册一个bean就相当于bean标签，方法名字就是id,返回值就是class属性

package com.config;

import com.zx.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

/**
 * @Author Tim
 * @Date 2020/7/24 17:51
 * @Version 1.0
 */
@Configuration//这个也会被容器托管，注册到容器中，因为他本就是一个@Component
@ComponentScan("com.zx")//不写也可以
public class UserConfig {
    @Bean//注册一个bean就相当于bean标签，方法名字就是id,返回值就是class属性
    public User getUser(){
        return new User();
    }
}

package com.zx;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

/**
 * @Author Tim
 * @Date 2020/7/24 17:48
 * @Version 1.0
 */
@Component
public class User {
    private String name;

    public String getName() {
        return name;
    }
    @Value("张三")
    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                '}';
    }
}

import com.config.UserConfig;
import com.zx.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

/**
 * @Author Tim
 * @Date 2020/7/24 17:57
 * @Version 1.0
 */
public class Test9 {
    public static void main(String[] args) {
        //如完全使用配置方法去做，通过 AnnotationConfigApplicationContext上下文去获取容器，通过配置类的class对象加载
        ApplicationContext ac = new AnnotationConfigApplicationContext(UserConfig.class);
        User user = ac.getBean("getUser",User.class);
        System.out.println(user.getName());
    }
}

方式三、

注解实现自动装配
使用注解要开启注解支持

 <context:annotation-config/>

1.@Autowired  直接在属性上使用即可或者在Set方法上使用也可以。 这个注解使用反射的方式实现的，可以不写   
 SET方法也是可以注入的（前提是你要自动装配的属性在IOC容器（spring）中存在 ，符合byType）如果自动装配
 的环境比较复杂，可以添加@Qualifier(value = "dog111")去配合@Autowired，获取唯一值。@Autowired(required = 
 false)//required = false 允许在容器中为null
  
2.@Resource (是JDK的注解。不是Sping)
      
3.@Nullable
如果可以传入NULL值，则标记为@Nullable，如果不可以，则标注为@Nonnull。那么在我们做一些不安全严谨操作
的编码操作时，这些注释会给我们一些警告。


@Resource和@Autowired都是做bean的注入时使用，其实@Resource并不是Spring的注解，它的包是
javax.annotation.Resource，但是Spring支持该注解的注入。

1、共同点
两者都可以写在字段和setter方法上。两者如果都写在字段上，那么就不需要再写setter方法。

2、不同点
（1）@Autowired
    @Autowired为Spring提供的注解，需要导入包org.springframework.beans.factory.annotation.Autowired;只按照
    byType注入。@Autowired注解是按照类型（byType）装配依赖对象，默认情况下它要求依赖对象必须存在，如果
    允许null值，可以设置它的required属性为false.如果我们想使用按照名称（byName）来装配，可以结合@Qualifier
    注解一起使用。

（2）@Resource
    @Resource默认按照ByName自动注入，由J2EE提供，需要导入包javax.annotation.Resource。@Resource有两
    个重要的属性：name和type,而Spring将@Resource注解的name属性解析为bean的名字，而type属性则解析bean
    的类型。所以，如果使用name属性，则使用byName的自动注入策略，而使用type属性时则使用byType自动注入策
    略。如果既不制定name也不制定type属性，这时将通过反射机制使用byName自动注入策略。

Spring注解开发
在spring4之后要使用注解开发，必须保证导入aop架包
1.使用注解要增加注解支持！（主要是开启程序的注解驱动）

  <context:annotation-config/>

2.扫描机制
指定要扫描的包，这个包下的注解就会生效（Spring特定的注解）
<context:component-scan base-package="com"/>
注解（bean）
1.@Component（组件）
    @Component 
    等价与 
    <bean id="user" class="com.entity.User"></bean>
2.@Value()
    Spring注解注入属性值使用 @Value("大黄")
    相当于
    <property name="xxx" value="xxx"></property>
3.@Component的衍生注解
  （1）@Repository(仓库 持久层)
  （2）@Service（业务层）
  （3）@Controller（控制层）
   这四个注解的功能都是一样的，都是代表将某个类注册到Spring中，装配Bean
4.作用域的注解
    @Scope("singleton")

package com.bean;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.lang.NonNull;
import org.springframework.lang.Nullable;

import javax.annotation.Resource;

/**
 * @Author Tim
 * @Date 2020/7/24 14:37
 * @Version 1.0
 */
public class Peope {
    @Resource
    private Cat cat;
    @Autowired(required = false)//required = false 允许在容器中为null
    @Qualifier(value = "dog111")
    private Dog dog;

    private String name;

    public void show(){
        cat.Show();
        dog.show();
        System.out.println("你们都是我的宠物");
    }
}

package com.bean;

/**
 * @Author Tim
 * @Date 2020/7/24 14:30
 * @Version 1.0
 */
public class Cat {
    private String name;
    public void Show(){
        System.out.println("你好我是小猫咪");
    }
}



package com.bean;

/**
 * @Author Tim
 * @Date 2020/7/24 14:36
 * @Version 1.0
 */
public class Dog {
    private String name;
    public void show(){
        System.out.println("我是一个汪星人");
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
    <bean id="cat" class="com.bean.Cat"></bean>
    <bean id="dog11" class="com.bean.Dog"></bean>
    <bean id="dog111" class="com.bean.Dog"></bean>

    <bean id="people" class="com.bean.Peope"></bean>
    <!-- 开启注解支持-->
    <context:annotation-config/>

</beans>

最后

感谢你看到这里，看完有什么的不懂的可以在评论区问我，觉得文章对你有帮助的话记得给我点个赞，每天都会分享java相关技术文章或行业资讯，欢迎大家关注和转发文章！