本篇博客主要是使用java代码模拟spring的IOC容器，实现依赖注入；当然只是模拟spring容器中简单的一点实现原理而已，加深一些自己对spring框架的底层原理的理解；
使用的技术：dom4j xml解析技术 工厂模式 java反射技术
关于工厂模式：主要作用是对象的的解耦，通过容器中的方法获取对象，而不是在需要的类中去 new 对象；针对接口编程，不需要关注具体的实现方式；
如：一个对象：Car 依赖的对象有 Engine Wheel Door
不用工厂模式此时如果需要创建Car,则需要在Car 对象中 创建 Engine Wheel Door 三个对象，这样的弊端是在代码中耦合了太多其他的对象：此时如果Engine 对象和 Wheel对象改变了属性，那么调用者在调用时也需要做修改；如果依赖的对象很多的话，对于调用者是一件很麻烦的事情；
public class Car implements ICar{
private Engine engine;
private Wheel wheel;
private Door door;
public Car(Engine engine, Wheel wheel, Door door) {
super();
this.engine = engine;
this.wheel = wheel;
this.door = door;
}
public static void main(String[] args) {
Engine engine=new Engine();
Wheel wheel=new Wheel();
Door door=new Door();
Car car=new Car(new Engine(), new Wheel(), new Door());
}
}
此时就引入了工厂模式：
Car的工厂类如下所示：
public class Factory implements Ifactory{
@Override
public Car createCar() {
Engine engine=new Engine();
Wheel wheel=new Wheel();
Door door=new Door();
return new Car(engine, wheel, door);
}
}
调用者需要Car的对象的时候只需要调用工厂类的 createCar() 方法即可：这是就算有依赖的类更改了属性或者方法，对于调用方而言可以不做任何更改；
public static void main(String[] args) {
Factory f=new Factory();
ICar car=f.createCar();
}
当然，这样并不完美：试想一个场景：Engine 有 大众的 丰田的 Wheel 也有大众和丰田的 Door 也分为大众和丰田的，现在调用方需要的是大众的Car
那么在工厂类中就需要更改为大众类，如果有上千个品牌，那么工厂类的维护也是一件很痛苦的事，这是引入统一接口，接口的引用指向具体的实现类，具体的实现由调用方指定，这样就减少了代码的耦合；
但是，基于接口的工厂模式还是不完美，这种方式：我需要在工厂类中 new 对象 并且需要通过构造器或者是set方法把需要注入的对象注入进来，此时，试想一个场景：如果你有100个对象需要被其他对象注入，那么这个工厂类则需要维护100 个方法来返回对象；工厂类的维护一件很复杂的任务；
这是可以想到用配置文件来管理这些类的名称，然后在工厂类中通过在配置文件中的类的名称实现类的创建和注入；这样需要增删改工厂类的创建对象则可以通过更改配置文件来实现，这样就方便了很多；
这就是一种比较完美的实现方式：IOC模式；
下面通过java代码来实现ioc模式：
mydoc.xml的配置如下：
<beans>
<bean id="userController" class="bz.beppe.controller.UserController">
<property name="userService" ref="userService"></property>
</bean> <bean id="userService" class="bz.beppe.serviceImpl.UserServiceImpl"></bean> </beans>
userService的接口代码：
public interface UserService {
public void getUser();
}
实现代码如下：
public class UserServiceImpl implements UserService{
@Override
public void getUser() {
System.out.println("i am beppe!!");
}
}
UserController的代码如下
public class UserController {
private UserService userService;
public void setUserService(UserService userService) {
this.userService = userService;
}
public void getUser(){
userService.getUser();
// System.out.println(user.getName());
}
public void say(){
System.out.println("say something");
}
}
下面模拟spring 的Ioc来实现最基本的依赖注入：
工厂接口如下：BeanFactory 这个接口不做任何的实现，只有一个getBean(String id) 的方法 具体的具体的工厂类需要实现这个接口，并且覆盖相应的方法：
public interface BeanFactory {
public Object getBean(String id);
}
以下为BeanFatory的具体实现类；IOC容器的关键，实现依赖注入；这里用一个Map容器来存储对象，并且可以通过key来获取对象
public class ClassPathXmlApplicationContext implements BeanFactory{
private Map<String,Object> beans=new HashMap<String,Object>(); //创建容器，用来存储需要被IOC容器管理的对象
// 构造该容器时就初始化beans的值
public ClassPathXmlApplicationContext(String filePath){ //在创建工厂对象的时候就将需要被管理的对存放到map中
Document doc = getDocument(filePath); //解析 xml 文件
Element rootElement = doc.getRootElement();
List<Element> beanElements = rootElement.elements();
for (Element beanElement : beanElements) { //获取bean 标签 并且实例化对象
String idStr = beanElement.attributeValue("id");
String classStr=beanElement.attributeValue("class");
System.out.println(idStr+":"+classStr);
try {
Class<?> clazz = Class.forName(classStr);
Object obj = clazz.newInstance();
beans.put(idStr, obj);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
for (Element beanElement1 : beanElements) {
List<Element> propertyElements = beanElement1.elements();
for (Element propertyElement : propertyElements) { //获取<bean> 标签下的所有property标签 并且 通过调用set方法来进行注入：关键的方法
Element parentElement=propertyElement.getParent();
Object contoller=getBean(parentElement.attributeValue("id"));
String nameStr = propertyElement.attributeValue("name");
String refStr=propertyElement.attributeValue("ref");
Object service = getBean(refStr);
String methodStr="set"+nameStr.substring(0, 1).toUpperCase()+nameStr.substring(1);
try {
Method method=contoller.getClass().getMethod(methodStr, service.getClass().getInterfaces()[0]);
method.invoke(contoller, service);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
@Override
public Object getBean(String id) {
// TODO Auto-generated method stub
return beans.get(id);
}
private Document getDocument(String filePath){
try {
// URL url=new URL(filePath);
SAXReader redaer=new SAXReader();
Document doc = redaer.read(filePath);
return doc;
} catch (DocumentException e) {
// TODO Auto-generated catch block
System.out.println("路径不存在");
e.printStackTrace();
}
return null;
}
}
这就是一个简单的spring IOC容器，当然，功能远没有spring IOC那么强大，基本的实现原理是一致的；