Spring内部原理模拟实现（一）—————— 开开开山怪

Spring模拟实现

引入

知道Spring框架的的人，应该对 IOC（控制反转） 和 DI （依赖注入）都有一定的认识。

IOC ：IOC全称为“Inversion of Control”，即控制反转，不是一种技术，而是一种设计思想。在这种设计思想中，你设计好的对象交给容器管理，而不是在应用程序内部对对象进行管理。控制的含义是IOC容器控制了对象（也可以包括文件及其他外部资源）；而反转的含义是IOC容器负责创建及注入依赖的对象，但在传统的应用程序中，我们需要在对象内部去创建（new）依赖的对象，这叫“正”，在这样的情况下，对象之间的耦合度就非常高。
DI：DI全称为“Dependency Injection”，即依赖注入，在系统运行过程中，动态的向某个对象注入它所依赖的对象。比如A依赖一个对象B（一般依赖的是接口），在运行前，A并不知道自己依赖的B的具体实现是怎么样的，IOC容器会在适当的时候为A创建一个合适的B对象，并且注入，这就是依赖注入。

上述两个概念摘自 https://blog.csdn.net/L_BestCoder/article/details/79318353

正题

这篇Spring的内部原理模拟实现，针对的是可配置的普通类，并且采用懒汉模式来实现。

因为我们bean容器中存放的都是经过我们配置好的文件中的类，那对于那些jar包中的类，我们是不能够进行配置工作的（毕竟你不能改其原代码吧）所以这篇主要说可配置的普通类来抛个砖，关于那些jar包中的类，我们怎样放入bean容器中并进行使用，请仔细阅读 Spring内部原理模拟实现（二）。

OK，正题正题
控制反转就是当你需要一个类对象的时候，不再采用new的方式来进行，而是将控制权交给Spring中的bean容器，这个bean容器由beanFatory这个类来承载。

beanFactory这个类会根据配置文件创建所需要的类对象放入bean容器（我这里的bean容器事实上就是一个map）中，这些类就是以后我们所需要的，当然在我们想要获取一个类对象时，beanFactory会看对象的创建是否需要依赖于另一个对象（这相当于一个类中拥有其他类作为成员），这里的依赖关系，需要采用注解来配置，并且之后进行判断。

为了方面起见，beanFactory类在后面给出。

在这里先引出两个注解 Component 和 autoWire：

@Retention(RUNTIME)
@Target(FIELD)
public @interface autoWire {
 String name() default "";
}

@Retention(RUNTIME)
@Target(TYPE)
public @interface Component {
 String name() default "";
}

<1> Component 注解：（对类注解）
这是对类的注解，表明这个类是需要放入bean容器中的类，当扫描每个带有Component 注解的类的时候，我们采用beanDefinition类对这些扫描到的类进行封装。

public class beanDefinition {
	private Class<?> kclass;
	private Object object;
	private Boolean inject;
	
	beanDefinition() {
	 
	}
	//剩余代码不展示，就是对此类成员的getter 和 setter方法
} 

进行封装后，形成一个bean容器(就是我上边说的map<xx,xx>),当然map的键为扫描到的类的名称，值就是封装这个类的 beanDefinition类对象。

形成这样的map的原因是，当我们需要引用一个bean容器中的类的时候，可以直接通过类名称在map中找到对应的beanDefinition类对象，再采用beanDefinition中getObject()方法。便可以获取到需要引用的类对象。但是此时获得到的仅仅是一个类的对象，这个对象中的其他成员的值为0或者null。

那么就说到上面我们所说的，一个对象的引用是否需要其他的对象（意思是一个类对象拥有其他类成员，而这些成员也是需要进行初始化的，不应该是0或者null）。那 autoWire注解起作用了。

<2> autoWire注解：（对成员注解）
对成员的注解是因为，我们需要引用一个类的时候，该类中的成员是其他的类类型，事实上这些成员需要实例化（意思为注入），那这个注解就是，当我们引用一个类，我们通过扫描该类的成员，拥有此注解的成员就是需要注入的成员，这些成员的注入（相当于他们的值不再是0或者null了）需要进行实例化，那此时的实例化就不是手动new，直接根据成员类型，从bean容器中获取一个Object对象对该成原进行赋值操作。这个过程也叫注入的过程，由beanFatory类来完成。

beanFactory类 （代码中用到包扫描）

public class beanFactory {
 private static final Map<String, beanDefinition> map;
 
 static {
  map = new HashMap<String, beanDefinition>();
 }
 public beanFactory() {
  
 }
 
 public  void beanCollection(String Packagename) {
  //对给定的包进行类的扫描产生bean
  new PackageScanner() {
   
   @Override
   public void dealClass(Class<?> klass) {
    if(klass.isAnnotation()
      ||klass.isPrimitive()
      ||klass.isArray()
      ||klass.isEnum()
      ||klass.isInterface()
      ||!klass.isAnnotationPresent(Component.class)) {
     return;
    }
    
    beanDefinition bd = new beanDefinition();
    Object object;
    try {
     object = klass.newInstance();
     bd.setKclass(klass);
     bd.setObject(object);
     bd.setInject(false);
    } catch (Exception e) {
    }
    
    String className = klass.getName();
    map.put(className, bd);  
    
   }
  }.scanPackage(Packagename);
  
 }
 
 
    private void inject(beanDefinition bd) throws RuntimeException {
     Class<?> klass = bd.getKclass();
     Object superObject = bd.getObject();
     //得到类中的成员
     Field[] fields = klass.getDeclaredFields();
     
     for (Field field : fields) {
     //如果成员拥有autoWire注解，说明此成员需要从bean容器中获取对象进行对自己的实例化
      if (!field.isAnnotationPresent(autoWire.class)) {
       continue;
      }
      //因为是通过反射机制进行成员赋值操作，避免成员权限是private
      field.setAccessible(true);
      //成员进行实例化需要从bean容器中取得相关对象，所以采用了getBean方法
      Object object= getBean(field.getType());
      if (object == null) {
       //运行时异常
       throw new HasNoBeanException("类[" + klass.getName()
    + "]的[" + field.getName()
    + "]成员没有对应的Bean！");
      }
      try {
    field.set(superObject, object);
   } catch (Exception e) {
    e.printStackTrace();
   }
      
     }   
     
    }
    
    public <T> T getBean(Class<?> klass) {
  return getBean(klass.getName());  
 }
    
 @SuppressWarnings("unchecked")
 //这个方法就是给外部用的，直接采用getBean就可获得一个类的对象，当然内部也可以用，因为成员的
 //注入也需要从bean容器进行对象的获取
 public <T> T getBean(String className) {

  beanDefinition bd = map.get(className);
  if (bd == null) {
   return null;
  }
  //在这里得到需求类的对象，并且对象中的成员要进行注入
  Object object = bd.getObject();
  //判断对象中的成员是否注入
  if(!bd.isInject()) {
   //这里要做的事情是给inject赋值，为了避免循环注入
   bd.setInject(true);   
   //开始注入
   inject(bd);
   
  }
  
  return (T) object;
  
 }
}

其实整个代码有一处需要注意的就是循环注入的问题。
因为其实代码中采用了递归的手法，在用户最开始调用getBean方法的时候，getBean方法在判断当前的对象是否需要注入的时候，调用了inject方法，但在inject方法中进行成员的注入的时候，还是要采用getBean方法从bean容器中获取成员的对象，此时获取后又要判断成员的成员需不需要注入。
这个一个循环注入的例子，下面就这代码克服循环注入的情况

所以在我们的beanDefinition类中有一个成员是boolean inject,可以采用inject的值来避免循环注入。

代码中的这一步就避免了循环注入的情况，当A类的B成员没有进行注入，表明A类没有完成注入，那先设定A类已经注入。要对A完成注入，首先得对B的完成注入，B类的C成员没有进行注入，表明B类没有完成注入，那就设定B类已经注入。要对B完成注入，首先得对C完成注入，C类的A成员没有进行注入，表明C类没有完成注入，可开始我们已经设定A完成注入了，所以到此就截止，不会再循环注入了。

最后给出测试类来只来验证异常 (给出的类的成员并没有什么实际的意义，只是来进行验而已）

studentMessage类

@Component
public class studentMessage {
	private String studentName;	
	@autoWire
	private classOne classone; 	 
	@autoWire
	private classTwo classtwo;
	
	public  studentMessage() {
	  
	} 
	public classOne getCn() {
	 return classone;
	}
	public classTwo getct() {
	 return classtwo;
	}
	//后边也是相应的成员 getter 和 setter 方法，不占用地方了
}

classOne类

@Component

public class classOne {
	private Calendar birth;
	
	public classOne() {
	 
	}
	//同样的后边的getter 和setter
}

classTwo类（注意，这个类没有component注解，说明studentMessage不能完成注入，会最后结果会出现异常）

public class classTwo {
	private classThree three;
	
	public classTwo() {
	 
	}
}

结果：