Spring05 SpringIOC & DI-阿里云开发者社区

名词解释

今天我们来介绍Spring框架的最重要的part之一 SpringIOC 和 DI

这里的SpringIOC 其实是容器的意思,Spring是一个包含了很多工具方法的IOC容器

什么是IOC呢?

IOC其实是Spring的核心思想

Inversion of Control (控制反转)

可能这里你还是不理解这个是啥意思其实就是我们一般创建对象的方式是使用new等方式创建,但是这里我们让Spring帮助我们创建对象,程序中只需要进行DI(对象注入)即可

Spring是一个IOC容器,所以有时候Spring也称之为Spring容器

这里举一个生活上的例子来解释一下SpringIOC的含义

我们招聘的时候,其实企业员工的入职和解雇等操作都得老板自己来,但是这里我们老板转给了HR来处理

案例对比

传统方式

假如我们需要实现这么一个依赖关系的思路

我们第一版本先使用传统方式进行操作一下

//轮胎
public class Tire {
    private int size;
    private String color;
 
    public Tire(int size) {
        System.out.println("tire size:"+size);
    }
}
 
//底盘
public class Bottom {
    private Tire tire;
 
    public Bottom(int size) {
        tire = new Tire(size);
        System.out.println("tire init...");
    }
}
 
//框架
public class Framework {
    private Bottom bottom;
 
    public Framework(int size) {
        bottom =  new Bottom(size);
        System.out.println("bottom init....");
    }
}
 
//汽车
public class Car {
    private Framework framework;
 
    public Car(int size) {
        framework = new Framework(size);
        System.out.println("framework init...");
    }
 
    public void run() {
        System.out.println("car run...");
    }
}
 
//启动类
public class Main {
    public static void main(String[] args)
    {
        Car car = new Car(10);
        car.run();
    }
}

这里我们发现,我们如果对车万一需要进行一些操作,就会导致牵一发而动全身的效果

比如,如果我们为车的轮胎指定轮胎的厂家,这样我们就需要从轮胎类逐个的向上进行修改

这样程序的耦合度就太高了,于是我们现在介绍一下SpringIOC的方式来管理对象

注:这里只是模拟SpringIOC的方式来创建对象,这里SpringIOC其实我们也可以理解为一种思想,本质上要求交给Spring管理的对象是无状态的

SpringIOC版本

这里我们可以将对象的创建放到一块儿,Spring框架的想法是将对象的创建交给Spring来,我们向使用的时候只需要使用DI注入即可

这里我们先模拟一下程序的解耦,避免这种牵一发而动全身的操作存在

//bottom
public class Bottom {
    private Tire tire;
 
    public Bottom(Tire tire) {
        this.tire = tire;
        System.out.println("tire init...");
    }
}
 
 
 
//Car
public class Car {
    private Framework framework;
 
    public Car(Framework framework) {
        this.framework = framework;
        System.out.println("framework init...");
    }
 
    public void run() {
        System.out.println("car run...");
    }
}
 
 
//Framework
public class Framework {
    private Bottom bottom;
 
    public Framework(Bottom bottom) {
        this.bottom = bottom;
        System.out.println("bottom init....");
    }
}
 
 
 
//Tire
public class Tire {
    private int size;
    private String color;
 
    public Tire(int size, String color) {
        System.out.println("tire size:"+size+",color:"+color);
    }
}
 
 
 
//Main
public class Main {
    public static void main(String[] args) {
        Tire tire = new Tire(17, "red");
        Bottom bottom = new Bottom(tire);
        Framework framework = new Framework(bottom);
        Car car = new Car(framework);
        car.run();
    }
}

这里我们发现了对象创建的思路是这样的

传统方式是创建Car再去找需求的依赖,是一个从下到上的结构

而IOC的方式是将对象依赖注入,是改进之后的控制权反转

这里我们可以看出IOC思维的优势

1.减少了类之间的耦合度

2.便于对象的集中管理

DI

解释就是依赖注入的意思,我们刚刚这种传对象的操作其实理论依据就是DI

IOC详解

下面我们进行SpringIOC的详解

首先我们提出一个Bean的概念 Spring中的对象称之为Bean

我们如果想把某些对象交给Spring管理,我们可以用以下注解来修饰

1.类注解

@Repository @Service @Component @Configuration @Controller

2.方法注解

@Bean

注:Spring也不一定需要在web网页上显示,我们也可以在控制台打印

首先我们来尝试一下这五大类注解

@Component
public class UserComponent {
    public void doComponent()
    {
        System.out.println("UserComponent");
    }
}
 
 
@Configuration
public class UserConfig {
    public void doConfig()
    {
        System.out.println("UserConfig doConfig");
    }
}
 
 
@Repository
public class UserRepo {
    public void doRepo()
    {
        System.out.println("UserRepo");
    }
}
 
 
@Service
public class UserService {
 
    public void doService() {
        System.out.println("UserService doService");
    }
}
 
 
@Controller
public class helloTest {
    public void hello()
    {
        System.out.println("hello");
    }
}
 
//启动类
@SpringBootApplication
public class SpringIocApplication {
 
    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(SpringIocApplication.class, args);
        helloTest bean = context.getBean(helloTest.class);
        bean.hello();
    }
 
}

这里我们只需要用相同的模板就可以实现这里的IOC操作

这里我们介绍一下getBean的几个参数

我们可以根据类型找到类,可以根据类型+方法名找到类,也可以只根据方法名寻找类

注意这里Bean的名字是以小驼峰的方式去拿的

注意这里获取到的三个对象都是同一个对象

类的命名规则:如果只有开头字母是大写的,那么我们就将第一个字母变成小写的,如果前两个都是大写字母,那么我们就直接返回这个名字

假设这里我们使用的类名是HElloTest,我们使用首字母小写小驼峰的方式就会直接失败

这里我们可以看到日志显示找不到这个Bean 实际上开头两个字母都大写Bean就不会修改名称,直接使用原名即可获取

使用的就是这个方法

注:idea中查询类使用 ctrl + shift + alt + n

再查询方法可以使用ctrl + f查询

Application和BeanFactory之间的关系?

1.父子关系 BeanFactory有的功能Application都有

2.除此之外Application有很多其他的功能

3.BeanFactory是一个懒加载的方式

Application是一个预加载的方式,效率更高

五大注解的对比

我们看到除了component其他的四大注解基本上都是一样的

可以混用嘛??

理论上可以,但是工作中一般不允许混用,但是其中的界限分割的不明确,有的时候还是混用的

@Controller @Conponent 主键

@Service 业务逻辑层 @Repository 数据层 @Configuration 表现层

注:这里的Controller有特殊用处,其余三个可以在理论上混用(事实上也可以)

其余四个注解都包含了Component

注:@Controller如果进行替换不一定能实现路由映射

注:这里不加上注解时无法将对象交给Spring管理的

这里我将@Controller注解删除

Spring就会获取不到这个Bean

下面开始使用Bean的方式书写

注意:@Bean的使用也需要配合五大注解一起使用

Spring不可能扫描所有的项目文件,这里我们就使用五大注解来标识一下需要扫描的文件

@Bean的命名方式就是方法名

Spring扫描的默认是哪些文件呢?

我们先做一个测试,将启动类放到component包下

这时候去获取component的类就是可以的,获取HelloTest的类就是失败的

Spring扫描的三大条件

1.使用五大注解标记类

2.使用Bean注解标记方法

3.默认扫描路径是启动类所在的目录以及子目录

如果我们向让其扫描其他的路径,就可以使用@ComponentScan(basePackages = "")

我们这样就可以获取User对象了

@Configuration
public class UserConfig {
    @Bean
 
    public User doConfig()
    {
        User u1 = new User();
        u1.setName("zhangsan");
        u1.setId(1001);
        return u1;
    }
}