自动注入注解

‘@Autowired’ 和‘@Inject’的报错信息完全相同，他们都是通过 ‘AutowiredAnnotationBeanPostProcessor’ 类实现的依赖注入，二者具有可互换性。 ‘@Resource’通过 ‘CommonAnnotationBeanPostProcessor’ 类实现依赖注入，即便如此他们在依赖注入时的表现还是极为相近的，以下是他们在实现依赖注入时执行顺序的概括：

@Autowired and @Inject

  1. Matches by Type
  2. Restricts by Qualifiers
  3. Matches by Name

@Resource

  1. Matches by Name
  2. Matches by Type
  3. Restricts by Qualifiers (ignored if match is found by name)

     ‘@Resource’在依据name注入的时候速度性能表现的比 ‘@Autowired’ 和‘@Inject’优越，但这是微不足道的，不足以作为优先选择 ‘@Resource’的原因。我倾向于使用 ‘@Resource’是因为它配置起来更简洁。

@Resource(name="person")
@Autowired@Qualifier("person")
@Inject@Qualifier("person")

    你也许会说使用字段 默认 名称作为注入时候的bean name，其他两种方式就会一样简洁：

@Resourceprivate Party person;
@Autowiredprivate Party person;
@Injectprivate Party person;

    确实如此。但是当你需要重构代码的时候又如何呢？使用’@Resource‘方式只需简单修改name属性即可，而无需触及注入Bean的名称(注入Bean的时候同意使用接口名称)。所以我建议使用注解方式实现注入的时候遵循以下语法风格：

1.在你的组件中明确限定bean名称而不是使用默认值 [@Component("beanName")]。

2.同时使用’@Resource‘和它的’name'属性 [@Resource(name="beanName")]。

3.避免使用‘@Qualifier’注解，除非你要创建一系列类似beans的集合。例如，你也许需要建立一个set集合来存放一系列“规则”定义。这个时候可以选择‘@Qualifier'注解方式。这种方式使得将大量遵循相同规则的类放入集合中变得容易。

4.使用如下配置限定需要尽心组件扫描的包： [context:component-scan base-package="com.sourceallies.person"]。这样做可以减小spring扫描很多无效的包的情况。

    遵循以上原则能增强你的，注解风格的，spring配置的可读性和稳定性。 

 

反射机制

反射的概念是由Smith在1982年首次提出的，主要是指程序可以访问、检测和修改它本身状态或行为的一种能力。
对于Java来说，就是在运行状态中，查询这个类、对象的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法、修改它的属性。
而所谓的依赖注入就是指在运行时（不是编译时）改变对象的属性或者调用对象的构造方法。
其实依赖注入是很容易实现的，你自己可以尝试一下，Spring的伟大之处并不在于技术有多难，而是在于他把这种技术发展成一种开发模式和框架。

具体java反射相关，参考 http://blog.csdn.net/liujiahan629629/article/details/18013523
模拟spring解析autowired，参考 http://blog.csdn.net/pingnanlee/article/details/45917639
注解原理 http://blog.csdn.net/rommel1/article/details/17096141

基于反射和注解机制，简单模拟Spring解析Autowired注解的过程。

1、自定义Autowired注解，代码如下

 
  1. package com.basic.reflect;  
  2.   
  3. import java.lang.annotation.ElementType;    
  4. import java.lang.annotation.Retention;    
  5. import java.lang.annotation.RetentionPolicy;    
  6. import java.lang.annotation.Target;    
  7.   
  8. @Retention(RetentionPolicy.RUNTIME)  
  9. @Target({ ElementType.FIELD, ElementType.METHOD })  
  10. public @interface Autowired {  
  11.     //注解的name属性    
  12.     public String name() default "";    
  13. }  

2、定义相关的业务和Dao类，以及获取Bean的容器（在容器中基于反射实现自动注入） 

  1. public class PersonDao {  
  2.     public int add(Object o) {  
  3.         System.out.println("dao autowird ok ");  
  4.         return 0;  
  5.     }  
  6. }  
  7. public class ServiceImpl {  
  8.     @Autowired  
  9.     private PersonDao personDao;  
  10.   
  11.     public int addPerson(Object obj) {  
  12.         return personDao.add(obj);  
  13.     }  
  14. }  
  15. public class BeanContainer {  
  16.     public static Object getBean(String name) {  
  17.         try {  
  18.             Class<?> clazz = Class.forName("com.basic.reflect.ServiceImpl");  
  19.             Object bean = clazz.newInstance();  
  20.             Field[] fileds = clazz.getDeclaredFields();  
  21.             for (Field f : fileds) {  
  22.                 if (f.isAnnotationPresent(Autowired.class)) {                          
  23.                     // 基于类型注入  
  24.                     Class<?> c = f.getType();  
  25.                     Object value = c.newInstance();  
  26.                     //允许访问private字段    
  27.                     f.setAccessible(true);    
  28.                     //把引用对象注入属性    
  29.                     f.set(bean, value);                            
  30.                 }  
  31.             }  
  32.             return bean;  
  33.         } catch (Exception e) {  
  34.             e.printStackTrace();  
  35.         }  
  36.         return null;  
  37.     }  
  38. }   

3、测试类

  1. public class Test {  
  2.     public static void main(String[] args) {  
  3.         ServiceImpl impl = (ServiceImpl) BeanContainer.getBean("service");  
  4.         String name = "test";  
  5.         impl.addPerson(name);  
  6.     }  
  7. }  

总结，上面的代码简单模拟了Spring解析Autowired的过程，写的比较简单，但是精髓已经写到了，主要就是利用反射机制生成实例并且解析注解对其属性进行赋值。其实Spring框架的核心Ioc和Aop的实现，还是利用了java最基本的东西，比如Aop就是利用了动态代理，Ioc就是利用了反射机制

 

posted on 2015-12-14 15:34  GOvoid  阅读(1018)  评论(0)  编辑  收藏  举报