浅析spring中注解的运行

为了了解注解的运行机制，需要自定义一个注解，如下方式来模拟注解方式实现注入对象：

1.新建一个自定义注解MyResource.java

@Retention(RetentionPolicy.RUNTIME) // 定义注解有效期为运行期
@Target({ElementType.FIELD,ElementType.METHOD}) // 定义可以注解的位置
public @interface MyResource {
String name() default "";
}

2.自定义spring中的注解运行

package com.heying.test;

import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.XPath;
import org.dom4j.io.SAXReader;

import com.heying.service.MyResource;
import com.heying.service.PropertyDdefinition;
import com.heying.service.XmlBeanDefinition;

public class MyClassPathXmlApplicationContext {
private List<XmlBeanDefinition> beanDefinitions = new ArrayList<XmlBeanDefinition>();
private Map<Object, Object> sigletons = new HashMap<Object, Object>();

public MyClassPathXmlApplicationContext(String fileName) {
this.readXmlFile(fileName);
this.instanceBeans();
this.annotationInject();
this.injectObject();
}

/**
* 注解
*/
private void annotationInject() {
for (Object beanName : sigletons.keySet()) {
Object bean = sigletons.get(beanName);
if(bean != null){
try {
PropertyDescriptor[] ps = Introspector.getBeanInfo(bean.getClass()).getPropertyDescriptors();
for (PropertyDescriptor propertyDescriptor : ps) {
Method setter = propertyDescriptor.getWriteMethod();
if(setter != null && setter.isAnnotationPresent(MyResource.class)){
MyResource myTest = setter.getAnnotation(MyResource.class); //获取注解

if(myTest.name() != null && !"".equals(myTest.name())){
Object value = sigletons.get(myTest.name());
setter.setAccessible(true);
setter.invoke(bean,value); // 引入对象到属性
}else{
Object value = sigletons.get(propertyDescriptor.getName());
// 没有标注name 或者没有找到的时候就会按照类型去寻找
if(value == null){
for (Object key : sigletons.keySet()) {
if(propertyDescriptor.getPropertyType().isAssignableFrom(sigletons.get(key).getClass())){
value = sigletons.get(key);
setter.setAccessible(true);
setter.invoke(bean,value); // 引入对象到属性
break;
}
}
}
}
}
}

Field[] fields = bean.getClass().getDeclaredFields();
for (Field field : fields) {
if(field.isAnnotationPresent(MyResource.class)){
MyResource myTest = field.getAnnotation(MyResource.class); //获取注解
Object value = null;
if(myTest.name() != null && !"".equals(myTest.name())){
value = sigletons.get(myTest.name());
}else{
value = sigletons.get(field.getName());
// 没有标注name 或者没有找到的时候就会按照类型去寻找
if(value == null){
for (Object key : sigletons.keySet()) {
if(field.getType().isAssignableFrom(sigletons.get(key).getClass())){
value = sigletons.get(key);
break;
}
}
}
}
field.setAccessible(true);
field.set(bean, value);
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
}

/**
* 依赖注入
*/
private void injectObject() {
for ( XmlBeanDefinition beanDefinition : beanDefinitions) {
Object bean = sigletons.get(beanDefinition.getId());
if(bean != null){
try {
PropertyDescriptor[] propers = Introspector.getBeanInfo(bean.getClass()).getPropertyDescriptors();

for (PropertyDdefinition propertyDdefinition : beanDefinition.getDdefinitions()) {
for (PropertyDescripto
4000
r propertyDescriptor : propers) {
if(propertyDdefinition.getName().equals(propertyDescriptor.getName())){  // 判断是否相等
Method setter = propertyDescriptor.getWriteMethod(); // 获取set方法
if(setter != null){
Object value = sigletons.get(propertyDdefinition.getRef());
setter.setAccessible(true);
setter.invoke(bean,value); // 引入对象到属性
}
break;
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
}

/**
* bean 实例化
*/
private void instanceBeans(){
for ( XmlBeanDefinition beanDefinition : beanDefinitions) {
try {
if(beanDefinition.getName() != null && !"".equals(beanDefinition.getName())){
sigletons.put(beanDefinition.getId(), Class.forName(beanDefinition.getName()).newInstance());
}
} catch (Exception e) {
e.printStackTrace();
}
}
}

/**
* 读取XML信息
* @param fileName
*/
@SuppressWarnings("unchecked")
private void readXmlFile(String fileName) {
SAXReader saxReader = new SAXReader();
Document document = null;

try {
URL xmlPath = this.getClass().getClassLoader().getResource(fileName); // 获取相对路径
document = saxReader.read(xmlPath); // 读取xml文件

Map<String, String> nsMap = new HashMap<String, String>();
nsMap.put("ns", "http://www.springframework.org/schema/beans"); // 加入命名空间
XPath xPath = document.createXPath("//ns:beans/ns:bean"); // 创建查询路径
xPath.setNamespaceURIs(nsMap); // 设置命名空间

List<Element> beans = xPath.selectNodes(document); // 获取所有节点
for (Element element : beans) {
String id = element.attributeValue("id");
String clazz = element.attributeValue("class");
XmlBeanDefinition xmlBeanDefinition = new XmlBeanDefinition(id, clazz);

XPath propertysub = document.createXPath("ns:property");
propertysub.setNamespaceURIs(nsMap); // 设置空间

List<Element> propertys = propertysub.selectNodes(element);
for (Element property : propertys) {
String propertyName = property.attributeValue("name");
String propertyRef = property.attributeValue("ref");
System.out.println("[propertyName="+propertyName+",propertyRef="+propertyRef+"]");
PropertyDdefinition ddefinition = new PropertyDdefinition(propertyName, propertyRef);
xmlBeanDefinition.getDdefinitions().add(ddefinition);
}
beanDefinitions.add(xmlBeanDefinition);
}
} catch (Exception e) {
e.printStackTrace();
}
}

/**
* 获取bean实例
* @param beanName
* @return
*/
public Object getBean(String beanName){
return this.sigletons.get(beanName);
}
}

输出的结果和使用j2ee的注解有相同的效果