spring中注解的实现原理

最新推荐文章于 2024-07-24 00:03:51 发布

小城风带香

最新推荐文章于 2024-07-24 00:03:51 发布

阅读量2.1k

点赞数 1

分类专栏： JAVA 文章标签： spring

本文链接：https://blog.csdn.net/xwq911/article/details/50126653

版权

JAVA 专栏收录该内容

172 篇文章 0 订阅

订阅专栏

@Autowired和@Resource的区别：

在Java中使用@Autowired和@Resource注解进行装配，这两个注解分别是：
1、@Autowired按照默认类型(类名称)装配依赖对象，默认情况下它要求依赖对象必须存在，如果允许为null,可以设置它的required属性为false
如果我们按名称装配，可以结合@Qualifie注解一起使用。
如：
@Autowired @qualifie("personDaoBean")
private PersonDaoBean personDaoBean;

@Resource默认按照名称(name="test")进行装配,名称可以通过@resource的name属性设定，当找不到与名称匹配的bean才会按类型装配

注意：如果没有指定name属性，并且安装默认的名称依然找不到依赖对象时，@Resource会回退到按类型装配。但一旦指定了name属性，就只能按名称装配了。

下面的示例来简单的讲述spring注解原理：

本例实现了在set方法上和在字段属性上注解的处理解析。

1、定义注解

     Java代码   
     
   
 package com.yt.annotation;  
   
 import java.lang.annotation.ElementType;  
 import java.lang.annotation.Retention;  
 import java.lang.annotation.RetentionPolicy;  
 import java.lang.annotation.Target;  
   
 /** 
  * @Description:定义注解 
  * @ClassName: ZxfResource 
  * @Project: spring-aop 
  * @Author: zxf 
  * @Date: 2011-6-7 
  */  
 // 在运行时执行  
 @Retention(RetentionPolicy.RUNTIME)  
 // 注解适用地方(字段和方法)  
 @Target({ ElementType.FIELD, ElementType.METHOD })  
 public @interface ZxfResource {  
   
     //注解的name属性  
     public String name() default "";  
 }  

2、带有注解的服务类

     Java代码   
     
   
 package com.yt.annotation;  
   
 /** 
  * @Description: 带有注解的服务 
  * @ClassName: UserDaoImpl 
  * @Project: spring-aop 
  * @Author: zxf 
  * @Date: 2011-6-7 
  */  
 public class UserServiceImpl {  
   
     public UserDaoImpl userDao;  
     public User1DaoImpl user1Dao;  
   
     // 字段上的注解,可以配置name属性  
     @ZxfResource  
     public User2DaoImpl user2Dao;  
   
     // set方法上的注解，带有name属性  
     @ZxfResource(name = "userDao")  
     public void setUserDao(UserDaoImpl userDao) {  
         this.userDao = userDao;  
     }  
   
     // set方法上的注解，没有配置name属性  
     @ZxfResource  
     public void setUser1Dao(User1DaoImpl user1Dao) {  
         this.user1Dao = user1Dao;  
     }  
   
     public void show() {  
         userDao.show();  
         user1Dao.show1();  
         user2Dao.show2();  
         System.out.println("这里是Service方法........");  
     }  
 }  

3、要注入的DAO

     Java代码   
     
   
 package com.yt.annotation;  
   
 /** 
  * @Description: 要注入的DAo类 
  * @ClassName: UserDaoImpl 
  * @Project: spring-aop 
  * @Author: zxf 
  * @Date: 2011-6-7 
  */  
 public class UserDaoImpl {  
       
     String name ;  
       
     public void show(){  
         System.out.println("这里是dao方法........");  
     }  
 }  

     Xml代码   
     
   
 <?xml version="1.0" encoding="UTF-8"?>  
 <beans>  
     <bean id = "userDao" class="com.yt.annotation.UserDaoImpl" />  
     <bean id = "user1Dao" class="com.yt.annotation.User1DaoImpl" />  
     <bean id = "user2Dao" class="com.yt.annotation.User2DaoImpl" />  
     <bean id = "userService" class = "com.yt.annotation.UserServiceImpl" />  
 </beans>  

4、注解处理器

     Java代码   
     
   
 package com.yt.annotation;  
   
 import java.beans.Introspector;  
 import java.beans.PropertyDescriptor;  
 import java.lang.reflect.Field;  
 import java.lang.reflect.Method;  
 import java.util.ArrayList;  
 import java.util.HashMap;  
 import java.util.Iterator;  
 import java.util.List;  
 import java.util.Map;  
 import org.apache.log4j.Logger;  
 import org.dom4j.Document;  
 import org.dom4j.DocumentException;  
 import org.dom4j.Element;  
 import org.dom4j.io.SAXReader;  
   
 /** 
  * @Description: spring中的注解原理 
  * @ClassName: ClassPathXMLApplicationContext 
  * @Project: spring-aop 
  * @Author: zxf 
  * @Date: 2011-6-3 
  */  
 public class ClassPathXMLApplicationContext {  
   
     Logger log = Logger.getLogger(ClassPathXMLApplicationContext.class);  
   
     List<BeanDefine> beanList = new ArrayList<BeanDefine>();  
     Map<String, Object> sigletions = new HashMap<String, Object>();  
   
     public ClassPathXMLApplicationContext(String fileName) {  
         //读取配置文件中管理的bean  
         this.readXML(fileName);  
         //实例化bean  
         this.instancesBean();  
         //注解处理器  
         this.annotationInject();  
     }  
   
     /** 
      * 读取Bean配置文件 
      * @param fileName 
      * @return 
      */  
     @SuppressWarnings("unchecked")  
     public void readXML(String fileName) {  
         Document document = null;  
         SAXReader saxReader = new SAXReader();  
         try {  
             ClassLoader classLoader =   
                 Thread.currentThread().getContextClassLoader();  
             document = saxReader.read(classLoader.getResourceAsStream(fileName));  
             Element beans = document.getRootElement();  
             for (Iterator<Element> beansList = beans.elementIterator();   
                 beansList.hasNext();) {  
                 Element element = beansList.next();  
                 BeanDefine bean = new BeanDefine(  
                         element.attributeValue("id"),  
                         element.attributeValue("class"));  
                 beanList.add(bean);  
             }  
         } catch (DocumentException e) {  
             log.info("读取配置文件出错....");  
         }  
     }  
       
     /** 
      * 实例化Bean 
      */  
     public void instancesBean() {  
         for (BeanDefine bean : beanList) {  
             try {  
                 sigletions.put(bean.getId(),   
                         Class.forName(bean.getClassName()).newInstance());  
             } catch (Exception e) {  
                 log.info("实例化Bean出错...");  
             }  
         }  
     }  
       
     /** 
      * 注解处理器 
      * 如果注解ZxfResource配置了name属性，则根据name所指定的名称获取要注入的实例引用， 
      * 如果注解ZxfResource;没有配置name属性，则根据属性所属类型来扫描配置文件获取要 
      * 注入的实例引用 
      *  
      */  
     public void annotationInject(){  
         for(String beanName:sigletions.keySet()){  
             Object bean = sigletions.get(beanName);  
             if(bean!=null){  
                 this.propertyAnnotation(bean);  
                 this.fieldAnnotation(bean);  
             }  
         }  
     }  
       
     /** 
      * 处理在set方法加入的注解 
      * @param bean 处理的bean 
      */  
     public void propertyAnnotation(Object bean){  
         try {  
             //获取其属性的描述  
             PropertyDescriptor[] ps =   
                 Introspector.getBeanInfo(bean.getClass()).getPropertyDescriptors();  
             for(PropertyDescriptor proderdesc : ps){  
                 //获取所有set方法  
                 Method setter = proderdesc.getWriteMethod();  
                 //判断set方法是否定义了注解  
                 if(setter!=null && setter.isAnnotationPresent(ZxfResource.class)){  
                     //获取当前注解，并判断name属性是否为空  
                     ZxfResource resource = setter.getAnnotation(ZxfResource.class);  
                     String name ="";  
                     Object value = null;  
                     if(resource.name()!=null&&!"".equals(resource.name())){  
                         //获取注解的name属性的内容  
                         name = resource.name();  
                         value = sigletions.get(name);  
                     }else{ //如果当前注解没有指定name属性,则根据类型进行匹配  
                         for(String key : sigletions.keySet()){  
                             //判断当前属性所属的类型是否在配置文件中存在  
                             if(proderdesc.getPropertyType().isAssignableFrom(sigletions.get(key).getClass())){  
                                 //获取类型匹配的实例对象  
                                 value = sigletions.get(key);  
                                 break;  
                             }  
                         }  
                     }  
                     //允许访问private方法  
                     setter.setAccessible(true);  
                     //把引用对象注入属性  
                     setter.invoke(bean, value);   
                 }  
             }  
         } catch (Exception e) {  
             log.info("set方法注解解析异常..........");  
         }  
     }  
       
     /** 
      * 处理在字段上的注解 
      * @param bean 处理的bean 
      */  
     public void fieldAnnotation(Object bean){  
         try {  
             //获取其全部的字段描述  
             Field[] fields = bean.getClass().getFields();  
             for(Field f : fields){  
                 if(f!=null && f.isAnnotationPresent(ZxfResource.class)){  
                     ZxfResource resource = f.getAnnotation(ZxfResource.class);  
                     String name ="";  
                     Object value = null;  
                     if(resource.name()!=null&&!"".equals(resource.name())){  
                         name = resource.name();  
                         value = sigletions.get(name);  
                     }else{  
                         for(String key : sigletions.keySet()){  
                             //判断当前属性所属的类型是否在配置文件中存在  
                             if(f.getType().isAssignableFrom(sigletions.get(key).getClass())){  
                                 //获取类型匹配的实例对象  
                                 value = sigletions.get(key);  
                                 break;  
                             }  
                         }  
                     }  
                     //允许访问private字段  
                     f.setAccessible(true);  
                     //把引用对象注入属性  
                     f.set(bean, value);  
                 }  
             }  
         } catch (Exception e) {  
             log.info("字段注解解析异常..........");  
         }  
     }  
       
     /** 
      * 获取Map中的对应的bean实例 
      * @param beanId 
      * @return 
      */  
     public Object getBean(String beanId) {  
         return sigletions.get(beanId);  
     }  
   
   
     public static void main(String[] args) {  
         ClassPathXMLApplicationContext path = new ClassPathXMLApplicationContext(  
                 "configAnnotation.xml");  
         UserServiceImpl userService =(UserServiceImpl)path.getBean("userService");  
         userService.show();  
     }  
 }  

====================================================================================================

以上部分都是从别人博客里转载过来的。自己研究了一下，确实受益匪浅，同时也自己实现了一遍，自己的代码如下：

package MySpring;

import org.apache.log4j.Logger;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.io.File;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

/**
 * Created by Administrator on 2015/12/2.
 */
public class FileSystemXmlApplicationContext {

    private final static Logger logger = Logger.getLogger(FileSystemXmlApplicationContext.class);

    List<BeanDefine> beandefines = new ArrayList<>();

    Map<String, Object> contextMap = new LinkedHashMap<>();


    public FileSystemXmlApplicationContext(String fileName) {
        //解析XML配置文件
        detectionXML(fileName);
        //实例化配置文件中的bean
        instanceXmlBeans();
        //根据注解注入bean中需要的类
        injectBeans();
    }


    /**
     * 解析XML配置文件
     */
    public void detectionXML(String fileName) {
        SAXReader saxReader = new SAXReader();
        try {
            //获取项目根路径 即：proxy
            String relativelyPath = System.getProperty("user.dir");
            File file = new File(relativelyPath + "/src/" + fileName);
            Document document = saxReader.read(file);
            Element rootElement = document.getRootElement();
            for (Iterator iterator = rootElement.elementIterator(); iterator.hasNext(); ) {
                Element element = (Element) iterator.next();
                BeanDefine beanDefine = new BeanDefine(element.attributeValue("id"), element.attributeValue("class"));
                beandefines.add(beanDefine);
            }

        } catch (DocumentException e) {
            logger.info("解析XML文件失败……");
            e.printStackTrace();
        }
    }

    /**
     * 实例化bean
     */
    public void instanceXmlBeans() {
        for (BeanDefine beanDefine : beandefines) {
            if (null != beanDefine.getClassName() && !"".equals(beanDefine.getClassName())) {
                try {
                    contextMap.put(beanDefine.getId(), Class.forName(beanDefine.getClassName()).newInstance());
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 根据注解注入bean中需要的类
     */
    public void injectBeans() {
        for (Map.Entry entry : contextMap.entrySet()) {
            try {

                //如果注解是在属性上
                propertyInject(entry.getValue());
                //如果注解是在setter方法上
                fieldInject(entry.getValue());

            } catch (Exception e) {
                e.printStackTrace();
            }

        }

    }

    /**
     * 如果注解是在属性上
     */
    public void propertyInject(Object ob) {
        Field[] fields = ob.getClass().getFields();
        for (Field field : fields) {
            if (field.isAnnotationPresent(XiaoResource.class)) {
                XiaoResource annotation = field.getAnnotation(XiaoResource.class);
                Object o = null;

                for (Map.Entry beanDefine : contextMap.entrySet()) {
                    if (annotation.name() == null || "".equals(annotation.name())) {
                        //没有配置name属性
                        if (field.getType().isAssignableFrom(beanDefine.getValue().getClass())) {
                            o = beanDefine.getValue();
                            break;
                        }
                    } else {
                        //配置了name属性
                        if (beanDefine.getKey().equals(annotation.name())) {
                            o = beanDefine.getValue();
                            break;
                        }
                    }
                }
                field.setAccessible(true);
                try {
                    field.set(ob, o);
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 如果注解是在setter方法上
     */
    public void fieldInject(Object ob) {
        try {
            PropertyDescriptor[] propertyDescriptors = Introspector.getBeanInfo(ob.getClass()).getPropertyDescriptors();
            for (PropertyDescriptor propertyDescriptor : propertyDescriptors) {
                Method method = propertyDescriptor.getWriteMethod();
                if (null != method) {
                    if (method.isAnnotationPresent(XiaoResource.class)) {
                        XiaoResource annotation = method.getAnnotation(XiaoResource.class);
                        Object o = null;
                        for (Map.Entry beanDefine : contextMap.entrySet()) {
                            //没有配置name属性
                            if (beanDefine.getValue().getClass().isAssignableFrom(propertyDescriptor.getPropertyType())) {
                                o = beanDefine.getValue();
                                break;
                            }
                            //配置了name属性
                            if (beanDefine.getKey().equals(annotation.name())) {
                                o = beanDefine.getValue();
                                break;
                            }
                        }
                        method.setAccessible(true);
                        method.invoke(ob, o);
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    public Object getBean(String beanName) {return contextMap.get(beanName);}


    public static void main(String[] args) {
        FileSystemXmlApplicationContext fileSystemXmlApplicationContext = new FileSystemXmlApplicationContext("configAnnotation.xml");
        UserServiceImpl userService = (UserServiceImpl) fileSystemXmlApplicationContext.getBean("userService");
        userService.show();
    }

}

重点在这里说一下我改了的地方以及发现的问题。我在实现的时候，发现把UserServiceImpl类改成如下：

package MySpring;

/**
 * Created by Administrator on 2015/12/1.
 */
public class UserServiceImpl {

    public UserDao userDao;
    @XiaoResource
    public UserDao user3Dao;
    @XiaoResource(name="userDao2")
    public UserDao user2Dao;


    @XiaoResource
    public void setUserDao(UserDaoImpl userDao) {
        this.userDao = userDao;
    }


    public void setUser1Dao(User1DaoImpl user1Dao) {
        this.user3Dao = user1Dao;
    }

    public void show(){
        userDao.show();
        user3Dao.show();
        user2Dao.show();
        System.out.println("这是一个Service方法……");
    }

}

则输出为：

这是一个dao的方法……
这是一个dao1的方法……
这是一个dao2的方法……
这是一个Service方法……

可是，奇怪了，为什么会输出dao1,而不是dao或dao2。研究了一下发现，原因出在Map上，原代码使用的是HashMap是“无序的”,这个无序并不是说真的无序，而是按hash来排了顺序，所以每次拍完后，排在最开头的就是User1DaoImpl，而如果我将HashMap改成LinkHashMap则会按照配置文件配置的顺序，输出如下结果：

这是一个dao的方法……
这是一个dao的方法……
这是一个dao2的方法……
这是一个Service方法……
恩，我们看到，两个dao。哈哈，就是要的这个结果。为什么呢？这个正好和spring的实现合理了吧。如果spring中一个接口有多个实例实现了它，我们虽然在配置文件中将bean都配上了，但却用注解去配置他们的属性类。如注解@ AutoWired和@resource，如果我们不给与name属性或者用@ Qualifier去指定那个实例，则会报错。如下：

org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name 'action.book.bookAction': Unsatisfied dependency expressed through bean property 'iBook': : No unique bean of type [service.interf.IBook] is defined: expected single matching bean but found 2: [bookImpl, bookImpl2]; nested exception is org.springframework.beans.factory.NoSuchBeanDefinitionException: No unique bean of type [service.interf.IBook] is defined: expected single matching bean but found 2: [bookImpl, bookImpl2]

There are many approaches to resolve ambiguity. 
1) Use @Qualifier next to your @Autowired so you can tell which one to inject by name. 
public class Something {
    @Autowired
    @Qualifier("hibernateOrderRepositoryImpl")
    private OrderRepository orderRepository;
}
2) Put @Primary on one of the implementations, then Spring will inject that one. 
@Primary
@Repository
public class HibernateOrderRepositoryImpl {
}
3) Only have one of the two implementations in your classpath at runtime, so that there will ever only be one implementation. 
For 3, I have yet to see any good examples of why you would need multiple implementations of a Service or a Repository or a Controller, EndPoint, or any other class that you write. 

However, there are cases where you might have multiple DataSources, TransactionManagers, or other infrastructure beans. In which case, you only have option #1, because you can't put @Primary into a class you didn't write and only have the .class of.

恩，不过，在网上还找到了一个关于@AutoWired注解的一个注意点： Autowired是先根据变量的名字在容器中找与名字相同的id的bean

http://www.bubuko.com/infodetail-826510.html

annotation.rar (4.2 KB)
下载次数: 216

小城风带香

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
spring中注解的实现原理

@Autowired和@Resource的区别：在Java中使用@Autowired和@Resource注解进行装配，这两个注解分别是：1、@Autowired按照默认类型(类名称)装配依赖对象，默认情况下它要求依赖对象必须存在，如果允许为null,可以设置它的required属性为false如果我们按名称装配，可以结合@Qualifie注解一起使用。如：@Aut
复制链接

扫一扫

专栏目录