学习spring: 1.引子

news2024/9/20 16:46:05

问题

我们来看一段代码:

package org.malred;

import org.malred.entity.Car;
import org.malred.entity.Tire;

/**
 * Hello world!
 *
 */
public class App {

  public static void main(String[] args) {
    Car car = new Car();
    Tire lt = new Tire();
    car.setLeftTire(lt);
    Tire rt = new Tire();
    car.setRightTire(rt);
    System.out.println("汽车组装完毕!");
    System.out.println(car);
  }
}

这里有两个类, 一个是Tire表示轮胎, 一个是Car表示汽车, 我们每次创建汽车, 都需要依赖于轮胎, 然后我们要一个一个地把轮胎组装(set)到车上.

现在汽车只有两个轮子, 如果有多个呢? 如果还需要电池、车门、车窗等依赖呢? 那就会导致我们的代码逻辑里, 多了很多这种组装的逻辑, 而忽略了主要逻辑, 增加很多冗余代码

解决方案: IoC容器

于是就出现了IoC容器这个解决方案, 通过一个外部的IoC Service Provider来帮我们管理对象的创建和依赖注入(set), 我们自己就不需要手动new和set, 只需要专注于业务逻辑

spring就是一款轻量级的框架, 为我们提供了一系列功能, 其中, spring core就包含IoC容器

体验IoC:

先体验, 了解一下Ioc的好处, 原理下一篇讲

新建maven项目, 使用引入spring core依赖

引入依赖

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.3.24</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>5.3.24</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.24</version>
        </dependency>
    </dependencies>

项目结构

实体类

WheelingSystem.java

@Component
// 车轮系统
public class WheelingSystem {
    private Tire frontLeftTire;
    private Tire frontRightTire;
    private Tire backLeftTire;
    private Tire backRightTire;

    public WheelingSystem(Tire frontLeftTire, Tire frontRightTire, Tire backLeftTire, Tire backRightTire) {
        this.frontLeftTire = frontLeftTire;
        this.frontRightTire = frontRightTire;
        this.backLeftTire = backLeftTire;
        this.backRightTire = backRightTire;
    }

    @Override
    public String toString() {
        return "WheelingSystem{" +
                "frontLeftTire=" + frontLeftTire +
                ", frontRightTire=" + frontRightTire +
                ", backLeftTire=" + backLeftTire +
                ", backRightTire=" + backRightTire +
                '}';
    }
}

Tire.java

@Component
// 轮胎
public class Tire {
    @Override
    public String toString() {
        return "轮胎";
    }
}

Car.java

@Component
// 汽车
public class Car {
    private WheelingSystem ws;
    private Buttery buttery;

    public Car(WheelingSystem ws, Buttery buttery) {
        this.ws = ws;
        this.buttery = buttery;
    }

    @Override
    public String toString() {
        return "Car{" +
                "ws=" + ws +
                ", buttery=" + buttery +
                '}';
    }
}

Buttery.java

@Component
// 汽车电瓶
public class Buttery {
    @Override
    public String toString() {
        return "电瓶";
    }
}

可以看到, 我们给类加上了@Component注解, 接下来我们使用spring配置类进行扫描, 有这个注解的类会被识别并注册到IoC容器
而且我们提供了有参构造方法, IoC容器可以根据这些构造方法来了解依赖关系, 进行自动依赖注入

配置类

@Configuration//声明配置类
@ComponentScan(value = "org.malred")//配置自动扫描组件，双引号里配置要扫码的包
public class SpringIoCConfig {
}

spring 启动!

public class App {
    public static void main(String[] args) {
        // spirng工厂实例
        ApplicationContext context =
                new AnnotationConfigApplicationContext(SpringIoCConfig.class);
        // 获取IoC容器里Car类的实例
        Car car = context.getBean(Car.class);
        System.out.println(car);
    }
}