你的位置:首页 > Java教程

[Java教程]【Java】模拟Sping,实现其IOC和AOP核心(一)

【Java】模拟Sping,实现其IOC和AOP核心(一) - 松饼人 - 博客园

【Java】模拟Sping,实现其IOC和AOP核心(一) 在这里我要实现的是Spring的IOC和AOP的核心,而且有关IOC的实现,注解+XML能混合使用! 参考资料: IOC:控制反转(...

Spring中IOC和AOP的实现原理 - 亮大王的博客 - CSDN博客

【Java】Spring框架的简单模拟实现 - chan272的博客 - CSDN博客

Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。 首先,Spring...代理和CGLIB动态代理的拦截器,这是Spring框架中AOP的核心,通过此次模...

java编程,spring里ioc和aop用什么原理实现的_百度知道

2个回答 - 回答时间: 2016年10月31日

主要应用了java的反射技术,很酷; 可以根据给定的参数(主要是字符串) 创建相应的bean,访问相应的方法或构造器以及成员变量; 具体应用可以查看帮助文档 java...更多关于【Java】模拟Sping,实现其IOC和AOP核心(一)的问题gt;gt;

...模仿tiny-spring 模拟实现spring源码中核心的ioc和aop功能,原...

模仿tiny-spring 模拟实现spring源码中核心的ioc和aop功能,原项目地址 https://...Java 1 https://gitee./yunweizhaoyang/tiny-spring-mock.git git@...

仿照Spring 实现简单的 IOC 和 AOP - 上篇 - 个人文章 - Segment...

aop ioc spring java 7.1k 次阅读 · 读完需要 32 分钟 ...在实现自己的 IOC 和 AOP 前,我的想法比较简单,就是实现一个非常简单的 IOC...

模拟Java-Sping,实现其IOC和AOP核心(一) - 简书

在这里我要实现的是Spring的IOC和AOP的核心,而且有关IOC的实现,注解+XML能混合使用! 参考资料: IOC:控制反转(Inversion of Control,缩写为IoC),是面向...

SpringIOC和AOP实现机制模拟-CSDN下载

Spring核心IoC和AOP的理解_java_脚本之家

本文主要介绍了Spring核心IoC和AOP的相关知识。具有很好的参考价值,下面跟着小编一起来看下吧spring 框架的优点是一个轻量级笔记简单易学的框架,实际...

AOP和IOC的概念以及在Spring中是如何应用?-CSDN问答

AOP与IOC的概念(即spring的核心)1.IOC:Spring是开源...但是对象不应该都由Java虚拟机进行的管理的吗?rnrn2...模拟spring ioc aop的功能,理解spring io...

Java Spring IoC与AOP 笔记_慕课手记

Java Spring IoC与AOP 笔记 2016.07.29 00:19 2849浏览 笔记源码连接:Spring.html(imocc上的排版和html不同,建议看云盘里的源码,自己看完是视频总结的...

spring两大核心对象IOC和AOP(新手理解)

spring两大核心对象IOC和AOP(新手理解)的更多相关文章 Java轻量级业务层框架Spring...一.Spring核心类概述. Spring里面有两个最核心的类这是Spring实...

Spring的IOC和AOP丶一个站在Java后端设计之路的男青年个人博客网站

面向切面(AOP)拦截是到方法级别的,面向对象编程拦截是到对象级别的。当我们需要给分散的对象引入公共行为时候,一般采用切面思想,例如日志、例如统一异...

java面试之-spring ioc和aop - 超哥的工作点滴 - ITeye博客

java面试题javaspringiocaop 面试官问道这个问题基本上是想知道 是否了解aop 和ioc的基本概念, 以及大体的实现机制等, 因此我们在回答这个问题时应当...

spring核心之Ioc和aop - - ITeye博客

博客分类: java javaspringiocaop spring核心是Ioc和aop,白话来讲: Ioc:不需手工的new、set,spring根据xml和annotation的配置来new和set对应的类; a...

spring IOC和AOP的原理 - - ITeye博客

AOPSpringIOCBean编程     spring依赖注入:依赖...推荐的还是要实现一个接口。实现过程大概就是实现了...用struts2下载文件 | java类加载器2 2010...

关于spring,IOC和AOP的解析原理和举例_陈超超_新浪博客

获取类的实例,相信任何人只要会用java的反射机制,那么自己写一个IOC框架也不是...关于spring aop 反射实现 AOP 动态代理模式(Spring AOP 的实现 原理)...

spring的IOC和AOP详细讲解 - 思维80 - OSCHINA

ioc是控制反转,是spring的核心思想。通过面向接口编程来实现对业务组件的动态依赖。 aop是面向 切面编程,它并不是只在spring或者java中才有的,它和面...

第2章 Spring Framework的核心:IoC容器的实现 - 51CTO.

本篇将对Spring的核心IoC容器和AOP的实现原理进行阐述。IoC容器和AOP是Spring...首先,Spring的目标在于让Java EE的开发变得更容易,这就意味着Spring框...

关于Spring AOP和IOC的一些总结

不能控制,后来就出现了Spring,Spring简单来说就是一个容器,核心就是:IOC和AOP...那么DI是如何实现的呢? Java 1.3之后一个重要特征是反射(reflection),...深圳较场尾游报价深圳较场尾游报价深圳较场尾游报价深圳较场尾游报价深圳较场尾游报价深圳较场尾游跟团北京出发去萨尔瓦多旅游 北京出发去萨尔瓦多旅游 北京出发去萨尔瓦多旅游 北京出发去萨尔瓦多旅游 北京出发去萨尔瓦多旅游 北京出发去萨尔瓦多旅游 北京出发去萨摩亚旅游 北京出发去萨摩亚旅游 北京出发去萨摩亚旅游 北京出发去萨摩亚旅游 北京出发去萨摩亚旅游 北京出发去萨摩亚旅游 北京出发去塞尔维亚旅游 北京出发去塞尔维亚旅游 北京出发去塞尔维亚旅游 北京出发去塞尔维亚旅游 北京出发去塞尔维亚旅游 北京出发去塞尔维亚旅游 北京出发去塞拉利昂旅游 北京出发去塞拉利昂旅游 北京出发去塞拉利昂旅游 北京出发去塞拉利昂旅游 北京出发去塞拉利昂旅游 北京出发去塞拉利昂旅游

参考资料:
IOC:控制反转(Inversion of Control,缩写为IoC),是面向对象编程中的一种设计原则,可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入(Dependency Injection,简称DI),还有一种方式叫“依赖查找”(Dependency Lookup)。通过控制反转,对象在被创建的时候,由一个调控系统内所有对象的外界实体,将其所依赖的对象的引用传递给它。也可以说,依赖被注入到对象中。
AOP:Aspect Oriented Programming的缩写,意为:面向切面编程,通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。
(以上是度娘给出的说法,可以看到这样的说法很不容易让人理解,过于官方化,下面是我的理解)

IOC:我们平时在写Java程序时,总要通过new的方式来产生一个对象,对象的生死存亡是与我们直接挂钩的,我们需要它时,就new一个,不需要他时就通过GC帮我们回收;控制反转的意思就是将对象的生死权交给第三方,由第三方来生成和销毁对象,而我们只在需要时从第三方手中取获取,其余不管,这样,对象的控制权就在第三方手里,我们只有使用权!这就是所谓的控制反转!
在Spring中,提供了

AOP :就是动态代理的体现,在Spring中就是利用JDKProxy或者CGLibProxy技术,对方法进行拦截!
比如说有一个叫做fun()的方法,我们在其执行前后对其拦截:

 

就像这样,fun看成是纵向的线,那么就相当于用平面把这条线截断了!

 

有了上面的铺垫,我们可以大概知道,Sping的IOC和AOP可以帮我们创建并管理对象,可以对对象的方法进行拦截,那么这两个技术合在一起,就可以达到自动帮我们创建、管理、并对对象进行拦截!

下面先给出我简化的SpringIOC容器框图:
模拟的IOC框图

这是我简化后的IOC框图,实际上的SpringIOC是非常庞大的,里面包含了许多接口,以及继承关系,它把要处理的事务区分的非常细腻,将问题由大化小,层层递减,把面向接口,高内聚低耦合体现的淋漓尽致。
Spring提供了注解和

BeanFactory:
在别的地方说法是一个最底层容器,其实不要被其“误导”,在我这它仅仅只是一个接口,只提供了最基础的一些方法,而方法的具体实现就需要真正的高级容器了!代码如下:

 1 public interface BeanFactory { 2  String FACTORY_BEAN_PREFIX = "&"; 3  Object getBean(String var1) throws BeansException; 4  <T> T getBean(String var1, Class<T> var2) throws BeansException; 5  <T> T getBean(Class<T> var1) throws BeansException; 6  Object getBean(String var1, Object... var2) throws BeansException; 7  <T> T getBean(Class<T> var1, Object... var2) throws BeansException; 8  boolean containsBean(String var1); 9  boolean isSingleton(String var1) throws NoSuchBeanDefinitionException;10  boolean isPrototype(String var1) throws NoSuchBeanDefinitionException;11  boolean isTypeMatch(String var1, Class<?> var2) throws NoSuchBeanDefinitionException;12  Class<?> getType(String var1) throws NoSuchBeanDefinitionException;13  String[] getAliases(String var1);14 }

(这里我直接挪用了Spring的源码,由于是模拟实现,所以后面只实现了其getBean的方法)

 

ApplicationContext:
在别的地方的说法是一个高级容器,其实,它还是一个接口,只不过在源码中其继承了许多接口(核心还是BeanFactory),是一个集大成者,提供了远比BeanFactory更多的功能。但目前所要实现的核心暂时用不上它,所以暂时留一个空接口吧...

1 public interface ApplicationContext extends BeanFactory {2  // TODO3 }

说到这里,就不能往下继续了,因为在上面我们看到的,所谓的“容器”,仅仅是定义了接口,完全不能装东西啊,还有,所谓的容器里又要装什么?这里就要引入Bean!

Bean:
其实就是IOC容器里存放的东西!前面我说过,Spring会根据我们给出的映射关系,帮我们创建对象并存储起来,那么是否这个对象就是Bean?是!但也不是!如果说Spring仅仅只是帮我们管理对象,那么它的功能也太单一了,那么,现在不得不再次提到前面说过的AOP!
前面说到Spring中的AOP使用了JDKProxy和CGLibProxy这两种代理技术,这两种技术的目的都是产生代理对象,对方法进行拦截。那么,是否这个代理对象就是我们的Bean?不完全是!Bean其实是原对象+代理对象!先不急,看到后面就会明白!

下面介绍两种动态代理技术:
JDKProxy
使用JDK代理,其所代理的类,必须要实现某一个接口:

 1 @SuppressWarnings("unchecked") 2 public <E> E getJDKProxy(Class<?> klass, Object tagObject) { 3  return (E) Proxy.newProxyInstance(klass.getClassLoader(),  4    klass.getInterfaces(), 5    new InvocationHandler() { 6     @Override 7     public Object invoke(Object proxy, Method method, Object[] args)  8       throws Throwable { 9      // TODO 置前拦截,可对参数args进行判断10      Object result = null;11      try {12       result = method.invoke(tagObject, args);13      } catch (Exception e) {14       // TODO 对异常进行拦截15       throw e;16      }17      // TODO 置后拦截,可对方法返回值进行修改18      return result;19     }20    });21 }

使用JDK代理的话就不得不传入一个原始对象,所以如果不考虑CGLib代理,那么Bean就是原始对象+代理对象!

 

CGLibProxy:
使用CGLib代理,是让被代理的类作为代理对象的父类,故原类不能被final修饰,也不能对final修饰的方法拦截!

以下是网上绝大多数人给出的用法:

 1 @SuppressWarnings("unchecked") 2 public <E> E getCGLibProxy(Class<?> klass) { 3  Enhancer enhancer = new Enhancer(); 4  enhancer.setSuperclass(klass); // 从这里可以明显看到,让被代理的类作为了代理对象的父类 5  enhancer.setCallback(new MethodInterceptor() { 6   @Override 7   public Object intercept(Object proxyObject, Method method, Object[] args, MethodProxy methodProxy)  8     throws Throwable { 9    // TODO 置前拦截,可对参数args进行判断10    Object result = null;11    try {12     result = methodProxy.invokeSuper(proxyObject, args);13    } catch (Exception e) {14     // TODO 对异常进行拦截15     throw e;16    }17    // TODO 置后拦截,可对方法返回值进行修改18    return result;19   }20  });21  return (E) enhancer.create();22 }

这种方式是没错,但是不适用于后面要做的,至于原因,后面分析到了就会明白!
所以使用如下方式:

 1 @SuppressWarnings("unchecked") 2 public <E> E getCGLibProxy(Class<?> klass, Object tagObject) { 3  Enhancer enhancer = new Enhancer(); 4  enhancer.setSuperclass(klass); 5  enhancer.setCallback(new MethodInterceptor() { 6   @Override 7   public Object intercept(Object proxyObject, Method method, Object[] args, MethodProxy methodProxy)  8     throws Throwable { 9    // TODO 置前拦截,可对参数args进行判断10    Object result = null;11    try {12     result = method.invoke(tagObject, args);13    } catch (Exception e) {14     // TODO 对异常进行拦截15     throw e;16    }17    // TODO 置后拦截,可对方法返回值进行修改18    return result;19   }20  });21  return (E) enhancer.create();22 }

由于是模拟实现,后面就全部采用CGLib代理!
可以看到以上面这种方式进行CGLib代理就需要原始对象,那么前面说到的Bean就必须是原对象+代理对象!
当然我知道以invokeSuper那种方式是不需要原始对象,但是原因不是因为Bean,还在后面!

综上,Bean的定义如下:

1 public interface BeanElement {2  <E> E getProxy();3  Object getObject();4  boolean isDI(); // 用于以后判断是否完成注入5 }

在这里我把BeanElement定义为了一个接口,后面会产生两个分支,会产生两种不同处理方式的Bean,用接口更灵活,耦合也低!

现在知道了Bean到底是什么,我们就可以往下继续进行:


AbstractApplicationContext:
ApplicationContext的具体实现类,但它是一个抽象类,只能实现部分功能,往后在它的基础上还要分化成两支,那么,把所有的Bean存在这里面再合适不过了!

 1 public abstract class AbstractApplicationContext implements ApplicationContext { 2  protected static final Map<String, String> beanNameMap; // key : id  value : className 3  protected static final Map<String, BeanElement> beanMap; // key : className value : Bean 4  protected AopFactory aopFactory; // Aop工厂,生产代理对象 5   6  static { 7   beanNameMap = new HashMap<>(); 8   beanMap = new HashMap<>(); 9  }10  11  protected AbstractApplicationContext() {12   aopFactory = new AopFactory();13   // 设置切面14   aopFactory.setAdvice(15     (new AdviceHander())16     .setIntercepterFactory(new IntercepterLoader()));17  }18  19  protected void add(String id, String className, BeanElement bean) throws BeansException {20   if (beanMap.containsKey(className)) {21    // TODO 可以抛异常!22    return;23   }24   beanMap.put(className, bean);25   if (id.length() <= 0) return;26   if (beanNameMap.containsKey(id)) {27    throw new BeansException("bean:" + id + "已定义!");28   }29   beanNameMap.put(id, className);30  }31 }

其中的aopFactory是代理工厂,负责生产代理,会在后面给出,先不急。
可以看到,AbstractApplicationContext这个类持有了两张静态的map,第一组是用来存取Bean的别名(id),第二组用来存放真正的Bean,这就是我们真正意义上的容器,由于其map都是static修饰的,在类加载的时候就存在了,所以往后有别的类继承它时,这两个map是共享的!只增加了一个add方法,只要是继承自它的子类,都会通过这种方式添加Bean!并且这个类是protected的,不对外提供使用!

 

我们先进行左边的分支,用注解的方式完成IOC
这里说的注解都是自定义注解,属于RUNTIME,就必须通过反射机制来获取,反射机制就要得到类或者类名称,那么就先得到符合要求的类,这里就要用到包扫描,我在前面的博客中有介绍过:【Java】包、jar包的扫描
首先是对类的注解:
@Component

1 @Retention(RetentionPolicy.RUNTIME)2 @Target(ElementType.TYPE)3 public @interface Component {4  String id() default "";5 }

其中的id相当于类名称的别名,具有唯一性,如果不设置则不处理!通过这个注解我们就可以判断哪个类是需要进行操作的,就应该自动地为这个类生成一个对象和代理对象,将其添加到beanMap中,就是bean的标志!
如果说用过Spring的

1 <bean id="XXX" class="XXX">2  ......3 </bean>

注解中的id就相当于id属性,我们是通过反射机制得到注解的,当然能得到类名称,那就相当于有了class属性!

但是仅仅有这个注解是完全不够的,我们只能通过反射机制产生一个对象,但它的成员都没赋值,仅仅是一具躯壳,所以就需要对成员添加注解,将我们需要的值注入进来;当然也可以给方法添加注解,通过setter方法给成员赋值,Spring就是使用的这种方式!
这是对成员的注解:
@Autowired

1 @Retention(RetentionPolicy.RUNTIME)2 @Target({ElementType.FIELD, ElementType.METHOD, ElementType.CONSTRUCTOR})3 public @interface Autowired {4  boolean requisite() default true;5 }

这里直接使用的spring源码,在源码中,这个注解可以成员、方法以及构造方法添加。其中的requisite是是否必须注入,这是Spring提供的更为细腻的操作,我的实现暂时不考虑它。

如果说这个注解是给成员添加的,那么标志着它需要赋值!使用这个注解的前提是它本身是一个复杂类型,不是基本类型,它的赋值,是将我们beanMap中的符合要求的Bean注入进去!至于基本类型后面有别的解决办法。
用Component 和Autowired注解其实就相当于如下

1 <bean id="XXX" class="XXX">2  <property name="XXX" ref="XXX">3 </bean>

我们还是通过反射机制得到的Autowired注解,那么一定可以得到成员名称,和成员类型,成员名称就相当于name属性,通过成员类型就可以得到类型名称,就相当于ref属性!

如果说是给构造方法添加,那么就规定了我们在反射机制执行时需要调用哪个构造方法,相当于如下:

1 <bean id="XXX" class="XXX">2  <constructor-arg index="0" ref="XXX">3  <constructor-arg index="1" ref="XXX">4 </bean>

对于构造方法的处理我觉得使用注解的方式比

还有一种就是对方法添加,实际上就是提供给setter方法使用的,通过执行setter方法给成员赋值,可能看到这里会觉得这样做是不是多次一举,其实不是,因为这样做会避免我后面会谈到的循环依赖的问题!所以给方法添加,和对成员添加等效:

1 <bean id="XXX" class="XXX">2  <property name="XXX" ref="XXX">3 </bean>


上面我说过使用Autowired 是不处理基本类型的,它是将bean注入的,基本类型完全没有必要作为bean,那么,我们就可以给出一个注解,直接赋值:

1 @Retention(RetentionPolicy.RUNTIME)2 @Target({ElementType.FIELD, ElementType.PARAMETER})3 public @interface Value {4  String value();5 }

其中value就是我们要注入的值,但是它是String类型的,可能需要强制类型转换
演示如下:

 1 @Component 2 public class TestA { 3  @Autowired 4  private TestB testB; 5  @Value(value="直接赋值") 6  private String member; 7   8  public TestA() { 9  }10 11 }12 13 @Component(id = "testB")14 public class TestB {15  private int a;16  private TestA testA;17  18  @Autowired19  public TestB(@Value(value="10")int a, TestA testA) {20   this.a = a;21   this.testA = testA;22  }23  24 }

就相当于:

1 <bean class="xxx.xxx.TestA">2  <property name="testB" ref="xxx.xxx.TestB">3  <property name="member" value="直接赋值">4 </bean>5 <bean id="testB" class="xxx.xxx.TestB">6  <constructor-arg index="0" value="10"></constructor-arg>7  <constructor-arg index="1" ref="xxx.xxx.TestA"></constructor-arg>8 </bean>

为了简单处理,Autowired注解我在后面就只处理成员的。

有了上面的两个注解是否够呢?当然不够。仔细想一想,如果说我们需要Spring帮我们创建的对象,其对应的类又被打成了jar包,那么我们完全没有办法对已经形成jar包的代码添加注解;又或者说是我们需要创建的对象不是通过反射机制就能产生的,它是一个工厂对象,需要走工厂模式那一套来创建,上面的两个注解就远远不能满足我们的要求了!

 

@Bean

1 @Retention(RetentionPolicy.RUNTIME)2 @Target(ElementType.METHOD)3 public @interface Bean {4  String id() default "";5 }

可以看出这是对方法的注解,因为我们可以通过反射机制执行方法,将方法的返回值作为Bean的原始对象,再产生一个代理对象,这样就能解决上面的所说的问题!

 1 @Component 2 public class Action { 3   4  @Bean(id="getDocumentBuilderFactory") 5  public DocumentBuilderFactory getDocumnet() throws Exception { 6   return DocumentBuilderFactory.newInstance(); 7  } 8   9  @Bean10  public DocumentBuilder getDocumentBuilder(DocumentBuilderFactory factory) throws Exception {11   return factory.newDocumentBuilder();12  }13  14 }

就相当于:

1 <bean class="xxx.xxx.Action "></bean>2 <bean class="javax. id="getDocumentBuilderFactory" 3  factory-method="newInstance"></bean>4 <bean class="javax. 5  factory-bean="getDocumentBuilderFactory" factory-method="newDocumentBuilder">6 </bean>

有了这些注解,我们就能对包进行扫描,可以继续向下进行!

AnnotationContext:
这个类继承自AbstractApplicationContext,它也是protected的,不对外提供,我用它来进行有关注解的扫描和解析,但它的功能有限,不能完成全部的注入,这会涉及到注入的顺序,以及注入之间的依赖关系:

 1 /** 2  * 执行包扫描 3  * 将符合要求的结果添加到父类AbstractApplicationContext的beanMap中 4  * 只处理@Component和@Bean注解 5  * @Autowired注解留给下一级处理 6 */ 7 public class AnnotationContext extends AbstractApplicationContext { 8  // method缓冲区,保存暂时不能执行的方法,其中的MethodBuffer用来封装method,以及invoke时所需要的内容 9  private List<MethodBuffer> methodList;  10  11  protected AnnotationContext() { 12  } 13   14  protected AnnotationContext(String packageName) { 15   scanPackage(packageName); 16  } 17   18  /** 19   * 通过aopFactory产生代理对象,将代理对象和原始对象封装成bean添加到父类的map中 20  */ 21  private void addBean(Class<?> klass, Object object, String id, String className) { 22   // aopFactory是其父类AbstractApplicationContext的成员,原来产生代理对象 23   Object proxy = aopFactory.creatCGLibProxy(klass, object); 24   // AnnoationBean是BeanElement接口的一个实现类 25   AnnotationBean bean = new AnnotationBean(object, proxy); 26   // 父类AbstractApplicationContext的add方法 27   add(id, className, bean); 28  } 29   30  protected void scanPackage(String packageName) { 31   new PackageScanner() { 32    @Override 33    public void dealClass(Class<?> klass) { 34     if (!klass.isAnnotationPresent(Component.class)) return; 35     Component component = klass.getAnnotation(Component.class); 36     String className = klass.getName(); 37     String name = component.id(); 38     try { 39      // 这里简单起见,不考虑构造方法的重载,默认执行无参构造  40      Object object = klass.newInstance(); 41      // 产生BeanElement,加入到beanMap中 42      addBean(klass, object, name, className); 43      // 处理带有@Bean注解的方法 44      dealMethod(klass, object); 45     } catch (Exception e) { 46      // TODO  47      e.printStackTrace(); 48     } 49    } 50   }.scanPackage(packageName); 51   if (methodList == null) return; 52   // 执行缓存的所有方法 53   for (MethodBuffer methodBuffer : methodList) { 54    // 获得方法执行所需要的东西 55    String id = methodBuffer.getId(); 56    Class<?> returnClass = methodBuffer.getReturnClass(); 57    Method method = methodBuffer.getMethod(); 58    Object object = methodBuffer.getObject(); 59    Parameter[] parameters = methodBuffer.getParameters(); 60     61    try { 62     dealMultiParaMethod(returnClass, method, object, parameters, id); 63    } catch (Exception e) { 64     // TODO  65     e.printStackTrace(); 66    }  67   } 68   methodList.clear(); 69  } 70   71  private void dealMultiParaMethod(Class<?> returnClass, Method method,  72    Object object, Parameter[] parameters, String id)  73      throws BeansException, IllegalAccessException, IllegalArgumentException,  74      InvocationTargetException, ValueOnlyPrimitiveType { 75   int count = parameters.length; 76   Object[] result = new Object[count]; 77    78   for (int index = 0; index < count; index++) { 79    Parameter para = parameters[index]; 80    // 判断参数是否带有@Value注解 81    if (para.isAnnotationPresent(Value.class)) {  82     Class<?> type = para.getType(); 83     // 判断@Value注解标识的参数是否是基本类型(八大类型和String) 84     if (!type.isPrimitive() && !type.equals(String.class)) { 85      throw new ValueOnlyPrimitiveType("Value只能用基本类型!"); 86     } 87     // TypeConversion是我自己的一个工具类,用于将字符串转换成基本类型! 88     result[index] = TypeConversion.getValue(para.getAnnotation(Value.class).value(),  89            para.getType().getSimpleName()); 90    } else { 91     // 如果不是基本类型,那么就需要从beanMap中获取符合要求的bean 92     result[index] = getBean(para.getType()); 93    } 94   } 95   // 执行方法,获得方法返回值 96   Object returnObject = method.invoke(object, result); 97   // 为方法执行结果创建bean,添加到beanMap中 98   addBean(returnClass, returnObject , id, returnClass.getName()); 99  }100  101  /**102   * 遍历所有方法,处理带有@Bean注解的方法103  */104  private void dealMethod(Class<?> klass, Object object) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {105   Method[] methods = klass.getDeclaredMethods();106   for (Method method : methods) {107    if (!method.isAnnotationPresent(Bean.class)) continue; 108    109    Class<?> returnType = method.getReturnType();110    if (returnType.equals(void.class)) {111     // TODO 如果没有返回值,那么根本没有必要做112     return;113    }114    String id= method.getAnnotation(Bean.class).id();115    Parameter[] parameters = method.getParameters();116    // 判断方法是否有参数,没有参数,直接执行,添加Bean117    // 有参数就先缓存起来,等所有都扫描完成后再执行118    if (parameters.length <= 0) {119     Object returnObject = method.invoke(object);120     addBean(returnType, returnObject, id, returnType.getName());121    } else {122     (methodList = methodList == null ? new ArrayList<>() : methodList)123      .add(new MethodBuffer(returnType, object, method, parameters, id));124    }125   }126  }127  128 }

这个类只负责扫描包,为带有@Component注解的类通过反射机制生成对象,再通过代理工厂将其加工成代理对象,然后封装再AnnotationBean中作为bean,将其添加到BeanMap中!
其次还处理了带有@Bean注解的的方法,如果说是方法带有参数,那么就像将这个方法的执行延后,等所有东西都扫描完成后再执行;而对于无参的方法,则可以直接执行,并为执行结果产生的对象创建代理,生成AnnotationBean,添加进beanMap中。至于@Autowired注解这个类暂不处理,留给下一级处理!
AnnotationBean 类如下:

 1 /** 2  * 注解分支中BeanElement的具体实现类 3 */ 4 public class AnnotationBean implements BeanElement { 5  private boolean DI; // 判断是否完成注入 6  private Object object; // 原始对象 7  private Object proxy; // 代理对象 8   9  AnnotationBean() {10   this(false, null, null);11  }12  13  AnnotationBean(Object object, Object proxy) {14   this(false, object, proxy);15  }16  17  AnnotationBean(boolean dI, Object object, Object proxy) {18   DI = dI;19   setObject(object);20   setProxy(proxy);21  }22  23  @Override24  public Object getObject() {25   return object;26  }27  28  AnnotationBean setObject(Object object) {29   this.object = object;30   return this;31  }32 33  AnnotationBean setProxy(Object proxy) {34   this.proxy = proxy;35   return this;36  }37 38  void setDI(boolean DI) {39   this.DI = DI;40  }41  42  @Override43  public boolean isDI() {44   return DI;45  }46 47  @Override48  @SuppressWarnings("unchecked")49  public <E> E getProxy() {50   return (E) proxy;51  }52  53 }

MethodBuffer 类如下:

 1 /** 2  * 带有@Bean注解的方法封装类 3 */ 4 public class MethodBuffer { 5  private String id; // bean的id 6  private Class<?> returnType; // 方法返回值类型 7  private Object object; // 方法执行所需对象 8  private Method method; // 方法本身 9  private Parameter[] parameters; // 方法所需参数10  11  MethodBuffer() {12  }13 14  MethodBuffer(Class<?> returnType, Object object, Method method, Parameter[] parameters, String id) {15   this.returnType = returnType;16   this.object = object;17   this.method = method;18   this.parameters = parameters;19   this.id = id;20  }21 22  String getId() {23   return id;24  }25  26  Object getObject() {27   return object;28  }29 30  Class<?> getReturnType() {31   return returnType;32  }33 34  Method getMethod() {35   return method;36  }37 38  Parameter[] getParameters() {39   return parameters;40  }41  42 }

*在处理@Bean注解时,就能发现我前面提出的问题,用CGLibProxy产生的代理为什么还需要原始对象?
我们处理@Bean注解,是为了得到方法的返回值,如果直接对返回值所对应的类进行代理,产生代理对象,那么,在方法执行时,如果原始对象的成员被赋值了,那么代理对象是不会知道的,那么产生的代理是不完整的!使用methodProxy.invokeSuper(proxyObjet, args)方法是不可行的了!所以一定要保存原始对象,使用method.invoke(object, args)才是合理的!

AnnotationConfigApplicationContext:
这是注解这一支最高级的容器,是最终留给用户使用的,用来完成最后@Autowired注解标识的成员的注入!
如果说是需要注入的bean都能找的到,且这些bean都完成了注入,那么其注入过程会非常简单,但若是,彼此之间的依赖关系比较复杂,你中有我,我中有你,会形成一个环形闭环,陷入死循环,这就是循环依赖!


循环依赖

 

这里有四个类ClassA、ClassB、ClassC、ClassD,并且都没有完成注入,如果现在想getBean得到ClassA的Bean,那么就需要先对ClassA的Bean完成注入,但是其注入又需要ClassB,那么,就需要先将B注入,但B又要C,那就先注入C,可是C需要D,只能先注入D,但是D确需要A!绕了一圈又回来了,陷入了死循环,这就是我们要解决的循环依赖!


解决方案:
一、前面我说过@Autowired注解可以给setter方法添加,用来解决循环依赖!
如果说我们使用这种方式给ClassA的setClassB方法添加@Autowired,而不是给其ClassB成员添加,那么这个循环自然而然就不会出现!
二、假设自身以完成注入:
在ClassA注入之前,让它的状态变为完成注入,然后继续找B,发现B没注入,找C,C没注入,找D,D没注入,找A,此时A的状态是完成注入,自然也就不会产生闭环!

所以AnnotationConfigApplicationContext就是为了最后的注入:

 1 public class AnnotationConfigApplicationContext extends AnnotationContext { 2  public AnnotationConfigApplicationContext() { 3  } 4  // 调用父类的构造 5  public AnnotationConfigApplicationContext(String packageName) { 6   super(packageName); 7  } 8  // Advice是代理的拦截处理,内部使用默认的一种方式,用户也可以注入一种方式 9  public AnnotationConfigApplicationContext setAdvice(Advice advice) {10   aopFactory.setAdvice(advice);11   return this;12  }13  14  public AnnotationConfigApplicationContext parsePackage(String packageName) {15   scanPackage(packageName);16   return this;17  }18  19  @Override20  public Object getBean(String name) throws BeansException {21   String className = beanNameMap.get(name);22   return className == null ? get(name) : get(className);23  }24 25  private <T> T get(String className, Class<?> klass) throws BeansException {26   BeanElement bean = beanMap.get(className);27   if (bean == null) {28    throw new BeansException("Bean :" + klass + "不存在!");29   }30   if (!bean.isDI() && bean instanceof AnnotationBean) {31    autowired(klass, (AnnotationBean)bean);32   }33   return bean.getProxy();34  }35  36  @Override37  public <T> T getBean(Class<T> klass) throws BeansException {38   return get(klass.getName());39  }40  41  private void autowired(AnnotationBean bean) throws BeansException {42   // 一开始令自身完成注入43   bean.setDI(true);44   Object object = bean.getObject();45   Class<?> klass = object.getClass(); 46   Field[] fields = klass.getDeclaredFields();47   Object arg = null;48   for (Field field : fields) {49    if (field.isAnnotationPresent(Value.class)) {50     try {51      // 注入基本类型的值52      arg = injectValue(field);53     } catch (ValueOnlyPrimitiveType e) {54      e.printStackTrace();55     }56    } else if (field.isAnnotationPresent(Autowired.class)) {57     // 注入bean中的Bean58     arg = injectBean(field);59    } else {60     continue;61    }62    try {63     // 成员注入64     field.setAccessible(true);65     field.set(object, arg);66    } catch (Exception e) {67     throw new BeansException(klass + "依赖关系不正确!");68    }69   }70  }71  72  private Object injectValue(Field field) throws ValueOnlyPrimitiveType {73   Class<?> type = field.getType();74   if (!type.isPrimitive() && !type.equals(String.class)) {75    throw new ValueOnlyPrimitiveType("Value只能用于八大基本类型!");76   }77   Value value = field.getAnnotation(Value.class);78   return TypeConversion.getValue(value.value(), type.getSimpleName());79  }80  81  private Object injectBean(Field field) throws BeansException {82   Class<?> fieldType = field.getType();83   BeanElement fieldBean = beanMap.get(fieldType.getName());84   if (fieldBean == null) { return null;}85   if (!fieldBean.isDI() && fieldBean instanceof AnnotationBean) {86    autowired((AnnotationBean)fieldBean);87   }88   return fieldBean.getProxy();89  }90 }

这里解决循环依赖就使用了我上面给出的第二种方案,利用递归来实现!

注解部分的简单实现已基本完成,虽然有些地方没有处理或是处理的比较简陋,但是SpringIOC的核心思想就是如此,只不过Spring实现的更为精致、细腻!
来看看它的使用:
先给出几个需要注入的类:

 1 @Component(id="studentA") 2 public class StudentA { 3  @Value(value="我是A") 4  String name; 5  @Autowired 6  private StudentB B; 7   8  public StudentA() { 9  }10  11  @Override12  public String toString() {13   return "A:" + name + "->" + B;14  }15  16 }17 18 @Component19 public class StudentB {20  @Value(value="我是B")21  private String name;22  @Autowired23  private StudentC C;24  25  public StudentB() {26  }27 28  @Override29  public String toString() {30   return "B:" + name + "->" + C;31  }32  33 }34 35 @Component36 public class StudentC {37  @Value(value="我是C")38  private String name;39  40  @Autowired41  private StudentA A;42  43  public StudentC() {44  }45 46  @Override47  public String toString() {48   return "C:" + name;49  }50  51 }52 53 public class StudentD {54  private String name;55  @Autowired56  private StudentA A;57  58  public StudentD(String name) {59   this.name = name;60  }61 62  @Override63  public String toString() {64   return "D:" + name + "->" + A;65  }66  67 }68 69 @Component70 public class MethodAction {71  public MethodAction() {72  }73 74  @Bean(id="studentD")75  public StudentD getStudentD(@Value(value="我是D")String name) {76   return new StudentD(name);77  }78 }

主函数:

1 public static void main(String[] args) throws BeansException {2  ApplicationContext applicationContext = 3     new AnnotationConfigApplicationContext("com.zc.ioc.demo");4   StudentD studentD = applicationContext.getBean(StudentD.class);5   System.out.println(studentD);6 7 }

结果是:

或者这样使用:

1 public static void main(String[] args) throws BeansException {2  BeanFactory beanFactory = new AnnotationConfigApplicationContext("com.zc.ioc.demo");3   StudentD studentD = (StudentD) beanFactory.getBean("studentD");4   System.out.println(studentD);5 }

结果:

有关