`

简单模拟 Spring 的 ioc

 
阅读更多

beans.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans>
	<bean id="userDao" class="com.test.dao.impl.UserDaoImpl" />
	
	<bean id="userService" class="com.test.service.UserService">
		<property name="userDao" bean="userDao" />
	</bean>
</beans>

 

UserDao

package com.test.dao;

import com.test.entity.User;

public interface UserDao {
	public void save(User u);
}

 

UserDaoImpl

package com.test.dao.impl;

import com.test.dao.UserDao;
import com.test.entity.User;

public class UserDaoImpl implements UserDao {

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

 

User

package com.test.entity;

public class User {
	private int uid;
	
	private String uname;

	public int getUid() {
		return uid;
	}

	public void setUid(int uid) {
		this.uid = uid;
	}

	public String getUname() {
		return uname;
	}

	public void setUname(String uname) {
		this.uname = uname;
	}

}

 

UserService

package com.test.service;

import com.test.dao.UserDao;
import com.test.entity.User;

public class UserService {
	private UserDao userDao;
	
	public UserDao getUserDao() {
		return userDao;
	}

	public void setUserDao(UserDao userDao) {
		this.userDao = userDao;
	}

	public void save(User u) {
		userDao.save(u);
	}
}

 

BeanFactory

package myspring;

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

 

ClassPathXmlApplicationContext

package myspring;

import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.jdom.Document;
import org.jdom.Element;
import org.jdom.JDOMException;
import org.jdom.input.SAXBuilder;

public class ClassPathXmlApplicationContext implements BeanFactory {

	private Map<String, Object> beans = new HashMap<String, Object>();
	
	@SuppressWarnings("unchecked")
	public ClassPathXmlApplicationContext () throws JDOMException, IOException, InstantiationException, IllegalAccessException, ClassNotFoundException, SecurityException, NoSuchMethodException, IllegalArgumentException, InvocationTargetException {
		SAXBuilder sax = new SAXBuilder();
		Document doc = sax.build(this.getClass().getClassLoader().getResourceAsStream("beans.xml"));
		Element element = doc.getRootElement();
		List<Element> list = element.getChildren("bean");
		Element e = null;
		for (int i = 0; i < list.size(); i++) {
			e = list.get(i);
			String id = e.getAttributeValue("id");
			String clazz = e.getAttributeValue("class");
			Object o = Class.forName(clazz).newInstance();
			beans.put(id, o);
			for (Element propElement : (List<Element>)e.getChildren("property")) {
				String name = propElement.getAttributeValue("name");
				String bean = propElement.getAttributeValue("bean");
				System.out.println(name + " " + bean);
				Object beanObject = beans.get(bean);
				String methodName = "set" + name.substring(0, 1).toUpperCase() + name.substring(1); 
				System.out.println(methodName);
				Method m = o.getClass().getMethod(methodName, beanObject.getClass().getInterfaces()[0]);
				m.invoke(o, beanObject);
			}
		}
	}
	
	
	public Object getBean(String bean) {
		return this.beans.get(bean);
	}

}

 

UserServiceTest(JUnit)

package com.test.service;

import static org.junit.Assert.*;

import java.io.IOException;
import java.lang.reflect.InvocationTargetException;

import myspring.BeanFactory;
import myspring.ClassPathXmlApplicationContext;

import org.jdom.JDOMException;
import org.junit.Test;

import com.test.dao.UserDao;
import com.test.entity.User;

public class UserServiceTest {

	@Test
	public void testSave() {
		BeanFactory cpxac = null;
		try {
			cpxac = new ClassPathXmlApplicationContext();
		} catch (JDOMException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (SecurityException e) {
			e.printStackTrace();
		} catch (NoSuchMethodException e) {
			e.printStackTrace();
		} catch (IllegalArgumentException e) {
			e.printStackTrace();
		} catch (InvocationTargetException e) {
			e.printStackTrace();
		}
		UserService uService = (UserService)cpxac.getBean("userService");
//		UserDao userDao = (UserDao)cpxac.getBean("userDao");
//		uService.setUserdao(userDao);
		User u = new User();
		uService.save(u);
	}

}

 

到此结束

分享到:
评论

相关推荐

    以注解方式模拟Spring IoC AOP

    模拟Spring的IoC,我们可以创建一个简单的容器类,其中包含一个Map来存储bean。然后使用注解处理器扫描带有特定注解(如`@Component`)的类,并将它们注册到容器中。当需要注入依赖时,容器可以解析注解并自动装配。...

    简单模拟springIoc容器

    在`YQIoc`这个压缩包中,可能包含了实现简单模拟Spring IoC容器的代码。通常,这个模拟会包含以下几个部分: 1. **Bean定义**:这是描述对象如何创建和配置的数据结构。在我们的例子中,bean定义可能是以XML形式...

    模拟spring ioc过程

    这个"模拟spring ioc过程"的学习例子是基于Java语言的,旨在帮助理解Spring框架中的这两个核心概念。在Java工程中,我们通常会通过配置文件(如XML或Java配置类)来定义bean的定义和它们之间的依赖关系。在实际运行...

    模拟Spring的IOC

    通过以上步骤,我们可以构建一个简单的IOC容器,模拟Spring的核心功能。这不仅有助于理解Spring的工作原理,也为我们自定义轻量级框架提供了可能。在实际开发中,了解并掌握Spring的IOC机制能够帮助我们更好地设计和...

    java模拟spring ioc

    通过以上步骤,我们可以实现一个简单的Java模拟Spring IOC的系统。这种方式可以帮助开发者更好地理解Spring的工作原理,并在没有Spring框架的环境中实现相同的功能。不过,需要注意的是,Spring框架提供了更高级的...

    模拟spring IOC非常好的事例

    下面我们将深入探讨这个"模拟spring IOC非常好的事例"所涵盖的知识点。 首先,我们需要理解什么是IOC。IOC是一种设计模式,它的主要思想是将对象的创建和管理权交给一个外部容器,而不是由对象自身来负责。这样可以...

    反射模拟springIOC.rar

    1. **配置文件解析**:在`springIOC_0602`项目中,我们有一个XML配置文件,它定义了bean的声明和它们的依赖。JDOM库被用来读取这个文件,解析bean的定义,包括bean的类名、属性、依赖等。 2. **Bean的创建**:解析...

    模拟Spring IoC

    在这个模拟Spring IoC的项目中,我们可以深入理解以下几个关键知识点: 1. **容器的概念**:Spring IoC容器是管理对象及其依赖关系的核心组件。在这个模拟项目中,会有一个类或接口扮演容器的角色,负责创建对象、...

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

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

    模拟spring ioc技术

    本篇文章将详细解析“模拟Spring IOC技术”的核心概念,并通过一个小Demo帮助你深入理解IOC的工作原理。 首先,我们来解释一下什么是IOC和DI。控制反转(IOC)是编程中的一个设计原则,它改变了对象获取依赖的方式...

    模拟实现Spring的IOC

    模拟实现__Spring的Ioc 1、Spring主要两个作用:实例化Bean,动态装配Bean。并将所有的bean放到spring容器中,调用时从容器中取。Spring容器就是一个bean的Map:private Map, Object&gt; beans = new HashMap, Object&gt;...

    SpringIoc示例代码

    Spring IOC,全称Inversion of Control,即“控制反转”,是Spring框架的核心特性之一。在传统的Java应用程序中,对象的创建和管理通常由开发者自己控制。而在Spring IOC中,这种控制权被反转,对象的创建、初始化、...

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

    描述中的链接指向了CSDN博客的一个文章,虽然具体内容无法直接复制到这里,但我们可以根据文章标题推测,该文章详细介绍了如何从零开始构建一个简单的IOC容器,以此来模拟Spring框架的工作原理。通过这种方式,学习...

    模拟springIOC

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

    SpringIOC和AOP实现机制模拟

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

    Spring IOC AOP MVC 简单例子

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

    基于java简单模拟实现spring_ioc

    在这个项目中,“基于java简单模拟实现spring_ioc”显然是为了帮助开发者理解Spring的IoC容器是如何工作的,以及如何通过Java代码来模拟这个过程。 首先,让我们了解什么是Spring的IoC。IoC是一种设计模式,它将...

    spring IOC 简易实现

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

    java 解析xml,模拟spring框架ioc

    模拟Spring的IOC功能,我们可以创建一个简单的解析器类,该类负责加载XML配置文件,解析Bean定义,实例化和注入依赖。为了实现这个功能,我们需要了解和使用Java的DOM或SAX解析库,以及反射API。这是一个很好的学习...

    spring IOC实现(墨者革离)

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

Global site tag (gtag.js) - Google Analytics