两个月前跟着b站动力节点王鹤老师的Spring框架教程视频学习完了Spring框架，在学习过程中我将视频中涉及的代码都一行一行手敲了一遍，并且把Spring入门相关的资料整理了一下，在这里记录一下我在Spring框架学习过程中的笔记和一些心得，希望能帮助到想要通过文字教程入门Spring这一框架的小伙伴哦！
视频地址：2020最新Spring框架教程【IDEA版】-Spring框架从入门到精通
- 1. IoC 简介
- 2. Spring 程序初步
- 1）创建 Maven 项目
- 2）引入相关 Maven 依赖
- 3）定义接口与其实现类
- 4）创建 Spring 配置文件
- 5）测试
- 3. 容器接口和实现类
- ApplicationContext 接口（容器）
- 1）配置文件在类路径下
- 2） ApplicationContext 容器中对象的装配时机
- 3）使用 spring 容器创建的 java 对象
控制反转（IoC，Inversion of Control），是一种设计思想，而不是一个具体的技术实现。指将传统上由程序代码直接操控的对象调用权交给容器，通过容器来实现对象的装配和管理。控制反转就是对 对象控制权 的转移，从程序代码本身反转到了外部容器。通过容器实现对象的创建、属性赋值、依赖的管理。
不过， IoC 并非 Spirng 特有，在其他语言中也有应用。
控制：指的是对象创建（实例化、管理）的权力
反转：把原来的开发人员管理、创建对象的权限转移给代码之外的容器实现。由容器代替开发人员管理对象、创建对象、给属性赋值。
正转：由开发人员在代码中使用 new 构造方法创建对象，开发人员主动管理对象。
public static void main(String args[]){
Student student = new Student(); // 在代码中， 创建对象。--正转。
}
容器：是一个服务器软件，一个框架（Spring）
为什么要使用 ioc ： 目的就是减少对代码的改动，也能实现不同的功能，实现解耦合。
将对象之间的相互依赖关系交给 IoC 容器来管理，并由 IoC 容器完成对象的注入。这样可以很大程度上简化应用的开发，把应用从复杂的依赖关系中解放出来。 IoC 容器就像是一个工厂一样，当我们需要创建一个对象的时候，只需要配置好配置文件 / 注解即可，完全不用考虑对象是如何被创建出来的。
在实际项目中一个 Service 类可能依赖了很多其他的类，假如我们需要实例化这个 Service，你可能要每次都要搞清这个 Service 所有底层类的构造函数，这可能会把人逼疯。如果利用 IoC 的话，你只需要配置好，然后在需要的地方引用就行了，这大大增加了项目的可维护性且降低了开发难度。
在 Spring 中， IoC 容器是 Spring 用来实现 IoC 的载体， IoC 容器实际上就是个 Map（key，value），Map 中存放的是各种对象。
Spring 时代我们一般通过 XML 文件来配置 Bean，后来开发人员觉得 XML 文件来配置不太好，于是 SpringBoot 注解配置就慢慢开始流行起来。
java中创建对象有哪些方式：
- 使用构造方法 ， new Student()
- 反射
- 序列化
- 克隆
- IoC ：容器创建对象
- 动态代理
IoC 的体现：
servlet 中 1：创建类继承 HttpServlet
2：在 web.xml 注册 servlet ，使用
myservlet com.kaho.controller.MyServlet
3：使用 Servlet 的过程中没有创建 Servlet 对象， 即没有 MyServlet myservlet = new MyServlet();
4：Servlet 是 Tomcat 服务器创建的。 Tomcat 也称为容器
Tomcat 作为容器：里面存放有 Servlet 对象、Listener、Filter 等对象
IoC 的技术实现：
IoC 技术的实现方式是 依赖注入（DI）
DI（Dependency Injection）：依赖注入， 只需要在程序中提供要使用的对象名称就可以， 至于对象如何在容器中创建、赋值、查找都由容器内部实现。程序代码不做定位查询，这些工作由容器自行完成。程序运行过程中，若需要调用另一个对象协助时，无须在代码中创建被调用者，而是依赖于外部容器，由外部容器创建后传递给程序。
Spring 是使用依赖注入(DI)实现了 IoC 的功能，Spring 底层创建对象，使用的是反射机制。
Spring 容器是一个超级大工厂，负责创建、管理所有的 Java 对象，这些 Java 对象被称为 Bean。Spring 容器管理着容器中 Bean 之间的依赖关系，Spring 使用**“依赖注入”**的方式来管理 Bean 之间的依赖关系。使用 IoC 实现对象之间的解耦合。
2. Spring 程序初步 1）创建 Maven 项目 2）引入相关 Maven 依赖pom.xml：
3）定义接口与其实现类4.0.0 com.kaho ch01-hello-spring 1.0-SNAPSHOT UTF-8 1.8 1.8 junit junit 4.11 test org.springframework spring-context 5.2.5.RELEASE maven-compiler-plugin 3.1 1.8 1.8
接口：
package com.kaho.service;
public interface SomeService {
void doSome();
}
实现类：
package com.kaho.service.impl;
import com.kaho.service.SomeService;
public class SomeServiceImpl implements SomeService {
public SomeServiceImpl(){
super();
System.out.println("SomeServiceImpl的无参数构造方法");
}
@Override
public void doSome() {
System.out.println("====业务方法doSome()====");
}
}
4）创建 Spring 配置文件
在 src/main/resources/ 目录 创建一个 Spring 配置文件，具体步骤如下：
文件名可以随意，但 Spring 建议的名称为 applicationContext.xml。这里暂且先将其命名为 beans.xml
配置该文件的相关信息：
5）测试
package com.kaho;
import com.kaho.service.SomeService;
import com.kaho.service.impl.SomeServiceImpl;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyTest {
@Test
public void test01(){
//传统构造对象方式
SomeService service = new SomeServiceImpl();
service.doSome();
}
@Test
public void test02(){
//使用spring容器创建的对象
//1.指定spring配置文件的名称
String config = "beans.xml";
//2.创建表示spring容器的对象，ApplicationContext
// ApplicationContext就是表示Spring容器，通过该容器获取对象
// ClassPathXmlApplicationContext：表示从类路径中加载spring的配置文件
ApplicationContext ac = new ClassPathXmlApplicationContext(config);
//从容器中获取某个对象，通过调用ApplicationContext对象的方法
//getBean("配置文件中的bean的id值") 默认返回的是Object类型对象，所以要强转
SomeService service = (SomeService) ac.getBean("someService");
//使用spring创建好的对象
service.doSome();
}
@Test
public void test03(){
String config = "beans.xml";
ApplicationContext ac = new ClassPathXmlApplicationContext(config);
//使用spring提供的方法，获取容器中定义的对象的数量——getBeanDefinitionCount()
int nums = ac.getBeanDefinitionCount();
System.out.println("容器中定义的对象数量:" + nums);
//容器中每个定义的对象的名称——getBeanDefinitionNames()，返回String型数组
String[] names = ac.getBeanDefinitionNames();
for (String name : names){
System.out.println(name);
}
}
//获取一个非自定义的类对象
@Test
public void test04(){
String config = "beans.xml";
ApplicationContext ac = new ClassPathXmlApplicationContext(config);
//使用getBean()
Date date = (Date) ac.getBean("mydate");
System.out.println("Date:" + date);
}
}
3. 容器接口和实现类
ApplicationContext 接口（容器）
ApplicationContext 用于加载 Spring 的配置文件，在程序中充当“容器”的角色。其实现类有两个。
1）配置文件在类路径下若 Spring 配置文件存放在项目的类路径下，则使用 ClassPathXmlApplicationContext 实现类进行加载。
@Test
public void test02(){
//spring配置文件在类路径下(classpath)
//1.指定spring配置文件的名称
String config = "beans.xml";
//2.创建表示spring容器的对象
ApplicationContext ac = new ClassPathXmlApplicationContext(config);
//从容器中获取某个对象，通过调用ApplicationContext对象的方法
//getBean("配置文件中的bean的id值")
SomeService service = (SomeService) ac.getBean("someService");
service.doSome();
}
2） ApplicationContext 容器中对象的装配时机
ApplicationContext 容器，会在容器对象初始化时，将其中的所有对象一次性全部装配好（spring创建对象：默认调用的是无参构造方法）。以后代码中若要使用到这些对象，只需从内存中直接获取即可。执行效率较高，但占用内存。
3）使用 spring 容器创建的 java 对象
