Spring IoCDI入门

一：Spring IoC&DI概念

(1)Spring概念

💗Spring是包含了众多工具方法的IoC容器，是一个开源框架，让我们的开发更加简单

🌟Spring的两大核心和特点：IoC和AOP

(2)IoC的介绍

1.概念

💗IoC: InversionofControl (控制反转)，即Spring是⼀个能装对象的"控制反转"的容器

(IoC是Spring的核心思想，也是常见的面试题)

💜①控制反转：即控制权反转，指创建对象的过程被反转了；把创建对象的控制权交给了Spring，由Spring进行管理对象，既可以存对象，也可以取出来

🌟例：当需要某个对象时，传统开发模式中需要自己通过new创建对象，现在不需要再进行创建，把创建对象的任务交给容器，程序中只需要依赖注入(DependencyInjection,DI)就可以了，此时让容器来进行一系列操作

💜②举例：

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

(2)在类上面添加@RestController和@Controller注解，就是把这个对象交给Spring管理，Spring框架启动时就会加载该类，把对象交给Spring管理，也属于是IoC思想

2.作用

①资源集中管理：资源不由使用资源的双方管理，而由不使用资源的第三方管理；即IoC容器会帮我们管理⼀些资源(对象等)，我们需要使用时，只需要从IoC容器中去取就可以了

②降低耦合度：我们在创建实例的时候不需要了解其中的细节，降低了使用资源双方的依赖程度，也就是我们说的耦合度

(3)DI的介绍

1.概念

💗DI: DependencyInjection(依赖注入)

🌟容器在运行期间，动态的为应用程序提供运行时所依赖的资源，称之为依赖注入

2.DI与IoC的关系

💜IoC是个思想，而思想只是一种指导原则，最终还要有可行的落地方案，而DI就属于具体的实现；所以也可说DI是IoC的一种实现

(4)IoC&DI实现方式

💗①IoC：把对象创建控制权交给Spring，即存东西

💗②DI：把依赖对象取出来，并赋值给该对象的属性，即取东西

(5)Bean

1.Bean的概念

💜Spring是一个容器，存的是对象，而对象这个词在Spring的范畴内称为Bean

2.Bean的命名约定

💗①五大类注解的命名约定

(1)默认情况：Bean名称为首字母小写

(2)特殊情况：Bean名称为类名；当前两个字符都是大写的情况下

💗②@Bean方法注解的命名约定

💚Bean名称为@Bean方法注解下的方法名

二：IoC注解详解

(1)注解分类

①类注解：@Controller、@Service、@Repository、@Component、@Configuration

(这五大注解只能加在类上，并且只能加在自己的代码中；不能把第三方包给Spring管理)

②方法注解：@Bean

(如果加入了一些第三方jar包也想给Spring管理，就可以使用@Bean)

(2)应用分层

💞三层架构

💗代码分层逻辑和调用先后：先由Controller去调用Service，然后Service去调用Dao

①Controller(表现层)：接受请求，返回结果

②Service(业务逻辑层)：主要处理业务相关逻辑

③Dao(数据层)：处理数据的，包含数据的存储，增删改查

(3)类注解-@Controller(控制器存储)

1.作用

💗Spring框架启动加载时，把这个对象交给Spring容器管理；等到需要时再从容器里拿

🌟当包是Controller时，这个包里的类就用@Controller来存储Bean(对象)

(包是Controller表示是表现层，用于接收请求返回结果)

2.使用代码观察结果

①初谈DemoApplication运行类

💗其中，SpringApplication.run(DemoApplication.class, args)这一行代码的run就表示Spring这个应用开始启动，启动之后返回的就是上文说到的IoC容器
package com.example.demo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {

	public static void main(String[] args) {
		SpringApplication.run(DemoApplication.class, args);
	}
}

②ApplicationContext

💗ApplicationContext用来接收返回的IoC容器

(此时的IoC容器就存放了很多由Spring管理的对象)

💛即获取Spring上下文；这里的上下文指的就是Spring运行环境

ApplicationContext翻译过来就是：Spring上下文；因为对象都交给Spring管理了，所以获取对象要从Spring中获取，那么就得先得到Spring的上下文
package com.example.demo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;

@SpringBootApplication
public class DemoApplication {

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

③getBean方法

💗getBean方法即从Spring上下文中获取对象

(上文说过Bean就是Spring范畴里对象的意思)

💙主要的三个getBean方法

(1)String s：表示Bean的名称

(根据名称来获取Bean，要强制类型转换才能调用方法)

(2)Class<T> aClass：表示Bean的类型；可以加泛型参数的指定

(根据名称来获取Bean，可直接调用方法)

④尝试运行观察结果

1.先在com.example.demo目录下创建一个Controller包，然后创建一个UserController类

(@Controller这个注解十分重要，没有它就不会把UserController对象交给Spring管理)

package com.example.demo.Controller;
import org.springframework.stereotype.Controller;


@Controller   //这个@Controller至关重要
public class UserController {
    public void doController(){
        System.out.println("do Controller.....");
    }
}

2.再在DemoApplication类中获取对象且执行方法

package com.example.demo;
import com.example.demo.Controller.UserController;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;

@SpringBootApplication
public class DemoApplication {

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

		//从Spring上下文中获取对象
        //根据类来获取UserController对象
		UserController bean = context.getBean(UserController.class);

		//执行doController的方法
		bean.doController();
	}
}

3.运行并观察结果

4.去掉UserController类中的@Controller注解再次运行

(4)类注解-@Service(服务存储)

1.作用

💗Spring框架启动加载时，把这个对象交给Spring容器管理；等到需要时再从容器里拿

🌟当包是Service时，这个包里的类就用@Service来存储Bean(对象)

(包是Service表示是业务逻辑层，用于主要处理业务相关逻辑)

2.使用代码观察结果

1.先在com.example.demo目录下创建一个Service包，然后创建一个UserService类

package com.example.demo.Service;
import org.springframework.stereotype.Service;

@Service  //@Service至关重要
public class UserService {
    public void doService(){
        System.out.println("do Service.....");
    }
}

2.再在DemoApplication类中获取对象且执行方法

package com.example.demo;
import com.example.demo.Controller.UserController;
import com.example.demo.Service.UserService;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;

@SpringBootApplication
public class DemoApplication {

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

		//根据类来获取UserService对象
		UserService bean1 = context.getBean(UserService.class);
		//根据名称来获取UserService对象(由于根据名称来获取Bean，要强转才可调用方法)
		UserService bean2 = (UserService)context.getBean("userService");
		//根据名称和类来获取UserService对象
		UserService bean3 = context.getBean("userService",UserService.class);

		//执行doService的方法
		bean1.doService();
		bean2.doService();
		bean3.doService();
	}
}

3.运行并观察结果

(5)类注解-@Repository(仓库存储)

1.作用

💗Spring框架启动加载时，把这个对象交给Spring容器管理；等到需要时再从容器里拿

🌟当包是Dao时，这个包里的类就用@Repository来存储Bean(对象)

(包是Dao表示是数据层，用于处理数据的，包含数据的存储，增删改查)

2.使用代码观察结果

1.先在com.example.demo目录下创建一个Repo包，然后创建一个UserRepository类

package com.example.demo.Repo;
import org.springframework.stereotype.Repository;


@Repository
public class UserRepository {
    public void doRepository(){
        System.out.println("do Repository.....");
    }
}

2.再在DemoApplication类中获取对象且执行方法

package com.example.demo;
import com.example.demo.Controller.UserController;
import com.example.demo.Repo.UserRepository;
import com.example.demo.Service.UserService;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;

@SpringBootApplication
public class DemoApplication {

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

		//根据类来获取UserRepository对象
		UserRepository bean1 = context.getBean(UserRepository.class);
		//根据名称来获取UserRepository对象(由于根据名称来获取Bean，要强转才可调用方法)
		UserRepository bean2 = (UserRepository)context.getBean("userRepository");
		//根据名称和类型来获取UserRepository对象
		UserRepository bean3 = context.getBean("userRepository",UserRepository.class);

		//执行doRepository的方法
		bean1.doRepository();
		bean2.doRepository();
		bean3.doRepository();
	}
}

3.运行并观察结果

(6)类注解-@Component(组件存储)

1.作用

💗Spring框架启动加载时，把这个对象交给Spring容器管理；等到需要时再从容器里拿

🌟Component表示除了那三个应用分层之外的代码，即不属于那三个分层的其它代码，比如一些组件等等

2.使用代码观察结果

1.先在com.example.demo目录下创建一个Component包，然后创建一个UserComponent类

package com.example.demo.Component;
import org.springframework.stereotype.Component;

@Component
public class UserComponent {
    public void doComponent(){
        System.out.println("do Component.....");
    }
}

2.再在DemoApplication类中获取对象且执行方法

package com.example.demo;
import com.example.demo.Component.UserComponent;
import com.example.demo.Controller.UserController;
import com.example.demo.Repo.UserRepository;
import com.example.demo.Service.UserService;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;

@SpringBootApplication
public class DemoApplication {

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

		//根据类来获取UserRepository对象
		UserComponent bean1 = context.getBean(UserComponent.class);
		//根据名称来获取UserRepository对象(由于根据名称来获取Bean，要强转才可调用方法)
		UserComponent bean2 = (UserComponent)context.getBean("userComponent");
		//根据名称和类型来获取UserRepository对象
		UserComponent bean3 = context.getBean("userComponent",UserComponent.class);

		//执行doRepository的方法
		bean1.doComponent();
		bean2.doComponent();
		bean3.doComponent();
	}
}

3.运行并观察结果

(7)类注解-@Configuration(配置存储)

1.作用

💗Spring框架启动加载时，把这个对象交给Spring容器管理；等到需要时再从容器里拿

🌟Configuration表示配置层；用于处理项目中的⼀些配置信息

2.使用代码观察结果

1.先在com.example.demo目录下创建一个Configuration包，然后创建一个UserConfiguration类

package com.example.demo.Configuration;
import org.springframework.context.annotation.Configuration;

@Configuration
public class UserConfiguration {
    public void doConfiguration(){
        System.out.println("do Configuration.....");
    }
}

2.再在DemoApplication类中获取对象且执行方法

package com.example.demo;
import com.example.demo.Component.UserComponent;
import com.example.demo.Configuration.UserConfiguration;
import com.example.demo.Controller.UserController;
import com.example.demo.Repo.UserRepository;
import com.example.demo.Service.UserService;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;

@SpringBootApplication
public class DemoApplication {

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

		//根据类来获取UserRepository对象
		UserConfiguration bean1 = context.getBean(UserConfiguration.class);
		//根据名称来获取UserRepository对象(由于根据名称来获取Bean，要强转才可调用方法)
		UserConfiguration bean2 = (UserConfiguration)context.getBean("userConfiguration");
		//根据名称和类型来获取UserRepository对象
		UserConfiguration bean3 = context.getBean("userConfiguration",UserConfiguration.class);

		//执行doRepository的方法
		bean1.doConfiguration();
		bean2.doConfiguration();
		bean3.doConfiguration();
	}
}

3.运行并观察结果

(8)为什么要这么多类注解

💗与应用分层相关；用不同的注解就可以区分不同层次

@Controller：控制层；接收请求，对请求进行处理，并进行响应

@Servie：业务逻辑层；处理具体的业务逻辑

@Repository：数据访问层，也称为持久层；负责数据访问操作

@Configuration：配置层；处理项目中的⼀些配置信息

(9)类注解之间的关系

💜@Controller、@Servie、@Repository、@Configuration，它们本身就是属于@Component的衍生类，也可以理解为"子类"

(10)方法注解-@Bean

1.应用场景

①@Bean注解可以在使用外部包里的类

(类注解不能加在外部包里的类，此时就需要@Bean注解)

②⼀个类，需要定义多个不同的对象时，此时就需要@Bean注解

💙比如说数据库操作可能需要多个数据源

(如果使用类注解，得到的对象是一模一样的；只有使用方法注解才可以获得不同的对象)

2.方法注解要结合类注解使用

1.方法

🌟@Bean要配合类注解才能将对象正常的存储到Spring容器中

2.代码演示

①场景演示：假设UserInfo类是外部包的类，此时我需要用它定义对象

②先在Configuration包下创建一个UserInfo类

package com.example.demo.Configuration;
import lombok.Data;


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

③再在Configuration包下创建一个BeanConfiguration类，我们用它来创建UserInfo对象

package com.example.demo.Configuration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration  //@Bean方法注解要结合类注解才能拿到对象，少了类注解就不行了
public class BeanConfiguration {
    @Bean
    public UserInfo userInfo1(){   
        UserInfo userInfo1 = new UserInfo();
        userInfo1.setId(1);
        userInfo1.setName("zhangsan");
        userInfo1.setAge(18);
        return userInfo1;
    }

}

④最后在DemoApplication获取UserInfo对象

package com.example.demo;
import com.example.demo.Component.UserComponent;
import com.example.demo.Configuration.UserConfiguration;
import com.example.demo.Configuration.UserInfo;
import com.example.demo.Controller.UserController;
import com.example.demo.Repo.UserRepository;
import com.example.demo.Service.UserService;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;

@SpringBootApplication
public class DemoApplication {

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

		//获取外部包里的UserConfiguration
		UserInfo userInfo = context.getBean(UserInfo.class);
		System.out.println(userInfo);
	}
}

⑤观察运行结果

3.定义多个对象

1.方法

💙@Bean可以针对同⼀个类, 定义多个对象

💗此时我们需要通过Bean的名称来获取不同对象，Bean的名称就是就是@Bean注解下的方法名

2.代码演示

①场景演示：假设UserInfo类是外部包的类，此时我需要用它定义多个对象

②跟前面一样，如果创建了UserInfo类就不用创建了

③在BeanConfiguration类创建两个对象，模拟多对象

package com.example.demo.Configuration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration  //类注解结合@Bean方法注解才能拿到，少了类注解就不行了
public class BeanConfiguration {
    @Bean
    public UserInfo userInfo1(){   //第一个对象
        UserInfo userInfo1 = new UserInfo();
        userInfo1.setId(1);
        userInfo1.setName("zhangsan");
        userInfo1.setAge(18);
        return userInfo1;
    }

    @Bean
    public UserInfo userInfo2(){   //第二个对象
        UserInfo userInfo2 = new UserInfo();
        userInfo2.setId(2);
        userInfo2.setName("lisi");
        userInfo2.setAge(28);
        return userInfo2;
    }
}

④最后在DemoApplication获取这两个UserInfo对象

(此时就需要用到根据Bean的名称获取对象，Bean的名称就是@Bean注解下的方法名)

package com.example.demo;
import com.example.demo.Component.UserComponent;
import com.example.demo.Configuration.UserConfiguration;
import com.example.demo.Configuration.UserInfo;
import com.example.demo.Controller.UserController;
import com.example.demo.Repo.UserRepository;
import com.example.demo.Service.UserService;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;

@SpringBootApplication
public class DemoApplication {

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

		//根据Bean名称获取不同的UserInfo对象
		//Bean的名称就是@Bean注解下的方法名
		UserInfo userInfo1 = (UserInfo) context.getBean("userInfo1");
		UserInfo userInfo2 = (UserInfo) context.getBean("userInfo2");
		System.out.println(userInfo1);
		System.out.println(userInfo2);
	}
}

⑤观察运行结果

4.传递方法参数

1.方法

💗给形参也写个方法，方法的数据类型与参数类型对应，并且加上@Bean注解

2.代码演示

①同样还是用到UserInfo类，只不过在BeanConfiguration类给userInfo1加个形参，此时就说明userInfo1需要一个String类型的Bean

(🌟注意这里我写了个方法并加上@Bean注解，此时也就有了一个String类型的Bean)

package com.example.demo.Configuration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration  //类注解结合@Bean方法注解才能拿到，少了类注解就不行了
public class BeanConfiguration {
    @Bean
    public String name(){
        return "wangwu";
    }

    @Bean
    public UserInfo userInfo1(String name){   //第一个对象
        UserInfo userInfo1 = new UserInfo();
        userInfo1.setId(1);
        userInfo1.setName(name);
        userInfo1.setAge(18);
        return userInfo1;
    }

    @Bean
    public UserInfo userInfo2(){   //第二个对象
        UserInfo userInfo2 = new UserInfo();
        userInfo2.setId(2);
        userInfo2.setName("lisi");
        userInfo2.setAge(28);
        return userInfo2;
    }
}

②获取对象并观察运行结果

package com.example.demo;
import com.example.demo.Component.UserComponent;
import com.example.demo.Configuration.UserConfiguration;
import com.example.demo.Configuration.UserInfo;
import com.example.demo.Controller.UserController;
import com.example.demo.Repo.UserRepository;
import com.example.demo.Service.UserService;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;

@SpringBootApplication
public class DemoApplication {

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

		//根据Bean名称获取不同的UserInfo对象
		//Bean的名称就是@Bean注解下的方法名
		UserInfo userInfo1 = (UserInfo) context.getBean("userInfo1");
		System.out.println(userInfo1);
	}
}

5.Bean的存储方式

1.原则

①如果需要的Bean类型，它的对象只有一个时，就直接赋值了

②如果需要的Bean类型，它的对象有多个时，就根据名字进行匹配，优先使用同名的

2.代码演示

①当我在加两个形参方法时，一个name，一个name2

package com.example.demo.Configuration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration  //类注解结合@Bean方法注解才能拿到，少了类注解就不行了
public class BeanConfiguration {
    @Bean
    public String name(){
        return "wangwu";
    }

    @Bean
    public String name2(){
        return "zhangsan";
    }

    @Bean
    public UserInfo userInfo1(String name){   //第一个对象
        UserInfo userInfo1 = new UserInfo();
        userInfo1.setId(1);
        userInfo1.setName(name);
        userInfo1.setAge(18);
        return userInfo1;
    }

    @Bean
    public UserInfo userInfo2(){   //第二个对象
        UserInfo userInfo2 = new UserInfo();
        userInfo2.setId(2);
        userInfo2.setName("lisi");
        userInfo2.setAge(28);
        return userInfo2;
    }
}

②userInfo1会优先调用相同名字的，即调用第一个方法，因为名字都为name

③当我删除了name，只保留一个name2，此时不管名字是否相同都直接赋值

package com.example.demo.Configuration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration  //类注解结合@Bean方法注解才能拿到，少了类注解就不行了
public class BeanConfiguration {

    @Bean
    public String name2(){
        return "zhangsan";
    }

    @Bean
    public UserInfo userInfo1(String name){   //第一个对象
        UserInfo userInfo1 = new UserInfo();
        userInfo1.setId(1);
        userInfo1.setName(name);
        userInfo1.setAge(18);
        return userInfo1;
    }

    @Bean
    public UserInfo userInfo2(){   //第二个对象
        UserInfo userInfo2 = new UserInfo();
        userInfo2.setId(2);
        userInfo2.setName("lisi");
        userInfo2.setAge(28);
        return userInfo2;
    }
}

6.Bean的重命名

💜当你给Bean的形参加上一个字符串，这个字符串就是你指定的Bean名，后续就通过它来获取对象

①name={} 可以省略

②只有⼀个名称时，{}也可以省略

(11)路径扫描

1.特点

💗默认扫描DemoApplication启动类所在的目录

2.推荐做法

🌟把启动类放在我们希望扫描的包的路径下, 这样我们定义的Bean(对象)就都可以被扫描到

3.@ComponentScan

①作用

💙指定根目录，使得根目录下的所有子目录都可以被启动类扫描到

②演示

Ⅰ.当你把启动类放在了Controller包下，启动类就只能扫描到Controller下的Bean

Ⅱ.当你试图去获取Service包下的Bean时，启动类就会扫描不到

Ⅲ.此时就可以在启动类加上@ComponentScan注解，指定它的扫描路径，最后运行成功

三：DI注解详解

(1)DI注解作用

💗提供IoC容器在创建Bean时所依赖的对象，即注入依赖的对象

🌟把对象取出来放到某个类的属性中

(2)DI依赖注入的三种方式

①属性注入(Field Injection)

(1)优点：

简洁，使用方便

(2)缺点:

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

2.不能注入⼀个Final修饰的属性

②构造方法注入(Constructor Injection)

(1)优点：

1.可以注入final修饰的属性

2.注入的对象不会被修改

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

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

(2)缺点:

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

③Setter注入(Setter Injection)

(1)优点：

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

(2)缺点:

1.不能注入⼀个Final修饰的属性

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

(3)属性注入

1.注解

💗使用@Autowired注解，给类的属性中实现注入，让Spring帮我们自动创建对象

(即把当前类依赖的属性通过@Autowired注入到当前类中)

🌟属性注入和类型相匹配，与注入的属性名称无关

(与类型相关，与名称无关)

🌟如果一个类型存在多个对象，会优先进行名称匹配，即相同名字的，如果没有同名则报错

(下文@Autowired存在问题的原因)

2.代码演示

①此时UserController是依赖UserService的，我们通过@Atuowired来给UserController注入依赖的UserService对象，此时不用我们自己创建UserService对象，就可以直接使用UserService的方法了

package com.example.demo.Controller;
import com.example.demo.Service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;


@Controller
public class UserController {
    @Autowired
    private UserService userService;

    public void doController(){
        userService.doService();
        System.out.println("do Controller.....");
    }
}

②运行启动类并观察结果

(预期结果：当调用doController时就会调用到doService)

package com.example.demo;
import com.example.demo.Controller.UserController;
import com.example.demo.Service.UserService;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.ComponentScan;

@SpringBootApplication
public class DemoApplication {

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

		//根据类来获取UserController对象
		UserController bean1 = context.getBean(UserController.class);

		//执行doController的方法
		bean1.doController();
	}
}

(4)构造方法注入

1.注解

💗使用@Autowired注解，在类的构造方法中实现注入

🌟如果类只有一个构造方法，那么@Autowired注解可以省略

🌟如果类中有多个构造方法，那么需要加上@Autowired来明确指定到底使用哪个构造方法

2.代码演示

💚如下所示，给带一个参数的构造方法带上@Autowired，就表示告诉Spring说要调用这个带一个参数的构造方法

package com.example.demo.Controller;
import com.example.demo.Configuration.UserInfo;
import com.example.demo.Service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;


@Controller
public class UserController {
    private UserService userService;
    private UserInfo userInfo;

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

    public UserController(UserService userService,UserInfo userInfo){
        this.userService = userService;
        this.userInfo = userInfo;
    }

    public void doController(){
        userService.doService();
        System.out.println("do Controller.....");
    }
}

(5)Setter方法注入

1.注解

💗在设置set方法的时候需要加上@Autowired注解

2.代码演示

package com.example.demo.Controller;
import com.example.demo.Configuration.UserInfo;
import com.example.demo.Service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;


@Controller
public class UserController {
    private UserService userService;

    @Autowired
    public void setUserService(UserService userService){
        this.userService = userService;
    }

    public void doController(){
        userService.doService();
        System.out.println("do Controller.....");
    }
}

(6)@Autowired存在的问题

1.问题描述

💗当同⼀类型存在多个bean时，使用@Autowired会存在问题

💚涉及到了上述的属性注入；因为属性注入时，如果一个类型存在多个对象，会优先进行名称匹配，即相同名字的，如果没有同名则报错，此时使用@Autowired会存在问题

2.代码演示

3.解决办法

①@Autowired下的属性名和需要使用的对象名保持一致

②@Primary

③@Qualifier

④@Resource

(下文细说)

(7)@Primary

1.作用

💗当存在多个相同类型的Bean注入时，加上@Primary注解，来确定默认的实现

🌟即在对象中，加上@Primary，此时就默认这个为运行时的对象

2.代码演示

①BeanConfiguration类的代码

package com.example.demo.Configuration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;

@Configuration  //类注解结合@Bean方法注解才能拿到，少了类注解就不行了
public class BeanConfiguration {
    @Bean
    public String name(){
        return "wangwu";
    }

    @Bean
    public UserInfo userInfo1(String name){   //第一个对象
        UserInfo userInfo1 = new UserInfo();
        userInfo1.setId(1);
        userInfo1.setName(name);
        userInfo1.setAge(18);
        return userInfo1;
    }

    @Bean
    public UserInfo userInfo2(){   //第二个对象
        UserInfo userInfo2 = new UserInfo();
        userInfo2.setId(2);
        userInfo2.setName("lisi");
        userInfo2.setAge(28);
        return userInfo2;
    }
}

②UserController类的代码

(注意此时我的属性名没有一个是和我的对象名是一致的，userInfo≠userInfo1≠userInfo2)

package com.example.demo.Controller;
import com.example.demo.Configuration.UserInfo;
import com.example.demo.Service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;


@Controller
public class UserController {
    @Autowired
    private UserInfo userInfo;

    public void testuser(){
        System.out.println(userInfo);
    }
}

③运行DemoApplication启动类代码观察结果

package com.example.demo;
import com.example.demo.Controller.UserController;
import com.example.demo.Service.UserService;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.ComponentScan;

@SpringBootApplication
public class DemoApplication {

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

		//根据类来获取UserController对象
		UserController bean1 = context.getBean(UserController.class);

		//执行doController的方法
		bean1.testuser();
	}
}

(8)@Qualifier

1.作用

💗指定当前要注入的Bean对象；在@Qualifier的value属性中，指定注入的Bean的名称

🌟@Qualifier注解不能单独用，必须配合@Autowired使用；一般是写在@Autowired上方

2.代码演示

①BeanConfiguration类的代码

package com.example.demo.Configuration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;

@Configuration  //类注解结合@Bean方法注解才能拿到，少了类注解就不行了
public class BeanConfiguration {
    @Bean
    public String name(){
        return "wangwu";
    }

    @Bean
    public UserInfo userInfo1(String name){   //第一个对象
        UserInfo userInfo1 = new UserInfo();
        userInfo1.setId(1);
        userInfo1.setName(name);
        userInfo1.setAge(18);
        return userInfo1;
    }

    @Bean
    public UserInfo userInfo2(){   //第二个对象
        UserInfo userInfo2 = new UserInfo();
        userInfo2.setId(2);
        userInfo2.setName("lisi");
        userInfo2.setAge(28);
        return userInfo2;
    }
}

②UserController类的代码

(注意@Qualifier；此时我指定了使用名为userInfo2的对象)

package com.example.demo.Controller;
import com.example.demo.Configuration.UserInfo;
import com.example.demo.Service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Controller;


@Controller
public class UserController {
    @Qualifier("userInfo2")
    @Autowired
    private UserInfo userInfo;

    public void testuser(){
        System.out.println(userInfo);
    }
}

③运行DemoApplication启动类代码观察结果

(代码同上，就不重复了)

(9)@Resource

1.作用

💗按照Bean的名称进行注入；通过name属性指定要注入的Bean的名称

🌟加了@Resource就不需要同时加@AutoWired了

2.代码演示

①BeanConfiguration类的代码

(代码同上，就不重复了)

②UserController类的代码

(注意没有了@AutoWired，我使用了@Resource指定了使用名为userInfo2的对象)
package com.example.demo.Controller;
import com.example.demo.Configuration.UserInfo;
import com.example.demo.Service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Controller;

import javax.annotation.Resource;


@Controller
public class UserController {
    @Resource(name = "userInfo2")
    private UserInfo userInfo;

    public void testuser(){
        System.out.println(userInfo);
    }
}
③运行DemoApplication启动类代码观察结果

(代码同上，就不重复了)

(10)常见面试题

💖使用@Autowired和@Resource是最多的