Spring IoCDI

一、Spring 是什么？

Spring 是包含众多工具方法的 IoC 容器。

1.1 什么是容器？

容器是用来容纳某种物品的装置。例如生活中的水杯、垃圾桶、冰箱等等这些都是容器。

1.2 什么是 IoC？

IoC 是控制反转，Bean 的控制权发生了反转。

什么是控制反转？也就是控制权反转。什么的控制权发生了反转？获取依赖对象的过程发生了反转，也就是说，当需要某个对象时，传统开发模式中需要自己通过 new 创建对象，现在不需要再进行创建，把创建对象的任务交给容器，程序中只需要依赖注入就可以了。

这个容器称为：IoC 容器，Spring 是 IoC 容器，所以有时 Spring 也称为 Spring 容器。

控制反转是一种思想，在生活也是处处体现。

比如自动驾驶，传统驾驶方式，车辆的横向和纵向驾驶权由驾驶员来控制，现在交给了驾驶自动化系统控制。

比如招聘，企业的员工招聘、入职、解雇等控制权，由老板交给 HR 来处理。

1.3 IoC 介绍

接下来我们通过案例来了解一下什么是 IoC。
需求：造一辆车

1.3.1 传统开发

我们的实现思路是这样的：

先设计轮子，然后根据轮子的大小设计出底盘，接着根据底盘设计车身，最后根据车身设计好整个汽车。这里就出现了一个“依赖”关系：汽车依赖车身，车身依赖底盘，底盘依赖车轮子。

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

1.3.2 问题分析

这样设计看起来没问题，但是可维护性却很低。

接下来需求有了变更：随着对车的需求量越来越大，个性化需求也会越来越多，我们需要加工多尺寸轮胎。

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

这是修改后的代码。

修改的代码如图所示：

修改后代码会继续进行报错，需要继续进行修改。

从以上代码可以看出，以上程序的问题是：当最底层代码改动后，整个调用链上的所有代码都需要修改。

程序的耦合度非常高（修改一处代码，影响其他处的代码修改）。

1.3.3 解决方案

我们尝试换一种思路,我们先设计汽车的大概样子,然后根据汽车的样子来设计车身,根据车身来设计底盘.最后根据底盘来设计轮子.这时候,依赖就倒置过来了:轮子依赖底盘,底盘依赖车身,车身依赖汽车.

这就类似我们打造一辆完整的汽车,如果所有的配件都是自己造,那么当客户需求发生改变的时候,比如轮胎的尺寸不再是原来的尺寸了,那我们要自己动来改了,但如果我们是把轮胎外包出去,那么即使是轮胎的尺寸发生改变了,我们就只需要想代理工厂下订单就行了,我们自身是不需要出力的.

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

代码经过以上调整,无论底层类如何变化,整个调用链是不用做任何改变的,这样就完成了代码之间的解耦,从而实现了更加灵活,通用的程序设计了.

1.3.4 IoC优势

在传统的代码中对象创建顺序是:Car->Framework->Bottom->Tire

改进之后解耦的代码的对象创建顺序是:Tire->Bottom->Framework->Car

我们发现一个规律,通常程序的实现代码,类的创建顺序是反的,传统代码是Car控制并创建了Framework,Framework创建了Botom,依次往下,二改进之后的控制权发生的反转,不再是使用对象创建并控制依赖对象了,而是把依赖对象注入当前对象中,依赖对象的控制权不再由当前类控制了.

这部分代码,就是IoC容器做的工作.

从上面可以看出来,IoC容器具备以下优点:

资源不有使用资源的双方管理,而又不使用的第三方管理,这可以带来很多好处.第一,资源集中管理,实现资源的配置和易管理.第二,降低了使用双方依赖程度,也就是我们说的耦合度.

  1. 资源集中管理:IoC容器会帮我们管理一些资源,我们需要使用时,只需要从IoC容器中去获取就可以了
  2. 我们在创建实例的时候不需要了解其中的细节,降低了使用资源双方的依赖程度,也就是耦合度.

Spring就是一种IoC容器,帮助我们来做了这些资源管理.

1.4DI

DI:(依赖注入):容器在运行期间,动态的为应用程序提供运行时所依赖的资源,称之为依赖注入.

Spring是一个IoC容器,作为容器,那么它就具备两个最基础的功能:

  1. 存
  2. 取


二.IoC详解

前面我们提到IoC控制反转,也就是将对象的控制权交给Spring的IoC容器,由IoC容器创建及管理对象,也就是bean的存储

2.1Bean的存储

想把某个对象交给IoC容器管理,需要在类上添加一个注解.Spring框架为了更好的服务Web应用程序,提供了更丰富的注解.

共有两类注解类型可以实现:

  1. 类注解:@Controller,@Service,@Component,@Configuration
  2. 方法注解:@Bean

2.1.1@Controller

使用@Controller存储bean的代码如下所示:

@Controller public class UserController { public void sayHi(){ System.out.println("hi,UserController"); } }

如何在Spring容器中获取对象

@SpringBootApplication public class SpringIoCCsdnDemoApplication { public static void main(String[] args) { ApplicationContext context= SpringApplication.run(SpringIoCCsdnDemoApplication.class, args); UserController userController =(UserController) context.getBean("userController"); userController.sayHi(); UserController bean = context.getBean(UserController.class); bean.sayHi(); // (context.getBean("userController", UserController.class)) UserController bean1 = context.getBean("userController", UserController.class); bean1.sayHi(); } }

2.1.2 Beam命名约定

比如

类名:UserController,Bean的名称:userController

类名:AccountManager,Bean的名称:accountmanager

类名:AccountService,Bean的名称:accountService

类名:UController,Bean的名称:UController

类名:AManager,Bean的名称:AManager

2.1.3 @Service

@Service public class ServiceController { public void saiHi(){ System.out.println("hi,serviceController!"); } }

在Spring容器中获取

ServiceController serviceController =(ServiceController) context.getBean("serviceController"); serviceController.saiHi(); ServiceController bean = context.getBean(ServiceController.class); bean.saiHi(); ServiceController bean1 = context.getBean("serviceController", ServiceController.class); bean1.saiHi(); System.out.println(serviceController); System.out.println(bean); System.out.println(bean1);

2.1.4@Repository

@Repository public class ReposityController { public void sayHi(){ System.out.println("hi,ReposityController"); } }

从Spring仓库中获取

ReposityController bean = context.getBean(ReposityController.class); System.out.println(bean); bean.sayHi(); ReposityController bean1 = context.getBean("reposityController", ReposityController.class); System.out.println(bean1); bean1.sayHi(); ReposityController reposityController =(ReposityController) context.getBean("reposityController"); reposityController.sayHi(); System.out.println(reposityController);

2.1.5 @Compoent

@Component public class CompoentController { public void sayHi(){ System.out.println("hi,CompoentController"); } }

从Spring仓库中获取

CompoentController bean =(CompoentController) context.getBean("compoentController"); System.out.println(bean); bean.sayHi(); CompoentController bean1 = context.getBean(CompoentController.class); bean1.sayHi(); System.out.println(bean1); CompoentController compoentController = context.getBean("compoentController", CompoentController.class); compoentController.sayHi(); System.out.println(compoentController);

3.1.6 @Configuration

@Configuration public class ConfigurationController { public void sayHi(){ System.out.println("hi,ConfigurationController"); } }

从Spring仓库中获取

ConfigurationController bean = context.getBean(ConfigurationController.class); System.out.println(bean); bean.sayHi(); ConfigurationController configurationController =(ConfigurationController) context.getBean("configurationController"); configurationController.sayHi(); System.out.println(configurationController); ConfigurationController bean1 = context.getBean("configurationController", ConfigurationController.class); bean1.sayHi(); System.out.println(bean1);

2.2为啥么要这么多注解?

  • @Controller:控制层,接收请求,对请求进行处理,并进行响应
  • @Service:业务逻辑层,处理具体的业务逻辑
  • @Repository:数据访问层,也称为持久层,负责数据访问操作
  • @Configuration:配置层,处理项目中的一些配置信息

应用分层,调用流程如下:

类注解之间的关系

查看@Controller/@Service/@Repository/@Configuration等注解的源码大线:

其实这些注解里面都有一个@Compoent,说明它们本身就是属于@Compoent的"子类".@Component是一个元注解,也就是说可以注解其他类注解,@Controller,@Service,@Repository等.这些注解被称为@Component的衍生注解,@Controller,@Service和@Repository用于具体的用例分类(分别在控制层,业务逻辑层,持久化层),在开发过程中,如果你要在业务逻辑使用@Component或@Service,显然@Srevice是更好的选择.

2.3方法注解@Bean

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

  1. 使用外部包里的类,没办法添加类注解
  2. 一个类,需要多个对象,比如多个数据源

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

@Component public class BeanController { @Bean public User user(){ User user=new User(); user.setName("zhangsan"); user.setAge(18); return user; } } User user= context.getBean(BeanController.class).user(); System.out.println(user);

定义多个对象

@Bean public User user1(){ User user=new User(); user.setName("zhangsan"); user.setAge(18); return user; } @Bean public User user2(){ User user=new User(); user.setName("lisi"); user.setAge(18); return user; } User user= context.getBean(User.class); System.out.println(user);

运行结果

报错信息显示:期望只有一个匹配,结果发现了两个user1,user2

User user1 =(User) context.getBean("user1"); System.out.println(user1); User user2=(User) context.getBean("user2"); System.out.println(user2);

name={}可以省略,如下代码所示:

@Bean({"u1","user"}) public User user(){ User user=new User(); user.setAge(19); user.setName("lisi"); return user; }

只有一个名称时,{}也可以省略

@Bean("u2") public User user1(){ User user=new User(); user.setAge(19); user.setName("lisi"); return user; }

2.4扫描路径

使用前面学习的四个注解声明的bean,一定会生效吗?

不一定(原因:bean想要生效,还需要被Spring扫描)

三.DI详解

关于依赖注入,Spring也给我们提供了三种方式:

  1. 属性注入
  2. 构造方法注入
  3. Setter注入

3.1属性注入

属性注入是使用@Autowired实现的.将Service类注入到Controller类中.

@Service public class UserService { public void sayHi(){ System.out.println("hi,userService"); } } @Controller public class UserInjection { @Autowired private UserService userService; public void sayHi1(){ userService.sayHi(); System.out.println("hi,userInjection"); } }

去掉@Autowired,在运行一下程序看看结果

3.2构造方法注入

@Controller public class UserInjection2 { // @Autowired private UserService userService; @Autowired public UserInjection2(UserService service) { this.userService=service; } public void sayhi2(){ userService.sayHi(); System.out.println("hi,userInjection2"); } }

注意事项:如果类只有一个构造方法,那么@Autowired注解可以省略;如果类中有多个构造方法,那么需要添加上@Autowired来明确指定到底使用哪个构造方法.

3.3Setter注入

Setter注入和属性的Setter方法实现类似,只不过在设置set方法的时候需要加上@Autowired注解

@Controller public class UserInjection3 { private UserService userService; @Autowired public void setUserService(UserService userService) { this.userService = userService; } public void sayhi1(){ userService.sayHi(); System.out.println("hi,UserInjection3"); } }

3.4三种注入优缺点分析

属性注入

优点:简洁,方便;

缺点:

只能用于IoC容器,如果是非IoC容器不可用,并且只有在使用的时候才会出现NPE(空指针异常)

不能注入一个Final修饰的属性

构造函数注入

优点:

可以注入final修饰的属性

注入的对象不会被修改

依赖对象在使用前一定会被完全初始化,因为依赖是在类的构造方法中执行的,二构造方法是在类加载阶段就会执行的方法

通用性好,构造方法是JDK支持的,所以更换任何框架,都是适用的

缺点:

注入多个对象时,代码会比较繁琐

Setter注入

优点:方便在类实例之后,重新对该对象进行配置或者注入

缺点:

不能注入一个FInal修饰的属性

注入对象可能会改变,因为setter方法可能会被多次调用,就会被修改的风险