AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

129.【Spring 注解_IOC】（五）

2023-09-24 93
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 129.【Spring 注解_IOC】

(四)、自动装配

什么是自动装配?

Spring利用依赖注入(DI),完成对IOC容器中各个组件的依赖关系赋值

1.@Autowired 自动装配

/**
 * @Author Jsxs
 * @Date 2023/8/17 11:14
 * @PackageName:com.jsxs.config
 * @ClassName: MainConfigOfAutowried
 * @Description: TODO
 * 自动装配:
 * Spring利用依赖注入(DI),完成对IOC容器中各个组件的依赖关系赋值
 * 1. @Autowired:自动注入
 * 原理:假如我们service类需要用到dao类那么我们在service中声明 dao类为私有变量并加上@Autowired注解
 *  (1).那么默认按照类型去容器中找对应的组件: 好比如:  applicationContext.getBean(BookMapper.class); 假如找到一个的话，那么就从IOC容器中取值并赋值
 *  (2).如果找到多个相同类型的组件，再将属性的名称作为的id去容器中查找。 比如: applicationContext.getBean("bookMapper") 通过具体组件名获取
 *  (3).如果想指定使用某一个同类型不同命的组件，那么需要使用 @Qualifier("book2") 进行指定需要的组件
 * @Version 1.0
 */
(1). 自动装配(原理是从IOC容器中获得值并赋值)

1.BookMapper.java

package com.jsxs.mapper;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Repository;
/**
 * @Author Jsxs
 * @Date 2023/8/12 9:39
 * @PackageName:com.jsxs.Mapper
 * @ClassName: BookMapper
 * @Description: TODO
 * @Version 1.0
 */
@Repository
public class BookMapper {
    private String label="1";
    public String getLabel() {
        return label;
    }
    public void setLabel(String label) {
        this.label = label;
    }
    @Override
    public String toString() {
        return "BookMapper{" +
                "label='" + label + '\'' +
                '}';
    }
}

2.BookService.java

package com.jsxs.service;
import com.jsxs.mapper.BookMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
/**
 * @Author Jsxs
 * @Date 2023/8/12 9:33
 * @PackageName:com.jsxs.service
 * @ClassName: BookService
 * @Description: TODO
 * @Version 1.0
 */
@Service
public class BookService {
//  ⭐⭐
    @Autowired
    private BookMapper bookMapper;
    public void print(){
        System.out.println("1111111111111111111"+bookMapper);
    }
    @Override
    public String toString() {
        return "BookService{" +
                "bookMapper=" + bookMapper +
                '}';
    }
}

3.配置类的书写

package com.jsxs.config;
import com.jsxs.mapper.BookMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
/**
 * @Author Jsxs
 * @Date 2023/8/17 11:14
 * @PackageName:com.jsxs.config
 * @ClassName: MainConfigOfAutowried
 * @Description: TODO
 * 自动装配:
 * Spring利用依赖注入(DI),完成对IOC容器中各个组件的依赖关系赋值
 * 1. @Autowired:自动注入
 * 原理:假如我们service类需要用到dao类那么我们在service中声明 dao类为私有变量并加上@Autowired注解
 *  (1).那么默认按照类型去容器中找对应的组件: 好比如:  applicationContext.getBean(BookMapper.class); 假如找到一个的话，那么就从IOC容器中取值并赋值
 *  (2).如果找到多个相同类型的组件，再将属性的名称作为的id去容器中查找。 applicationContext.getBean("bookMapper")
 * @Version 1.0
 */
@Configuration
@ComponentScan(value = "com.jsxs")  // ⭐⭐
public class MainConfigOfAutowried {
}

4.测试

package com.jsxs.Test;
import com.jsxs.mapper.BookMapper;
import com.jsxs.config.MainConfigOfAutowried;
import com.jsxs.service.BookService;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
/**
 * @Author Jsxs
 * @Date 2023/8/17 11:23
 * @PackageName:com.jsxs.Test
 * @ClassName: IOCTest_Autowried
 * @Description: TODO
 * @Version 1.0
 */
public class IOCTest_Autowried {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfigOfAutowried.class);
        for (String beanDefinitionName : applicationContext.getBeanDefinitionNames()) {
            System.out.println(beanDefinitionName);
        }
        // 判断我们是否是从IOC容器中获得值并赋值?
        BookMapper bean = applicationContext.getBean(BookMapper.class);
        BookService bean1 = applicationContext.getBean(BookService.class);
        System.out.println(bean1);
        System.out.println(bean);
    }
}

(2).@AutoWried(先类型后属性名)

这里我们第一个组件通过 @Reposity 注解扫描注入IOC容器，然后第二个组件通过 @Bean 的方式注入IOC容器。所以在这里我们就会发现在同一个IOC容器中有两个相同类型但不同名的组件。

1.BookMapper.java

package com.jsxs.mapper;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Repository;
/**
 * @Author Jsxs
 * @Date 2023/8/12 9:39
 * @PackageName:com.jsxs.Mapper
 * @ClassName: BookMapper
 * @Description: TODO
 * @Version 1.0
 */
 // 组件1
@Repository
public class BookMapper {
    private String label="1";
    public String getLabel() {
        return label;
    }
    public void setLabel(String label) {
        this.label = label;
    }
    @Override
    public String toString() {
        return "BookMapper{" +
                "label='" + label + '\'' +
                '}';
    }
}

2.BookService.java

package com.jsxs.service;
import com.jsxs.mapper.BookMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
/**
 * @Author Jsxs
 * @Date 2023/8/12 9:33
 * @PackageName:com.jsxs.service
 * @ClassName: BookService
 * @Description: TODO
 * @Version 1.0
 */
@Service
public class BookService {
    @Autowired
    private BookMapper bookMapper;
    public void print(){
        System.out.println(bookMapper);
    }
    @Override
    public String toString() {
        return "BookService{" +
                "bookMapper=" + bookMapper +
                '}';
    }
}

3.配置类

package com.jsxs.config;
import com.jsxs.mapper.BookMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
/**
 * @Author Jsxs
 * @Date 2023/8/17 11:14
 * @PackageName:com.jsxs.config
 * @ClassName: MainConfigOfAutowried
 * @Description: TODO
 * 自动装配:
 * Spring利用依赖注入(DI),完成对IOC容器中各个组件的依赖关系赋值
 * 1. @Autowired:自动注入
 * 原理:假如我们service类需要用到dao类那么我们在service中声明 dao类为私有变量并加上@Autowired注解
 *  (1).那么默认按照类型去容器中找对应的组件: 好比如:  applicationContext.getBean(BookMapper.class); 假如找到一个的话，那么就从IOC容器中取值并赋值
 *  (2).如果找到多个相同类型的组件，再将属性的名称作为的id去容器中查找。 applicationContext.getBean("bookMapper")
 * @Version 1.0
 */
@Configuration
@ComponentScan(value = "com.jsxs")
public class MainConfigOfAutowried {
  // ⭐ 通过@Bena注入的同类型不同命组件
    @Bean("book2")
    public BookMapper bookMapper() {
        BookMapper bookMapper = new BookMapper();
        bookMapper.setLabel("2");
        return bookMapper;
    }
}

4.测试类

package com.jsxs.Test;
import com.jsxs.mapper.BookMapper;
import com.jsxs.config.MainConfigOfAutowried;
import com.jsxs.service.BookService;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
/**
 * @Author Jsxs
 * @Date 2023/8/17 11:23
 * @PackageName:com.jsxs.Test
 * @ClassName: IOCTest_Autowried
 * @Description: TODO
 * @Version 1.0
 */
public class IOCTest_Autowried {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfigOfAutowried.class);
        for (String beanDefinitionName : applicationContext.getBeanDefinitionNames()) {
            System.out.println(beanDefinitionName);
        }
        BookService bean1 = applicationContext.getBean(BookService.class);
        System.out.println(bean1);
    }
}

证明在同一个IOC容器中有两个相同类型但不同名的组件。

(3).@Qualifier 配合 @AutoWried

假如我们注入一个组件并未指定他的组件名，那么组件名就会默认是 首字母小写的驼峰命名。所以使用这个组件的目的主要是为了解决 相同类型但不同组件名 的需求。

1.BookMapper.java

package com.jsxs.mapper;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Repository;
/**
 * @Author Jsxs
 * @Date 2023/8/12 9:39
 * @PackageName:com.jsxs.Mapper
 * @ClassName: BookMapper
 * @Description: TODO
 * @Version 1.0
 */
@Repository  // ⭐组件一
public class BookMapper {
    private String label="1";
    public String getLabel() {
        return label;
    }
    public void setLabel(String label) {
        this.label = label;
    }
    @Override
    public String toString() {
        return "BookMapper{" +
                "label='" + label + '\'' +
                '}';
    }
}

2.BookService.java

package com.jsxs.service;
import com.jsxs.mapper.BookMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;
/**
 * @Author Jsxs
 * @Date 2023/8/12 9:33
 * @PackageName:com.jsxs.service
 * @ClassName: BookService
 * @Description: TODO
 * @Version 1.0
 */
@Service
public class BookService {
    @Autowired  // ⭐ 自动装配
    @Qualifier("book2") // 指定名字
    private BookMapper bookMapper;
    public void print(){
        System.out.println(bookMapper);
    }
    @Override
    public String toString() {
        return "BookService{" +
                "bookMapper=" + bookMapper +
                '}';
    }
}

3.配置类

package com.jsxs.config;
import com.jsxs.mapper.BookMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
/**
 * @Author Jsxs
 * @Date 2023/8/17 11:14
 * @PackageName:com.jsxs.config
 * @ClassName: MainConfigOfAutowried
 * @Description: TODO
 * 自动装配:
 * Spring利用依赖注入(DI),完成对IOC容器中各个组件的依赖关系赋值
 * 1. @Autowired:自动注入
 * 原理:假如我们service类需要用到dao类那么我们在service中声明 dao类为私有变量并加上@Autowired注解
 *  (1).那么默认按照类型去容器中找对应的组件: 好比如:  applicationContext.getBean(BookMapper.class); 假如找到一个的话，那么就从IOC容器中取值并赋值
 *  (2).如果找到多个相同类型的组件，再将属性的名称作为的id去容器中查找。 比如: applicationContext.getBean("bookMapper") 通过具体组件名获取
 *  (3).如果想指定使用某一个同类型不同命的组件，那么需要使用 @Qualifier("book2") 进行指定需要的组件
 * @Version 1.0
 */
@Configuration
@ComponentScan(value = "com.jsxs")  // ⭐扫描
public class MainConfigOfAutowried {
    @Bean("book2")  // ⭐⭐ 组件二
    public BookMapper bookMapper() {
        BookMapper bookMapper = new BookMapper();
        bookMapper.setLabel("2");
        return bookMapper;
    }
}

4.测试

package com.jsxs.Test;
import com.jsxs.mapper.BookMapper;
import com.jsxs.config.MainConfigOfAutowried;
import com.jsxs.service.BookService;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
/**
 * @Author Jsxs
 * @Date 2023/8/17 11:23
 * @PackageName:com.jsxs.Test
 * @ClassName: IOCTest_Autowried
 * @Description: TODO
 * @Version 1.0
 */
public class IOCTest_Autowried {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfigOfAutowried.class);
        for (String beanDefinitionName : applicationContext.getBeanDefinitionNames()) {
            System.out.println(beanDefinitionName);
        }
        BookService bean1 = applicationContext.getBean(BookService.class);
        System.out.println(bean1);
    }
}

(4).@Primary 首选装配

常用于: 相同类型不同名的组件，然后相比于 @Quailfier() 的使用是 在使用组件的时候添加，@Primary是在组件创建的时候，就默认未首选装配。

1.BookMapper.java

package com.jsxs.mapper;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Repository;
/**
 * @Author Jsxs
 * @Date 2023/8/12 9:39
 * @PackageName:com.jsxs.Mapper
 * @ClassName: BookMapper
 * @Description: TODO
 * @Version 1.0
 */
@Repository
public class BookMapper {
    private String label="1";
    public String getLabel() {
        return label;
    }
    public void setLabel(String label) {
        this.label = label;
    }
    @Override
    public String toString() {
        return "BookMapper{" +
                "label='" + label + '\'' +
                '}';
    }
}

2.BookService

package com.jsxs.service;
import com.jsxs.mapper.BookMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;
/**
 * @Author Jsxs
 * @Date 2023/8/12 9:33
 * @PackageName:com.jsxs.service
 * @ClassName: BookService
 * @Description: TODO
 * @Version 1.0
 */
@Service
public class BookService {
    @Autowired
//    @Qualifier("book2")  ⭐⭐ 这里我们不指定使用哪个具体名字的组件进行装配
    private BookMapper bookMapper;
    public void print(){
        System.out.println("1111111111111111111"+bookMapper);
    }
    @Override
    public String toString() {
        return "BookService{" +
                "bookMapper=" + bookMapper +
                '}';
    }

3.配置类

package com.jsxs.config;
import com.jsxs.mapper.BookMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
/**
 * @Author Jsxs
 * @Date 2023/8/17 11:14
 * @PackageName:com.jsxs.config
 * @ClassName: MainConfigOfAutowried
 * @Description: TODO
 * 自动装配:
 * Spring利用依赖注入(DI),完成对IOC容器中各个组件的依赖关系赋值
 * 1. @Autowired:自动注入
 * 原理:假如我们service类需要用到dao类那么我们在service中声明 dao类为私有变量并加上@Autowired注解
 *  (1).那么默认按照类型去容器中找对应的组件: 好比如:  applicationContext.getBean(BookMapper.class); 假如找到一个的话，那么就从IOC容器中取值并赋值
 *  (2).如果找到多个相同类型的组件，再将属性的名称作为的id去容器中查找。 比如: applicationContext.getBean("bookMapper") 通过具体组件名获取
 *  (3).如果想指定使用某一个同类型不同命的组件，那么需要使用 @Qualifier("book2") 进行指定需要的组件
 *  (4).@Qualifier("book2")需要在使用的时候加入注解，比较繁琐，我们希望在注册组件的时候就作为首选组件 @Primary
 * @Version 1.0
 */
@Configuration
@ComponentScan(value = "com.jsxs")
public class MainConfigOfAutowried {
    @Primary   // ⭐⭐⭐ 组件在注册的时候，我们就指定使用这个组件进行装配 同类型不同组件命的组件
    @Bean("book2")
    public BookMapper bookMapper() {
        BookMapper bookMapper = new BookMapper();
        bookMapper.setLabel("2");
        return bookMapper;
    }
}

4.测试

package com.jsxs.Test;
import com.jsxs.mapper.BookMapper;
import com.jsxs.config.MainConfigOfAutowried;
import com.jsxs.service.BookService;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
/**
 * @Author Jsxs
 * @Date 2023/8/17 11:23
 * @PackageName:com.jsxs.Test
 * @ClassName: IOCTest_Autowried
 * @Description: TODO
 * @Version 1.0
 */
public class IOCTest_Autowried {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfigOfAutowried.class);
        for (String beanDefinitionName : applicationContext.getBeanDefinitionNames()) {
            System.out.println(beanDefinitionName);
        }
        BookService bean1 = applicationContext.getBean(BookService.class);
        System.out.println(bean1);
    }
}

2.@Resource 和 @Inject [JSR标准]

Spring 还支持@Resource(JSR250) 和 @Inject(JSR330) [Java 规范]

(1).@Resource 自动装配

1.BookMapper.java

package com.jsxs.mapper;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Repository;
/**
 * @Author Jsxs
 * @Date 2023/8/12 9:39
 * @PackageName:com.jsxs.Mapper
 * @ClassName: BookMapper
 * @Description: TODO
 * @Version 1.0
 */
@Repository
public class BookMapper {
    private String label="1";
    public String getLabel() {
        return label;
    }
    public void setLabel(String label) {
        this.label = label;
    }
    @Override
    public String toString() {
        return "BookMapper{" +
                "label='" + label + '\'' +
                '}';
    }
}

2.BookServer.java

package com.jsxs.service;
import com.jsxs.mapper.BookMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
/**
 * @Author Jsxs
 * @Date 2023/8/12 9:33
 * @PackageName:com.jsxs.service
 * @ClassName: BookService
 * @Description: TODO
 * @Version 1.0
 */
@Service
public class BookService {
    // ⭐⭐假如需要指定具体的组件的话，我们需要添加name属性，如果不添加name属性的话，就默认按照变量名查找 applicationContext.getBean("bookMapper")
    @Resource(name = "book2")
    private BookMapper bookMapper;
    public void print(){
        System.out.println("1111111111111111111"+bookMapper);
    }
    @Override
    public String toString() {
        return "BookService{" +
                "bookMapper=" + bookMapper +
                '}';
    }
}

3.配置类

package com.jsxs.config;
import com.jsxs.mapper.BookMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
/**
 * @Author Jsxs
 * @Date 2023/8/17 11:14
 * @PackageName:com.jsxs.config
 * @ClassName: MainConfigOfAutowried
 * @Description: TODO
 * 自动装配:
 * Spring利用依赖注入(DI),完成对IOC容器中各个组件的依赖关系赋值
 * 1. @Autowired:自动注入
 * 原理:假如我们service类需要用到dao类那么我们在service中声明 dao类为私有变量并加上@Autowired注解
 *  (1).那么默认按照类型去容器中找对应的组件: 好比如:  applicationContext.getBean(BookMapper.class); 假如找到一个的话，那么就从IOC容器中取值并赋值
 *  (2).如果找到多个相同类型的组件，再将属性的名称作为的id去容器中查找。 比如: applicationContext.getBean("bookMapper") 通过具体组件名获取
 *  (3).如果想指定使用某一个同类型不同命的组件，那么需要使用 @Qualifier("book2") 进行指定需要的组件
 *  (4).@Qualifier("book2")需要在使用的时候加入注解，比较繁琐，我们希望在注册组件的时候就作为首选组件 @Primary
 *
 *  2. @Resource: 自动注入 ⭐⭐
 *  (1).@Resource和@Autowried都可以对IOC容器的组件进行自动装配，但是@Autowried是按照组件的类型和名称进行自动装配的
 *  (2).@Resource不能支持@Primary和@Quailifer这两个注解
 *  3. @Inject: 自动注入
 *  (1).能够支持@Primary和@Quailifer , 和 @Autowired一样
 *  (2).但是需要导入一个包
 * @Version 1.0
 */
@Configuration
@ComponentScan(value = "com.jsxs")
public class MainConfigOfAutowried {
    @Primary  // ⭐⭐ 这个添加是没有用的，因为@Resource不支持
    @Bean("book2")
    public BookMapper bookMapper() {
        BookMapper bookMapper = new BookMapper();
        bookMapper.setLabel("2");
        return bookMapper;
    }
}

4.测试类

package com.jsxs.Test;
import com.jsxs.mapper.BookMapper;
import com.jsxs.config.MainConfigOfAutowried;
import com.jsxs.service.BookService;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
/**
 * @Author Jsxs
 * @Date 2023/8/17 11:23
 * @PackageName:com.jsxs.Test
 * @ClassName: IOCTest_Autowried
 * @Description: TODO
 * @Version 1.0
 */
public class IOCTest_Autowried {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfigOfAutowried.class);
        for (String beanDefinitionName : applicationContext.getBeanDefinitionNames()) {
            System.out.println(beanDefinitionName);
        }
        BookService bean1 = applicationContext.getBean(BookService.class);
        System.out.println(bean1);
    }
}

(2).@Inject 自动装配

1.导入对应的 inject依赖

<dependency>
    <groupId>javax.inject</groupId>
    <artifactId>javax.inject</artifactId>
    <version>1</version>
</dependency>

2.BookMapper.java

package com.jsxs.mapper;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Repository;
/**
 * @Author Jsxs
 * @Date 2023/8/12 9:39
 * @PackageName:com.jsxs.Mapper
 * @ClassName: BookMapper
 * @Description: TODO
 * @Version 1.0
 */
@Repository
public class BookMapper {
    private String label="1";
    public String getLabel() {
        return label;
    }
    public void setLabel(String label) {
        this.label = label;
    }
    @Override
    public String toString() {
        return "BookMapper{" +
                "label='" + label + '\'' +
                '}';
    }
}

3.BookService.java

package com.jsxs.service;
import com.jsxs.mapper.BookMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import javax.inject.Inject;
/**
 * @Author Jsxs
 * @Date 2023/8/12 9:33
 * @PackageName:com.jsxs.service
 * @ClassName: BookService
 * @Description: TODO
 * @Version 1.0
 */
@Service
public class BookService {
    // @Inject 和 @Autowried 一模一样。 可以使用@Quailifer 和 @Primary ⭐⭐
    @Inject
    private BookMapper bookMapper;
    public void print(){
        System.out.println("1111111111111111111"+bookMapper);
    }
    @Override
    public String toString() {
        return "BookService{" +
                "bookMapper=" + bookMapper +
                '}';
    }
}

4.配置类

package com.jsxs.config;
import com.jsxs.mapper.BookMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
/**
 * @Author Jsxs
 * @Date 2023/8/17 11:14
 * @PackageName:com.jsxs.config
 * @ClassName: MainConfigOfAutowried
 * @Description: TODO
 * 自动装配:
 * Spring利用依赖注入(DI),完成对IOC容器中各个组件的依赖关系赋值
 * 1. @Autowired:自动注入
 * 原理:假如我们service类需要用到dao类那么我们在service中声明 dao类为私有变量并加上@Autowired注解
 *  (1).那么默认按照类型去容器中找对应的组件: 好比如:  applicationContext.getBean(BookMapper.class); 假如找到一个的话，那么就从IOC容器中取值并赋值
 *  (2).如果找到多个相同类型的组件，再将属性的名称作为的id去容器中查找。 比如: applicationContext.getBean("bookMapper") 通过具体组件名获取
 *  (3).如果想指定使用某一个同类型不同命的组件，那么需要使用 @Qualifier("book2") 进行指定需要的组件
 *  (4).@Qualifier("book2")需要在使用的时候加入注解，比较繁琐，我们希望在注册组件的时候就作为首选组件 @Primary
 *
 *  2. @Resource: 自动注入
 *  (1).@Resource和@Autowried都可以对IOC容器的组件进行自动装配，但是@Autowried是按照组件的类型和名称进行自动装配的
 *  (2).@Resource不能支持@Primary和@Quailifer这两个注解
 *  3. @Inject: 自动注入 ⭐⭐
 *  (1).能够支持@Primary和@Quailifer , 和 @Autowired一样
 *  (2).但是需要导入一个包
 * @Version 1.0
 */
@Configuration
@ComponentScan(value = "com.jsxs")
public class MainConfigOfAutowried {
    @Primary  // ⭐⭐⭐ 可以使用
    @Bean("book2")
    public BookMapper bookMapper() {
        BookMapper bookMapper = new BookMapper();
        bookMapper.setLabel("2");
        return bookMapper;
    }
}

5.测试

package com.jsxs.Test;
import com.jsxs.mapper.BookMapper;
import com.jsxs.config.MainConfigOfAutowried;
import com.jsxs.service.BookService;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
/**
 * @Author Jsxs
 * @Date 2023/8/17 11:23
 * @PackageName:com.jsxs.Test
 * @ClassName: IOCTest_Autowried
 * @Description: TODO
 * @Version 1.0
 */
public class IOCTest_Autowried {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfigOfAutowried.class);
        for (String beanDefinitionName : applicationContext.getBeanDefinitionNames()) {
            System.out.println(beanDefinitionName);
        }
        BookService bean1 = applicationContext.getBean(BookService.class);
        System.out.println(bean1);
    }
}

3.@Autowried自动装配原理

通过点击 @Autowried的源码，我们发现这个注解可以标注在构造器上、方法上等。

(1).标注在Set方法位置上
// 标注在方法上，Spring容器创建当前对象，就会调用方法，完成赋值的操作。
    // 方法使用的参数，自定义类型的参数的值是从IOC容器中获取， 比如说 我们启动IOC容器后，就会在IOC容器中找类型未 Car.class 类型的组件

如果需要自动装配的话，项目要求非要方法上的话，那么一定要优先选择 set 方法。

1. Car.java

package com.jsxs.bean;
import org.springframework.stereotype.Repository;
/**
 * @Author Jsxs
 * @Date 2023/8/14 17:12
 * @PackageName:com.jsxs.bean
 * @ClassName: Car
 * @Description: TODO
 * @Version 1.0
 */
@Repository  ⭐
public class Car {
    public Car(){
        System.out.println("Car Constructor ....");
    }
    public void init(){
        System.out.println("Car Init...");
    }
    public void destroy(){
        System.out.println("Car Destroy...");
    }
}

2.Boss.java

package com.jsxs.bean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
/**
 * @Author Jsxs
 * @Date 2023/8/17 17:34
 * @PackageName:com.jsxs.bean
 * @ClassName: Boss
 * @Description: TODO
 * @Version 1.0
 */
@Repository  ⭐⭐
public class Boss {
    private Car car;
    public Boss(Car car) {
        this.car = car;
    }
    public Boss() {
    }
    public Car getCar() {
        return car;
    }
    @Autowired  ⭐⭐⭐
    // 标注在方法上，Spring容器创建当前对象，就会调用方法，完成赋值的操作。
    // 方法使用的参数，自定义类型的参数的值是从IOC容器中获取， 比如说 我们启动IOC容器后，就会在IOC容器中找类型未 Car.class 类型的组件
    public void setCar(Car car) {
        this.car = car;
    }
    @Override
    public String toString() {
        return "Boss{" +
                "car=" + car +
                '}';
    }
}

3.配置类

package com.jsxs.config;
import com.jsxs.mapper.BookMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
/**
 * @Author Jsxs
 * @Date 2023/8/17 11:14
 * @PackageName:com.jsxs.config
 * @ClassName: MainConfigOfAutowried
 * @Description: TODO
 **/
@Configuration
@ComponentScan(value = "com.jsxs")  //⭐⭐⭐ 扫描
public class MainConfigOfAutowried {
    @Primary
    @Bean("book2")
    public BookMapper bookMapper() {
        BookMapper bookMapper = new BookMapper();
        bookMapper.setLabel("2");
        return bookMapper;
    }
}


文章标签：
Java
Spring
容器
关键词：
Spring注解
Spring IOC
Spring注解IoC
吉士先生
目录
相关文章
varin
|
17天前
|
缓存 监控 Java
SpringBoot @Scheduled 注解详解
使用`@Scheduled`注解实现方法周期性执行，支持固定间隔、延迟或Cron表达式触发，基于Spring Task，适用于日志清理、数据同步等定时任务场景。需启用`@EnableScheduling`，注意线程阻塞与分布式重复问题，推荐结合`@Async`异步处理，提升任务调度效率。
varin
332 128
HELLO程序员
|
1月前
|
XML 安全 Java
使用 Spring 的 @Aspect 和 @Pointcut 注解简化面向方面的编程 (AOP)
面向方面编程（AOP）通过分离横切关注点，如日志、安全和事务，提升代码模块化与可维护性。Spring 提供了对 AOP 的强大支持，核心注解 `@Aspect` 和 `@Pointcut` 使得定义切面与切入点变得简洁直观。`@Aspect` 标记切面类，集中处理通用逻辑；`@Pointcut` 则通过表达式定义通知的应用位置，提高代码可读性与复用性。二者结合，使开发者能清晰划分业务逻辑与辅助功能，简化维护并提升系统灵活性。Spring AOP 借助代理机制实现运行时织入，与 Spring 容器无缝集成，支持依赖注入与声明式配置，是构建清晰、高内聚应用的理想选择。
HELLO程序员
297 0
HELLO程序员
|
1月前
|
Java 测试技术 API
将 Spring 的 @Embedded 和 @Embeddable 注解与 JPA 结合使用的指南
Spring的@Embedded和@Embeddable注解简化了JPA中复杂对象的管理，允许将对象直接嵌入实体，减少冗余表与连接操作，提升数据库设计效率。本文详解其用法、优势及适用场景。
HELLO程序员
221 126
游客ei4oozwd2l7wm
|
2月前
|
XML JSON Java
Spring框架中常见注解的使用规则与最佳实践
本文介绍了Spring框架中常见注解的使用规则与最佳实践，重点对比了URL参数与表单参数的区别，并详细说明了@RequestParam、@PathVariable、@RequestBody等注解的应用场景。同时通过表格和案例分析，帮助开发者正确选择参数绑定方式，避免常见误区，提升代码的可读性与安全性。
游客ei4oozwd2l7wm
109 0
蓝易云
|
18天前
|
XML Java 数据格式
常用SpringBoot注解汇总与用法说明
这些注解的使用和组合是Spring Boot快速开发和微服务实现的基础，通过它们，可以有效地指导Spring容器进行类发现、自动装配、配置、代理和管理等核心功能。开发者应当根据项目实际需求，运用这些注解来优化代码结构和服务逻辑。
蓝易云
141 12
HELLO程序员
|
1月前
|
Java 测试技术 数据库
使用Spring的@Retryable注解进行自动重试
在现代软件开发中，容错性和弹性至关重要。Spring框架提供的`@Retryable`注解为处理瞬时故障提供了一种声明式、可配置的重试机制，使开发者能够以简洁的方式增强应用的自我恢复能力。本文深入解析了`@Retryable`的使用方法及其参数配置，并结合`@Recover`实现失败回退策略，帮助构建更健壮、可靠的应用程序。
HELLO程序员
131 1
使用Spring的@Retryable注解进行自动重试
HELLO程序员
|
1月前
|
传感器 Java 数据库
探索Spring Boot的@Conditional注解的上下文配置
Spring Boot 的 `@Conditional` 注解可根据不同条件动态控制 Bean 的加载，提升应用的灵活性与可配置性。本文深入解析其用法与优势，并结合实例展示如何通过自定义条件类实现环境适配的智能配置。
HELLO程序员
91 0
探索Spring Boot的@Conditional注解的上下文配置
HELLO程序员
|
1月前
|
智能设计 Java 测试技术
Spring中最大化@Lazy注解，实现资源高效利用
本文深入探讨了 Spring 框架中的 `@Lazy` 注解，介绍了其在资源管理和性能优化中的作用。通过延迟初始化 Bean，`@Lazy` 可显著提升应用启动速度，合理利用系统资源，并增强对 Bean 生命周期的控制。文章还分析了 `@Lazy` 的工作机制、使用场景、最佳实践以及常见陷阱与解决方案，帮助开发者更高效地构建可扩展、高性能的 Spring 应用程序。
HELLO程序员
54 0
Spring中最大化@Lazy注解，实现资源高效利用
HELLO程序员
|
1月前
|
安全 IDE Java
Spring 的@FieldDefaults和@Data：Lombok 注解以实现更简洁的代码
本文介绍了如何在 Spring 应用程序中使用 Project Lombok 的 `@Data` 和 `@FieldDefaults` 注解来减少样板代码，提升代码可读性和可维护性，并探讨了其适用场景与限制。
HELLO程序员
82 0
Spring 的@FieldDefaults和@Data：Lombok 注解以实现更简洁的代码

热门文章

最新文章

  • 1
    【Spring】原理解析：Spring Boot 自动配置
  • 2
    基于Spring AI Alibaba + Spring Boot + Ollama搭建本地AI对话机器人API
  • 3
    spring boot2升级boot3指南
  • 4
    Spring Boot四层架构深度解析
  • 5
    构建基于Java的AI智能体：使用LangChain4j与Spring AI实现RAG应用
  • 6
    SpringBoot @Scheduled 注解详解
  • 7
    使用 Spring 的 @Aspect 和 @Pointcut 注解简化面向方面的编程 (AOP)
  • 8
    【Spring】原理：Bean的作用域与生命周期
  • 9
    Spring Boot 整合Nacos 版本兼容适配 史上最详细文档
  • 10
    Spring WebFlux 响应式编程技术详解与实践指南
  • 1
    构建企业级AI智能体（Spring AI Alibaba + JManus实战）
    1222
  • 2
    京东二面：说下spring中常用的设计模式？ （一个 深入骨髓的答案， 面试官跪下了）
    316
  • 3
    基于Java 17 + Spring Boot 3.2 + Flink 1.18的智慧实验室管理系统核心代码
    266
  • 4
    Spring boot 使用mybatis generator 自动生成代码插件
    652
  • 5
    Java 21 与 Spring Boot 3.2 微服务开发从入门到精通实操指南
    444
  • 6
    Spring Boot 3.x 现代化应用开发实战技巧与最佳实践
    395
  • 7
    Spring AI Alibaba 1.0 GA 正式发布，Java 智能体开发进入新时代
    1699
  • 8
    📨 Spring Boot 3 整合 MQ 构建聊天消息存储系统
    416
  • 9
    Spring Boot 项目实操入门完整教程
    1145
  • 10
    Spring AI Alibaba 1.0 GA 正式发布，Java智能体开发进入新时代
    1080

    • 相关课程

    更多
  • 全面讲解Spring Cloud Alibaba技术栈（知识精讲+项目实战）第三阶段
  • 精通Spring Cloud Alibaba
  • 微服务框架 Spring Cloud 快速入门
  • Java Web开发系列课程 - Spring框架入门
  • Spring Boot 2.5.x开发实战
  • Spring Cloud微服务架构设计与开发实战

    • 相关电子书

    更多
  • 云栖社区特邀专家徐雷Java Spring Boot开发实战系列课程（第20讲）：经典面试题与阿里等名企内部招聘求职面试技巧
  • 微服务架构模式与原理Spring Cloud开发实战
  • 阿里特邀专家徐雷Java Spring Boot开发实战系列课程（第18讲）：制作Java Docker镜像与推送到DockerHub和阿里云Docker仓库
    • 下一篇
    阿里云云原生一体化数仓 — 数据治理新能力解读