模拟依赖注入

本实验采用全注解模拟，开始讨厌XML配置文件了

定义两注解：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Bean {
 public String Id() default "";
}


 @Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Autowired {
}

定义工厂接口：

public interface BeanFactory {

 Object getBean(String name) throws Exception;

// Object getBean(String name,Class requiredType) throws Exception;

 boolean containsBean(String name) throws Exception;


 //预留（默认全是单例）
 boolean isSingletion(String name) throws Exception;

}

实现工厂：

public class AnnotationBeanFactory implements BeanFactory{

 //存放工厂bean
 public static Map<String,Object> beanMap = new HashMap<String,Object>();

 //存放需要注入的bean
 public static Map<String,Object> initMap = new HashMap<String,Object>();

 public AnnotationBeanFactory (String packageName){
  init(packageName);
 }

 private void init(String packageName){
  //简单起见采用自定义工具类读文件,未做读取源扩展
  String[] names = MirrorUtil.getFilesName(MirrorUtil.getFilesByPackage(packageName));
  Class<?>[] classes = MirrorUtil.getClassesByNames(names, packageName);
  //初始化bean（包括需要注入的bean）
  initBeans(classes);
  //注入bean
  initAutoBeans(classes);
 }

 private static void initBeans(Class<?>[] classes){
  Assert.notNull(classes);
  for(Class<?> c : classes){
   if(MirrorUtil.hasBeanAnnotation(c)){
    String beanName = ((Bean)c.getAnnotation(Bean.class)).Id();
    try {
     Object o = c.newInstance();
     //Id默认采用类名（懒，未作驼峰转换）
     if(beanName==null||"".equals(beanName)){
      beanMap.put(c.getSimpleName().toString(), o);
     }else{
      beanMap.put(beanName, o);
     }
    } catch (InstantiationException e) {
     e.printStackTrace();
    } catch (IllegalAccessException e) {
     e.printStackTrace();
    }
   }
   if(MirrorUtil.hasAutowiredAnnotation(c)){
    try {
     Object o = c.newInstance();
     initMap.put(c.getSimpleName().toString(), o);
    } catch (InstantiationException e) {
     e.printStackTrace();
    } catch (IllegalAccessException e) {
     e.printStackTrace();
    }
   }
  }
 } 

 private static void initAutoBeans(Class<?>[] classes){
  Assert.notNull(classes);
  for(Class<?> c : classes){
   Field[] fields = c.getDeclaredFields();
   for(Field f : fields){
    if(MirrorUtil.hasAutowiredAnnotation(f)){
     try {
      //去除私有化变量不能反射限制
      f.setAccessible(true);
      Object o = initMap.get(c.getSimpleName().toString());
      f.set(o, beanMap.get(f.getName().toString()));
      beanMap.put(c.getSimpleName(), o);
      f.setAccessible(false);
     } catch (IllegalArgumentException e) {
      e.printStackTrace();
     } catch (IllegalAccessException e) {
      e.printStackTrace();
     } 
    }
   }
  }
 }

 public boolean containsBean(String name) throws Exception {
  return beanMap.containsKey(name);
 }

 public Object getBean(String name) throws Exception {
  return beanMap.get(name);
 }


 public boolean isSingletion(String name) throws Exception {
  return true;
 }

}

自定义懒惰工具类：

public class MirrorUtil {


 public static Class<?> getClass(String className){
  Class<?> c = null;
  try {
   c = Class.forName(className);
  } catch (ClassNotFoundException e) {
   e.printStackTrace();
  }
  return c;
 }

 public static String getClassPath(){
  return Thread.currentThread().getContextClassLoader().getResource(".").getPath().toString();
 }

 public static List<File> getFilesByDirectory(String directory){
  List<File> result = new ArrayList<File>();
  return getFilesByDirectory(directory,result);

 }

 public static String packageToPath(String packageName){
  String[] directorys = packageName.split("\\.");
  StringBuilder sb = new StringBuilder("");
  for(String s : directorys){
   sb.append(s).append("/");
  }
  return sb.deleteCharAt(sb.length()-1).toString();
 }

 private static List<File> getFilesByDirectory(String directory,List<File> result){
  File[] files = new File(directory).listFiles();
  for(int i=0;i<files.length;i++){
   if(files[i].isFile()){
    result.add(files[i]);
   }else{
    getFilesByDirectory(files[i].getName(),result);
   }
  }
  return result;
 }

 public static List<File> getFilesByPackage(String packageName){
  String path = packageToPath(packageName);
  return getFilesByDirectory(getClassPath()+path);
 }

 public static boolean hasBeanAnnotation(Class<?> c){
  Bean b = (Bean)c.getAnnotation(Bean.class);
  if(b==null){
   return false;
  }else{
   return true;
  }
 }

 public static boolean hasAutowiredAnnotation(Field f){
  Autowired autoWired = (Autowired) f.getAnnotation(Autowired.class);
  if(autoWired==null){
   return false;
  }else{
   return true;
  }
 }

 public static boolean hasAutowiredAnnotation(Class<?> c){
  Field[] fields = c.getDeclaredFields();
  for(Field f : fields){
   Autowired autoWired = (Autowired) f.getAnnotation(Autowired.class);
   if(autoWired==null){
    return false;
   }else{
    return true;
   }
  }
  return false;
 }


 public static Class<?>[] getClassesByNames(String[] names,String packageName){
  Assert.notNull(names);
  Class<?>[] classes = new Class[names.length];
  for(int i=0;i<names.length;i++){
  try {
   classes[i] = Class.forName(packageName+"."+names[i]);
  } catch (ClassNotFoundException e) {
   e.printStackTrace();
  }
  }
  return classes;
 }


 public static String[] getFilesName(List<?> files){
  String[] names = new String[files.size()];
  int i = 0;
  for(Object f : files){
   String s = ((File)f).getName();
   names[i] = s.substring(0, s.length()-6);
   i++;
  }
  return names;
 }


}

定义2个测试bean:

@Bean(Id="testBean")
public class TestBean {

 public void print(){
  System.out.println("init success");
 }

}


@Bean
public class TestPrint {

 @Autowired
 private TestBean testBean;

 public void print(){
  testBean.print();
 }
}

测试类：

[code="java"]

public class TestUtil {

public static void main(String[] args) throws Exception{

BeanFactory beanFactory = new AnnotationBeanFactory("ioc.test");
((TestPrint)beanFactory.getBean("TestPrint")).print();

}
}

</code>

完成。