‘@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的伟大之处并不在于技术有多难,而是在于他把这种技术发展成一种开发模式和框架。
基于反射和注解机制,简单模拟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. "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. "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. 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. "service");
4. "test";
5. impl.addPerson(name);
6. }
7. }
总结,上面的代码简单模拟了Spring解析Autowired的过程,写的比较简单,但是精髓已经写到了,主要就是利用反射机制生成实例并且解析注解对其属性进行赋值。其实Spring框架的核心Ioc和Aop的实现,还是利用了java最基本的东西,比如Aop就是利用了动态代理,Ioc就是利用了反射机制