spring IOC
软件151 秦康维
spring IOC
beans.xml
[html] view plain copy print?
<?xml version="1.0" encoding="UTF-8"?>
<beans>
<bean id="user" class="com.yyb.model.User" />
<bean id="userDAO" class="com.yyb.dao.impl.UserDAOImpl" />
<bean id="userService" class="com.yyb.service.UserService">
<property name="userDAO" bean="userDAO" />
</bean>
</beans>
BeanFactory
[java] view plain copy print?
public interface BeanFactory {
Object getBean(String name);
}
ClassPathXmlApplicationContext：读取xml文件内容，并创建对象及对象关系（使用setter方式）
[java] view plain copy print?
package com.yyb.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.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>();
public ClassPathXmlApplicationContext() throws JDOMException, IOException,
InstantiationException, IllegalAccessException,
ClassNotFoundException, SecurityException, NoSuchMethodException,
IllegalArgumentException, InvocationTargetException
{
SAXBuilder sb = new SAXBuilder();
// 构造文档对象
Document doc = sb.build(ClassPathXmlApplicationContext.class
.getClassLoader().getResourceAsStream("beans.xml"));
// 获取根元素
Element root = doc.getRootElement();
// 取到根元素所有元素
List list = root.getChildren();
for (int i = 0; i < list.size(); i++)
{
Element element = (Element) list.get(i);
// 取id子元素
String beanid = element.getAttributeValue("id");
// 取class子元素
String clzss = element.getAttributeValue("class");
// 实例化
Object o = Class.forName(clzss).newInstance();
// 将所有bean放入map中
beans.put(beanid, o);
// 获取property 进行依赖注入
for (Element propertyElement : (List<Element>) element
.getChildren("property"))
{
String name = propertyElement.getAttributeValue("name");
System.out.println(name);//userDAO
String bean = propertyElement.getAttributeValue("bean");
System.out.println(bean);//userDAO
// 从beans.xml中根据id取到类的对象
//Object beanObj = this.getBean(name);
// 从beans.xml中根据id取到类的对象
Object beanObj = this.getBean(bean);
System.out.println(beanObj);//com.yyb.dao.impl.UserDAOImpl@a09ee92
// 形成setXXX方法名
String methodName = "set" + name.substring(0, 1).toUpperCase()
+ name.substring(1);
System.out.println(name.substring(0, 1).toUpperCase());//U
System.out.println(name.substring(1));//serDAO
System.out.println(methodName);//setUserDAO
// 反射机制对方法进行调用，将对象在加载bean时就注入到环境上下文中
Method m = o.getClass().getMethod(methodName,
beanObj.getClass().getInterfaces()[0]);
System.out.println(o.getClass());//class com.yyb.service.UserService
System.out.println(beanObj.getClass().getInterfaces()[0]);//interface com.yyb.dao.UserDAO
System.out.println(m);//public void com.yyb.service.UserService.setUserDAO(com.yyb.dao.UserDAO)
// 执行注入,相当于执行了一个setXXX(args..)的方法
m.invoke(o, beanObj);
}
}
}
@Override
public Object getBean(String name)
{
return beans.get(name);
}
}
对于以上这段代码实现的效果为：
Service service=(Service)beans.get("userService");
Dao dao = (Dao)beans.get("userDAO");
//依赖注入，Service实现依赖dao的实现
service.setDao(dao);
User:实体类
[java] view plain copy print?
public class User {
private String userName;
private String password;
/**
* @return the userName
*/
public String getUserName()
{
return userName;
}
/**
* @param userName
* the userName to set
*/
public void setUserName(String userName)
{
this.userName = userName;
}
/**
* @return the password
*/
public String getPassword()
{
return password;
}
/**
* @param password
* the password to set
*/
public void setPassword(String password)
{
this.password = password;
}
public String toString()
{
StringBuffer sb = new StringBuffer();
sb.append(this.userName);
sb.append(this.password);
return sb.toString();
}
}
UserDAO
[java] view plain copy print?
public interface UserDAO {
void save(User u);
void delete();
}
UserDAOImpl
[java] view plain copy print?
public class UserDAOImpl implements UserDAO {
@Override
public void save(User u) {
System.out.println("User:" + u.toString());
}
@Override
public void delete() {
System.out.println("delete User");
}
}
UserService
[java] view plain copy print?
public class UserService {
private UserDAO userDAO;
public void addUser(User u)
{
this.userDAO.save(u);
}
/**
* @return the userDAO
*/
public UserDAO getUserDAO()
{
return userDAO;
}
/**
* @param userDAO
* the userDAO to set
*/
public void setUserDAO(UserDAO userDAO)
{
this.userDAO = userDAO;
}
}
下面我们来简单测试一下实现的效果：
Client
[java] view plain copy print?
public class client {
public static void main(String[] args) throws InstantiationException, IllegalAccessException, ClassNotFoundException, SecurityException, NoSuchMethodException, IllegalArgumentException, InvocationTargetException, JDOMException, IOException {
BeanFactory factory = new ClassPathXmlApplicationContext();
//通过工厂直接获取
UserService userService = (UserService) factory.getBean("userService");
//其实User也可以从工厂中获得
User u=(User)factory.getBean("user");
//User u = new User();
u.setUserName("yyb");
u.setPassword("1234");
userService.addUser(u);//打印结果yyb1234
}
}
当然以上我们是通过setter方法注入，还可以使用构造器注入，也就是在建立对象的时候建立关系（即在UserService的构造函数中添加对userDAO的赋值操作）
总结：
以上通过IOC的一个简要实现实例，模拟了Spring中IOC的实现，虽然只是完成了Spring中依赖注入的一小部分工作，但是很好的展现了Java反射机制在Spring中的应用，能使我们能更好的从原理上了解IOC的实现，也能为我们实现自己的Spring框架提供了方案。
