Component

如果每次配置组件都需要通过 XML 文件进行配置就会非常的繁琐，也容易出错，所以 spring 有一直可以自动配置组件的方法，即扫描当前包和子包的类， 通过标记 Component 关键字，自动装配组件

新建 Main.java

  1. @Configuration
  2. @ComponentScan
  3. public class Main {
  4.     public static void main(String[] args) {
  5.         ApplicationContext applicationContext = new AnnotationConfigApplicationContext(Main.class);
  6.         UserService userService = applicationContext.getBean(UserService.class);
  7.         String user = userService.register();
  8.         System.out.println(user);
  9.     }
  10. }

@Configuration 表示这是一个配置类， 实例化 AnnotationConfigApplicationContext 必须要加上这个注解
@ComponentScan 表示这个类会去扫描当前包和子包的所有组件，通过 @AutoWired 进行注入

新建 UserService.java

  1. @Component
  2. public class UserService {
  3.     private EmailService emailService;
  5.     public UserService(@Autowired EmailService emailService){
  6.         this.emailService = emailService;
  7.     }
  9.     public String register(){
  10.         this.emailService.sendEmail();
  11.         return "register successful";
  12.     }
  13. }

新建 EmailService.java

  1. @Component
  2. public class EmailService {
  3.     public void sendEmail(){
  4.         System.out.println("send email");
  5.     }
  6. }

这样我们就完成了 实例化 -> 注入 两个流程了

Bean

需要注意的一点是，这个只适用于当前包及其子包，如果是不同的包呢？ 如何进行实例化和注入？
不同的包，或者第三方的包，我们通过 @Bean 注解来进行注入

新建一个包以及类
注意， 这个类不属于之前的包

  1. import javax.annotation.PostConstruct;
  2. import javax.annotation.PreDestroy;
  4. public class SecurityService {
  5.     @PostConstruct
  6.     public void init(){
  7.         System.out.println("init Security checking");
  8.     }
  10.     @PreDestroy
  11.     public void shutdown(){
  12.         System.out.println("Security testing done!");
  13.     }
  15.     public void doSecurityCheck(){
  16.         System.out.println("Do Security Checking. ");
  17.     }
  19. }

然后在 UserService 中注入

  1. @Component
  2. public class UserService {
  4.     @Autowired
  5.     private SecurityService securityService;
  7.     public User Register(){
  8.         System.out.println("Register User");
  9.         System.out.println("register successful");
  10.         securityService.doSecurityCheck();
  11.         return new User();
  12.     }
  13. }

最后在 Main 文件里面实例化组件

  1. @ComponentScan
  2. @Configuration
  3. public class Main {
  5.     @Bean
  6.     public SecurityService createSecurityService(){
  7.         return new SecurityService();
  8.     }
  9.     public static void main(String[] args) {
  10.         ApplicationContext context = new AnnotationConfigApplicationContext(Main.class);
  11.         UserService userService = context.getBean(UserService.class);
  12.         User user = userService.Register();
  13.     }
  14. }

第三方包因为我们无法扫描到，所以通过 @Bean 的方法来进行注入