Spring 原理：IOC的概念

本文源码：spring原理     备用下载：spring原理

我们先来回顾一下，在没有使用spring的时候，后台业务是怎么操作的：

一，首先要有一个model（或者称为domain）类，用来存放bean

User.java

package com.haizhu.model;

public class User {
	private String username;
	private String password;
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
}

二：dao操作层，是用来和数据库打交道，执行具体的增删查改

1、dao接口：之所以使用接口是为了跨平台，当你需要oracle的数据库，就按照oracle的要求实现这个dao接口，当你需要mysql数据库就实现mySQL的接口

package com.haizhu.dao;

import com.haizhu.model.User;

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

2、daoImpl实现：按照数据库的不同进行不同的具体实现

package com.haizhu.dao.impl;

import com.haizhu.dao.UserDao;
import com.haizhu.model.User;

public class UserDaoImpl implements UserDao {
	@Override
	public void addUser(User u) {
		System.out.println(" A user saved !");
	}
}

注：为了简化范例，这里没有执行数据库的操作，只是将数据输出到控制台。

三：service业务层，用来处理繁杂的业务关系

1、service接口：这里接口是为了对比一般实现方法和使用类似spring注入方法的区别

package com.haizhu.service;

import com.haizhu.model.User;

public interface UserService {
	public void addUser(User u);
}

2、serviceImpl一般实现：没有使用spring的时候，UserDao需要手动初始化

package com.haizhu.service.impl;

import com.haizhu.dao.UserDao;
import com.haizhu.dao.impl.UserDaoImpl;
import com.haizhu.model.User;
import com.haizhu.service.UserService;

// 当使用原始的方法的时候，这么做，来进行初始化
public class SimpleUserServiceImpl implements UserService {
	// 这里UserDao 需要手动实例化，与spring的主要区别就在这里
	private UserDao newUserDao = new UserDaoImpl();

	public void addUser(User u){
		newUserDao.addUser(u);
	}
}

四：测试

package com.haizhu.service.impl;

import org.junit.Test;

import com.haizhu.model.User;
import com.haizhu.service.UserService;

public class SimpleUserServiceImplTest {

	@Test
	public void test() {
		// 实例化一个 UserService，具体的实现是SimpleUserServiceImpl
		UserService service = new SimpleUserServiceImpl();
		// 实际项目中，这个 user 是从页面传递过来的，通过struts在action中进行接收
		User u = new User();
		// 调用dao层的具体操作方法，现实数据库操作
		service.addUser(u);
	}
}

结果：

 A user saved !

下面我们来看看使用配置文件的方式实现上面的功能：

一：注入dao的service实现

package com.haizhu.service.impl;

import com.haizhu.dao.UserDao;
import com.haizhu.model.User;
import com.haizhu.service.UserService;
import com.haizhu.spring.BeanFactory;
import com.haizhu.spring.ClassPathXmlApplicationContext;
// 当使用spring的时候，交给xml配置文件来初始化
public class DIDaoUserServiceImpl implements UserService {
	BeanFactory factory = new ClassPathXmlApplicationContext();
	private UserDao springUserDao = (UserDao) factory.getBean("u");;
	public void addUser(User u) {
		springUserDao.addUser(u);
	}
}

二：定义一个工厂接口BeanFactory，可以通过名字取出对应的UserDaoImpl

package com.haizhu.spring;

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

工厂的具体实现

package com.haizhu.spring;

import java.io.IOException;
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 ClassPathXmlApplicationContext implements BeanFactory{

	// 作为存储所有 bean 的容器
	private Map<String,Object> beans = new HashMap<String,Object>();
	// 构造方法
	public ClassPathXmlApplicationContext(){
		try {
			SAXBuilder sb = new SAXBuilder();
			Document doc = sb.build(this.getClass().getClassLoader().getResourceAsStream("beans.xml"));
			Element root = doc.getRootElement();// 获取根元素
			List<?> list = root.getChildren("bean");
			for(int i=0;i<list.size();i++){
				Element element =(Element)list.get(i);
				String id = element.getAttributeValue("id");
				String clazz = element.getAttributeValue("class");
				System.out.println(id+"："+clazz);
				Object o= Class.forName(clazz).newInstance();
				// 将这个bean放到beans容器中
				beans.put(id, o);;
			}
		}catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (JDOMException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} //构造文档对象
	}
	
	public Object getBean(String name) {
		// 根据名字从beans容器中取出这个bean
		return beans.get(name);
	}

}

三：配置文件 beans.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans>
	<bean id="u" class="com.haizhu.dao.impl.UserDaoImpl"></bean>
</beans>

四：测试

package com.haizhu.service.impl;

import org.junit.Test;

import com.haizhu.model.User;
import com.haizhu.service.UserService;

public class DIDaoUserServiceImplTest {
	@Test
	public void test() {
		UserService service = new DIDaoUserServiceImpl();
		User u = new User();
		service.addUser(u);
	}
}

上面只是自动注入了dao，service还是需要手动实例化，下面我们将sercie也放入容器：

一：service实现

package com.haizhu.service.impl;

import com.haizhu.dao.UserDao;
import com.haizhu.model.User;
import com.haizhu.service.UserService;
// 当使用spring的时候，交给xml配置文件来初始化
public class SpringUserServiceImpl implements UserService {
	private UserDao userDao;
	
	public void addUser(User u) {
		userDao.addUser(u);
	}

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

}

二：工厂实现

package com.haizhu.spring;

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.input.SAXBuilder;

public class ClassPathXmlApplicationContext implements BeanFactory {

	private Map<String, Object> beans = new HashMap<String, Object>();

	// IOC Inverse of Control DI Dependency Injection
	public ClassPathXmlApplicationContext() {
		try {
			SAXBuilder sb = new SAXBuilder();
			Document doc = sb.build(this.getClass().getClassLoader().getResourceAsStream("beans.xml"));// 构造文档对象
			Element root = doc.getRootElement(); // 获取根元素HD
			List<?> list = root.getChildren("bean");// 取名字为disk的所有元素
			for (int i = 0; i < list.size(); i++) {
				Element element = (Element) list.get(i);
				String id = element.getAttributeValue("id");
				String clazz = element.getAttributeValue("class");
				Object o = Class.forName(clazz).newInstance();
				System.out.println(id);
				System.out.println(clazz);
				beans.put(id, o);
				for (Element propertyElement : (List<Element>) element.getChildren("property")) {
					String name = propertyElement.getAttributeValue("name"); // userDAO
					String bean = propertyElement.getAttributeValue("bean"); // u
					Object beanObject = beans.get(bean);// UserDAOImpl instance
					String methodName = "set" + name.substring(0, 1).toUpperCase() + name.substring(1);
					System.out.println("method name = " + methodName);
					Method m = o.getClass().getMethod(methodName,beanObject.getClass().getInterfaces()[0]);
					m.invoke(o, beanObject);
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public Object getBean(String id) {
		return beans.get(id);
	}

}

三：修改beans.xml

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

四：测试

package com.haizhu.service.impl;

import org.junit.Test;

import com.haizhu.model.User;
import com.haizhu.service.UserService;
import com.haizhu.spring.BeanFactory;
import com.haizhu.spring.ClassPathXmlApplicationContext;

public class SpringUserServiceImplTest {
	@Test
	public void test() {
		// 取出容器中的service
		BeanFactory applicationContext = new ClassPathXmlApplicationContext();
		UserService service = (UserService) applicationContext.getBean("service");
		User u = new User();
		service.addUser(u);
	}
}

一般使用ApplicationContext，替换BeanFactory

package com.haizhu.service.impl;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.haizhu.model.User;
import com.haizhu.service.UserService;

public class UserServiceImplTest extends UserServiceImpl {

	@Test
	public void test() {
		ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
		UserService service = (UserService)ctx.getBean("service");
		User u = new User();
		service.addUser(u);
	}
}

可以看出，使用注入的方式，只需要改变配置文件就可以更改dao的实现，这样灵活性大大提高。