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

Java EE进阶5：Spring IoCDI

news 2025/11/16 8:58:37

1.IoC & DI 入门

1.1 Spring概念

Introduction to the Spring IoC Container and Beans :: Spring Frameworkhttps://docs.spring.io/spring-framework/reference/core/beans/introduction.html

1.2 IoC介绍

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

（1）传统程序开发

最终程序的实现代码如下：

package com.example.springiocdemo.v1;public class Main {public static void main(String[] args) {Car car = new Car();car.run();}//汽车static public class Car{private Framework framework;public Car(){this.framework = new Framework();System.out.println("car init..."); //init 初始化}public void run(){System.out.println("car run...");}}//框架static public class Framework{private Bottom bottom;public Framework(){this.bottom = new Bottom();System.out.println("Framework init...");}}//底盘static public class Bottom{private Tire tire;public Bottom(){this.tire = new Tire();System.out.println("Bottom init...");}}//轮胎static public class Tire{private int size = 17;public Tire(){System.out.println("tire size:" + size);}}}

（2）问题分析

（3）解决方案

（4） IoC程序开发

基于以上思路，我们把调⽤汽车的程序示例改造一下，把创建子类的方式，改为注入传递的方式。

具体实现代码如下：

package com.example.springiocdemo.v2;public class Main {public static void main(String[] args) {Tire tire = new Tire(20, "red");Bottom bottom = new Bottom(tire);Framework framework = new Framework(bottom);Car car = new Car(framework);car.run();}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...");}}static class Framework {private Bottom bottom;public Framework(Bottom bottom) {this.bottom = bottom;System.out.println("Framework init...");}}static class Bottom {private Tire tire;public Bottom(Tire tire) {this.tire = tire;System.out.println("Bottom init...");}}static class Tire {private int size;private String color;public Tire(int size, String color) {this.size = size;System.out.println("轮胎尺⼨：" + size + "，轮胎颜色：" + color);}}}

（5） IoC优势

1.3 DI介绍

2.IoC & DI 使用

实现:（1）把BookDao交给Spring管理,由Spring来管理对象

（2）把BookService交给Spring管理,由Spring来管理对象

（3）删除创建BookDao的代码,从Spring中获取对象

（4）删除创建BookService的代码,从Spring中获取对象

（5）重新运行程序 http://127.0.0.1:8080/book_list.html

3.IoC详解-Bean的存储

通过上面的案例,我们已经知道了SpringIoC和DI的基本操作,接下来我们来系统的学习SpringIoC和DI的操作。

前面我们提到IoC控制反转，就是将对象的控制权交给Spring的IOC容器，由IOC容器创建及管理对象。

也就是bean的存储.

在之前的入门案例中，要把某个对象交给IOC容器管理，需要在类上添加⼀个注解： @Component，而Spring框架为了更好的服务web应用程序，提供了更丰富的注解。【Spring帮我们new了对象所以我们可以直接调用】

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

1. 类注解：@Controller、@Service、@Repository、@Component、@Configuration.

2. 方法注解：@Bean. （bean的名称 = 方法名）

3.1 类注解

（1）@Controller（控制器存储）

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

    @Controller // 将对象存储到 Spring 中 public class UserController {public void sayHi(){System.out.println("hi,UserController...");}}

如何观察这个对象已经存在Spring容器当中了呢? 接下来我们学习如何从Spring容器中获取对象

    @SpringBootApplicationpublic class SpringIocDemoApplication {public static void main(String[] args) {//获取Spring上下⽂对象 ApplicationContext context = SpringApplication.run(SpringIocDemoApplication.class, args);//从Spring上下⽂中获取对象 UserController userController = context.getBean(UserController.class);//使⽤对象 userController.sayHi();}}

获取bean对象的其他方式

上述代码是根据类型来查找对象,如果Spring容器中,同⼀个类型存在多个bean的话,怎么来获取呢?

ApplicationContext也提供了其他获取bean的方式,ApplicationContext获取bean对象的功能,是父类BeanFactory提供的功能。

// 1. 根据bean名称获取bean Object getBean(String var1) throws BeansException;// 2. 根据bean名称和类型获取bean <T> T getBean(String var1, Class<T> var2) throws BeansException;// 3. 按bean名称和构造函数参数动态创建bean,只适⽤于具有原型(prototype)作⽤域的bean Object getBean(String var1, Object... var2) throws BeansException;// 4. 根据类型获取bean <T> T getBean(Class<T> var1) throws BeansException;// 5. 按bean类型和构造函数参数动态创建bean, 只适⽤于具有原型(prototype)作⽤域的
bean<T> T getBean(Class<T> var1, Object... var2) throws BeansException;

常用的是上述1,2,4种,这三种方式,获取到的bean是⼀样的，其中1,2种都涉及到根据名称来获取对象，bean的名称是什么呢?

Spring bean是Spring框架在运行时管理的对象,Spring会给管理的对象起⼀个名字。比如学校管理学生,会给每个学生分配一个学号,根据学号,就可以找到对应的学生。Spring也是如此,给每个对象起⼀个名字,根据Bean的名称(BeanId)就可以获取到对应的对象。

Bean命名约定

我们看下官方文档的说明:https://docs.spring.io/spring-framework/reference/core/beans/definition.html#beans-beanname

    @SpringBootApplicationpublic class SpringIocDemoApplication {public static void main(String[] args) {//获取Spring上下⽂对象ApplicationContext context = SpringApplication.run(SpringIocDemoApplication.class, args);//根据bean类型, 从Spring上下⽂中获取对象；有局限性，一个类型对应多个bean。UserController userController1 = context.getBean(UserController.class);//根据bean名称, 从Spring上下⽂中获取对象；一个bean可以有多个名称，但是名称不会重复。UserController userController2 = (UserController)context.getBean("userController");//根据bean类型+名称, 从Spring上下⽂中获取对象UserController userController3 = context.getBean("userController",UserController.class);System.out.println(userController1);System.out.println(userController2);System.out.println(userController3);}}

（2）@Service（服务存储）

使用@Service存储bean的代码如下所示：

    @Servicepublic class UserService {public void sayHi(String name) {System.out.println("Hi," + name);}}

读取bean的代码：

    @SpringBootApplicationpublic class SpringIocDemoApplication {public static void main(String[] args) {//获取Spring上下⽂对象 ApplicationContext context = SpringApplication.run(SpringIocDemoApplication.class, args);//从Spring中获取UserService对象 UserService userService = context.getBean(UserService.class);//使⽤对象 userService.sayHi();}}

（3）@Repository（仓库存储）

使用@Repository 存储bean的代码如下所示：

    @Repositorypublic class UserRepository {public void sayHi() {System.out.println("Hi, UserRepository~");}}

读取bean的代码：

    @SpringBootApplicationpublic class SpringIocDemoApplication {public static void main(String[] args) {//获取Spring上下⽂对象 ApplicationContext context = SpringApplication.run(SpringIocDemoApplication.class, args);//从Spring上下⽂中获取对象 UserRepository userRepository = context.getBean(UserRepository.class);//使⽤对象 userRepository.sayHi();}}

（4）@Component（组件存储）

使用@Component存储bean的代码如下所示：

    @Componentpublic class UserComponent {public void sayHi() {System.out.println("Hi, UserComponent~");}}

读取bean的代码：

    @SpringBootApplicationpublic class SpringIocDemoApplication {public static void main(String[] args) {//获取Spring上下⽂对象 ApplicationContext context = SpringApplication.run(SpringIocDemoApplication.class, args);//从Spring上下⽂中获取对象 UserComponent userComponent = context.getBean(UserComponent.class);//使⽤对象 userComponent.sayHi();}}

（5）@Configuration（配置存储）

使用@Configuration存储bean的代码如下所示：

    @Configurationpublic class UserConfiguration {public void sayHi() {System.out.println("Hi,UserConfiguration~");}}

读取bean的代码：

    @SpringBootApplicationpublic class SpringIocDemoApplication {public static void main(String[] args) {//获取Spring上下⽂对象 ApplicationContext context = SpringApplication.run(SpringIocDemoApplication.class, args);//从Spring上下⽂中获取对象 UserConfiguration userConfiguration = context.getBean(UserConfiguration.class);//使⽤对象 userConfiguration.sayHi();}}

3.2 为什么要这么多类注解？

类注解之间的关系

3.3 方法注解@Bean

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

① 使用外部包里的类,没办法添加类注解

② 一个类,需要多个对象,比如多个数据源

这种场景,我们就需要使用方法注解@Bean ，我们先来看看方法注解如何使用：

public class BeanConfig {@Beanpublic User user(){User user = new User();user.setName("zhangsan");user.setAge(18);return user;}
}

然而，当我们写完以上代码，尝试获取bean对象中的user时却发现，根本获取不到：

@SpringBootApplication
public class SpringIocDemoApplication {public static void main(String[] args) {//获取Spring上下⽂对象ApplicationContext context = SpringApplication.run(SpringIocDemoApplication.class, args);//从Spring上下⽂中获取对象 User user = context.getBean(User.class);//使⽤对象 System.out.println(user);}
}

以上程序的执行结果如下：

这是为什么呢？下面来解释一下

（1）方法注解要配合类注解使用

在Spring框架的设计中，方法注解 @Bean 要配合类注解才能将对象正常的存储到Spring容器中，如下代码所示。

@Component
public class BeanConfig {@Beanpublic User user(){User user = new User();user.setName("zhangsan");user.setAge(18);return user;}
}

再次执行以上代码，运行结果如下：

（2）定义多个对象

对于同⼀个类,如何定义多个对象呢? 比如多数据源的场景,类是同一个,但是配置不同,指向不同的数据源。

我们看下@Bean的使用

@Component
public class BeanConfig {@Beanpublic User user1(){User user = new User();user.setName("zhangsan");user.setAge(18);return user;}@Beanpublic User user2(){User user = new User();user.setName("lisi");user.setAge(19);return user;}
}

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

@SpringBootApplication
public class SpringIocDemoApplication {public static void main(String[] args) {//获取Spring上下⽂对象 ApplicationContext context = SpringApplication.run(SpringIocDemoApplication.class, args);//从Spring上下⽂中获取对象 User user = context.getBean(User.class);//使⽤对象 System.out.println(user);}
}

运行结果:

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

从报错信息中,可以看出来,@Bean注解的bean,bean的名称就是它的方法名

//因为一个类型（即对象0..0）可以对应多个bean（即多个名称，即它的方法名），所以根据bean类型, 从Spring上下文中获取对象就有局限性。【一个类型可以对应多个bean的前提是一个bean可以有多个名称……………】

//因为一个bean可以有多个名称（bean的名称就是它的方法名！！），但是名称不会重复，所有可以根据根据bean名称, 从Spring上下文中获取对象。

（结合前面命名bean时的代码再思考一下）

    @SpringBootApplicationpublic class SpringIocDemoApplication {public static void main(String[] args) {//获取Spring上下⽂对象ApplicationContext context = SpringApplication.run(SpringIocDemoApplication.class, args);//根据bean类型, 从Spring上下⽂中获取对象；有局限性，一个类型对应多个bean。UserController userController1 = context.getBean(UserController.class);//根据bean名称, 从Spring上下⽂中获取对象；一个bean可以有多个名称，但是名称不会重复。UserController userController2 = (UserController)context.getBean("userController");//根据bean类型+名称, 从Spring上下⽂中获取对象UserController userController3 = context.getBean("userController",UserController.class);System.out.println(userController1);System.out.println(userController2);System.out.println(userController3);}}

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

@SpringBootApplication
public class SpringIocDemoApplication {public static void main(String[] args) {//获取Spring上下⽂对象 ApplicationContext context = SpringApplication.run(SpringIocDemoApplication.class, args);//根据bean名称, 从Spring上下⽂中获取对象 User user1 = (User) context.getBean("user1");User user2 = (User) context.getBean("user2");System.out.println(user1);System.out.println(user2);}
}

运行结果:

（3）重命名Bean

可以通过设置name属性给Bean对象进行重命名操作，如下代码所示。

@Bean(name = {"u1","user1"})
public User user1(){User user = new User();user.setName("zhangsan");user.setAge(18);return user;
}

此时我们使用u1就可以获取到User对象了，如下代码所示。

@SpringBootApplication
public class SpringIocDemoApplication {public static void main(String[] args) {//获取Spring上下⽂对象 ApplicationContext context = SpringApplication.run(SpringIocDemoApplication.class, args);//从Spring上下⽂中获取对象 User u1 = (User) context.getBean("u1");//使⽤对象 System.out.println(u1);}
}

3.4 扫描路径

再运行代码:

@SpringBootApplication
public class SpringIocDemoApplication {public static void main(String[] args) {//获取Spring上下⽂对象 ApplicationContext context = SpringApplication.run(SpringIocDemoApplication.class, args);//从Spring上下⽂中获取对象 User u1 = (User) context.getBean("u1");//使⽤对象 System.out.println(u1);}
}

@ComponentScan({"com.example.demo"})
@SpringBootApplication
public class SpringIocDemoApplication {public static void main(String[] args) {//获取Spring上下⽂对象 ApplicationContext context = SpringApplication.run(SpringIocDemoApplication.class, args);//从Spring上下⽂中获取对象 User u1 = (User) context.getBean("u1");//使⽤对象 System.out.println(u1);}
}

4.DI详解

4.1 属性注入

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

Service类的实现代码如下：

import org.springframework.stereotype.Service;
@Service
public class UserService {public void sayHi() {System.out.println("Hi,UserService");}
}

Controller类的实现代码如下：

@Controller
public class UserController {//注⼊⽅法1: 属性注⼊ @Autowiredprivate UserService userService;public void sayHi(){System.out.println("hi,UserController...");userService.sayHi();}
}

获取Controller中的sayHi方法：

@SpringBootApplication
public class SpringIocDemoApplication {public static void main(String[] args) {//获取Spring上下⽂对象 ApplicationContext context = SpringApplication.run(SpringIocDemoApplication.class, args);//从Spring上下⽂中获取对象 UserController userController = (UserController) context.getBean("userController");//使⽤对象 userController.sayHi();}
}

最终结果如下：

4.2 构造方法注入

构造方法注入是在类的构造方法中实现注入，如下代码所示：

@Controller
public class UserController2 {//注⼊⽅法2: 构造⽅法 private UserService userService;@Autowiredpublic UserController2(UserService userService) {this.userService = userService;}public void sayHi(){System.out.println("hi,UserController2...");userService.sayHi();}
}

注意事项：如果类只有一个构造方法，那么@Autowired注解可以省略；如果类中有多个构造方法，那么需要添加上@Autowired来明确指定到底使用哪个构造方法。(优先使用无参的)

4.3 Setter注入

Setter注入和属性的Setter方法实现类似，只不过在设置set方法的时候需要加上@Autowired注解，如下代码所示：

@Controller
public class UserController3 {//注⼊⽅法3: Setter⽅法注⼊ private UserService userService;@Autowiredpublic void setUserService(UserService userService) {this.userService = userService;}public void sayHi(){System.out.println("hi,UserController3...");userService.sayHi();}
}

练习一下：尝试一下set方法如果不加@Autowired注解能注入成功吗？不能

4.4 三种注入优缺点分析

更多DI相关内容参考：https://docs.spring.io/spring-framework/reference/core/beans/dependencies.html

4.5 @Autowired存在问题

当同一类型存在多个bean时,使用@Autowired会存在问题

@Component
public class BeanConfig {@Bean("u1")public User user1(){User user = new User();user.setName("zhangsan");user.setAge(18);return user;}@Beanpublic User user2() {User user = new User();user.setName("lisi");user.setAge(19);return user;}
}

@Controller
public class UserController {@Autowiredprivate UserService userService;//注⼊user @Autowiredprivate User user;public void sayHi(){System.out.println("hi,UserController...");userService.sayHi();System.out.println(user);}
}

报错的原因是：非唯一的Bean对象。

如何解决上述问题呢？ Spring提供了以下几种解决方案： • @Primary • @Qualifier • @Resource

（1）使用@Primary注解：当存在多个相同类型的Bean注入时，加上@Primary注解，来确定默认的实现。

@Component
public class BeanConfig {@Primary //指定该bean为默认bean的实现@Bean("u1")public User user1(){User user = new User();user.setName("zhangsan");user.setAge(18);return user;}@Beanpublic User user2() {User user = new User();user.setName("lisi");user.setAge(19);return user;}
}

（2）使用@Qualifier注解：指定当前要注入的bean对象。在@Qualifier的value属性中，指定注入的bean 的名称。

• @Qualifier注解不能单独使用，必须配合@Autowired使用

@Controller
public class UserController {@Qualifier("user2") //指定bean名称 @Autowiredprivate User user;public void sayHi(){System.out.println("hi,UserController...");System.out.println(user);}
}

（3）使用@Resource注解：是按照bean的名称进行注入。通过name属性指定要注入的bean的名称。

@Controller
public class UserController {@Resource(name = "user2")private User user;public void sayHi(){System.out.println("hi,UserController...");System.out.println(user);}
}

常见面试题:

@Autowird与@Resource的区别

• @Autowired是spring框架提供的注解，而@Resource是JDK提供的解。

• @Autowired默认是按照类型注入（也有名称），而@Resource是按照名称注入（也有类型）。相比于@Autowired来说， @Resource支持更多的参数设置，例如name设置，根据名称获取Bean。