spring的核心是IOC，控制反转，也叫DI依赖注入，意思就是以前类的实例化由自己控制，什么时候需要什么时候就new一个，现在改了，new的动作交由spring来管理，spring使用BeanFactory来实例化、配置和管理对象，但是它只是一个接口，里面有一个getBean()方法。我们一般都不直接用BeanFactory，而是用它的实现类ApplicationContext，这个类会自动解析我们配置的applicationContext.xml，然后根据我们配置的bean来new对象，将new好的对象放进一个Map中，键就是我们bean的id,值就是new的对象。
原理听起来比较清晰，下面就模拟一个具体实现。
整个工程的结构图如下所示：
pom.xml添加解析xml的依赖，用最简单的即可。
<dependency>
<groupId>org.jdom</groupId>
<artifactId>jdom</artifactId>
<version>2.0.2</version>
</dependency>
定义一个model，User.java
public class User {
private int id;
private String name;
//get set省略
}
定义接口UserDao.java
public interface UserDao {
/**
* 新增用户
* @param user
*/
public void add(User user);
}
定义UserDao的实现类UserDaoImpl.java
public class UserDaoImpl implements UserDao {
@Override
public void add(User user) {
System.out.println("新增用户成功");
}
}
定义接口UserService.java
public interface UserService {
/**
* 新增用户
* @param user
*/
public void add(User user);
}
定义UserService接口的实现类UserServiceImple.java
public class UserServiceImpl implements UserService {
private UserDao userDao;
public UserDao getUserDao() {
return userDao;
}
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
@Override
public void add(User user) {
userDao.add(user);
System.out.println("Service执行新增用户。。。");
}
}
这里面定义Userdao，并加入set方法。这里是模拟spring，主要模拟spring中的IOC功能，所以在此我们一样要在service层中定义dao的实例，当然不用new出来，我们就通过spring的IOC把这里的dao层注入进来。不要忘了对dao提供set get方法，因为IOC的底层其实就是利用反射机制实现的，他把dao注入进来，其实底层就是通过反射set进来的。
核心配置文件Beans.xml
<beans>
<bean id="userDao" class="com.critc.dao.UserDaoImpl"/>
<bean id="userService" class="com.critc.service.UserServiceImpl">
<property name="userDao" bean="userDao"/>
</bean>
</beans>
Bean工厂接口BeanFactory.java
public interface BeanFactory {
public Object getBean(String id);
}
里面就一个方法，就是根据id来获取Bean
ClassPathXmlApplicationContext 来实现BeanFactory
public class ClassPathXmlApplicationContext implements BeanFactory {
private Map<String, Object> beans = new HashMap<String, Object>();
public ClassPathXmlApplicationContext() throws Exception, Exception {
SAXBuilder sb = new SAXBuilder();
Document doc = sb.build(this.getClass().getClassLoader()
.getResourceAsStream("beans.xml")); // 构造文档对象
Element root = doc.getRootElement(); // 获取根元素HD
List list = root.getChildren("bean");// 取名字为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");
Object o = Class.forName(clazz).newInstance();
System.out.print("bean id is " + id);
System.out.println(", clazz is " + clazz);
beans.put(id, o);
// 遍历property
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
// 构造setter方法
String methodName = "set" + name.substring(0, 1).toUpperCase() + name.substring(1);
System.out.println("setter method name = " + methodName);
Method m = o.getClass().getMethod(methodName, beanObject.getClass().getInterfaces()[0]);
m.invoke(o, beanObject);
}
}
}
@Override
public Object getBean(String id) {
return beans.get(id);
}
}
定义模拟的ClassPathXmlApplicationContext类，通过他，在我们new出他的对象的时候，他来加载配置文件，然后把我们的dao操作注入到我们的service层，在spring中，ClassPathXmlApplicationContext类实现了BeanFactory接口，在此我们也定义一个BeanFactory接口，其实这个接口没什么具体的作用，我们就是为了来模拟spring。
这一段代码是核心，解释一下：
首先我们定义了一个容器Map<String, Object> beans，这个容器的作用就是用来装我们从配置文件里解析来的一个个bean，为什么要用map类型，很简单就能想到，整个工程中的bean id一定要唯一，不能冲突，我们配置文件中每一个bean都有一个id来作为自己的唯一身份。我们把这个id存到map的key里面，然后value就装我们的具体bean对象。
说完这个容器之后，下面我们在来看一下ClassPathXmlApplicationContext的构造方法，这个构造方法是我们spring管理容器的核心，这个构造方法的前半部分是利用的jdom解析方式，把xml里面的bean一个个的解析出来，然后把解析出来的bean在放到我们bean容器里。后半部分主要是在对配置文件进行解析出bean的同时去查看一下这个bean中有没有需要注射bean的，如果有的话，他就去通过这些里面的property属性获取他要注射的bean名字，然后构造出set方法，然后通过反射，调用注入bean的set方法，这样我们所需要的bean就被注入进来了。
最后我们就来看一下实现接口的getBean放了，其实这个方法很简单，就是根据提供的bean的id，从bean容器内把对应的bean取出来。
我们所需的东西都定义好了，下面我们据来测试一下，看看模仿的spring到底能不能自动把我们所需要的dao层给我们注入进来。
Test.java测试IOC
public class Test {
public static void main(String[] args)throws Exception {
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext();
User user = new User();
UserService userService = (UserService) context.getBean("userService");
userService.add(user);
}
}
打印出
整个的原理就是这些，不过Spring的BeangongFactory实现要比这复杂的多，还要涉及注解、多种注入方式等等，不过原理就是这些。
