当前位置： 首页 > article >正文

《JavaEE进阶》----11.＜SpringIOCDI【Spring容器+IOC详解+DI介绍】＞

article 2024/11/13 13:47:18

本篇博客会详细讲解什么是Spring。

SpringIOC

SpringID

五个类注解：@Controller、@Service、@Repository、@Component、@Configuration

一个方法注解：@Bean

什么是Spring

IOC容器

Spring 是包含众多工具的IOC容器。能装东西的容器。

1.容器

如我们之前学的

TomCat就是Web容器

list/map：数据容器

学校：学生的容器。

Spring容器：是一个装对象的容器

2.IOC（Inversion of Control）：控制翻转（控制权翻转）。指的是对象的控制权，对象交给Spring控制。指的是获取依赖对象的权利/过程。

IOC在之前的博客SpringMVC项目实践中已经用到了。就是我们在类上面添加注解。

@RestController和@Controller注解。

就是把这个对象交给Spring管理。Spring框架启动时就会加载该类。把对象交给Spring管理,就是IoC思想.

传统开发中：

对象谁使用谁控制

当我们想要获取依赖对象。我们需要new一个对象。这个对象定义在方法中 或者 定义在外面。这个对象的控制权都是谁使用谁控制。

现代开发中

对象交给Spring控制

现在我们已经不需要自己去创建这个对象。而是把创建对象的任务交给Spring容器（也就是Spring、SpringIOC容器）。我们只需要在程序中通过依赖注入（DI）（Dependeny Injection）就可以了。

控制反转思想在生活中的体现。

如开车。（驾驶权控制反转）

传统驾驶方式驾驶控制权是驾驶员的。

现在自动驾驶，驾驶权交给了自动驾驶系统。

如招聘,

企业的员工招聘，入职。解雇等控制权，从老板控制。

现在转交给HR（human resources）(人力资源)来处理

经典面试题：

1.Spring，SpringBoot，SpringMVC之间的区别和联系，你是如何理解的?

我的理解

1.Spring 是一个框架

2.SpringBoot 使我们在创建项目的时候可以直接添加一些依赖。并且内置web服务器、提供许多注解方便我们书写代码。对项目进行更多的监控指标，更好的了解项目的运行情况。简化我们的开发。

3.SpringMVC 是一个框架。是针对Web开发的一种MVC的思想的实现。也被称作Spring Web MVC（Spring Web）。在创建项目时，我们添加的依赖Spring Web实际上引的就是SpringMVC。可以认为Spring给我们提供的Web功能就叫做SpringMVC。

假如把Spring看作火车。（而做项目相当于坐火车） 但是它买票不方便。 

因此就可以把SpringBoot看作是12306。而12306不仅可以订票还可以订酒店。打的等等。让我们坐火车（做项目更加的方便）

而SpringMVC 可以认为是火车里面提供的一些功能。比如买票，改签，插座等等。（注解/Cookie&Session）

2.Spring两大核心思想IOC和AOP

待续

3.常见面试题：ApplicationContext VS BeanFactory

1.继承关系和功能方面来说：

Spring 容器有两个顶级的接口：BeanFactory和 ApplicationContext。其中BeanFactory提供了基础的访问容器的能力，而ApplicationContext 属于BeanFactory的⼦类，它除了继承了BeanFactory的所有功能之外， 它还拥有独特的特性，还添加了对国际化支持、资源访问支持、以及事件传播等方面的支持.

2.从性能方面来说：

ApplicationContext 是⼀次性加载并初始化所有的 Bean 对象，而BeanFactory 是需要那个才去加载那个，因此更加轻量. (空间换时间) 

一、IOC介绍+代码实践

通过一些代码，更清楚的理解Spring中的IOC。

通用程序的实现代码，类的创建顺序是反的。

总结：

传统代码

是Car控制并创建了Framework。Framework创建并创建了Bottom，依次往下

IOC思想

是把依赖对象注⼊将当前对象中，依赖对象的控制权不再由当前类控制了.这样的话,即使依赖类发生任何改变，当前类都是不受影响的，这就是典型的控制反转，也就是 IoC 的实现思想。

这部分代码就是IOC容器做的工作。

IOC容器的优点

资源不由使用资源的双方管理，而由不适用资源的第三方管理。

1.资源集中管理：IOC容器会帮我们管理一些资源（对象等）。我们使用时，从IOC容器取就可以了。

2.在创建实例的时候不需要了解其中的细节。降低了使用资源双方的依赖程度。也就是耦合度。

Spring就是一种IOC容器。帮助我们来做了这些资源。

1.1传统方式代码造车 

public class TraditionNewCarExample {
    /**
     * 传统方式造车
     * 1.先造轮胎
     * 2.再造底盘
     * 3.再造车身
     * 4.汽车出品
     * 这样设计可维护性很低。比如当需要加工多种尺寸的轮胎。
     * 这时候就需要对程序进行修改。我们会发现牵一发而动全身。
     * 我们需要去传入参数了。
     *
     * 创建对象的方式是：new car -> new Framework -> new bottom -> new tire
     */


    static class Tire{
        private int size;

        public Tire(){
            this.size = 20;
            System.out.println("轮胎尺寸："+size);
        }
    }

    static class Bottom{
        private Tire tire;

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

    static class Framework{

        private Bottom bottom;

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

    static class Car{
        private Framework framework;

        public Car(){
            this.framework = new Framework();
            System.out.println("car init...");
        }

        public void run(){
            System.out.println("Car run");
        }
    }


    public static void main(String[] args) {

        Car car = new Car();
        car.run();
    }
}

1.2 更新维护传统方式的代码

public class RenewTraditionNewCar {

        /**
         * 传统方式造车
         * 1.先造轮胎
         * 2.再造底盘
         * 3.再造车身
         * 4.汽车出品
         * 这样设计可维护性很低。比如当需要加工多种尺寸的轮胎。
         * 这时候就需要对程序进行修改。我们会发现牵一发而动全身。
         * 我们需要去传入参数了。
         * 下面是对传统新建汽车的修改
         * 可以看出，当最底层的代码改动之后。整个调用链上的所有代码都需要修改。
         * 因此代码耦合度非常高。
         */


        static class Tire{
            private int size;

            public Tire(int size){
                this.size = size;
                System.out.println("轮胎尺寸："+size);
            }
        }

        static class Bottom{
            private Tire tire;

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

        static class Framework{

            private Bottom bottom;

            public Framework(int size){
                this.bottom = new Bottom(size);
                System.out.println("Bottom init..");
            }
        }

        static class Car{
            private Framework framework;

            public Car(int size){
                this.framework = new Framework(size);
                System.out.println("car init...");
            }

            public void run(){
                System.out.println("Car run");
            }
        }


        public static void main(String[] args) {

            Car car = new Car(15);
            car.run();
        }
}

1.3IOC思想代码造车

/**
 * IOC模式造车
 * 把创建子类的方式改为注入传递的方式。
 *
 * 创建对象的方式是：new tire -> new bottom -> new Framework -> new tire
 */
public class IOCNewCar {
    public static void main(String[] args) {
        Tire tire = new Tire(20);
        Bottom bottom = new Bottom(tire);
        Framework framework = new Framework(bottom);
        Car car = new Car(framework);
        car.run();
    }



    static class Tire{
        private int size;

        public Tire(int size){
            this.size = size;
            System.out.println("轮胎尺寸："+size);
        }
    }

    static class Bottom{
        private Tire tire;

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

    static class Framework{
        private Bottom bottom;

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

    static class Car{
        private Framework framework;

        public Car(Framework framework){
            this.framework = framework;

            System.out.println("Car init...");
        }
        public void run(){
            System.out.println("Car run...");
        }
    }

}

 二、DI介绍

什么是DI呢？

Dependency Injection（依赖注入）

容器在运行期间，动态的为应用程序提供运行时所依赖的资源。称为依赖注入

依赖注入（DI）和控制翻转（IOC）是从不同的角度描述同一件事。

就是指通过引入IOC容器。利用依赖关系注入的方式。实现对象之间的解耦合。

IoC是一种思想。 

IoC是对象的控制反转，主要是用来创建对象的。实现把创建的对象的控制权交给Spring容器。

IOC是对依赖对象的创建。依赖对象的控制权交给Spring。管理依赖对象，对应存。

DI就是具体的实现。也就是DI是IoC的一种实现。

依赖注入，对IoC创建的依赖进行对象注入。可以认为依赖注入是如何拿到和使用IoC创建的依赖对象。对应取。

就像MVC是一种思想，而SpringMVC是具体的实现。

上面IOC思想代码造车的案例就是通过构造函数的方式，把依赖对象注入到需要使用的对象中

三、Spring IoC 和 DI的基本操作

 上面是初步了解。接下来具体学习SpringIoC和DI的代码实现。我们还会用到许多的注解。

Spring是IOC容器。那么容器就有最基础的两个功能：

  • 存对象（@Component）加上这个注解相当于我们把这个对象交给Spring管理了
  • 取对象（@AutoWired）加上这个注销相当于我们把这个对象从Spring拿出来了

 Spring容器 管理的主要是对象，这些对象我们称之为  “Bean”。我们把这些对象交给Spring管理。

由Spring负责对象的创建和销毁。

我们写的程序只需要告诉Spring哪些需要存。以及如何从Spring中取出对象。

我们下面以写图书管理系统为例。将Controller层、Service层、Dao层的解耦。

3.1把BookDao 交给Spring管理,由Spring来管理对象

Dao层

@Component
public class BookDao {
    /**
     * 1.把BookDao交给Spring管理，由Spring来管理对象。
     * 数据Mock 获取图书信息
     */
    public List<BookInfo> mockData() {
        List<BookInfo> books = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            BookInfo book = new BookInfo();
            book.setId(i);
            book.setBookName("书籍"+i);
            book.setAuthor("作者"+i);
            book.setCount(i*5+3);
            book.setPrice(new BigDecimal(new Random().nextInt(100)));
            /**
             * new Random().nextInt(100):
             * 这一部分代码使用java.util.Random类生成一个随机整数。
             * nextInt(100)会生成一个范围在0（含）到100（不含）之间的随机整数。
             */
            book.setPublish("出版社"+i);
            book.setStatus(1);
            books.add(book);
        }
        return books;
    }
}

3.2把BookService交给Spring管理,由Spring来管理对象

Service层

@Component
public class BookService {

    private BookDao bookDao = new BookDao();

    public List<BookInfo> getBookList(){
        List<BookInfo> books = bookDao.mockData();

        for (BookInfo book:books){
            if(book.getStatus() == 1){
                book.setStateCN("可借阅");
            }else {
                book.setStateCN("不可借阅");
            }
        }
        return books;
    }
}

3.3把BookController交给Spring管理,由Spring来管理对象

@RestController
@RequestMapping("/book")
public class BookController {

    @Autowired
    private BookService bookService;

    @RequestMapping("/getList")
    public List<BookInfo> getList(){
        List<BookInfo> books = bookService.getBookList();
        return books;
    }
}

四、IoC详细用法

五个（类注解）和一个（方法注解）

存对象：

五大类注解@Controller，@Service，@repository，@component，@configuration

一个方法注解@bean. 

@RestController不是，因为@RestController = @ResponseBody+@Controller

它之所以可以帮我们存对象，是里面Controller的原因，而不是其本身。

加了注解Spring会帮我们管理。没有加注解，Spring不会帮我们管理。

4.1 五个类注解

4.1.1五个注解的使用

五个注解属于类注解。他们用法相同。

之所以有五个注解，用法相同是为了分类使用。在存储这块的效果是一样的，

一点点差别

在请求入口上，（有@RequestMapping注解）只能使用@Controller企业规范。

功能上除了Controller都一样。

更多的不同是从概念上赋予了不同的含义。

1.表现层：@Controller

2.业务逻辑层：@Service

3.数据层：Dao，使用的注解是@Repository

除了这些层，还会遇到别的组件如redis等 用@component注解

相关的一些配置 用@configuration注解

分这些注解为了让我们更方便的找到相关代码

在详细介绍五个类注解之前，我们先了解一下启动类。 

@SpringBootApplication启动类

被这个注解标识的叫做启动类

启动类注解。当

ApplicationContext context = SpringApplication.run(IocDomeApplication.class, args);

.run这个方法在运行的时候，就会帮我们创建对象了。创建完对象，有一个返回结果

返回类型为ConfigurableApplicationContext。它的父类是ApplicationContext

ApplicationContext可以认为是spring的一个上下文。可以理解为记录执行内容顺序的存放之处。

可以认为是一个spring的运行环境，spring是一个IOC容器，它的运行环境里面包含了很多个对象，帮我们管理这些对象

这些对象就存放在ApplicationContext。当通过@Controller注解存入了这个对象到Spring容器。我们取的时候，其实具体就是在ApplicationContext中取的。

常用的三种获取bean(对象)的方式。（附带六个注解使用示例）

注意：

1.获取bean的方式用下面的哪个注解都可以。这是只是演示他们是可以存对象到Spring容器的。

2.获取Bean的功能是BeanFeactory提供的。

注：这五个注解的用法是通用的，这里只是讲解获取bean的三种最常用方式。注解无所谓。

bean：Spring管理的对象都称之为bean。

1.根据类型来获取bean（对象）。
①@Controller注解（控制存储）

1.首先使用@Controller注解存储UserController对象

@Controller("bean") //创建对象  //括号中是对bean进行重命名 如果没有指定名称spring帮我们指定
public class UserController {
    public void say(){
        System.out.println("Hi Controller!!!");
    }
}

2.从ApplicationContext取出UserController的对象

3.getBean方法就是获取对象

ApplicationContext context = SpringApplication.run(IocDomeApplication.class, args);

UserController bean1 = context.getBean(UserController.class);
bean1.say();
2.根据名称来获取bean（对象）
②Service注解（服务存储）

1.首先使用@Service注解存储UserService对象

@Service
public class UserService {
    public void say(){
        System.out.println("Hi UserService!!!");
    }
}
bean名称的命名规则

bean这个名称为类名的小驼峰形式。

参考如下打印。l

例外：如果前两位都是大写字母，bean的名称不变，否则是小驼峰形式。

decapitalize("UserService")方法是bean名称的命名规则。

System.out.println(Introspector.decapitalize("UserService"));
//userService

2.从Spring上下文。ApplicationContext类中获取对象

3.可以根据类型来获取对象，但我们换一种根据对象名称（名称被自动从UserService转换为userService）去拿。

而这种方式需要我们根据类型进行强转。这是因为返回类型为Object

ApplicationContext context = SpringApplication.run(IocDomeApplication.class, args);

UserService userService =(UserService) context.getBean("userService");
userService.say();
3.根据名称和类获取bean。
③Component注解

从ApplicationContext获取对象

1.首先使用@Component注解存储UserComponent对象

@Component
public class UserComponent {
    public void say(){
        System.out.println("Hi UserComponent!!!");
    }
}

2.从Spring上下文。ApplicationContext类中获取对象

ApplicationContext context = SpringApplication.run(IocDomeApplication.class, args);

根据名称和类获取bean。

UserComponent userComponent = context.getBean("userComponent", UserComponent.class);
userComponent.say();

④@Repository注解

存

@Repository
public class UserRepository {
    public void say(){
        System.out.println("Hi Repository!!!");
    }
}

取

//4.通过Repository注解
UserRepository userRepository = (UserRepository) context.getBean("userRepository");
userRepository.say();

⑤@configuration注解（配置存储）

存

@Configuration
public class UserConfiguration {
    public void say(){
        System.out.println("Hi Configuration!!!");
    }
}

取

​//5.通过configuration注解
UserConfiguration userConfiguration = context.getBean(UserConfiguration.class);
userComponent.say();


PS：

Spring是一个服务，服务启动。程序运行完。不会像学语法时那样直接结束。而是会一直提供服务。直到我们结束它。

上下文：

以CPU执行线程为例。CPU一秒执行上亿次。执行速度非常快来实现并发执行。当执行线程1到第二次执行线程1时。CPU怎么知道它执行到哪里了，接着哪里继续执行。这就是通过上下文记录的。Spring的上下文同理。

获取bean对象,父类BeanFactory提供的功能 

4.1.2五大注解之间的关系

我们发现五个类注解中都有@component注解。

我们可以认为，其他是个注解是@component的衍生类。@component也可以称作父类 *

@component是一个元注解。也就是说可以注解其他类注解。

下面三个注解用于更具体的例

@Controller：控制层

@Service：业务逻辑层

@Repository：持久化层

单从功能上看，Controller除了具备让spring管理的功能外，接口的第一层入口必须为Controller，其他怎么调用都行

4.2一个方法注解@Bean

类注解是添加到某个类上的，但是存在两个问题:

1.使用外包部的类，没有办法添加注解

2.一个类，需要多个对象，比如多个数据源。

这种场景我们就需要使用方法注解

 ⑥@Bean注解 的使用

@Bean注解的方法。通过使用@Bean注解，Spring 容器会将这个方法的返回值注册为一个 Bean（对象），从而使其可以被应用程序的其他部分注入和使用。

为了更方便找到@Bean注解，应该告诉Spring哪个类中有@Bean。此时通过@Configuration来根据这个注解生成这个对象

@Bean需要配合五大注解一起使用。

@Bean注解定义的对象，默认名称为方法名

@Bean注解定义的对象，重命名，也是@Bean（）在括号中写新名字

4.2.1定义多个对象

定义了多个对象的话,我们根据类型获取对象,获取的是哪个对象呢?

此时会报错哟：期望只有⼀个匹配,结果发现了多个

我们需要

@Bean注解的bean,bean的名称就是它的方法名 

接下来我们根据名称来获取bean对象

存

@Configuration
public class BeanConfig {
    @Bean
    public UserInfo userInfo(){
        UserInfo userInfo = new UserInfo();
        userInfo.setId(120);
        userInfo.setName("张三");
        userInfo.setAge(18);
        return userInfo;
    }

    @Bean
    public UserInfo userInfo2(){
        UserInfo userInfo2 = new UserInfo();
        userInfo2.setId(121);
        userInfo2.setName("李四");
        userInfo2.setAge(28);
        return userInfo2;
    }
}

取（方法名）

UserInfo userInfo = (UserInfo) context.getBean("userInfo");
UserInfo userInfo2 = (UserInfo) context.getBean("userInfo2");
System.out.println(userInfo);
System.out.println(userInfo2);

4.2.2bean的重命名

重命名名字也可以使用数组形式分别命名与之对应的下面的方法。例如：@Bean({"u1","u2"})

bean可以针对同一个类，定义多个对象

存

@Configuration
public class BeanConfig {
    @Bean({"u1","u2"})
    public UserInfo userInfo(){
        UserInfo userInfo = new UserInfo();
        userInfo.setId(120);
        userInfo.setName("张三");
        userInfo.setAge(18);
        return userInfo;
    }

    @Bean
    public UserInfo userInfo2(){
        UserInfo userInfo2 = new UserInfo();
        userInfo2.setId(121);
        userInfo2.setName("李四");
        userInfo2.setAge(28);
        return userInfo2;
    }
}

取（重命名+类名）

​//6.通过@Bean方法注解
UserInfo userInfo = context.getBean("u1",UserInfo.class);
UserInfo userInfo2 = context.getBean("u2",UserInfo.class);
System.out.println(userInfo);
System.out.println(userInfo2);
​

隐藏条件：

这五大注解必须在Spring的扫描路径下才会生效。

扫描路径默认为：启动类所在的路径。

是被@componentScan标识的当前类所在的路径。@SpringBootApplication包含了@componentScan。因此也是被@SpringBootApplication标识的类

由于本篇博客内容已经很多了，下一篇文章，我们会持续SpringIoC&ID的创作

会详细讲到扫描路径及关于其剩下的知识内容。


http://www.kler.cn/a/294578.html

相关文章：

  • ESLint 使用教程（三）：12个ESLint 配置项功能与使用方式详解
  • 沃飞长空郭亮博士荣获中国航空航天月桂奖
  • 【Threejs】相机控制器动画
  • WPF 应用程序中使用 Prism 框架时，有多种方式可以注册服务和依赖项
  • go T 泛型
  • .NET中通过C#实现Excel与DataTable的数据互转
  • tcp 流量控制
  • 开发一款通过蓝牙连接控制水电表的微信小程序
  • ubuntu 安装python3 教程
  • 开篇_____何谓安卓机型“工程固件” 与其他固件的区别 作用
  • springboot websocket 服务端
  • 用 Python 编写桌面时钟程序
  • MATLAB绘图基础5：MATLAB数据导入
  • Redis总结，是什么，干什么，怎么利用？
  • element table 表格 span-method 某一列进行相同合并 支持树结构表格
  • 数据结构基础之《（2）—对数器》
  • 海外直播对网速、带宽、安全的要求
  • Docker容器创建时，无法访问镜像源：Could not connect to archive.ubuntu.com:80
  • C语言操作符详解1（含进制转换，原反补码）
  • 消息队列 think-queue tp5.0
  • 使用Docker启动Redis容器并映射端口
  • ChatGPT3.5/4.0新手使用手册，国内中文版使用教程
  • 记录 vue-router 跳转到第一个有权限的菜单的实现方式
  • 【大模型开发】传统向量模型 vs 重排序模型：原理、实现与应用
  • 欺诈文本分类检测（十二）：模型导出与部署
  • 八大排序原来也不过如此