IOC在java框架中到处可见，我们只需要创建类，而不需要自己来创建实例，以及实例及实例之间的组织关系，而是通过配置文件或者注解来表明对象与对象之间的关系，最终有第三方根据配置文件及注解将需要的组件对象进行实例化的过程就是IOC。不知道这个理解是否正确，就将就着这么理解吧。通常我们使用别的框架来完成这个步骤。spring 大概大家都知道，典型的IOC ,实现也很强大。不过，spring 还是java写的，自己也来搞一个吧，虽然简单，但也能说明问题；即使很烂，也是一种实现。对吧？如果你是大牛，注意：别笑掉大牙！
接下来就自己完成这么一个小框架吧！首先声明，所有的IOC 在本人看来必须要使用java 的反射技术，如果没有反射技术，那么这一切都是空话。 废话不说 开始吧！
首先我们定义一个类似spring配置文件的xml，用来定义需要框架组织的对象及组织关系。
<?xml version="1.0" encoding="UTF-8"?> <beans> <bean id="dao" class="com.sample.spring.egclasses.EgDao" single="true"/> <bean id="service" class="com.sample.spring.egclasses.EgSevice"> <setProperty name="egDao" refer="dao"/> </bean> <bean id="service1" class="com.sample.spring.egclasses.EgSevice"> <setProperty name="egDao" refer="dao"/> </bean> </beans>
看看这2个配置的类
package com.sample.spring.egclasses;
public class EgDao
{
public void callMe()
{
System.out.println("Dao is called");
}
}
package com.sample.spring.egclasses;
public class EgSevice
{
private EgDao egDao;
public void callMe(){
egDao.callMe();
}
public EgDao getEgDao()
{
return egDao;
}
}
接下来编写一个了一个classloader 本来想在这个里面干点什么，但是现在还没有想到。
package com.sample.spring;
public class SampleClassLoader extends ClassLoader
{
private SampleClassLoader()
{
super();
}
private static final SampleClassLoader thisInstance;
static{
thisInstance=new SampleClassLoader();
}
public static SampleClassLoader getClassLoader(){
return thisInstance;
}
}
接下来就是我们这雷人的框架核心了。
package com.sample.spring;
import java.io.IOException;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.jdom2.Document;
import org.jdom2.Element;
import org.jdom2.JDOMException;
import org.jdom2.input.SAXBuilder;
public class SampleSpringContainer
{
private static final Map<String,Bean> beans=new HashMap<String, Bean>();
static final Map<String,Object> singles=new HashMap<String, Object>();
static{
SAXBuilder sb = new SAXBuilder();
try
{
Document doc =sb.build(SampleSpringContainer.class.getClassLoader().getResourceAsStream("com/sample/spring/springSample.xml"));
Element rootElement = doc.getRootElement();
List<Element> beans = rootElement.getChildren("bean");
buidBeans(beans);
initBeans();
}
catch (JDOMException e)
{
e.printStackTrace();
}
catch (IOException e)
{
e.printStackTrace();
}
}
private static void buidBeans(List<Element> beans){
for(Element bean :beans){
String id = bean.getAttributeValue("id");
if(SampleSpringContainer.beans.containsKey(id))continue;
String clas = bean.getAttributeValue("class");
boolean single =Boolean.valueOf(bean.getAttributeValue("single"));
Bean mbean=new Bean(clas, single);
SampleSpringContainer.beans.put(id, mbean);
List<Element> dependences = bean.getChildren("setProperty");
for(Element dependence :dependences){
String name = dependence.getAttributeValue("name");
String agr = dependence.getAttributeValue("refer");
Bean dbean2 = SampleSpringContainer.beans.get(agr);
if(dbean2==null){
buidDependenceBeans(beans,agr);
dbean2=SampleSpringContainer.beans.get(agr);
}
if(dbean2==null){
throw new IllegalArgumentException(id+"property "+name+"is not found");
}
mbean.getDependence().put(name, dbean2);
}
}
}
private static void initBeans()
{
for(Map.Entry<String, Bean> bean:beans.entrySet()){
if(!bean.getValue().getDependence().isEmpty()){
for(Map.Entry<String, Bean> dep:bean.getValue().getDependence().entrySet()){
deepBuildDependence(dep.getValue().getDependence());
}
}
singles.put(bean.getValue().getClassName(), bean.getValue().newInstance());
}
}
private static void deepBuildDependence(Map<String, Bean> dependence)
{
for(Map.Entry<String, Bean> dep:dependence.entrySet()){
Bean bean = dep.getValue();
if(!bean.getDependence().isEmpty()){
deepBuildDependence(bean.getDependence());
}
singles.put(bean.getClassName(), bean.newInstance());
}
}
private static void buidDependenceBeans(List<Element> beans,final String rid){
for(Element bean :beans){
String id = bean.getAttributeValue("id");
if(!rid.equals(id))continue;
String clas = bean.getAttributeValue("class");
boolean single =Boolean.valueOf(bean.getAttributeValue("single"));
Bean mbean=new Bean(clas, single);
SampleSpringContainer.beans.put(id, mbean);
List<Element> dependences = bean.getChildren("setProperty");
for(Element dependence :dependences){
String name = dependence.getAttributeValue("name");
String agr = dependence.getAttributeValue("refer");
Bean dbean2 = SampleSpringContainer.beans.get(agr);
if(dbean2==null){
buidDependenceBeans(beans,agr);
dbean2=SampleSpringContainer.beans.get(agr);
}
if(dbean2==null){
throw new IllegalArgumentException("");
}
mbean.getDependence().put(name, dbean2);
}
}
}
public static Object getBean(final String beanId){
Bean bean = beans.get(beanId);
if(bean!=null){
if(bean.isSingle()){
return singles.get(beanId);
}else{
return bean.newInstance();
}
}
return null;
}
}
class Bean{
private String className;
private boolean isSingle;
public Bean(String className, boolean isSingle)
{
super();
this.className = className;
this.isSingle = isSingle;
}
private Map<String,Bean> dependence=new HashMap<String, Bean>();
public String getClassName()
{
return className;
}
public void setClassName(String className)
{
this.className = className;
}
public boolean isSingle()
{
return isSingle;
}
public Map<String, Bean> getDependence()
{
return dependence;
}
public Object newInstance(){
SampleClassLoader classLoader = SampleClassLoader.getClassLoader();
Object newInstance=null;
try
{
Class<?> loadClass = classLoader.loadClass(className);
newInstance= loadClass.newInstance();
for(Map.Entry<String, Bean> entity:dependence.entrySet()){
Field field = loadClass.getDeclaredField(entity.getKey());
field.setAccessible(true);
if(entity.getValue().isSingle()){
field.set(newInstance,SampleSpringContainer.singles.get(entity.getValue().getClassName()));
}else{
field.set(newInstance, entity.getValue().newInstance());
}
}
}
catch (ClassNotFoundException e)
{
e.printStackTrace();
}
catch (InstantiationException e)
{
e.printStackTrace();
}
catch (IllegalAccessException e)
{
e.printStackTrace();
}
catch (SecurityException e)
{
e.printStackTrace();
}
catch (NoSuchFieldException e)
{
e.printStackTrace();
}
return newInstance;
}
}
这个类有点长，此处并没有太多的考虑，最靠谱的首先是能够实现，对吧？
呵呵 在编写一个带main函数的类测试一下，总的有图有真相吧？
package com.sample.spring;
import com.sample.spring.egclasses.EgSevice;
public class TestSpring
{
/**
* @param args
*/
public static void main(String[] args)
{
EgSevice bean = (EgSevice) SampleSpringContainer.getBean("service");
bean.callMe();
EgSevice bean1 = (EgSevice) SampleSpringContainer.getBean("service1");
bean1.callMe();
System.out.println(bean.getEgDao()==bean1.getEgDao());
}
}
执行结果如图：
没有骗你吧？不管咋地 首先是完成了功能。 呵呵 注解篇，请看续集！
相关推荐
springIOC手写框架分析springIOC手写框架分析springIOC手写框架分析springIOC手写框架分析springIOC手写框架分析springIOC手写框架分析springIOC手写框架分析springIOC手写框架分析springIOC手写框架分析springIOC...
1. 设计ORM框架：定义接口或抽象类，用于表示数据库操作，然后创建具体的实现类，如实体类、数据访问对象（DAO）。接着，实现数据绑定和查询功能。 2. 实现MVC架构：创建模型类来处理业务逻辑，视图类用于展示结果...
在本项目中，我们将根据Spring的IoC原理，尝试实现自己的IoC框架。 首先，理解IoC的概念至关重要。IoC是指应用程序的控制权由传统的方式（如：对象直接创建和管理依赖关系）转移到框架或容器中，这样对象不再负责...
【IOC框架详解】 IOC（Inversion of Control）框架是一种软件设计模式，主要目的是为了降低对象间的耦合度，实现更好的可扩展性和可维护性。在传统的面向对象编程中，对象通常自行创建和管理它们所依赖的其他对象，...
### 多种IOC框架的比较 #### 概述 在软件开发领域，特别是.NET平台下，依赖注入（Inversion of Control, IOC）容器是管理对象生命周期和服务定位的关键工具。本文将对比分析几种主流的.NET IOC框架：Spring.NET、...
本教程将带你深入理解这两个概念，并通过手写一个简易的IoC和AOP框架来加深理解。 **依赖注入（IoC）** 依赖注入是Spring的核心特性之一，它允许开发者将对象的创建和管理权交给框架，从而降低组件之间的耦合度。在...
学习这个框架，开发者可以深入理解IOC和AOP的概念，掌握如何在C#中实现和使用这两种模式，提升自己的编程技巧和软件设计能力。同时，了解和使用开源框架，也有助于扩展视野，了解业界最佳实践。
1. **容器**：这是IOC的核心，它负责管理所有对象的生命周期，包括创建、初始化、装配以及销毁对象。当需要某个对象时，不再由代码直接创建，而是由容器根据配置或规则来提供。 2. **依赖注入**：这是IOC的主要实现...
Spring 框架系列（7）- Spring IOC 实现原理详解之 IOC 初始化流程 本文将详细解释 Spring 框架中的 IOC（Inversion of Control，控制反转）实现原理之 IOC 初始化流程。IOC 是一种软件设计模式，用于将软件系统中...
Android进阶——框架打造之IOC框架 实现通过Id找到控件的功能 实现通过Id找到Color、String资源 实现绑定view的点击事件、长按事件 实现绑定SetContentView 实现绑定网络的检测功能
### Spring IOC框架学习知识点 #### 一、Spring IOC框架简介 Spring框架是一个开源的企业级Java应用框架，它提供了丰富的功能来简化企业应用开发。其中，Inversion of Control (IoC)容器是Spring的核心特性之一，...
自己做的一个小型的IOC框架，希望大家一起研究下
在开发 Flex 应用程序时，Spring Actionscript IOC 框架和 Cairngorm MVC 模式结合使用，可以显著提升代码的可维护性和可扩展性。Spring Actionscript 是一个针对 Actionscript3 设计的轻量级框架，其灵感来源于 ...
Spring 框架中的 IoC（Inversion of Control，控制反转）是一种重要的设计模式，它改变了传统程序设计中对象创建和管理的方式。IoC 的核心思想是将对象的实例化和依赖关系的管理从对象自身剥离出来，交给一个外部的...
Flex IOC（Inversion of Control）框架是用于构建可扩展且松耦合的ActionScript和Flex应用程序的工具。IOC，也称为依赖注入，是一种设计模式，它允许组件之间的依赖关系在运行时被管理，而不是在代码中硬编码。这种...
【 Castle 框架与 IOC 技术详解】 Castle框架是一个针对.NET平台的开源软件开发框架，它集合了多种成熟的应用技术，如ActiveRecord、AspectSharp、MonoRail以及MicroKernel/Windsor等。其中，MicroKernel是Castle的...
关于Spring框架中的IoC（控制反转）概念，我们可以通过一个幽默的例子来深入理解其核心思想。在编程领域，特别是面向对象编程中，控制反转（IoC）是一种设计原则，用于减少代码之间的耦合度，提高代码的可读性和可...
自己写了三个分别关于WEB,IOC,ORM的框架现将全部开源，内有说明文档，测试示例项目，框架源代码文件，sql语句等
轻量级的IOC框架，用于取代Spring在j2se项目中进行使用。
在Android开发中，IOC（Inversion of Control，控制反转）框架是提高代码可维护性和可扩展性的重要工具。本教程的下篇将深入探讨如何构建一个Android中的IOC框架，主要涉及的技术点包括依赖注入、注解处理以及反射...