一文打通基于注解管理Bean

左手的ㄟ右手 2023-10-09 21:58 119阅读 0赞

![f8854864de5e426982d91ed0904b08bc.png][]

**目录**

开启组件扫描

情况一：最基本的扫描方式

情况二：指定要排除的组件

情况三：仅扫描指定组件

使用注解定义 Bean

@Autowired注入

①场景一：属性注入

②场景二：set注入

③场景三：构造方法注入

④场景四：形参上注入

⑤场景五：只有一个构造函数，无注解

⑥场景六：@Autowired注解和@Qualifier注解联合+

总结

@Resource注入

①场景一：根据name注入

②场景二：name未知注入

③场景三 其他情况

总结

spring全注解开发

--------------------

从 Java 5 开始，Java 增加了对注解（Annotation）的支持，它是代码中的一种特殊标记，可以在编译、类加载和运行时被读取，执行相应的处理。开发人员可以通过注解在不改变原有代码和逻辑的情况下，在源代码中嵌入补充信息。

Spring 从 2.5 版本开始提供了对注解技术的全面支持，我们可以使用注解来实现自动装配，简化 Spring 的 XML 配置。

Spring 通过注解实现自动装配的步骤如下：

1.  引入依赖
2.  开启组件扫描
3.  使用注解定义 Bean
4.  依赖注入

### 开启组件扫描 ###

Spring 默认不使用注解装配 Bean，因此我们需要在 Spring 的 XML 配置中，通过 context:component-scan 元素开启 Spring Beans的自动扫描功能。开启此功能后，Spring 会自动从扫描指定的包（base-package 属性设置）及其子包下的所有类，如果类上使用了 @Component 注解，就将该类装配到容器中。

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xmlns:context="http://www.springframework.org/schema/context"
           xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
        http://www.springframework.org/schema/context
                http://www.springframework.org/schema/context/spring-context.xsd">
        
        <context:component-scan base-package="com.atguigu.spring6"></context:component-scan>
    </beans>

> 注意：在使用 context:component-scan 元素开启自动扫描功能前，首先需要在 XML 配置的一级标签 <beans> 中添加 context 相关的约束。

#### **情况一：最基本的扫描方式** ####

<context:component-scan base-package="com.atguigu.spring6">
    </context:component-scan>

#### **情况二：指定要排除的组件** ####

<context:component-scan base-package="com.atguigu.spring6">
        
        
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
            
    </context:component-scan>

#### **情况三：仅扫描指定组件** ####

<context:component-scan base-package="com.atguigu" use-default-filters="false">
        
        
        
        
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    	
    </context:component-scan>

### 使用注解定义 Bean ###

Spring 提供了以下多个注解，这些注解可以直接标注在 Java 类上，将它们定义成 Spring Bean。

<table> 
 <thead> 
  <tr> 
   <th>注解</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>@Component</td> 
   <td>该注解用于描述 Spring 中的 Bean，它是一个泛化的概念，仅仅表示容器中的一个组件（Bean），并且可以作用在应用的任何层次，例如 Service 层、Dao 层等。 使用时只需将该注解标注在相应类上即可。</td> 
  </tr> 
  <tr> 
   <td>@Repository</td> 
   <td>该注解用于将数据访问层（Dao 层）的类标识为 Spring 中的 Bean，其功能与 @Component 相同。</td> 
  </tr> 
  <tr> 
   <td>@Service</td> 
   <td>该注解通常作用在业务层（Service 层），用于将业务层的类标识为 Spring 中的 Bean，其功能与 @Component 相同。</td> 
  </tr> 
  <tr> 
   <td>@Controller</td> 
   <td>该注解通常作用在控制层（如SpringMVC 的 Controller），用于将控制层的类标识为 Spring 中的 Bean，其功能与 @Component 相同。</td> 
  </tr> 
 </tbody> 
</table>

### @Autowired注入 ###

> 单独使用@Autowired注解，**默认根据类型装配**。【默认是byType】

源码：

@Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD, ElementType.ANNOTATION_TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface Autowired {
        boolean required() default true;
    }

源码中有两处需要注意：

*  第一处：该注解可以标注在哪里？

> 1.  构造方法上
> 2.  注解上
> 3.  属性上
> 4.  形参上
> 5.  方法上

*  第二处：该注解有一个required属性，默认值是true，表示在注入的时候要求被注入的Bean必须是存在的，如果不存在则报错。如果required属性设置为false，表示注入的Bean存在或者不存在都没关系，存在的话就注入，不存在的话，也不报错。

#### ①场景一：属性注入 ####

创建UserDao接口

public interface UserDao {
    
        public void print();
    }

创建UserDaoImpl实现

@Repository
    public class UserDaoImpl implements UserDao {
    
        @Override
        public void print() {
            System.out.println("Dao层执行结束");
        }
    }

创建UserService接口

public interface UserService {
    
        public void out();
    }

创建UserServiceImpl实现类

@Service
    public class UserServiceImpl implements UserService {
    
        @Autowired
        private UserDao userDao;
    
        @Override
        public void out() {
            userDao.print();
            System.out.println("Service层执行结束");
        }
    }

创建UserController类

@Controller
    public class UserController {
    
        @Autowired
        private UserService userService;
    
        public void out() {
            userService.out();
            System.out.println("Controller层执行结束。");
        }
    
    }

测试

public class UserTest {
    
        private Logger logger = LoggerFactory.getLogger(UserTest.class);
    
        @Test
        public void testAnnotation(){
            ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
            UserController userController = context.getBean("userController", UserController.class);
            userController.out();
            logger.info("执行成功");
        }
    
    }

![97a195e2b344437fb1a9f49b75bb7510.png][]

以上构造方法和setter方法都没有提供，经过测试，仍然可以注入成功。

#### ②场景二：set注入 ####

修改UserServiceImpl类

@Service
    public class UserServiceImpl implements UserService {
        
        private UserDao userDao;
        @Autowired
        public void setUserDao(UserDao userDao) {
            this.userDao = userDao;
        }
    
        @Override
        public void out() {
            userDao.print();
            System.out.println("Service层执行结束");
        }
    }

修改UserController类

@Controller
    public class UserController {
    
        private UserService userService;
    
        @Autowired
        public void setUserService(UserService userService) {
            this.userService = userService;
        }
    
        public void out() {
            userService.out();
            System.out.println("Controller层执行结束。");
        }
    
    }

测试：成功调用

#### ③场景三：构造方法注入 ####

修改UserServiceImpl类

@Service
    public class UserServiceImpl implements UserService {
    
        private UserDao userDao;
    
        @Autowired
        public UserServiceImpl(UserDao userDao) {
            this.userDao = userDao;
        }
    
        @Override
        public void out() {
            userDao.print();
            System.out.println("Service层执行结束");
        }
    }

修改UserController类

@Controller
    public class UserController {
    
        private UserService userService;
    
        @Autowired
        public UserController(UserService userService) {
            this.userService = userService;
        }
    
        public void out() {
            userService.out();
            System.out.println("Controller层执行结束。");
        }
    
    }

测试：成功调用

#### ④场景四：形参上注入 ####

修改UserServiceImpl类

@Service
    public class UserServiceImpl implements UserService {
    
        private UserDao userDao;
    
        public UserServiceImpl(@Autowired UserDao userDao) {
            this.userDao = userDao;
        }
    
        @Override
        public void out() {
            userDao.print();
            System.out.println("Service层执行结束");
        }
    }

修改UserController类

@Controller
    public class UserController {
    
        private UserService userService;
    
        public UserController(@Autowired UserService userService) {
            this.userService = userService;
        }
    
        public void out() {
            userService.out();
            System.out.println("Controller层执行结束。");
        }
    
    }

测试：成功调用

#### ⑤场景五：只有一个构造函数，无注解 ####

修改UserServiceImpl类

@Service
    public class UserServiceImpl implements UserService {
    
        @Autowired
        private UserDao userDao;
    
        public UserServiceImpl(UserDao userDao) {
            this.userDao = userDao;
        }
    
        @Override
        public void out() {
            userDao.print();
            System.out.println("Service层执行结束");
        }
    }

测试通过

**当有参数的构造方法只有一个时，@Autowired注解可以省略。**

说明：有多个构造方法时呢？大家可以测试（再添加一个无参构造函数），测试报错

#### ⑥场景六：@Autowired注解和@Qualifier注解联合+ ####

添加dao层实现

@Repository
    public class UserDaoRedisImpl implements UserDao {
    
        @Override
        public void print() {
            System.out.println("Redis Dao层执行结束");
        }
    }

测试：测试异常

错误信息中说：不能装配，UserDao这个Bean的数量等于2

怎么解决这个问题呢？\*\*当然要byName，根据名称进行装配了。\*\*

修改UserServiceImpl类

@Service
    public class UserServiceImpl implements UserService {
    
        @Autowired
        @Qualifier("userDaoImpl") // 指定bean的名字
        private UserDao userDao;
    
        @Override
        public void out() {
            userDao.print();
            System.out.println("Service层执行结束");
        }
    }

#### **总结** ####

*  @Autowired注解可以出现在：属性上、构造方法上、构造方法的参数上、setter方法上。
 *  当带参数的构造方法只有一个，@Autowired注解可以省略。（）
 *  **@Autowired注解默认根据类型注入。如果要根据名称注入的话，需要配合@Qualifier注解一起使用。**

### @Resource注入 ###

@Resource注解也可以完成属性注入。那它和@Autowired注解有什么区别？

*  @Resource注解是JDK扩展包中的，也就是说属于JDK的一部分。所以该注解是标准注解，更加具有通用性。(JSR-250标准中制定的注解类型。JSR是Java规范提案。)
 *  @Autowired注解是Spring框架自己的。
 *  **@Resource注解默认根据名称装配byName，未指定name时，使用属性名作为name。通过name找不到的话会自动启动通过类型byType装配。**
 *  **@Autowired注解默认根据类型装配byType，如果想根据名称装配，需要配合@Qualifier注解一起用。**
 *  @Resource注解用在属性上、setter方法上。
 *  @Autowired注解用在属性上、setter方法上、构造方法上、构造方法参数上。

@Resource注解属于JDK扩展包，所以不在JDK当中，需要额外引入以下依赖：【**如果是JDK8的话不需要额外引入依赖。高于JDK11或低于JDK8需要引入以下依赖。**】

<dependency>
        <groupId>jakarta.annotation</groupId>
        <artifactId>jakarta.annotation-api</artifactId>
        <version>2.1.1</version>
    </dependency>

#### ①场景一：根据name注入 ####

修改UserDaoImpl类

@Repository("myUserDao")
    public class UserDaoImpl implements UserDao {
    
        @Override
        public void print() {
            System.out.println("Dao层执行结束");
        }
    }

修改UserServiceImpl类

@Service
    public class UserServiceImpl implements UserService {
    
        @Resource(name = "myUserDao")
        private UserDao myUserDao;
    
        @Override
        public void out() {
            myUserDao.print();
            System.out.println("Service层执行结束");
        }
    }

#### ②场景二：name未知注入 ####

修改UserDaoImpl类

@Repository("myUserDao")
    public class UserDaoImpl implements UserDao {
    
        @Override
        public void print() {
            System.out.println("Dao层执行结束");
        }
    }

修改UserServiceImpl类

@Service
    public class UserServiceImpl implements UserService {
    
        @Resource
        private UserDao myUserDao;
    
        @Override
        public void out() {
            myUserDao.print();
            System.out.println("Service层执行结束");
        }
    }

测试通过

当@Resource注解使用时没有指定name的时候，还是根据name进行查找，这个name是属性名。

#### ③场景三 其他情况 ####

@Service
    public class UserServiceImpl implements UserService {
    
        @Resource
        private UserDao userDao1;
    
        @Override
        public void out() {
            userDao1.print();
            System.out.println("Service层执行结束");
        }
    }

测试异常

根据异常信息得知：显然当通过name找不到的时候，自然会启动byType进行注入，以上的错误是因为UserDao接口下有两个实现类导致的。所以根据类型注入就会报错。

@Resource的set注入可以自行测试

#### 总结 ####

@Resource注解：默认byName注入，没有指定name时把属性名当做name，根据name找不到时，才会byType注入。byType注入时，某种类型的Bean只能有一个

### spring全注解开发 ###

全注解开发就是不再使用spring配置文件了，写一个配置类来代替配置文件。

@Configuration
    //@ComponentScan({"com.atguigu.spring6.controller", "com.atguigu.spring6.service","com.atguigu.spring6.dao"})
    @ComponentScan("com.atguigu.spring6")
    public class Spring6Config {
    }

测试类

@Test
    public void testAllAnnotation(){
        ApplicationContext context = new AnnotationConfigApplicationContext(Spring6Config.class);
        UserController userController = context.getBean("userController", UserController.class);
        userController.out();
        logger.info("执行成功");
    }

[f8854864de5e426982d91ed0904b08bc.png]: https://img-blog.csdnimg.cn/f8854864de5e426982d91ed0904b08bc.png
[97a195e2b344437fb1a9f49b75bb7510.png]: https://img-blog.csdnimg.cn/97a195e2b344437fb1a9f49b75bb7510.png