`
chinrui
  • 浏览: 97586 次
  • 性别: Icon_minigender_1
社区版块
存档分类
最新评论

Spring IOC(DI)模拟

阅读更多
Spring DI Simulation

解释:IOC Inverse Of Control(控制反转) 或者 DI Dependency Injection(依赖注入)
观察以下代码,发现UserService类并没有对自己的属性UserDAO进行初始化,但是UserDAO仍然不为null,因为ClassPathXmlApplicationContext类初始化的时候,通过读取配置文件bean.xml将UserDAO对象注入到UserService对象里面。所以明面上没有对其进行初始化,使用配置文件初始化类对象,易于控制,不必修改类代码,可扩展性强。
User类
package com.edu.hpu.model;

public class User {

	private String name;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
}

UserDAO接口
package com.edu.hpu.dao;

import com.edu.hpu.model.User;

public interface UserDAO {

	public void save(User user);
	
}
UserDAOImpl类Implements UserDAO
package com.edu.hpu.impl;

import com.edu.hpu.dao.UserDAO;
import com.edu.hpu.model.User;

public class UserDAOImpl implements UserDAO {

	public void save(User user) {
		System.out.println("user saved!");
	}
	
}

4、UserService类
package com.edu.hpu.service;

import com.edu.hpu.dao.UserDAO;
import com.edu.hpu.model.User;

public class UserService {

	private UserDAO userDAO;
	
	public void save(User user) {
		userDAO.save(user);
	}

	public UserDAO getUserDAO() {
		return userDAO;
	}

	public void setUserDAO(UserDAO userDAO) {
		this.userDAO = userDAO;
	}
}

BeanFactory接口
package com.hpu.spring;

public interface BeanFactory {
	public Object getBean(String name);
}

ClassPathXmlApplicationContext类 Implements BeanFactory(重点)
package com.hpu.spring;

import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
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;

import com.edu.hpu.dao.UserDAO;

public class ClassPathXmlApplicationContext implements BeanFactory {

	Map<String , Object> beans = new HashMap<String , Object>();
	
	public ClassPathXmlApplicationContext() {
		SAXBuilder sax = new SAXBuilder();
		try {
			Document doc = sax.build("beans.xml");
			Element root = doc.getRootElement();
			
			List<Element> children = root.getChildren();
			for(int i = 0; i < children.size(); i++) {
				Element child = children.get(i);
				
				String key = child.getAttributeValue("id");
				String className = child.getAttributeValue("class");
				//System.out.println(key + "   " + className);
				Object value = Class.forName(className).newInstance();
				//System.out.println(value);
				beans.put(key, value);
				
				for(Element pro : child.getChildren("property")) {
					if(pro != null) {
						String name = pro.getAttributeValue("name");
						String beanName = pro.getAttributeValue("bean");
						char c = name.charAt(0);
						c = Character.toUpperCase(c);
						name = "set" + c + name.substring(1);
						Object bean = beans.get(beanName);
						Method methodName = value.getClass().getMethod(name, bean.getClass().getInterfaces()[0]);
						methodName.invoke(value, bean);
						System.out.println(name);
						System.out.println(bean);
					}
				}
			}
		} catch (JDOMException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} catch(ClassNotFoundException e) {
			e.printStackTrace();
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		} catch (SecurityException e) {
			e.printStackTrace();
		} catch (IllegalArgumentException e) {
			e.printStackTrace();
		} catch (NoSuchMethodException e) {
			e.printStackTrace();
		} catch (InvocationTargetException e) {
			e.printStackTrace();
		}
	}
	
	@Override
	public Object getBean(String name) {
		return beans.get(name);
	}
}

bean.xml配置文件
<?xml version="1.0" encoding="UTF-8"?>
<beans>
	<bean id="u" class="com.edu.hpu.impl.UserDAOImpl"></bean>
	
	<bean id="userService" class="com.edu.hpu.service.UserService">
		<property name="userDAO" bean="u"/>
	</bean>
</beans>

测试类
package com.edu.hpu.sevice;

import org.junit.Test;

import com.edu.hpu.model.User;
import com.edu.hpu.service.UserService;
import com.hpu.spring.BeanFactory;
import com.hpu.spring.ClassPathXmlApplicationContext;

public class TestUser {

	@Test
	public void testSave() {
		BeanFactory bf = new ClassPathXmlApplicationContext();
		
		UserService service = (UserService)bf.getBean("userService");
		User u = new User();
		service.save(u);
	}
	
}
分享到:
评论

相关推荐

    模拟Spring的IOC

    **模拟Spring的IOC** 在Java世界中,Spring框架以其强大的依赖注入(Dependency Injection,简称DI)和控制反转(Inversion of Control,简称IOC)能力,成为企业级应用开发的首选框架之一。理解并模拟Spring的IOC...

    SpringIoc示例代码

    2. **依赖注入(DI)**:Spring IOC的主要功能之一就是依赖注入。有两种方式实现DI:构造器注入和setter注入。构造器注入是在Bean实例化时通过构造函数传递依赖,而setter注入则是通过调用setter方法设置依赖。在`...

    spring ioc di aop详解

    在 Spring 中,IOC(Inversion of Control,控制反转)和 DI(Dependency Injection,依赖注入)是两个核心概念,而 AOP(Aspect Oriented Programming,面向切面编程)则是实现模块化和解耦的重要工具。现在,我们...

    模拟spring IOC非常好的事例

    在IT行业中,Spring框架是Java企业级应用开发的首选框架,尤其在控制反转(Inversion of Control,简称IOC)和依赖注入(Dependency Injection,简称DI)方面,它提供了强大的支持。Spring的IOC容器是其核心特性,它...

    Spring IOC AOP MVC 简单例子

    例如,`SpringIOC`目录中的配置文件(如`applicationContext.xml`)用于定义bean的定义和它们之间的依赖关系。通过XML或注解方式声明bean,Spring可以自动管理bean的实例化、初始化和销毁,从而简化了代码并提高了可...

    SpringIOC和AOP实现机制模拟

    Spring框架是Java开发中不可或缺的一部分,它通过提供控制反转(IOC)和面向切面编程(AOP)等核心特性,极大地简化了企业级应用的构建。让我们深入探讨这两个概念及其在Spring中的实现机制。 首先,Spring的控制...

    使用Spring IOC/DI 模拟某超市管理功能

    (3)MarketDao类:模拟数据库访问,包含属性对象 Market m,和方法Product findByid(String id)来实现根据商品编号查找商品,方法List&lt;product&gt; findAll()来实现返回仓库(商品集合),方法void addpro(Product p)...

    java模拟spring ioc

    以下将详细介绍Spring的IOC和DI概念以及如何模拟这些概念。 **依赖注入(Dependency Injection,DI)** 是一种设计模式,它允许对象之间的依赖关系在运行时动态地传递,而不是在代码中硬编码。这样可以提高代码的可...

    模拟Spring IoC

    在Spring框架中,IoC通过依赖注入(Dependency Injection, DI)来实现,它允许容器在运行时向对象注入所需的依赖。 在这个模拟Spring IoC的项目中,我们可以深入理解以下几个关键知识点: 1. **容器的概念**:...

    自定义ioc容器,spring ioc容易模拟程序

    Spring框架是Java开发中最常用的DI实现,其核心就是IOC(Inversion of Control,控制反转)容器。本篇文章将深入探讨如何自定义IOC容器,并通过对比来理解Spring的IOC机制。 首先,我们来理解什么是IOC。传统的编程...

    模拟spring ioc技术

    这个例子展示了如何模拟Spring的IOC和DI。虽然实际的Spring框架提供了更强大和复杂的功能,如自动扫描、AOP(面向切面编程)、事务管理等,但这个简单的模拟可以帮助我们理解核心理念。通过这个小Demo,你应该能更好...

    spring IOC实现(墨者革离)

    在这个名为"spring_IOC实现(墨者革离)"的项目中,我们可以通过模拟城门叩问的编剧场景来理解这一概念。 首先,控制反转的基本思想是将对象的创建和依赖关系的管理从应用程序中分离出来,交给一个外部容器(在...

    java练习之模拟SPRING IOC,我的SUMMER

    这个练习分为三个主要部分,旨在帮助我们掌握XML配置文件的读取,模拟Spring的IoC机制,以及对Struts框架的简单模拟。下面将逐一解析这些知识点。 **1. XML读取** XML(Extensible Markup Language)是一种通用的...

    简单模拟springIoc容器

    在Java开发领域,Spring框架是应用最广泛的轻量级框架之一,其中的核心概念就是Inversion of Control(IoC,控制反转)和Dependency Injection(DI,依赖注入)。IoC容器是Spring实现这一理念的重要工具,它负责管理...

    什么是Ioc和DI

    在实际应用中,DI通常作为IoC容器的一部分来实现,例如Spring框架中的BeanFactory或ApplicationContext,它们都提供了依赖注入的功能,从而帮助开发人员遵循IoC的原则,构建出更加灵活、可维护的软件系统。...

    Spring的IOC原理

    **Spring的IOC原理详解** **一、IoC理论背景** 在面向对象的软件设计中,对象间的耦合是不可避免的,它们通过相互合作实现业务逻辑。这种耦合就像机械手表中的齿轮,彼此啮合共同完成任务。随着软件系统规模的扩大...

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

    标题 "动手写框架,模拟简易的Spring IOC" 暗示了这个压缩包包含了一个教程或实践项目,目的是帮助我们理解Spring框架的核心组件——控制反转(Inversion of Control,简称IOC)。Spring框架是Java开发中广泛使用的...

    基于java简单模拟实现spring_ioc

    Spring的核心特性之一是依赖注入(Dependency Injection,简称DI),也称为控制反转(Inversion of Control,IoC)。在这个项目中,“基于java简单模拟实现spring_ioc”显然是为了帮助开发者理解Spring的IoC容器是...

    模拟springIOC

    在本文中,我们将深入探讨“模拟Spring IOC”的概念,以及如何通过自己实现的简单依赖注入来理解这个核心的Spring框架特性。Spring IOC,即Inversion of Control(控制反转),是软件设计模式的一种,它在Spring框架...

    模拟实现spring IOC AOP的例子

    在Spring中,IoC通过依赖注入(Dependency Injection,DI)来实现。依赖注入允许对象之间的依赖关系在运行时动态配置,而不是在编译时硬编码。在提供的例子中,你可以看到如何创建一个Bean工厂,模拟Spring的Bean...

Global site tag (gtag.js) - Google Analytics