Spring boot实现一个简单的ioc(2)
前言
跳过废话,直接看正文
仿照spring-boot的项目结构以及部分注解,写一个简单的ioc容器。
测试代码完成后,便正式开始这个ioc容器的开发工作。
正文
项目结构
实际上三四个类完全能搞定这个简单的ioc容器,但是出于可扩展性的考虑,还是写了不少的类。
因篇幅限制,接下来只将几个最重要的类的代码贴出来并加以说明,完整的代码请直接参考。
simpleautowired
代码
import java.lang.annotation.*; @target({elementtype.field}) @retention(retentionpolicy.runtime) @documented public @interface simpleautowired { boolean required() default true; string value() default ""; // this field is moved from @qualifier to here for simplicity }
说明
@simpleautowired的作用是用于注解需要自动装配的字段。
此类和spring的@autowired的作用类似。但又有以下两个区别:
- @simpleautowired只能作用于类字段,而不能作用于方法(这样实现起来相对简单些,不会用到aop)
- @simpleautowired中包括了required(是否一定需要装配)和value(要装配的bean的名字)两个字段,实际上是将spring中的@autowired以及qualifier的功能简单地融合到了一起
simplebean
代码
import java.lang.annotation.*; @target({elementtype.method, elementtype.annotation_type}) @retention(retentionpolicy.runtime) @documented public @interface simplebean { string value() default ""; }
说明
@simplebean作用于方法,根据方法返回值来生成一个bean,对应spring中的@bean
用value来设置要生成的bean的名字
simplecomponent
代码
import java.lang.annotation.*; @target({elementtype.method, elementtype.annotation_type}) @retention(retentionpolicy.runtime) @documented public @interface simplebean { string value() default ""; }
说明
@simplecomponent作用于类,ioc容器会为每一个拥有@simplecomponent的类生成一个bean,对应spring中的@component。特殊说明,为了简单起见,@simplecomponent注解的类必须拥有一个无参构造函数,否则无法生成该类的实例,这个在之后的simpleappliationcontext中的processsingleclass方法中会有说明。
simpleiocbootapplication
代码
import java.lang.annotation.*; @target({elementtype.type}) @retention(retentionpolicy.runtime) @documented public @interface simpleiocbootapplication { string[] basepackages() default {}; }
说明
@simpleiocbootapplication作用于应用的入口类。
这个启动模式是照搬了spring-boot的启动模式,将启动任务委托给simpleiocapplication来完成。ioc容器将根据注解@simpleiocbootapplication的相关配置自动扫描相应的package,生成beans并完成自动装配。(如果没有配置,默认扫描入口类(测试程序中的sampleapplication)所在的package及其子package)
以上就是这个ioc容器所提供的所有注解,接下来讲解ioc容器的扫描和装配过程的实现。
simpleiocapplication
代码
import com.clayoverwind.simpleioc.context.*; import com.clayoverwind.simpleioc.util.logutil; import java.util.arrays; import java.util.map; import java.util.logging.logger; public class simpleiocapplication { private class<?> applicationentryclass; private applicationcontext applicationcontext; private final logger logger = logutil.getlogger(this.getclass()); public simpleiocapplication(class<?> applicationentryclass) { this.applicationentryclass = applicationentryclass; } public static void run(class<?> applicationentryclass, string[] args) { new simpleiocapplication(applicationentryclass).run(args); } public void run(string[] args) { logger.info("start running......"); // create application context and application initializer applicationcontext = createsimpleapplicationcontext(); applicationcontextinitializer initializer = createsimpleapplicationcontextinitializer(applicationentryclass); // initialize the application context (this is where we create beans) initializer.initialize(applicationcontext); // here maybe exist a hidden cast // process those special beans processspecialbeans(args); logger.info("over!"); } private simpleapplicationcontextinitializer createsimpleapplicationcontextinitializer(class<?> entryclass) { // get base packages simpleiocbootapplication annotation = entryclass.getdeclaredannotation(simpleiocbootapplication.class); string[] basepackages = annotation.basepackages(); if (basepackages.length == 0) { basepackages = new string[]{entryclass.getpackage().getname()}; } // create context initializer with base packages return new simpleapplicationcontextinitializer(arrays.aslist(basepackages)); } private simpleapplicationcontext createsimpleapplicationcontext() { return new simpleapplicationcontext(); } private void processspecialbeans(string[] args) { callregisteredrunners(args); } private void callregisteredrunners(string[] args) { map<string, simpleiocapplicationrunner> applicationrunners = applicationcontext.getbeansoftype(simpleiocapplicationrunner.class); try { for (simpleiocapplicationrunner applicationrunner : applicationrunners.values()) { applicationrunner.run(args); } } catch (exception e) { throw new runtimeexception(e); } } }
说明
前面说到应用的启动会委托simpleiocapplication来完成,通过将应用入口类(测试程序中的sampleapplication)传入simpleiocapplication的构造函数,构造出simpleiocapplication的一个实例并运行run方法。在run方法中,会首先生成一个applicationcontext,并调用simpleapplicationcontextinitializer来完成applicationcontext的初始化(bean的扫描、装配)。然后调用processspecialbeans来处理一些特殊的bean,如实现了simpleiocapplicationrunner接口的bean会调用run方法来完成一些应用程序的启动任务。
这就是这个ioc容器的整个流程。
simpleapplicationcontextinitializer
代码
import java.io.ioexception; import java.util.linkedhashset; import java.util.list; import java.util.set; public class simpleapplicationcontextinitializer implements applicationcontextinitializer<simpleapplicationcontext> { private set<string> basepackages = new linkedhashset<>(); public simpleapplicationcontextinitializer(list<string> basepackages) { this.basepackages.addall(basepackages); } @override public void initialize(simpleapplicationcontext applicationcontext) { try { applicationcontext.scan(basepackages, true); } catch (classnotfoundexception e) { throw new runtimeexception(e); } catch (ioexception e) { throw new runtimeexception(e); } applicationcontext.setstartupdate(system.currenttimemillis()); } }
说明
在simpleiocapplication的run中,会根据basepackages来构造一个simpleapplicationcontextinitializer 的实例,进而通过这个applicationcontextinitializer来完成simpleapplicationcontext 的初始化。
在simpleapplicationcontextinitializer中, 简单地调用simpleapplicationcontext 中的scan即可完成simpleapplicationcontext的初始化任务
simpleapplicationcontext
说明:
终于到了最重要的部分了,在simpleapplicationcontext中将真正完成扫描、生成bean以及自动装配的任务。这里scan即为simpleapplicationcontext的程序入口,由simpleapplicationcontextinitializer在初始化时调用。
代码的调用逻辑简单易懂,就不多加说明了。
这里只简单列一下各个字段的含义以及几个比较关键的方法的作用。
字段
- startupdate:启动时间记录字段
- scannedpackages:已经扫描的包的集合,保证不重复扫描
- registeredbeans:已经完全装配好并注册好了的bean
- earlybeans : 只是生成好了,还未装配完成的bean,用于处理循环依赖的问题
- totalbeancount : 所有bean的计数器,在生成bean的名字时会用到其唯一性
方法
- processearlybeans:用于最终装配earlybeans 中的bean,若装配成功,则将bean移至registeredbeans,否则报错
- scan : 扫描并处理传入的package集合
- processsingleclass:处理单个类,尝试生成该类的bean并进行装配(前提是此类有@simplecomponent注解)
- createbeansbymethodsofclass : 顾名思义,根据那些被@bean注解的方法来生成bean
- autowirefields:尝试装配某个bean,lastchance代表是否在装配失败是报错(在第一次装配时,此值为false,在装配失败后会将bean移至earlybeans,在第二次装配时,此值为true,实际上就是在装配earlybeans中的bean,因此若仍然装配失败,就会报错)。在这个方法中,装配相应的bean时会从registeredbeans以及earlybeans中去寻找符合条件的bean,只要找到,不管是来自哪里,都算装配成功。
代码
import com.clayoverwind.simpleioc.context.annotation.simpleautowired; import com.clayoverwind.simpleioc.context.annotation.simplebean; import com.clayoverwind.simpleioc.context.annotation.simplecomponent; import com.clayoverwind.simpleioc.context.factory.bean; import com.clayoverwind.simpleioc.util.classutil; import com.clayoverwind.simpleioc.util.concurrenthashset; import com.clayoverwind.simpleioc.util.logutil; import java.io.ioexception; import java.lang.annotation.annotation; import java.lang.reflect.field; import java.lang.reflect.invocationtargetexception; import java.lang.reflect.method; import java.util.*; import java.util.concurrent.concurrenthashmap; import java.util.concurrent.atomic.atomiclong; import java.util.logging.logger; /** * @author clayoverwind * @e-mail clayanddev@163.com * @version 2017/4/5 */ public class simpleapplicationcontext implements applicationcontext { private long startupdate; private set<string> scannedpackages = new concurrenthashset<>(); private map<string, bean> registeredbeans = new concurrenthashmap<>(); private map<string, bean> earlybeans = new concurrenthashmap<>(); private final logger logger = logutil.getlogger(this.getclass()); atomiclong totalbeancount = new atomiclong(0l); atomiclong nameconflictcount = new atomiclong(0l); @override public object getbean(string name) { return registeredbeans.get(name); } @override public <t> t getbean(string name, class<t> type) { bean bean = (bean)getbean(name); return bean == null ? null : (type.isassignablefrom(bean.getclazz()) ? type.cast(bean.getobject()) : null); } @override public <t> t getbean(class<t> type) { map<string, t> map = getbeansoftype(type); return map.isempty() ? null : type.cast(map.values().toarray()[0]); } @override public boolean containsbean(string name) { return getbean(name) != null; } @override public <t> map<string, t> getbeansoftype(class<t> type) { map<string, t> res = new hashmap<>(); registeredbeans.entryset().stream().filter(entry -> type.isassignablefrom(entry.getvalue().getclazz())).foreach(entry -> res.put(entry.getkey(), type.cast(entry.getvalue().getobject()))); return res; } @override public void setstartupdate(long startupdate) { this.startupdate = startupdate; } @override public long getstartupdate() { return startupdate; } /** * try to autowire those beans in earlybeans * if succeed, remove it from earlybeans and put it into registeredbeans * otherwise ,throw a runtimeexception(in autowirefields) */ private synchronized void processearlybeans() { for (map.entry<string, bean> entry : earlybeans.entryset()) { bean mybean = entry.getvalue(); try { if (autowirefields(mybean.getobject(), mybean.getclazz(), true)) { registeredbeans.put(entry.getkey(), mybean); earlybeans.remove(entry.getkey()); } } catch (illegalaccessexception e) { throw new runtimeexception(e); } } } /** * scan base packages and create beans * @param basepackages * @param recursively * @throws classnotfoundexception */ public void scan(set<string> basepackages, boolean recursively) throws classnotfoundexception, ioexception { logger.info("start scanning......"); classloader classloader = thread.currentthread().getcontextclassloader(); // get all classes who haven't been registered set<class<?>> classes = new linkedhashset<>(); for (string packagename : basepackages) { if (scannedpackages.add(packagename)) { classes.addall(classutil.getclassesbypackagename(classloader, packagename, recursively)); } } // autowire or create bean for each class classes.foreach(this::processsingleclass); processearlybeans(); logger.info("scan over!"); } /** * try to create a bean for certain class, put it into registeredbeans if success, otherwise put it into earlybeans * @param clazz */ private void processsingleclass(class<?> clazz) { logger.info(string.format("processsingleclass [%s] ...", clazz.getname())); annotation[] annotations = clazz.getdeclaredannotations(); for (annotation annotation : annotations) { if (annotation instanceof simplecomponent) { object instance; try { instance = clazz.newinstance(); } catch (instantiationexception e) { throw new runtimeexception(e); } catch (illegalaccessexception e) { throw new runtimeexception(e); } long beanid = totalbeancount.getandincrement(); simplecomponent component = (simplecomponent) annotation; string beanname = component.value(); if (beanname.isempty()) { beanname = getuniquebeannamebyclassandbeanid(clazz, beanid); } try { if (autowirefields(instance, clazz, false)) { registeredbeans.put(beanname, new bean(instance, clazz)); } else { earlybeans.put(beanname, new bean(instance, clazz)); } } catch (illegalaccessexception e) { throw new runtimeexception(e); } try { createbeansbymethodsofclass(instance, clazz); } catch (invocationtargetexception e) { throw new runtimeexception(e); } catch (illegalaccessexception e) { throw new runtimeexception(e); } } } } private void createbeansbymethodsofclass(object instance, class<?> clazz) throws invocationtargetexception, illegalaccessexception { list<method> methods = getmethodswithannotation(clazz, simplebean.class); for (method method : methods) { method.setaccessible(true); object methodbean = method.invoke(instance); long beanid = totalbeancount.getandincrement(); class<?> methodbeanclass = methodbean.getclass(); //bean name simplebean simplebean = method.getannotation(simplebean.class); string beanname = simplebean.value(); if (beanname.isempty()) { beanname = getuniquebeannamebyclassandbeanid(clazz, beanid); } // register bean registeredbeans.put(beanname, new bean(methodbean, methodbeanclass)); } } private list<method> getmethodswithannotation(class<?> clazz, class<?> annotationclass) { list<method> res = new linkedlist<>(); method[] methods = clazz.getdeclaredmethods(); for (method method : methods) { annotation[] annotations = method.getannotations(); for (annotation annotation : annotations) { if (annotation.annotationtype() == annotationclass) { res.add(method); break; } } } return res; } /** * try autowire all fields of a certain instance * @param instance * @param clazz * @param lastchance * @return true if success, otherwise return false or throw a exception if this is the lastchance * @throws illegalaccessexception */ private boolean autowirefields(object instance, class<?> clazz, boolean lastchance) throws illegalaccessexception { field[] fields = clazz.getdeclaredfields(); for (field field : fields) { annotation[] annotations = field.getannotations(); for (annotation annotation : annotations) { if (annotation instanceof simpleautowired) { simpleautowired autowired = (simpleautowired) annotation; string beanname = autowired.value(); bean bean = getsimplebeanbynameortype(beanname, field.gettype(), true); if (bean == null) { if (lastchance) { if (!autowired.required()) { break; } throw new runtimeexception(string.format("failed in autowirefields : [%s].[%s]", clazz.getname(), field.getname())); } else { return false; } } field.setaccessible(true); field.set(instance, bean.getobject()); } } } return true; } /** * only used in autowirefields * @param beanname * @param type * @param allowearlybean * @return */ private bean getsimplebeanbynameortype(string beanname, class<?> type, boolean allowearlybean) { // 1. by name bean res = registeredbeans.get(beanname); if (res == null && allowearlybean) { res = earlybeans.get(beanname); } // 2. by type if (type != null) { if (res == null) { res = getsimplebeanbytype(type, registeredbeans); } if (res == null && allowearlybean) { res = getsimplebeanbytype(type, earlybeans); } } return res; } /** * search bean by type in certain beans map * @param type * @param beansmap * @return */ private bean getsimplebeanbytype(class<?> type, map<string, bean> beansmap) { list<bean> beans = new linkedlist<>(); beansmap.entryset().stream().filter(entry -> type.isassignablefrom(entry.getvalue().getclazz())).foreach(entry -> beans.add(entry.getvalue())); if (beans.size() > 1) { throw new runtimeexception(string.format("autowire by type, but more than one instance of type [%s] is founded!", beans.get(0).getclazz().getname())); } return beans.isempty() ? null : beans.get(0); } private string getuniquebeannamebyclassandbeanid(class<?> clazz, long beanid) { string beanname = clazz.getname() + "_" + beanid; while (registeredbeans.containskey(beanname) || earlybeans.containskey(beanname)) { beanname = clazz.getname() + "_" + beanid + "_" + nameconflictcount.getandincrement(); } return beanname; } }
后记
至此,一个简单的ioc容器就完成了,总结一下优缺点。
优点:
小而简单。
可以使用@simplebean、@simplecomponent以及@simpleautowired 来完成一些简单但常用的依赖注入任务.
缺点:
很明显,实现过于简单,提供的功能太少。
如果你想了解ioc的实现原理,或者你想要开发一个小型个人项目但又嫌spring过于庞大,这个简单的ioc容器或许可以帮到你。
如果你想做的不仅如此,那么你应该将目光转向。
完整代码参考:。
以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持。
上一篇: mysql导入导出命令解析
下一篇: 一个用JSP做的日历
推荐阅读
-
Spring boot实现一个简单的ioc(2)
-
基于 Spring Boot 2.x 使用 Activiti 创建一个简易的请假流程
-
spring一个接口2种实现的类注入 spring
-
spring一个接口2种实现的类注入 spring
-
《递归求阶乘和》要求实现一个计算非负整数阶乘的简单函数,并利用该函数求 1!+2!+3!+...+n! 的值。
-
用java的spring实现一个简单的IOC容器示例代码
-
Spring Boot实现Undertow服务器同时支持HTTP2、HTTPS的方法
-
Spring Boot实现Undertow服务器同时支持HTTP2、HTTPS的方法
-
Spring实现一个简单的SpringIOC容器
-
Spring boot实现一个简单的ioc(1)