Spring ----＞ IOC

一、 Spring 是一个包含众多工具的IoC容器

1. 场景解析：首先我们已经了解到了【Spring】是一个框架，但这个概念依旧很笼统，Spring又究竟为什么有这么强大的能力，可以帮我们快速搭建项目 ------------> Spring 是一个包含众多工具的IoC容器(这个Spring实际是指Spring Core、Spring Framework这个原生的框架)
2. 概念解析：
   • 包含众多工具：我们可以通过Spring引入并管理依赖
   • 容器：是一个被用烂了的概念，我们可以通俗理解为【里面可以装东西】，Tomcat和List等都可以理解为一个容器
     • List/Map……：装数据的容器
     • Tomcat：装web的容器
     • Spring容器：装对象的容器。
       • 因为Spring是用来简化Java开发的框架，Java又是面向对象的，所以Spring是装对象的容器。
       • “对象”这个词，在Spring的范围内称为“bean”
   • loC：见下面

二、 什么是IOC以及好处

1. loC是什么：控制(控制权)反转，是一种思想，Spring是其一种实现方式(具体表示为DI)，下面讲解都以Spring为例子
   • 是什么控制权：这取决于实现方式，此处因为管理的是对象，所以控制权指的是【创建和拿出对象的控制权】
   • 控制权反转是什么意思：由【谁用谁创建，自给自足】，变为【由Spring帮我们统一创建】
     • 此处是BookController需要BookService对象，所以他自己创建了
     • 交给Spring后，BookController将不自己创建，而是只负责去Spring里拿(把创建的操作外包出去)
       
2. 为什么我们使用了Spring提供的注解，Spring就能帮我们完成对应操作：控制反转思想的体现
   • 以@RequestController注解为例，加了这个注解，相当于告诉Spring帮我们管理这个对象，后续访问的时候，要求能访问到
3. loC的好处：减少模块之间的耦合
   • 如果自己创建，当被调用的类中出现了属性之类的修改，被调用方也需要跟着修改，代码修改量较大，耦合性较高
     
     

三、 如何实现loc思想

1. 核心：交给别人去创建，自己只负责接收
2. 方式一：手搓，需要自己new

public class Tire {
    private int size;

    public Tire(int size){
    	this.size = size;
        System.out.println("tire");
    }
}

public class Bottom {
    private Tire tire;

    public Bottom(Tire tire){
        this.tire = tire;
        System.out.println("bottom");
    }
}

public class Framework {
    private Bottom bottom;

    public Framework(Bottom bottom){
        this.bottom = bottom;
        System.out.println("framework");
    }
}

public class Main {
    public static void main(String[] args) {
        Tire tire = new Tire(20);
        Bottom bottom = new Bottom(tire);
        Framework framework = new Framework(bottom);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

3. 方式二：Spring 提供的方法
4. 为什么不用static解决loC问题：static是独立于整个类存在的，是所有对象共享的。而我们是需要给这个对象的某个属性赋值对象，两者不是一个概念

四、Spring提供的实现loC的方法 — 类注解+方法注解

4.1 类注解

类注解概念介绍

1. 有什么：@Controller、@Service、@Repository、@Configuration、@Component

   • @Controller(控制器存储)、@Service(服务存储)、@Repository(仓库存储)：分别对应了三层架构中的“Controller层”、“Service层”、“Dao层”
     • 数据库就是一个数据仓库
   • @Configuration(配置存储)：Spring能帮我们管理的配置是大众使用的，如果是那种小众的，由于性价比低，Spring并未支持，此时就需要我们手动配置了
   • @Component(组件存储)：让Spring帮我们管理组件相关的代码

2. 类注解作用：方便区分(看到这个注解就可知道该代码属于哪一层)

   • 共同点：都是告诉Spring帮我们管理对象
     • 原因：@Controller、@Service、@Repository、@Configuration都是根据@Component衍生的类(底层实现都是@Component)，所以前四个注解功能都是一样的(可以替代使用)，但是为了区分代码，我们需要分开使用
   • 区别：@Controller注解用于处理HTTP请求和响应，所以如果当前代码想被外界访问到，就一定需要使用@Controller
     • 为什么IDEA里代码都差不多，但@Controller有额外功能：在IDEA上我们看到的只是注解的定义，真正的功能实现在Spring的源码里
       

3. 使用范围：自己的代码 + 类上

4. 五大注解修饰的类，默认都是预加载，但我们可以设置为懒加载

5. 使用类注解得到的Bean：哪怕我们用不同的方式去获取，得到的都是同一个对象
   

6. 调用顺序：
   

类注解的使用

1. 如何知道让Spring管理的对象是否已经被Spring管理起来了：用启动类的run方法获得容器后，用getBean()方法尝试从该容器获得被管理的对象
   • SpringApplication.run()：启动这个项目，返回值就是这个loC容器(即Spring的运行环境)，用【ApplicationContext】接收
     • ApplicationContext：统一翻译过来是【Spring上下文】，我们也可以个人理解为【应用环境】
   • getBean()方法：常用的是下面这三种，s指的是Bean的名称，aClass指的是Bean的类型。名称需要参考下面【Bean的命名】
     • getBean(String s，Class< T> aClass)
     • getBean(String s)：使用名称获取，因为返回对象是Object，所以需要强转
     • getBean(Class< T> aClass)

2. 关于Spring的扫描：在Spring项目中，当项目启动时，它会根据配置扫描特定的注解以自动注册和管理Bean

   • 开始扫描：启动被@SpringBootApplication修饰的启动类后，会根据要扫描的包路径进行扫描(@ComponentScan)，如果没有该注解，@SpringBootApplication会默认扫描启动类所在的包以及子包
   • 扫描什么：Spring只处理有五大类注解的，比如@Data是Lombok提供的，SPring不会管
     • 首先只扫描类，查找五大类注解，这些注解告诉Spring框架，这些类需要被你管理，应该被注册为Bean，在应用程序中可用
     • 在有五大类注解的基础上，扫描其他与Bean管理相关的注解，如@Autowired
   • 补充：当遇到其他如RequestMapping这种由其他模块提供的注解，也会由对应模块赋予其功能

3. 关于扫描路径：
   

4. 关于Bean的命名：

   • Spring对Bean命名的处理：Spring在帮我们管理对象时，会给每一个对象起名字(默认情况)，当然我们也可以自定义名字
   • 命名规范：可以去Spring官方文档查看
     • 使用小驼峰命名风格，遵循Java标准进行定义
     • 如果类名前两位都为大写，如UService，Bean的名称为类名
   • Bean名称的唯一性：因为我们可以根据名称拿到对象，所以名称要求是唯一的
   • 原理：
     • IDEA如何快速查找“方法和类”：双击shift输入名称搜索

5. 关于定位当前类或方法所属于包：
   
6. 关于IDEA的报错：报错只是指当前代码不符合规范，并不意味着不能运行。
   • 怎么样才会提示报错：
     • IDEA的提示报错是IDEA根据官方文档包括Spring等它们的规则检测后，如果它觉得当前做法不符合规则，就会报错。
     • 但是不符合规则，不意味着真的错了，可能只是没有遵循官方推荐的方法
   • 关于颜色：可以进行设置，所以控制台红色不意味着报错
7. 代码格式化快捷键：Ctrl + Alit + L
8. 类注解的使用：

@Controller
public class UserController {
    public void doController(){
        System.out.println("do Controller");
    }
}

@SpringBootApplication
public class loCTest {

	public static void main(String[] args) {
		ApplicationContext context = SpringApplication.run(loCTest.class, args);
		UserController userController = context.getBean(UserController.class);
		userController.doController();
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

4.2 方法注解@Bean

1. 使用场景：
   • 让Spring管理第三方Jar包：由于五大注解使用范围有限，假如我们引入了一个第三方Jar包，且也希望交给Spring管理，是无法使用五大注解的
     • 引入配置：在Spring Framework时期是通过引入配置的方法引入
     • 使用注解：Spring Boot提供了@Bean管理该包
   • 需要多个对象：当一个类需要多个对象时，比如数据库操作需要多个数据源
2. 如何使用(不涉及传参)：
   • 使用@Bean可以定义多个对象
   • 搭配五大注解使用：因为Spring扫描是需要五大注解告诉它们哪些类是需要其管理的，所以要搭配使用
   • 获取Bean：
     • 使用名称获取Bean：当定义了多个对象时，就无法用类型来获取Bean了，因为获取到Bean不是唯一的，Spring不知道要获取哪个。此时我们需要使用名称(当使用@Bean时，bean的名称就是方法名)来获取Bean
     • 使用类型获取Bean：该类型只有一个的情况下，此时就不需要看名字，直接给赋值了。

@Data
public class UserInfo {
    private String username;
    private String password;
}
1
2
3
4
5

@Configuration
public class BeanConfig {
    @Bean
    public UserInfo userInfoZ(){
        UserInfo userInfo = new UserInfo();
        userInfo.setUsername("zhangsan");
        userInfo.setPassword("123456");
        return userInfo;
    }

    @Bean
    public UserInfo userInfoL(){
        UserInfo userInfo = new UserInfo();
        userInfo.setUsername("lisi");
        userInfo.setPassword("123456");
        return userInfo;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

@SpringBootApplication
public class loCTest {

    public static void main(String[] args) {
        ApplicationContext context = SpringApplication.run(loCTest.class, args);
       
        UserInfo userConfig = (UserInfo) context.getBean("userInfoZ");
        UserInfo userConfig1 = (UserInfo) context.getBean("userInfoL");
        System.out.println(userConfig == userConfig1); //结果为false

    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13

3. 如何使用(涉及传参)
   • 为什么要创建一个String对象：
     • 在UserInfoW()中参数是一个String类型，对于Spring来说，bean也可以是String、Integer这种类型。此处如果没有创建一个String类型，Spring认为这里需要一个String类型的bean，但它没有找到，故而报错
     • String会帮我们根据类型自动往里面注入对象，如果对应的对象只有一个，直接赋值。如果有多个，就会根据名称去匹配
   • public UserInfo userInfoW(String nameZ)：表示现在有一个叫userinfoW的UserInfo对象和里面一个叫nameZ的String对象要交给Spring管理，Spring需要把对象注入进去
   • public String nameW：定义了一个叫nameW的String类型的对象

@Configuration
public class BeanConfig {
    @Bean
    public UserInfo userInfoW(String nameZ){
        UserInfo userInfo = new UserInfo();
        userInfo.setUsername(nameZ);
        userInfo.setPassword("123456");
        return userInfo;
    }

    @Bean
    public String nameW(){
        return "wangwu";
    }

    @Bean
    public String nameZ(){	//定义了一个叫nameZ的String类型的对象
        return "zhaoliu";
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

@SpringBootApplication
public class loCTest {

    public static void main(String[] args) {
        ApplicationContext context = SpringApplication.run(loCTest.class, args);
       
        UserInfo userConfigW = (UserInfo) context.getBean("userInfoW");
        System.out.println(userConfigW.getUsername()); //zhaoliu

    }

}
1
2
3
4
5
6
7
8
9
10
11
12