image.png

在classpath中扫描组件

  • 组件扫描（component scanning）：Spring能够从classpath下自动扫描，侦测和实例化具有特定注解的组件

  • 特定组件包括

  • @Component : 基本注解，标识了一个受Spring管理的组件
    - @Respository：标识持久层组件
    - @Service：标识服务层（业务层）组件
    - @Controller ：标识表现层（视图层）组件

  • 对于扫描到的组件，Spring有默认的命名策略：使用非限定类名，第一个字母小写，也可以在注解中通过value属性值标识组件的名称

  • 当在组件类上使用了特定的注解之后，还需要在Spring的配置文件中声明:

-base-package属性指定一个需要扫描的基类包，Spring容器将会扫描这个基类包里及其子包中的所有类。
-当需要扫描多个包时，可以使用逗号分隔。
-如果仅希望扫描特定的类而非基类包下的所有类，可以使用resource-pattern属性过滤特定的类，示例在下面

  • 和子节点支持多种类型的过滤表达式

-type=”annotation” 过滤目标类
-type=”assinable” 所有继承或扩展目标类的类
-aspectj 所有类名以“某个名称”结束以及继承或扩展它们的类
-regex 正则匹配
-custom 采用Filter通过代码的方式定义过滤规则，该类必须实现org.springframework.core.type.TypeFilter接口

  1. <context:component-scan
  2.    base-package="com.lijunyang"
  3.    resource-pattern="autowire/*class">
  4.    <!--
  5.      <context:include-filter>子节点表示要包含的目标类
  6.     <context:exclude-filter>子节点表示要排除在外的目标类
  8.     <context:component-scan>下可以拥有若干个<context:include-filter>
  9.     或
  10.     <context:exclude-filter>子节点
  11.    -->
  12. </context:component-scan>   
  14. <context:component-scan
  15.    base-package="com.lijunyang"
  16.    use-default-filters="false">
  17.    <!-- <context:include-filter>节点要配合use-default-filters使用 -->
  18.     <context:include-filter type="annotation" 
  19.       expression="org.springframework.stereotype.Repository" />
  20. </context:component-scan> 
  22. <context:component-scan
  23.    base-package="com.lijunyang">
  24.     <context:exclude-filter type="annotation" 
  25.       expression="org.springframework.stereotype.Repository" />
  26. </context:component-scan>
  1. /*
  2. spring-demo
  3. |- /src
  4.     |- beans.xml
  5.     |- com
  6.       |- lijunyang
  7.         |- test
  8.           |- Main.java
  9.         |- model
  10.           |- TestObject.java
  11.       |- service
  12.           |- UserService.java
  13.       |- repository
  14.           |- UserRepository.java
  15.         |- UserRepositoryImpl.java
  16.       |- controller
  17.           |- UserComtroller.java
  18. */
  19. // TestObject.java
  20. import org.springframework.stereotype.Component
  21. @Conponent
  22. public class TestObject {
  24. }
  26. // UserRepository.java
  27. public interface UserRepository {
  28.     void save();
  29. }
  31. // UserRepositoryImpl.java
  32. import org.springframework.stereotype.Repository
  33. @Repository("userRepository")
  34. public class UserRepositoryImpl implements UserRepository {
  35.     @Override
  36.   public void save() {
  37.       System.out.println("UserRepository Save...");
  38.   }
  39. }
  41. // UserService.java
  42. import org.springframework.stereotype.Service
  43. @Service
  44. public class UserService {
  45.     public void add() {
  46.       System.out.println("UserService Add...");
  47.   }
  48. }
  50. // UserComtroller.java
  51. import org.springframework.stereotype.Controller
  52. public class UserController {
  53.     public void execute() {
  54.       System.out.println("UserController execute...");
  55.   }
  56. }
  58. // Main.java
  59. public class Main {
  60.     public static main(String args[]) {
  61.       ApplicationContext ct = new ClassPathXmlApplicationContext("beans.xml");
  62.     TestObject to = (TestObject) ct.getBean("testObject");
  63.     System.out.println(to);
  64.     UserController userController = (UserController) ct.getBean("userController");
  65.     System.out.println(userController);
  66.     UserService userService = (UserService) ct.getBean("userService");
  67.     System.out.println(userService);
  68.     // 当在<context:component-scan里使用了resource-pattern="repository/*class"时
  69.     // 下面的bean就不在生效了，此时会抛出异常
  70.     UserRepository userRepository = (UserRepository) ct.getBean("userRepository");
  71.     System.out.println(userRepository);
  72.   }
  73. }
  1. // beans.xml
  2. <beans>
  3.     <context:component-scan
  4.    base-package="com.lijunyang"
  5.    resource-pattern="repository/*class"
  6.                             />
  7. </beans>

第二阶段的代码 与 组件装配

  • 元素还会自动注册AutowiredAnnotationBeanPostProcessor实例，该实例可以自动装配具有@Autowired和@Resource，@inject注解的属性
  • @Autowired 注解自动装配具有兼容类型的单个Bean属性

-构造器，普通字段（即使是非public），一切具有参数的方法都可以应用@Autowired注解
-默认情况下，所有使用@Autowired注解的属性都需要被设置。当Spring找不到匹配的Bean装配属性时会抛出异常，若某一个属性不被设置，可以设置@Autowired注解的required属性为false。
-默认情况下，当IOC容器里存在多个类型兼容的Bean时，通过类型的自动装配将无法工资，此时可以在@Qualifier注解里提供Bean的名称，Spring允许对方法的入参标注@Qualifier已指定注入Bean的名称
-@Autowired 注解也可以应用在数组类型的属性上，此时Spring将会把所有匹配的Bean进行自动装配
-@Autowired 注解也可以应用在集合属性上，此时Spring读取该集合的类型信息，然后自动装配所有与之兼容的Bean
-@Autowired 注解用在java.util.Map上时，若该Map的键值为String，那么Spring将自动装配与之Map值类型兼容的Bean，此时Bean的名称作为键值

  1. /*
  2. spring-demo
  3. |- /src
  4.     |- beans.xml
  5.     |- com
  6.       |- lijunyang
  7.         |- test
  8.           |- Main.java
  9.         |- model
  10.           |- TestObject.java
  11.       |- service
  12.           |- UserService.java
  13.       |- repository
  14.           |- UserRepository.java
  15.         |- UserRepositoryImpl.java
  16.         |- UserJdbcRepository.java
  17.       |- controller
  18.           |- UserComtroller.java
  19. */
  20. // TestObject.java
  21. import org.springframework.stereotype.Component
  22. @Conponent
  23. public class TestObject {
  25. }
  27. // UserRepository.java
  28. public interface UserRepository {
  29.     void save();
  30. }
  32. // UserJdbcRepository.java
  33. import org.springframework.stereotype.Repository
  34. @Repository
  35. public class UserJdbcRepository implements UserRepository {  
  36.     @Override
  37.   public void save() {
  38.       System.out.println("UserJdbcRepository Save...");
  39.   }
  40. }
  42. // UserRepositoryImpl.java
  43. import org.springframework.stereotype.Repository
  44. // @Repository("userRepository")
  45. @Repository
  46. public class UserRepositoryImpl implements UserRepository {
  47.   @Autowired(required=false)
  48.   private TestObject testObject;
  50.     @Override
  51.   public void save() {
  52.       System.out.println("UserRepository Save...");
  53.     Syetem.out.println(testObject);
  54.   }
  55. }
  57. // UserService.java
  58. import org.springframework.stereotype.Service
  59. @Service
  60. public class UserService {
  61.     /*
  62.   @Autowired
  63.   @Qualifier("userRepositoryImpl")
  64.     private UserRepository userRepository;
  65.   */
  66.   private UserRepository userRepository;
  67.   /*
  68.   @Autowired
  69.   @Qualifier("userRepositoryImpl")
  70.   public void setUserRepository(UserRepository userRepository) {
  71.       this.userRepository = userRepository;
  72.   }
  73.   */
  74.   @Autowired
  75.   public void setUserRepository(@Qualifier("userRepositoryImpl") UserRepository userRepository) {
  76.       this.userRepository = userRepository;
  77.   }
  79.     public void add() {
  80.       System.out.println("UserService Add...");
  81.     userRepository.save();
  82.   }
  83. }
  85. // UserComtroller.java
  86. import org.springframework.stereotype.Controller
  87. public class UserController {
  88.     @Autowired
  89.     private UserService userService;
  90.     public void execute() {
  91.       System.out.println("UserController execute...");
  92.     userService.add();
  93.   }
  94. }
  96. // Main.java
  97. public class Main {
  98.     public static main(String args[]) {
  99.       ApplicationContext ct = new ClassPathXmlApplicationContext("beans.xml");
  100.     // TestObject to = (TestObject) ct.getBean("testObject");
  101.     // System.out.println(to);
  103.     UserController userController = (UserController) ct.getBean("userController");
  104.     System.out.println(userController);
  105.     userController.execute();
  107.     // UserService userService = (UserService) ct.getBean("userService");
  108.     // System.out.println(userService);
  110.     // 当在<context:component-scan里使用了resource-pattern="repository/*class"时
  111.     // 下面的bean就不在生效了，此时会抛出异常
  112.     // UserRepository userRepository = (UserRepository) ct.getBean("userRepository");
  113.     // System.out.println(userRepository);
  114.   }
  115. }

使用@Resource 或 @Inject 自动装配Bean

  • Spring还支持@Resource或@Inject注解，这两个注解和@Autowired注解的功能类似
  • @Resource注解要求提供一个Bean名称的属性，若该属性为null，则自动采用标注处的变量或方法名作为Bean的名称
  • @Inject和@Autowired注解一样是按类型匹配注入的Bean，但是没有reqired属性
  • 建议使用@Autowired注解