🏆作者简介,普修罗双战士,一直追求不断学习和成长,在技术的道路上持续探索和实践。
🏆多年互联网行业从业经验,历任核心研发工程师,项目技术负责人。
🎉欢迎 👍点赞✍评论⭐收藏
🔎 SpringBoot 领域知识 🔎
链接 | 专栏 |
---|---|
SpringBoot 专业知识学习一 | SpringBoot专栏 |
SpringBoot 专业知识学习二 | SpringBoot专栏 |
SpringBoot 专业知识学习三 | SpringBoot专栏 |
SpringBoot 专业知识学习四 | SpringBoot专栏 |
SpringBoot 专业知识学习五 | SpringBoot专栏 |
SpringBoot 专业知识学习六 | SpringBoot专栏 |
SpringBoot 专业知识学习七 | SpringBoot专栏 |
SpringBoot 专业知识学习八 | SpringBoot专栏 |
SpringBoot 专业知识学习九 | SpringBoot专栏 |
SpringBoot 专业知识学习十 | SpringBoot专栏 |
SpringBoot 专业知识学习十一 | SpringBoot专栏 |
SpringBoot 专业知识学习十二 | SpringBoot专栏 |
SpringBoot 专业知识学习十三 | SpringBoot专栏 |
SpringBoot 专业知识学习十四 | SpringBoot专栏 |
SpringBoot 专业知识学习十五 | SpringBoot专栏 |
SpringBoot 专业知识学习十六 | SpringBoot专栏 |
文章目录
- 🔎 Java 注解 @Component 学习(1)
- 🍁 01、@Component 注解在 Spring 中的作用是什么?
- 🍁 02、Spring 中还有哪些与 @Component 相关的常用注解?
- 🍁 03、@Component 注解和 @Bean 注解有什么区别?
- 🍁 04、@Component 注解是哪个模块的注解?
- 🍁 05、@Component 注解还有哪些派生注解?
- 🍁 06、什么是 @ComponentScan 注解,它的作用是什么?
- 🍁 07、如何设置 @ComponentScan 注解扫描的包路径?
- 🍁 08、@Component 注解和 @Configuration 注解的区别是什么?
- 🍁 09、在 Spring 中如何配置 @Component 的扫描规则?
- 🍁 10、@Component 注解是否可以扫描到抽象类?
🔎 Java 注解 @Component 学习(1)
🍁 01、@Component 注解在 Spring 中的作用是什么?
@Component
注解是 Spring 框架中的一个基本注解,它的作用是将一个 Java 类标识为 Spring 的组件(Bean)。被 @Component
注解标注的类会被 Spring 自动扫描并注册到应用上下文中,可以通过应用上下文获取并使用这些组件。
具体来说,@Component
注解可以用于标记任何一个普通的 Java 类,并将其纳入 Spring 管理。这样,它们就可以享受到 Spring 提供的各种依赖注入、自动装配、AOP 等特性。
需要注意的是,@Component
注解通常作为其他更具体的注解(如 @Service
、@Repository
、@Controller
等)的基础,用于创建具有特定用途的组件。但是,@Component
注解本身并没有明确定义 Bean 的角色或用途。
总结来说,@Component
注解的作用是将一个 Java 类标识为 Spring 组件(Bean),使其纳入 Spring 的管理与控制范围,可以享受到 Spring 提供的各种特性和便利。
🍁 02、Spring 中还有哪些与 @Component 相关的常用注解?
除了 @Component
注解之外,Spring 中还有许多与 @Component
相关的注解,它们都是基于 @Component
元注解的派生注解,用于指定不同类型的 Bean。
以下是一些常用的注解及其用途:
1.@Service
:用于标记服务层(Service),相当于早期的 Service
实现类上方也有一个 @Service
注解,用于告诉 Spring 容器,这个类是一个服务层组件,需要被扫描并加入到 Spring 容器中。
2.@Repository
:用于标记持久层(DAO),表示这是一个数据库相关的 Bean。与 @Service
注解类似,使用 @Repository
注解标记的类也会被 Spring 扫描并自动注入到其他组件中。
3.@Controller
:用于标记控制层(Controller),表示这是 MVC 架构中的控制器组件。Spring 会自动扫描使用了 @Controller
注解的类,并将其注册为控制器 Bean,在处理请求时自动将请求映射到相应的 @RequestMapping
注解标注的方法中进行处理。
4.@Configuration
:用于标记配置类,主要用于定义应用程序的 Bean 以及 Bean 之间的依赖关系。与 @Component
注解不同,@Configuration
注解不需要在类名前面添加前缀,其作用相当于一个工厂,用于生产 Bean,并使用 @Bean
注解将其返回。
5.@ControllerAdvice
:用于定义全局异常处理器,可以捕获处理所有 Controller 中抛出的异常。@ControllerAdvice
注解需要结合 @ExceptionHandler
注解一起使用,用于定义异常处理方法。
6.@ModelAttribute
:用于标注一个方法的返回值或方法参数,表示它们应该被添加到绑定到请求中的 Model 属性中。在使用 @ModelAttribute
标记的方法中,可以向模型中添加属性或组合多个模型属性。
总结来说,以上这些注解都是基于 @Component
注解派生出来的,用于表示不同类型的 Spring Bean 组件,使用这些注解可以更加精细地管理和控制应用程序中的组件。
🍁 03、@Component 注解和 @Bean 注解有什么区别?
@Component
注解和 @Bean
注解是 Spring 中用于创建 Bean 的两种不同方式,它们有一些区别。
1.作用对象不同:
@Component
注解:用于标记一个类为 Spring 的组件,并将其扫描和加载到 Spring 容器中。一般用于标记业务逻辑层(Service)、持久层(DAO)和控制层(Controller)等组件。@Bean
注解:用于标记一个方法为生产 Bean 的方法,可以被 Spring 容器扫描或手动在 Java 配置类中进行声明。一般用于配置类中,通过方法返回的对象将被注册为 Spring 容器中的一个 Bean。
2.对象实例化方式不同:
@Component
注解:被标记的类由 Spring 容器负责实例化和管理,Spring 会自动扫描组件并通过反射等机制进行实例化。@Bean
注解:被标记的方法由开发者手动编写代码来创建对象实例,可以在方法内部通过任何自定义逻辑来创建并返回对象。
3.使用场景不同:
@Component
注解:适用于任何需要被 Spring 托管管理的组件,可用于标记 Service、Repository、Controller 等组件类。@Bean
注解:适用于那些不能通过@Component
注解自动扫描和管理的对象,也可用于在配置类中手动创建第三方库的对象实例,或者定义一些特殊配置和定制。
4.功能扩展不同:
@Component
注解:可以与其他的派生注解(如@Service
、@Repository
、@Controller
)配合使用,用于更精确地声明组件的类型和角色。@Bean
注解:可以在注解的属性中指定初始化方法和销毁方法,用于进一步控制 Bean 的生命周期。
总结来说,@Component
注解是一种基于类级别的注解,用于标记和扫描组件类,由 Spring 进行实例化和管理;@Bean
注解是一种基于方法级别的注解,用户手动创建并返回对象实例,用于配置类中手动创建 Bean 对象。
以下是一个表格,总结了 @Component
注解和 @Bean
注解的主要区别:
区别 | @Component 注解 | @Bean 注解 |
---|---|---|
作用对象 | 类级别注解,用于标记组件类 | 方法级别注解,用于标记创建 Bean 的方法 |
实例化方式 | 自动扫描和通过反射实例化 | 手动编写代码创建和返回对象实例 |
使用场景 | 任何需要被 Spring 托管管理的组件 | 配置类中手动创建对象,特殊配置和定制 |
功能扩展 | 可与其他派生注解配合使用,精确声明组件类型和角色 | 可指定初始化方法、销毁方法,控制 Bean 的生命周期 |
请注意,@Component
、@Service
、@Repository
和 @Controller
注解都是基于 @Component
注解派生出来的,它们具有相似的作用和特点,都用于标记特定的组件类型。而 @Bean
注解则是一种不同的方式,用于在配置类中手动创建和返回对象实例。
🍁 04、@Component 注解是哪个模块的注解?
@Component
注解是 Spring Framework 核心模块中的注解之一,主要位于 org.springframework.stereotype
包下。该注解和其他基于 @Component
的派生注解(如 @Service
、@Repository
、@Controller
等)一起,是 Spring 框架中用于定义和管理组件的主要注解之一。
在 Spring 中,@Component
注解作为一个通用性的注解,主要用于标记那些需要被 Spring 托管管理的类,例如 Service、Repository、Controller 等等。在使用 @Component
注解时,Spring 会自动将被标记的类扫描并加载到 Spring 容器中,同时自动创建并初始化该组件的实例,以便在整个应用程序中进行使用。
除了 @Component
注解,Spring 还提供了一些与之相关的注解,它们都是基于 @Component
注解进行扩展的,包括:
@Service
:标记业务逻辑层(Service)的组件;@Repository
:标记 DAO(Data Access Object)层组件,用于数据库访问;@Controller
:标记控制层(Controller)的组件,用于处理用户请求和响应;@RestController
:组合注解,等同于@Controller
和@ResponseBody
的结合使用,常用于编写 RESTful 风格的 Web 服务;@Configuration
:标记一个类为 Spring 配置类,用于定义和配置 Bean 的创建和组装。
在使用 Spring 进行开发时,使用这些注解可以帮助我们更好地设计和编写代码,便于维护和管理。
🍁 05、@Component 注解还有哪些派生注解?
除了 @Component
注解,Spring Framework 还提供了不少基于 @Component
注解派生的子注解,这些注解在功能上和 @Component
注解类似,但在语义上有更明确的表示,可以更准确地表达其功能和作用,方便进行编码和管理。以下是部分派生注解列表:
@Service
:标记业务逻辑层(Service)的组件;@Repository
:标记 DAO(Data Access Object)层组件,用于数据库访问;@Controller
:标记控制层(Controller)的组件,用于处理用户请求和响应;@RestController
:组合注解,等同于@Controller
和@ResponseBody
的结合使用,常用于编写 RESTful 风格的 Web 服务;@Configuration
:标记一个类为 Spring 配置类,用于定义和配置 Bean 的创建和组装。
以上这些注解都是基于 @Component
注解实现的,Spring 在扫描组件时会自动扫描这些注解所标记的类,并将其加载到 Spring 容器中。一般来说,我们在定义组件时,可以根据组件的作用和职责,选择合适的注解来进行标记。
🍁 06、什么是 @ComponentScan 注解,它的作用是什么?
@ComponentScan
是 Spring 框架中的一个注解,在使用该注解时可以指定需要扫描的包路径,Spring 会自动扫描指定路径下的所有类,并将标有 @Component
及其派生注解(@Service
、@Repository
、@Controller
等)的类自动注入到 Spring 容器中进行管理。
使用 @ComponentScan
注解可以避免手动进行 Bean 的注册操作,也可以提高代码的可维护性和可读性,减少冗余代码,方便进行组件解耦和重构。通常情况下,我们会将 @ComponentScan
注解放置在配置类上,规定要扫描的包路径,例如:
@Configuration
@ComponentScan("com.example.demo")
public class AppConfig {}
在上述示例代码中,使用 @ComponentScan
注解来指定了要扫描的包路径,Spring 会自动扫描 com.example.demo
包及其子包下所有标记有 @Component
及其派生注解的组件类,并将其纳入 Spring 容器进行管理。
除了指定要扫描的包路径,@ComponentScan
还提供了其他一些常用属性,例如:
basePackages
:和value
属性作用相同,指定要扫描的包路径,支持使用数组的方式指定多个路径。basePackageClasses
:指定要扫描的类所在的包路径,Spring 会根据指定的类所在的包路径进行扫描。使用这个属性可以省略指定包名的繁琐操作。exclude
:指定要扫描的时候需要忽略的类或者包路径。支持使用正则表达式指定匹配规则。includeFilters
:指定要扫描的时候需要包含的类或者包路径。同时支持多种过滤规则,例如注解、正则表达式、自定义规则等。
总的来说,@ComponentScan
注解可以帮助我们自动装配 Bean,提升开发效率和代码可维护性。利用注解的方式,我们可以将各种 Bean 自动注入到容器,从而避免了手动配置和管理的繁琐操作。
🍁 07、如何设置 @ComponentScan 注解扫描的包路径?
@ComponentScan
注解用于指定 Spring 应该扫描哪些包来查找被标记为 @Component
、@Service
、@Controller
、@Repository
等注解的类,并将它们自动加载到 Spring 容器中。我们可以通过以下几种方式来设置 @ComponentScan
注解扫描的包路径:
1.通过 value
属性
@ComponentScan
的 value
属性可以用于设置扫描的基础包路径,例如:
@ComponentScan(value = "com.example.demo")
public class AppConfig {}
上述示例中,value
属性指定了 Spring 扫描的基础包路径为 com.example.demo
。
2.通过 basePackages
属性
与 value
属性类似,basePackages
属性也可以用于设置扫描的基础包路径,但这个属性支持传递多个包路径,可以使用数组的形式进行设置,例如:
@ComponentScan(basePackages = {"com.example.demo.service", "com.example.demo.dao"})
public class AppConfig {}
上述示例中,basePackages
属性指定了 Spring 扫描的基础包路径为 com.example.demo.service
和 com.example.demo.dao
。
3.通过 basePackageClasses
属性
我们也可以通过指定某个类的全限定名称来指定扫描的包路径,例如:
@ComponentScan(basePackageClasses = {UserService.class, UserDao.class})
public class AppConfig {}
上述示例中,basePackageClasses
属性指定了 Spring 扫描的基础包路径,这些基础包的路径与指定的类所在的包路径相关联。
总的来说,这三种设置扫描包路径的方式都可以实现相同的功能,通常情况下我们可以根据实际需求选择其中一种方式即可。同时,在实际项目开发中,为了更加清晰和规范,可能还需要结合实际情况使用多种方式来设置包路径,以确保扫描到全部需要的组件。
🍁 08、@Component 注解和 @Configuration 注解的区别是什么?
@Component
注解和 @Configuration
注解在 Spring 中有不同的使用场景和功能。
1.@Component
注解:
@Component
注解是 Spring 框架中用于标记一个类为组件类的注解,它是一个通用的注解,可以用于标记任何需要被 Spring 管理的类,如业务逻辑类、数据访问类、工具类等。被 @Component
注解标记的类会被 Spring 自动扫描并纳入 Spring 容器中进行管理。
@Component
注解是 Spring 提供的基本注解之一。它是基于 Java 注解的方式来实现对类的 Bean 定义。通过 @Component
注解,我们可以将类标记为一个 Bean,并通过自动扫描的方式将其加入到 Spring 容器。
使用了 @Component
注解的示例:
@Component
public class UserService {// ...
}
2.@Configuration
注解:
@Configuration
注解是 Spring 框架中用于定义配置类的注解。配置类是用于定义 Spring Bean 的 Java 类,通常与 @Bean
注解一起使用,用于配置和组装应用程序的组件。配置类可以包含多个被 @Bean
注解标记的方法,每个方法都会返回一个被 Spring 管理的 Bean 实例。
@Configuration
注解是 Spring 3.0+ 版本引入的。通过 @Configuration
注解,我们可以将一个普通的 Java 类标记为配置类,并使用 @Bean
注解在该类中定义需要创建的 Bean。
使用了 @Configuration
注解的示例:
@Configuration
public class AppConfig {@Beanpublic UserService userService() {return new UserService();}
}
在上述示例中,AppConfig
类被标记为配置类,其中定义了一个 userService()
方法,并通过 @Bean
注解将该方法返回的对象声明为一个 Bean。
区别总结:
@Component
注解主要用于标记普通的组件类,通过自动扫描的方式将其纳入 Spring 容器管理。适用于任何需要被 Spring 管理的类。@Configuration
注解主要用于定义配置类,通过@Bean
注解定义和组装 Spring Bean。适用于定义和管理 Bean 的配置类。@Component
注解是基本注解,用于标记任意需要被 Spring 管理的类;@Configuration
注解是配置注解,用于标记配置类并通过@Bean
注解定义 Bean。@Component
注解在平常的开发中更加常见,而@Configuration
注解一般在配置文件编写中使用较多。
这是一个比较 @Component
和 @Configuration
注解的区别的表格:
区别 | @Component | @Configuration |
---|---|---|
注解作用 | 标记普通的组件类 | 标记配置类和定义 Spring Bean |
注解类型 | 通用注解 | 配置注解 |
扫描方式 | 通过自动扫描将类纳入 Spring 容器 | 通过手动声明配置类进行定义 |
Bean 定义方式 | 不需要在类中明确定义 Bean | 通过 @Bean 注解在类中定义和组装 Bean |
使用场景 | 任何需要被 Spring 管理的类 | 定义和管理 Bean 的配置类 |
所属包 | org.springframework.stereotype.Component | org.springframework.context.annotation.Configuration |
Introduced in Spring | 2.5 版本以后 | 3.0 版本以后 |
是否需要结合 @Bean | 可以单独使用,也可以结合 @Bean 注解使用 | 必须与 @Bean 注解结合使用 |
示例 | @Component public class UserService { // … } | @Configuration public class AppConfig { @Bean public UserService userService() { return new UserService(); } } |
希望这个表格能够清楚地总结和对比 @Component
和 @Configuration
注解的区别。
🍁 09、在 Spring 中如何配置 @Component 的扫描规则?
在 Spring 中,你可以通过使用 @ComponentScan
注解来配置 @Component
的扫描规则。@ComponentScan
注解可以放在 Java 配置类上或者在 XML 配置文件中使用。
在 Java 配置类中配置 @ComponentScan
的扫描规则示例:
@Configuration
@ComponentScan(basePackages = "com.example")
public class AppConfig {// 配置其他的 Bean ...
}
上面的示例代码将告诉 Spring 在 com.example
包下扫描所有被 @Component
注解标记的类,并将它们自动注册为 Spring 的 Bean。
在 XML 配置文件中配置 @ComponentScan
的扫描规则示例:
<context:component-scan base-package="com.example" />
上面的示例配置会在 com.example
包下进行扫描,与 Java 配置类的方式相同,将被 @Component
注解标记的类自动注册为 Spring 的 Bean。
使用 @ComponentScan
注解时,你还可以指定其他的属性,比如 excludeFilters
、includeFilters
、useDefaultFilters
等,以更精细地控制扫描规则。
🍁 10、@Component 注解是否可以扫描到抽象类?
@Component
注解可以用于扫描到抽象类。当 @ComponentScan
扫描时,它会查找所有标记了 @Component
及其衍生注解(如 @Service
、@Repository
等)的类,并将它们注册为 Spring 的 Bean。
虽然抽象类无法直接实例化,但在某些情况下,我们可能希望将抽象类作为父类,在子类中实现具体逻辑。通过将 @Component
注解应用于抽象类,可以方便地定义一组具有共同特征的子类,并确保它们在 Spring 容器中被正确管理和使用。
以下是一个示例,展示了如何使用 @Component
注解扫描到抽象类:
@Component
public abstract class AbstractService {// 抽象类的方法或属性
}@Service
public class ConcreteService extends AbstractService {// 具体实现类的方法或属性
}
在上述示例中,AbstractService
是一个抽象类,被标记为 @Component
,而 ConcreteService
则是具体的实现类,被标记为 @Service
。当进行组件扫描时,Spring 会扫描 AbstractService
类并注册为一个 Bean,而 ConcreteService
则会继承 AbstractService
的特性并被单独注册为另一个 Bean,从而使两者都能够在 Spring 容器中使用。
当抽象类标记了@Component
注解时,它本身不会被实例化为Bean,因为抽象类无法直接实例化。但是,具体实现该抽象类的子类可以被实例化为Bean,并通过依赖注入的方式在Spring容器中使用。
例如,在下面的示例中,AbstractHandler
是一个抽象类,被标记为@Component
:
@Component
public abstract class AbstractHandler {public abstract void handle();
}
然后,我们可以定义一个具体实现该抽象类的子类,例如ConcreteHandler
:
@Component
public class ConcreteHandler extends AbstractHandler {@Overridepublic void handle() {// 具体实现逻辑}
}
在进行组件扫描时,Spring会扫描ConcreteHandler
类,并将其实例化为Bean。然后,通过依赖注入的方式,在其他地方使用AbstractHandler
的引用时,实际上注入的是ConcreteHandler
的实例。这样,我们可以通过抽象类来定义一组具有共同特征的子类,并使用它们在Spring容器中进行统一管理和使用。
需要注意的是,抽象类被实例化为Bean是通过具体实现类的实例来实现的,并且在注入时必须引用具体实现类的类型。Spring不能直接实例化抽象类,必须通过具体实现类来实例化和引用。