从Spring说起

一. Spring是什么

在前面的博文中,我们学会了SpringMVC的使用,可以完成一些基本功能的开发了,但是铁子们肯定有很多问题,下面来从Spring开始介绍,第一个问题,什么是Spring?

Spring是包含了众多工具方法的IOC容器.

Spring有两个核心思想--IOC和AOP,本章先来讲解IOC......

1.1 IOC思想

IOC(Inversion Of Control),控制反转,更详细的解释就是反转对象的控制权.

你们肯定更懵了,对象的控制权是啥,在谁手里?

实际上,这里的控制权指的是对象的创建和销毁,本来控制权是在程序猿手里的

来举个栗子~滑稽老铁攒够了养老钱,准备建一个自己的院子,于是他买好了一套毛坯别墅

要想住进去得有家具呀,老铁高低得给自己整一套舒服的.

public class DeluxeRoom {
    private  Furniture furniture;
    public DeluxeRoom(){
        furniture=new Furniture();
        System.out.println("建好了一套精装房");
    }
}

可是安家具之前得先铺一套地板.

public class Furniture {
    private  Floor floor;
    
    public Furniture(){
        floor=new Floor();
        System.out.println("安装了一套家具");
    }
}

滑稽又想起来马上就冬天了,要是不安地暖得给自己冻死,于是他在铺地板前又安上了地暖.

public class Floor {
    private HeatingSystem heatingSystem;
    public Floor() {
        this.heatingSystem = new HeatingSystem();
        System.out.println("安装好了地板");
    }
}

public class HeatingSystem {
    public HeatingSystem() {
        System.out.println("安装好了地暖");
    }
}

到此,滑稽老铁的房子终于完工了,虽然从外面看起来没多大区别...

我们的代码也写完了

public class App {
    public static void main(String[] args) {
        DeluxeRoom room=new DeluxeRoom();
    }
}

滑稽老铁的朋友鸡哥一看,这房子不错,我也要整一套.

但是鸡哥不想要水地暖了,想整一套电地暖.

于是我们在创建地暖的时候要增加一个参数--type,一连串的,其他类的初始化方法都要增加这个参数

//传统写法
public class HeatingSystem {
    private String type;//地暖分成水地暖和电地暖

    public HeatingSystem(String type) {
        this.type=type;
        System.out.println("安装好了地暖");
    }
}

public class Floor {
    private HeatingSystem heatingSystem;
    public Floor(String type) {
        this.heatingSystem = new HeatingSystem(type);
        System.out.println("安装好了地板");
    }
}


public class Furniture {
    private  Floor floor;

    public Furniture(String type){
        floor=new Floor(type);
        System.out.println("安装了一套家具");
    }
}

public class DeluxeRoom {
    private  Furniture furniture;
    public DeluxeRoom(String type){
        furniture=new Furniture(type);
        System.out.println("建好了一套精装房");
    }
}

因为地暖种类的改动,整套代码都要改变...

但是如果我们将代码改成下面这样,就不会发生导致蝴蝶效应~

//IOC实现
public class DeluxeRoom {
    private  Furniture furniture;
    public DeluxeRoom(Furniture furniture){
        this.furniture=furniture;
        System.out.println("建好了一套精装房");
    }
}

public class Furniture {
    private  Floor floor;

    public Furniture(Floor floor){
        this.floor=floor;
        System.out.println("安装了一套家具");
    }
}

public class Floor {
    private HeatingSystem heatingSystem;
    public Floor(HeatingSystem heatingSystem) {
        this.heatingSystem=heatingSystem;
        System.out.println("安装好了地板");
    }
}

public class HeatingSystem {
    private String type;
    public HeatingSystem(String type) {
        this.type=type;
        System.out.println("安装好了地暖");
    }
}

public class App {
    public static void main(String[] args) {
        HeatingSystem system=new HeatingSystem("电地暖");
        Floor floor=new Floor(system);
        Furniture furniture=new Furniture(floor);
        DeluxeRoom room=new DeluxeRoom(furniture);
    }
}

这两段代码有什么不同呢?

传统写法,一个类需要什么资源,就在类的内部构造这个对象;IOC实现,一个类需要什么资源,就让别人将这个资源传进来.

不难看出,当底层代码(HeatSystem)改动后,如果依照传统写法,整个调用链的所有代码都需要改动.

用术语来讲叫做"高耦合".

软件设计的原则: 高内聚低耦合

高内聚: 一个模块中的各个元素联系比较紧密,可以共同完成某一功能

低耦合: 不同模块之间的依赖程度越低越好,修改其中一个模块不会影响到其他模块的执行

实际上.生活中还是有很多这样的例子的.比如学校开展"六一"活动,要求每个班表演一个节目,不能因为滑稽老铁拉肚子,导致整个年级不能上台.

这与Spring有什么关系呢?

Spring就是将资源注入进来的工具.当我们需要一个对象时,可以不用手动创建,,而是从Spring中拿.

(APP类中的new可以全部不要,而是交给Spring注入)

1.2 DI实现

了解完IOC后,恭喜你,身为程序猿的觉悟又高了一层~

实际上,IOC是Spring的核心思想,而Spring是怎么实现这思想的呢?

DI(Dependencey Injection),依赖注入----Spring在运行期间,动态地为应用程序提供所依赖的资源.

我们可以使用Spring的方式更改一下IOC代码.

@Component//表示将该类交给Spring保管
public class DeluxeRoom {
    private  Furniture furniture;

    public DeluxeRoom(Furniture furniture){
        this.furniture=furniture;
        System.out.println("建好了一套精装房");
    }
}

@Component
public class Furniture {
    private  Floor floor;

    public Furniture(Floor floor){
        this.floor=floor;
        System.out.println("安装了一套家具");
    }
}

@Component
public class Floor {
    private HeatingSystem heatingSystem;
    public Floor(HeatingSystem heatingSystem) {
        this.heatingSystem=heatingSystem;
        System.out.println("安装好了地板");
    }
}

@Component
public class HeatingSystem {
    public HeatingSystem() {
        System.out.println("安装好了地暖");
    }
}

下面修改一下Spring的启动类

@SpringBootApplication
public class DemoApplication {
	public static void main(String[] args) {
		ApplicationContext context=SpringApplication.run(DemoApplication.class, args);
		DemoApplication room=context.getBean(DemoApplication.class);
	}
}

运行启动类,你就会得到一套精装房.

做个小小的总结,IOC是一种思想,而Spring使用了DI来实现这种思想.

就比如,独在异乡,非常想看见父母,这就是你的想法,给他们打视频就是一种实现方式.

1.3 容器

回顾Spring的定义,似乎还有一个词我们没搞懂---Spring是包含众多工具方法的IOC容器.

那么什么是容器呢?

从小的方面来看,一个水杯就是一个容器,我们可以用它来存水,想喝水的时候也可以从里面取.联系前面学过的Tomcat,不难想象它也是一个webapp容器,用来存储和运行多个webapp项目.

容器,就是帮助我们存取某一资源的工具

Spring也是一个容器,只不过它帮助我们管理的资源就是对象.

所有的容器不外乎两种操作----存和取,下面就来学习一下如何从Spring存取对象吧

二. 往Spring中存对象

有两种方式可以实现:

1. 五大类注解: @Controller,@Service,@Repository,@Component,@Configuration

2. 方法注解: @Bean

来看一下它们的使用吧

2.1 五大注解

2.1.1 @Controller

先创建一个UserController类

@Controller//表示将该类注入到Spring容器中
public class UserController {
    public void sayHi(){
        System.out.println("Hi,Controller!");
    }
}

那么我们怎么知道Spring中是否有这个对象?需要从Spring中取出来.

来看Spring启动类代码.

@SpringBootApplication
public class DemoApplication {
	public static void main(String[] args) {
		//运行run方法,会返回Spring上下文对象,也就是Spring
		ApplicationContext context=SpringApplication.run(DemoApplication.class, args);
		//从Spring中得到UserController对象
		UserController controller=context.getBean(UserController.class);
		//调用该对象的sayHi方法
		controller.sayHi();
	}
}

启动Spring项目,就会惊奇的发现我们确实取出了UserController对象.

如果我们将@Controller删掉,就会抛出NoSuchBeanDefinitionException这个异常(Bean在Spring就是对象的意思)

下面来逐次演示一下其他四大类注解,代码重复度很高,已经懂的老铁可以跳过~

2.1.2 @Service&@Repository&@Component&@Configuration

再来演示一下其他四大类注解

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

@Repository
public class UserRepo {
    public void sayHi(){
        System.out.println("Hi,Repository!");
    }
}

@Configuration
public class UserConfig {
    public void sayHi(){
        System.out.println("Hi,Configuration!");
    }
}

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

同样可以从Spring中取出这些对象,然后你就得到了一堆Hi~

@SpringBootApplication
public class DemoApplication {
	public static void main(String[] args) {
		//运行run方法,会返回Spring上下文对象,也就是Spring
		ApplicationContext context=SpringApplication.run(DemoApplication.class, args);
		//从Spring中得到UserController对象
		UserController controller=context.getBean(UserController.class);
		//调用该对象的sayHi方法
		controller.sayHi();

		UserService service=context.getBean(UserService.class);
		service.sayHi();

		UserRepo userRepo=context.getBean(UserRepo.class);
		userRepo.sayHi();

		UserConfig userConfig=context.getBean(UserConfig.class);
		userConfig.sayHi();
		
		UserCom userCom=context.getBean(UserCom.class);
		userCom.sayHi();

	}
}

2.1.3 getBean方法的使用

getBean有很多重载,这里只介绍三种常见的.

参数	说明
getBean(Class<T> var1)	根据参数类型返回对象
getBean(String var1)	根据名称返回对象
getBean(String var1, Class<T> var2)	根据名称和类型返回对象

其中根据类型返回对象我们已经使用过了,那么怎么根据名称取得对象呢?

在idea中找到下面这个类

最终我们会看见这样一个方法

用我蹩脚的English翻译一下吧,

如果名字的第一个字母和第二个字母都是大写,就返回这个名字
其余情况,将第一个字母改成小写,然后返回
这里的name是指类名

用代码来实现一下,帮助理解~

UserService service= (UserService) context.getBean("userService");//返回的是Object对象,需要强转
service.sayHi();

代码可以正常运行,表明我们取到了UserService对象.这种方式需要强转,接下来演示类型+名字的方式取到对象.

UserService service=context.getBean("userService",UserService.class);
service.sayHi();

2.1.4 ApplicationContext和BeanFactory

来简单了解一下ApplicationContext的源码,就会发现BeanFactory的痕迹

接着追溯到顶级接口BeanFactory接口,可以发现getBean这个方法就是这个接口提供的.

在SpringBoot出现之前,Spring中对象的存取是通过配置文件实现的.

BeanFactory也是这时候诞生的.下面简单演示一下(作为了解即可)

创建一个maven项目,下面是目录结构

需要先在pom.xml中引入Spring依赖

<dependencies>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.3.RELEASE</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-beans -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>5.2.3.RELEASE</version>
        </dependency>
    </dependencies>

//用App来演示Spring的存取
public class App {
    public static void main(String[] args) {
        BeanFactory factory=new XmlBeanFactory(new ClassPathResource("config.xml"));//使用配置文件获取到Spring上下文

        User user= (User) factory.getBean("user");//从Spring中获取User对象

        user.sayHi();//调用User对象的sayHi方法
    }
}

下面是User类的代码

public class User {
   public void sayHi(){
       System.out.println("Hi,User");
   }
}

Spring的配置文件如下

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="user" class="User"></bean>
</beans>

运行App的main方法,我们就能调用User对象的sayHi方法了.

然而,Spring并不推荐使用配置文件来实现对象的存取,而更推荐使用注解的方式.

可以看到,通过ApplicationContext和BeanFactory都可以获取到Spring上下文,下面来讲述一下二者的区别.

ApplicationContext也是一个接口,并且扩展了BeanFactory接口,属于BeanFactory的子类
ApplicationContext添加了对国际化支持,资源访问支持以及事件传播等方面的支持
BeanFactory的出现比较早,硬件的存储空间小,因此BeanFactory采用懒加载的方式去加载对象(用到哪个加载哪个);ApplicationContext采用预加载的方式加载.实际上这是可以通过代码改变加载方式的,此处不再拓展.

2.1.5 五大注解之间的关系和区别

同学们有没有想过一个问题,既然任意五大类注解中任意一个都可以实现对象的存储,为啥不直接搞成一个呢?

这涉及到另一种思想----应用分层.

Controller: 控制层,接收请求,响应请求

Service: 服务层,处理具体的业务逻辑

Repository: 数据访问层也称为持久层,负责访问数据库

Configuration: 配置层,处理项目中的一些配置信息

Component: 组件层,处理一些公用信息

来举个例子说明一下吧~

就好比你去面试,保安就是第一个看见你的人(Controller层),负责对你的身份进行检验;

进入公司后,你要先去找前台小姐姐(Service层),小姐姐知道你是来面试的,就会把你带到面试官面前;

如果你足够幸运,得到了面试官的认可,他就会把你分配到某一部门(把公司人员的信息当成一个数据库的话,面试官就是Repository层)

至于配置层和组件层,我们在后面创建SSM项目的时候会有更深层次的理解,这里先按下不表.

这些层之间的调用关系如下图

当程序抛出异常时,我们还可以根据异常信息定位到是哪一层出现了问题.

讲完这些注解的区别之后,我们来谈一下它们的联系.

可以发现,其余四个注解都是@Component的衍生注解,除此之外看起来并无区别.

当然,在这里展示的只是注解的声明,有关这些注解的源码需要看Spring源码.

在实际的开发中,我们也要实现应用分层,用包名划分不同层的类

2.2 方法注解@Bean

五大注解是添加到方法上的,这就产生了两个问题:

使用外部库中的类时,我们无法在这些类上添加注解,也就不能让Spring帮忙管理这些类对象
一个类需要注入多个对象时无法实现

来看一下类注解获取的对象是否是同一个

@SpringBootApplication
public class DemoApplication {
	public static void main(String[] args) {
		//获取Spring上下文
		ApplicationContext context=SpringApplication.run(DemoApplication.class, args);
        
		UserController controller=context.getBean(UserController.class);//根据类型获取bean
		UserController controller1=context.getBean("userController",UserController.class);//根据名称+类型获取bean
		System.out.println(controller1==controller);//判断两个引用指向的是否是同一个对象

	}
}

答案是true

于是就引入了方法注解@Bean,我们先来看看@Bean如何使用.

先创建一个实体类User,作为返回类型.

@Data
public class User {
    private String name;
    private Integer age;
}

因为直接操作实体类对象的往往是持久层,因此我们给UserRepo类添加一个getUser方法.

public class UserRepo {
    @Bean//将该方法的返回值注入到Spring容器中

    public User getUser(){
        User user=new User();//在实际项目中,这个user是从数据库中取出来的,不是我们new的
        user.setName("张三");
        user.setAge(18);
        return user;
    }
}

然后我们尝试获取一下这个User

@SpringBootApplication
public class DemoApplication {
	public static void main(String[] args) {
		//获取Spring上下文
		ApplicationContext context=SpringApplication.run(DemoApplication.class, args);

		//获取User对象并输出
		User user=context.getBean(User.class);
		System.out.println(user);
	}
}

运行代码,就会很幸运的遇见这位老朋友.

可以想象一下方法注入的工作过程----如果我们使用@Bean进行方法注入的话,Spring需要扫描所有类,然后对每个类的每个方法进扫描,这样的工作量无疑是巨大的!

为了缩短项目的启动时间,Spring规定@Bean要配合类注解使用.

@Repository
public class UserRepo {
    @Bean
    public User getUser(){
        User user=new User();//在实际项目中,这个user是从数据库中取出来的,不是我们new的
        user.setName("张三");
        user.setAge(18);
        return user;
    }
}

再次启动项目,就可以看到控制台的打印日志了.

2.2.1 定义多个对象

前面还提到过,方法注解用来解决针对同一个类,无法注入多个对象的问题.它是怎么解决的呢?

来看一下代码~

@Repository
public class UserRepo {
    @Bean
    public User getUser(){
        User user=new User();//在实际项目中,这个user是从数据库中取出来的,不是我们new的
        user.setName("张三");
        user.setAge(18);
        return user;
    }
    
    @Bean 
    public User getUser2(){
        User user=new User();
        user.setName("王五");
        user.setAge(58);
        return user;
    }
}

这时候,如果在getBean方法中传的是类型参数的话,就会触发NoUniqueBeanDefinitionException异常

因此我们在使用getBean方法的时候还应该传入名字.

那么@Bean注入的对象,名字应该是什么呢?是方法名.

来验证一下.

@SpringBootApplication
public class DemoApplication {
	public static void main(String[] args) {
		//获取Spring上下文
		ApplicationContext context=SpringApplication.run(DemoApplication.class, args);

		//获取User对象并输出
		User user=context.getBean("getUser",User.class);
		System.out.println(user);

		User user1=context.getBean("getUser2",User.class);
		System.out.println(user1);
	}
}

我们可以在控制台上看到Spring确实取出了两个User对象

2.2.1 @Bean重命名

肯定有同学会想到,如果不想使用方法名作为Spring中对象的名字,可不可以自己设置?

@Bean提供了name的属性.

因此,我们还可以这样使用@Bean

@Repository
public class UserRepo {
    @Bean({"zhangsan","get1"})//将返回的对象命名为"zhangsan"和"get1"
    public User getUser(){
        User user=new User();//在实际项目中,这个user是从数据库中取出来的,不是我们new的
        user.setName("张三");
        user.setAge(18);
        return user;
    }

    @Bean("wangwu")//将返回的对象命名为"wangwu"
    public User getUser2(){
        User user=new User();
        user.setName("王五");
        user.setAge(58);
        return user;
    }
}

我们使用自己的命名来获取User对象.

@SpringBootApplication
public class DemoApplication {
	public static void main(String[] args) {
		//获取Spring上下文
		ApplicationContext context=SpringApplication.run(DemoApplication.class, args);

		User user=context.getBean("zhangsan",User.class);//获取zhangsan这个对象
		System.out.println(user);

	}
}

结果如下

注意: 如果给注入我的对象进行重命名,默认的名字无法继续使用.

@SpringBootApplication
public class DemoApplication {
	public static void main(String[] args) {
		//获取Spring上下文
		ApplicationContext context=SpringApplication.run(DemoApplication.class, args);
        //继续使用方法名获取对象
		User user=context.getBean("getUser",User.class);
		System.out.println(user);

	}
}

2.2.3 @Bean传递参数

同学们有没有发现,@Bean修饰的方法都是无参的,如果我们想让用户自己传递一个name作为User的属性,该怎么定义呢?

这就需要将name也作为对象交给Spring保管.

@Repository
public class UserRepo {

    //定义一个方法,返回String类型的对象并注入到Spring中
    @Bean
    public String getName(){
        return "赵四";
    }


    @Bean
    public User getUserByName(String name){//传递的name实际上也是从Spring取得的
        User user=new User();
        user.setName(name);
        return user;
    }
}

@SpringBootApplication
public class DemoApplication {
	public static void main(String[] args) {

		//获取Spring上下文
		ApplicationContext context=SpringApplication.run(DemoApplication.class, args);

		User user=context.getBean("getUserByName",User.class);
		System.out.println(user);

	}
}

启动注解类,就会得到"赵四"对象

实际上,我们的问题并没有解决,传递的参数还是由程序猿指定的,而不是由用户动态输入确定的.关于这个问题在后面的文章再进行讨论...

2.3 @ComponentScan配置扫描路径

第一篇关于SpringMVC的文章中提到过,我们创建的对象要与启动类同级或者放在与启动类同级的目录下.

现在来解释一下为什么----

先改变一下目录结构

@SpringBootApplication
public class DemoApplication {
	public static void main(String[] args) {
		//获取Spring上下文
		ApplicationContext context=SpringApplication.run(DemoApplication.class, args);
		UserController controller=context.getBean(UserController.class);
		controller.sayHi();

		UserService service=context.getBean(UserService.class);
		service.sayHi();

	}
}

运行启动类,发现UserController对象正常执行sayHi方法,但是Spring却找不到UserService对象

需要使用@ComponentScan注解配置一下Spring的扫描路径

现在将UserSerivce的路径配置进去(以包为单位)

@SpringBootApplication
@ComponentScan("com.example.demo.service")//表示service包下的类让Spring扫描
public class DemoApplication {
	public static void main(String[] args) {
		//获取Spring上下文
		ApplicationContext context=SpringApplication.run(DemoApplication.class, args);
		UserController controller=context.getBean(UserController.class);
		controller.sayHi();

		UserService service=context.getBean(UserService.class);
		service.sayHi();

	}
}

然鹅程序却抛出了另一个异常----找不到UserController对象了

因此我们将两个包都放进去

@SpringBootApplication
@ComponentScan({"com.example.demo.service","com.example.demo.controller"})
public class DemoApplication {
	public static void main(String[] args) {
		//获取Spring上下文
		ApplicationContext context=SpringApplication.run(DemoApplication.class, args);
		UserController controller=context.getBean(UserController.class);
		controller.sayHi();

		UserService service=context.getBean(UserService.class);
		service.sayHi();

	}
}

这下程序终于可以正常运行了.

这是咋回事呢?来看一下启动类注解@SpringBootApplication

没有显式配置扫描路径时,Spring默认扫描启动类所在的包及其子包
如果程序员定义了扫描路径,默认路径不再使用

更推荐的做法还是不要移动启动类的位置,将它放到我们想要扫描的包下即可.

三. 从Spring中取对象

这一部分内容,实际上是DI(依赖注入)的实现,所谓依赖,指的是依赖的外部资源.

在上文演示的过程中,我们需要先获取Spring容器,再从这个容器中拿出来Spring存储的对象.

实际上,有三种简单的方式可以帮助获取到Spring存储的对象.

属注入
Setter注入
构造方法注入

3.1 属性注入

属性注入,就是在对象中定义一个属性,然后借助@Autowired注解自动将这个属性初始化.

比如,Controller层要调用Service层的方法,可以在内部设置一个UserService类型的成员变量.

@Controller
public class UserController {
    @Autowired
    private UserService service;//在内部定义一个service成员变量,并使用注解自动初始化这个对象
    
    public void sayHi(){
        service.sayHi();
    }
}

然后我们让启动类调用UserController的sayHi方法,,实际上调用的就是UserService的sayHi

@SpringBootApplication
public class DemoApplication {
	public static void main(String[] args) {
		//获取Spring上下文
		ApplicationContext context=SpringApplication.run(DemoApplication.class, args);
		UserController controller=context.getBean(UserController.class);
		controller.sayHi();


	}
}

运行成功!

3.2 Setter方注入

Setter方法注入也需要借助@Autowired注解

@Controller
public class UserController {

    private UserService service;

    @Autowired
    public void setService(UserService service) {
        this.service = service;
    }

    public void sayHi(){
        service.sayHi();
    }
}

程序仍可以正常运行~

3.3 构造方法注入

可以借助 @Autowired 注解实现

@Controller
public class UserController {

    private UserService service;

    @Autowired//该注解可省略
    public UserController(UserService service) {
        this.service = service;
    }

    public void sayHi(){
        service.sayHi();
    }
}

UserController同样可以从Spring中获取到UserService对象.

因为构造方法注入是Spring官方推荐的做法,当类中只存在一个构造方法时,可以不加@Autowired

如果类中有多个构造方法,Sprig会优先使用无参构造,也就不会对属性进行注入.这时就必须加上@Autowired注解.

@Controller
public class UserController {

    private UserService service;


    public UserController() {//Spring会优先使用无参构造注入UserController对象,因此service属性并没有被注入
    }

    public UserController(UserService service) {
        this.service = service;
    }

    public void sayHi(){
        service.sayHi();
    }
}

程序抛出了空指针异常~

此时我们就必须要给有参数的构造方法添加注解了.

@Autowired
public UserController(UserService service) {
        this.service = service;
}

3.4 三种注入方法的优缺点

1. 属性注入

优点: 使用方便

缺点: 无法注入final修饰的属性 ; 只适用于IOC容器,如果换了其他容器会抛出空指针异常

由final修饰的属性只能进行就地初始化和构造方法初始化,如果用@Autowired修饰final修饰的属性,idea会直接报错

2. Setter注入

优点: 方便在类实例之后,重新对该对象进行修改

缺点: 不能注入一个final修饰的属性; 注入的对象可能会改变,因为Setter方法可以被其他类调用;

实际上这有点强扯~可修改既是Setter的优点也是它的缺点,但实际上我们既然已经将对象交给Spring管理,就不会轻易去改变这个对象

3. 构造函数注入

优点: 可以注入final修饰的属性,因此也可以保证注入的对象不会被修改;

是JDK支持的,所以更换任何框架都适用

3.5 指定注入的对象名

@Autowired默认根据类型注入对象.

当该类型的对象只有一个时,Spring直接注入
当该类型的对象有多个时,Spring会根据名称注入

来看一下代码>>

@Repository
public class UserRepo {

    @Bean({"zhangsan","get1"})//使用方法注解往Spring中注入User对象
    public User getUser(){
        User user=new User();
        user.setName("张三");
        user.setAge(18);
        return user;
    }

}


@Service
public class UserService {

    @Autowired//Spring容器中只有一个User类型的对象,直接注入,与属性名无关
    private User user;

    public void sayUser(){
        System.out.println(user.toString());
    }
}

然后我们让启动类调用UserService对象的sayUser方法.

@SpringBootApplication
public class DemoApplication {
	public static void main(String[] args) {
		//获取Spring上下文
		ApplicationContext context=SpringApplication.run(DemoApplication.class, args);
		UserService service=context.getBean(UserService.class);
		service.sayUser();
		
	}
}

可以正确拿到User对象~

但是,如果我们注入多个User对象时

@Repository
public class UserRepo {
    @Bean({"zhangsan","get1"})
    public User getUser(){
        User user=new User();
        user.setName("张三");
        user.setAge(18);
        return user;
    }

    @Bean("wangwu")
    public User getUser2(){
        User user=new User();
        user.setName("王五");
        user.setAge(58);
        return user;
    }
}

再次调用sayUser方法,Spring发现了两个User类型的对象,注入时发生冲突

有两种解决办法:

更改USerService中的属性名
指定要取哪个对象

@Service
public class UserService {
    @Autowired
    private User zhangsan;//变量名要与@Bean重命名后的名字匹配

    public void sayUser(){
        System.out.println(zhangsan.toString());
    }
}

于是正确的拿到了zhangsan对象

@Autowired不能指定要拿的对象名称,我们需要借助另外一个注解@Qualifier来实现

@Service
public class UserService {
    @Autowired
    @Qualifier("zhangsan")//指定要取名称为zhangsan的这个对象,()中的对象名只能有一个
    private User user;

    public void sayUser(){
        System.out.println(user.toString());
    }
}

除了在DI时指定要注入的对象名,将对象注入到Spring容器中时还可以使用@Primary注解表示这个类型优先取这个对象

@Repository
public class UserRepo {
    @Bean({"zhangsan","get1"})
    public User getUser(){
        User user=new User();
        user.setName("张三");
        user.setAge(18);
        return user;
    }

    @Bean("wangwu")
    @Primary//除非用户显式指定要取的对象名,否则取出的对象就是该方法返回的对象
    public User getUser2(){
        User user=new User();
        user.setName("王五");
        user.setAge(58);
        return user;
    }
}


@Service
public class UserService {
    @Autowired
    private User user;

    public void sayUser(){
        System.out.println(user.toString());
    }
}

@SpringBootApplication
public class DemoApplication {
	public static void main(String[] args) {
		//获取Spring上下文
		ApplicationContext context=SpringApplication.run(DemoApplication.class, args);
		UserService service=context.getBean(UserService.class);
		service.sayUser();

	}
}

运行启动类,确实取出来的是王五User

仅一个@Autowired无法指定要取哪个对象,JDK给我们提供了另一个注解 @Resource

@Service
public class UserService {
    @Resource(name = "zhangsan")//要拿zhangsan这个对象
    private User user;

    public void sayUser(){
        System.out.println(user.toString());
    }
}

来简单总结一下@Autowired和@Resource注解的区别吧

@Autowired是Spring框架提供的,@Resource是JDK提供的注解
@Autowired不能指定要取的对象名,需要借助其他注解来实现;@Resource可以根据对象名唯一指定要取的对象
@Autowired默认优先按照类型进行注入, @Resource按照名称注入

四. Spring中的对象名

前文我们已经见过,Spring容器中对象的名字是非常重要的,必要情况下,我们取对象时就是根据对象名来取的.

五大类注解对象名规则:

如果类名的首字母大写,将首字母改为小写就是对象名
如果类名的首字母和第二个字母都是大写,类名就是对象名

我们在注入的时候可以更改默认的对象名,但是默认的名字无法继续使用

@Controller("userCon")//Spring中该对象的名字是userCon,只能指定一个
public class UserController {
    public void sayHi(){
        System.out.println("Hi,Controller");
    }
}

@SpringBootApplication
public class DemoApplication {
	public static void main(String[] args) {
		//获取Spring上下文
		ApplicationContext context=SpringApplication.run(DemoApplication.class, args);
		UserController controller=context.getBean("userCon",UserController.class);//使用对象名+类型的方式获取对象
		controller.sayHi();

	}
}

可以正确取到Controller

但是如果我们继续使用默认的名字获取对象,就会抛出我们的老朋友~

UserController controller=context.getBean("userController",UserController.class);//使用默认的名字获取对象
controller.sayHi();

其余的四大类注解雷同,不再演示~~

@Bean方法注入默认对象名规则

对象名即为方法名
可以显式修改对象名,并且可以设置为多个,但是默认的名字无法继续使用

这个在前文2.2.1中做过演示,不再展示

实际上,对象名就是对象的身份标识,就好像我们的身份证一样,不同对象的名字必须不同(哪怕是不同类型的对象)

@Controller("user")//Spring容器中该对象的名字是user
public class UserController {
    public void sayHi(){
        System.out.println("Hi,Controller");
    }
}


@Service("user")//Spring容器中该对象的名字是user
public class UserService {

    public void sayHi(){
        System.out.println("Hi,service");
    }
}

@SpringBootApplication
public class DemoApplication {
	public static void main(String[] args) {
		
		ApplicationContext context=SpringApplication.run(DemoApplication.class, args);
		UserController controller=context.getBean("user",UserController.class);
		controller.sayHi();

		UserService service=context.getBean("user",UserService.class);
		service.sayHi();
	}
}

运行启动类,会抛出对象名存储异常