`
viwo
  • 浏览: 221620 次
  • 性别: Icon_minigender_1
  • 来自: 大连
社区版块
存档分类
最新评论

IoC的简易实现

    博客分类：
  • JAVA
IOCBeanApachelog4jXML 
阅读更多
java 代码
  1.   
  2. package com.viwo.bean.factory;   
  3.   
  4. import java.util.HashMap;   
  5. import java.util.Iterator;   
  6. import java.util.Map;   
  7.   
  8. import org.apache.commons.beanutils.BeanUtils;   
  9. import org.apache.commons.digester.Digester;   
  10. import org.apache.log4j.Logger;   
  11.   
  12. import com.viwo.bean.config.ConfigBean;   
  13. import com.viwo.bean.interceptor.InterceptorProxyFactory;   
  14. import com.viwo.sqlmap.config.SqlMapConfig;   
  15.   
  16. /**  
  17.  * A simple IoC Container for beans, manage beans for you.  
  18.  *   
  19.  * @author viwo   
  20.  *    
  21.  */  
  22. public class BeanFactory {   
  23.   
  24.  private final static Logger logger = Logger.getLogger(SqlMapConfig.class);   
  25.  private Map configBeanMap = new HashMap();   
  26.  private static Map beanFactoryMap = new HashMap();   
  27.     
  28.     /**  
  29.      * a static synchronized method to get the Bean from a gived beanId  
  30.      *   
  31.      * @param beanId  
  32.      * @return Object  
  33.      */  
  34.  public static synchronized Object getBean(String beanId)   
  35.  {   
  36.   logger.info("[viwo]-->[enter getBean]");   
  37.   BeanFactory beanFactory = getBeanFactory();   
  38.   Map cfgMap = beanFactory.getConfigBeanMap();   
  39.   ConfigBean cfgBean = (ConfigBean)cfgMap.get(beanId);   
  40.   if(cfgBean == null)   
  41.   {   
  42.    //if there have not beanId will return null   
  43.    return null;   
  44.   }   
  45.   String transaction = cfgBean.getTransaction();   
  46.   Object beanObject = null;   
  47.   try    
  48.   {   
  49.    beanObject = Class.forName(cfgBean.getType()).newInstance();   
  50.   }    
  51.   catch (Exception e)    
  52.   {   
  53.    e.printStackTrace();   
  54.   }   
  55.      
  56.   Iterator itProperty = cfgBean.getPropertyMap().keySet().iterator();   
  57.   Iterator itRef = cfgBean.getRefMap().keySet().iterator();   
  58.      
  59.   while(itProperty.hasNext())   
  60.   {   
  61.    String propertyName = itProperty.next().toString();   
  62.    String propertyValue = cfgBean.getPropertyMap().get(propertyName).toString();   
  63.    try    
  64.    {   
  65.     BeanUtils.setProperty(beanObject, propertyName, propertyValue);   
  66.    }    
  67.    catch (Exception e)    
  68.    {   
  69.     e.printStackTrace();   
  70.    }   
  71.   }   
  72.      
  73.   while(itRef.hasNext())   
  74.   {   
  75.    String refName = itRef.next().toString();   
  76.    String refValue = cfgBean.getRefMap().get(refName).toString();   
  77.    Object refObject = BeanFactory.getBean(refValue);   
  78.    try    
  79.    {   
  80.     BeanUtils.setProperty(beanObject, refName, refObject);   
  81.    }    
  82.    catch (Exception e)    
  83.    {   
  84.     e.printStackTrace();   
  85.    }   
  86.   }   
  87.   //System.out.println(cfgBean.getType());   
  88.   if(transaction!=null&&!transaction.equals(""))   
  89.   {   
  90.    String[] trans = transaction.split(",");   
  91.    beanObject = InterceptorProxyFactory.getInterceptorProxyedObject(beanObject,trans);   
  92.   }   
  93.   return beanObject;   
  94.  }   
  95.     
  96.     /**  
  97.      * a static synchronized method to get the BeanFactoryConfig  
  98.      *    
  99.      * this method will initialize the properity of BeanFactory   
  100.      *   
  101.      * @return BeanFactory  
  102.      */  
  103.  private static synchronized BeanFactory getBeanFactory()   
  104.  {   
  105.   BeanFactory beanFactory = null;   
  106.   String path = "bean-config.xml";   
  107.   if(beanFactoryMap.get(path)==null)   
  108.   {   
  109.    Digester digester = new Digester();     
  110.       digester.setValidating(false);    
  111.       digester.addObjectCreate("beans", "com.viwo.bean.factory.BeanFactory");   
  112.          
  113.       digester.addObjectCreate("beans/bean", "com.viwo.bean.config.ConfigBean");   
  114.          
  115.       digester.addSetProperties("beans/bean");   
  116.          
  117.       digester.addCallMethod("beans/bean/property", "setProperty", 2);   
  118.       digester.addCallParam("beans/bean/property", 0, "name");   
  119.       digester.addCallParam("beans/bean/property", 1, "value");   
  120.          
  121.       digester.addCallMethod("beans/bean/ref", "setRef", 2);   
  122.          digester.addCallParam("beans/bean/ref", 0, "name");   
  123.       digester.addCallParam("beans/bean/ref", 1, "value");   
  124.          
  125.       digester.addSetNext("beans/bean", "addConfigBean", "com.viwo.bean.config.ConfigBean");   
  126.          
  127.       try    
  128.       {   
  129.        beanFactory = (BeanFactory)digester.parse(Thread.currentThread().getContextClassLoader().getResource("/"+path).getFile());   
  130.        beanFactoryMap.put(path, beanFactory);   
  131.       }    
  132.    catch (Exception e)   
  133.    {   
  134.     System.out.println(e.getMessage());   
  135.    }   
  136.   }   
  137.   else  
  138.   {   
  139.    beanFactory = (BeanFactory)beanFactoryMap.get(path);   
  140.   }   
  141.   return beanFactory;   
  142.  }   
  143.  public void addConfigBean(ConfigBean configBean)   
  144.  {   
  145.   configBeanMap.put(configBean.getId(), configBean);   
  146.  }   
  147.  public Map getConfigBeanMap()    
  148.  {   
  149.   return configBeanMap;   
  150.  }   
  151.     
  152. }   
分享到：
| "iBATIS"的简易实现
评论
1 楼 piaochunzhi 2007-03-08  
我晕 重新编辑一下 
package com.viwo.bean.factory;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import org.apache.commons.beanutils.BeanUtils;
import org.apache.commons.digester.Digester;
import org.apache.log4j.Logger;

import com.viwo.bean.config.ConfigBean;
import com.viwo.bean.interceptor.InterceptorProxyFactory;
import com.viwo.sqlmap.config.SqlMapConfig;

/**
 * A simple IoC Container for beans, manage beans for you.
 * 
 * @author viwo 
 *  
 */
public class BeanFactory {

 private final static Logger logger = Logger.getLogger(SqlMapConfig.class);
 private Map configBeanMap = new HashMap();
 private static Map beanFactoryMap = new HashMap();
 
    /**
     * a static synchronized method to get the Bean from a gived beanId
     * 
     * @param beanId
     * @return Object
     */
 public static synchronized Object getBean(String beanId)
 {
  logger.info("[viwo]-->[enter getBean]");
  BeanFactory beanFactory = getBeanFactory();
  Map cfgMap = beanFactory.getConfigBeanMap();
  ConfigBean cfgBean = (ConfigBean)cfgMap.get(beanId);
  if(cfgBean == null)
  {
   //if there have not beanId will return null
   return null;
  }
  String transaction = cfgBean.getTransaction();
  Object beanObject = null;
  try 
  {
   beanObject = Class.forName(cfgBean.getType()).newInstance();
  } 
  catch (Exception e) 
  {
   e.printStackTrace();
  }
  
  Iterator itProperty = cfgBean.getPropertyMap().keySet().iterator();
  Iterator itRef = cfgBean.getRefMap().keySet().iterator();
  
  while(itProperty.hasNext())
  {
   String propertyName = itProperty.next().toString();
   String propertyValue = cfgBean.getPropertyMap().get(propertyName).toString();
   try 
   {
    BeanUtils.setProperty(beanObject, propertyName, propertyValue);
   } 
   catch (Exception e) 
   {
    e.printStackTrace();
   }
  }
  
  while(itRef.hasNext())
  {
   String refName = itRef.next().toString();
   String refValue = cfgBean.getRefMap().get(refName).toString();
   Object refObject = BeanFactory.getBean(refValue);
   try 
   {
    BeanUtils.setProperty(beanObject, refName, refObject);
   } 
   catch (Exception e) 
   {
    e.printStackTrace();
   }
  }
  //System.out.println(cfgBean.getType());
  if(transaction!=null&&!transaction.equals(""))
  {
   String[] trans = transaction.split(",");
   beanObject = InterceptorProxyFactory.getInterceptorProxyedObject(beanObject,trans);
  }
  return beanObject;
 }
 
    /**
     * a static synchronized method to get the BeanFactoryConfig
     *  
     * this method will initialize the properity of BeanFactory 
     * 
     * @return BeanFactory
     */
 private static synchronized BeanFactory getBeanFactory()
 {
  BeanFactory beanFactory = null;
  String path = "bean-config.xml";
  if(beanFactoryMap.get(path)==null)
  {
   Digester digester = new Digester();  
      digester.setValidating(false); 
      digester.addObjectCreate("beans", "com.viwo.bean.factory.BeanFactory");
      
      digester.addObjectCreate("beans/bean", "com.viwo.bean.config.ConfigBean");
      
      digester.addSetProperties("beans/bean");
      
      digester.addCallMethod("beans/bean/property", "setProperty", 2);
      digester.addCallParam("beans/bean/property", 0, "name");
      digester.addCallParam("beans/bean/property", 1, "value");
      
      digester.addCallMethod("beans/bean/ref", "setRef", 2);
         digester.addCallParam("beans/bean/ref", 0, "name");
      digester.addCallParam("beans/bean/ref", 1, "value");
      
      digester.addSetNext("beans/bean", "addConfigBean", "com.viwo.bean.config.ConfigBean");
      
      try 
      {
       beanFactory = (BeanFactory)digester.parse(Thread.currentThread().getContextClassLoader().getResource("/"+path).getFile());
       beanFactoryMap.put(path, beanFactory);
      } 
   catch (Exception e)
   {
    System.out.println(e.getMessage());
   }
  }
  else
  {
   beanFactory = (BeanFactory)beanFactoryMap.get(path);
  }
  return beanFactory;
 }
 public void addConfigBean(ConfigBean configBean)
 {
  configBeanMap.put(configBean.getId(), configBean);
 }
 public Map getConfigBeanMap() 
 {
  return configBeanMap;
 }
 
}
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    spring IOC 简易实现

    NULL 博文链接：https://zhengshuo.iteye.com/blog/573192

    IOC容器简单实现

    **IOC容器简单实现** IOC（Inversion of Control）容器是软件设计模式中的一种，它将对象的创建和管理权从代码本身转移到一个外部容器，即IOC容器。这种反转控制使得程序更加灵活，降低了组件之间的耦合性，提高了...

    一个简单的模仿spring的ioc实现

    这个“一个简单的模仿spring的ioc实现”项目旨在帮助开发者理解Spring Ioc的核心概念，并通过自己的代码实现来加深对这一机制的理解。 首先，Spring Ioc的主要目标是解耦应用程序组件。它通过管理对象的生命周期和...

    Spring.NET学习笔记-实现一个简易的IoC框架

    ### Spring.NET学习笔记-实现一个简易的IoC框架 #### 一、背景介绍与理论基础 在.NET领域中，Spring.NET框架是一个非常重要的轻量级框架，它支持依赖注入（Dependency Injection, DI）和面向切面编程（Aspect ...

    java代码实现简易版IOC容器！.docx

    在这个简易版的Java IOC容器实现中，我们将探讨如何通过自定义注解和反射机制来构建一个基础的IoC容器。 首先，我们有两个自定义注解：`@MyComponent` 和 `@MyAutowired`。 1. `@MyComponent` 是一个类型注解，...

    自主实现的简易Spring框架

    本项目"自主实现的简易Spring框架"显然是对Spring核心功能的一种简化版实现，旨在帮助开发者深入理解Spring的核心机制。 首先，我们来讨论一下Spring的核心组件——IoC（Inversion of Control）容器。IoC也被称为...

    手动实现一个ioc容器.zip

    在压缩包子文件"my-spring-ioc-master"中，可能包含了一个完整的示例项目，该项目演示了如何手动构建一个简易的Spring IOC容器。项目中可能包括以下部分： - **BeanDefinition**: 表示Bean定义的类，存储Bean的信息...

    简单的ioc框架, just a simple

    3. **接口**：在IOC框架中，提倡使用接口而非具体的实现类，因为接口可以更好地隐藏实现细节，提高组件之间的解耦。通过定义接口，不同的实现可以在运行时动态切换，这在多环境或多版本兼容时非常有用。 4. **配置*...

    手写简单实现ioc、aop事务demo

    在这个“手写简单实现ioc、aop事务demo”中，我们将探讨如何通过工厂模式和动态代理来实现这些概念。 首先，让我们了解IOC的核心思想。在传统的编程中，对象创建和管理的控制权在程序员手中，而IOC则是将这种控制权...

    自己写的类struts的简易的mvc实现+一个类Spring的IOC和简单AOP

    在这个简易实现中，"Model"负责处理业务逻辑和数据存储，"View"负责显示用户界面，而"Controller"则作为两者之间的桥梁，接收用户请求，处理后转发到相应的视图或模型。 **简易MVC实现** 这个简易实现可能包括以下...

    动手写框架，模拟简易的SpringIOC.rar

    在我们的简易实现中，可能会有一个类扮演Bean工厂的角色，用于实例化和管理对象。 3. **ApplicationContext**：在Spring中，ApplicationContext扩展了BeanFactory，提供了更多企业级应用所需的功能，如资源加载、...

    手写spring ioc(三) 资源org.zip

    在本资源"手写spring ioc(三) 资源org.zip"中，我们主要关注的是如何实现一个简易版的Spring IOC（Inversion of Control）容器，它涵盖了ioc的基本功能，包括解决循环依赖、使用构造器注入以及自动注入等核心特性。...

    手写IOC,DI，servlet

    从【压缩包子文件的文件名称列表】"ShouXieMVC"来看，这可能是作者实现的一个简易的Model-View-Controller（MVC）架构。MVC是一种设计模式，常用于Web应用，它将业务逻辑（Model）、用户界面（View）和控制逻辑...

    C#实现IOC代码，供学习用

    标题中提到的“C#实现IOC代码”通常指的是开发者为了理解和掌握DI原理，自己编写了一个简易的IOC容器。这有助于深入理解DI的工作机制，并为实际项目中的应用打下基础。 **什么是IOC（控制反转）？** 控制反转是指将...

    模拟Spring架构的简易实现

    "模拟Spring架构的简易实现"这个项目可能是为了理解和学习Spring框架的基本原理而创建的，它可能通过简单的代码来模拟Spring的一些核心功能。 首先，我们要理解Spring的核心概念。依赖注入是Spring最基础的设计模式...

    ioc_java_源码

    本压缩包"ioc_java_源码"提供了一个基于Java反射的简易Ioc实现。我们可以从以下几个关键点来理解这个实现： 1. **Bean定义**：在Ioc容器中，每个对象被称为一个Bean。你需要定义Bean的元信息，包括类名、初始化参数...

    针对大厂面试，模仿Spring写的简易版IOC小框架，完美解释三级缓存解决属性注入循环依赖的问题

    在这个名为"spring-simple-master"的压缩包中，包含了一个简易版的IOC（Inversion of Control，控制反转）小框架，其灵感来源于Spring的核心机制。这个项目特别关注如何使用三级缓存来解决属性注入过程中的循环依赖...

    Spring boot实现一个简单的ioc（1）

    在本文中，我们将创建一个简易的IOC容器，以理解其工作原理，并在实际项目中实现类似Spring Boot的自动装配功能。 首先，我们定义测试项目结构。项目包含以下几个关键组件： 1. **SampleApplication**：这是项目的...

    简易实现Spring流程代码

    Spring框架是Java开发中广泛应用的一个开源框架，以其强大的IoC（Inversion of Control，控制反转）和AOP（Aspect Oriented Programming，面向切面编程）功能而著名。本篇文章将详细解析Spring框架的初始化过程，...

Magicbox
Global site tag (gtag.js) - Google Analytics