本文主要是介绍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) {//对给定的包进行类的扫描产生beannew PackageScanner() {@Overridepublic 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;}//因为是通过反射机制进行成员赋值操作，避免成员权限是privatefield.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; @autoWireprivate classOne classone; @autoWireprivate classTwo classtwo;public studentMessage() {} public classOne getCn() {return classone;}public classTwo getct() {return classtwo;}//后边也是相应的成员 getter 和 setter 方法，不占用地方了
}
classOne类
@Componentpublic class classOne {private Calendar birth;public classOne() {}//同样的后边的getter 和setter
}
classTwo类（注意，这个类没有component注解，说明studentMessage不能完成注入，会最后结果会出现异常）
public class classTwo {private classThree three;public classTwo() {}
}
结果：
这篇关于Spring内部原理模拟实现（一）—————— 开开开山怪的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！
