xml方式简单实现springIOC

1：什么是IOC
IOC是一种思想==控制反转，IOC意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制，在springIOC中,就是由spring来负责控制对象的生命周期和对象间的关系。
2 ：IOC实现思路
SpringIOC实现思路有两种，
一种是通过xml+反射,
第二种是通过注解+扫包+反射。
2.1：通过xml实现，先获取xml文件，读取该xml,根据传入的参数匹配对应的beanId，得到class地址，通过反射创建的对象注入容器（ConcurrentHashMap）
2.2：通过注解实现，先获取扫描的路径范围，判断类上是否加上了注解，把加上注解的类通过反射创建出对象注入到容器中（ConcurrentHashMap）注意，key首字母小写。
通过注解实现IOC====》传送门
自己的一点理解，如有不对请过往大神指出，感激！！！
目录结构:

项目是用maven管理，所使用jar

 <!-- 引入Spring-AOP等相关Jar -->
       <dependency>
           <groupId>org.springframework</groupId>
           <artifactId>spring-core</artifactId>
           <version>3.0.6.RELEASE</version>
       </dependency>
       <dependency>
           <groupId>org.springframework</groupId>
           <artifactId>spring-context</artifactId>
           <version>3.0.6.RELEASE</version>
       </dependency>
       <dependency>
           <groupId>org.springframework</groupId>
           <artifactId>spring-aop</artifactId>
           <version>3.0.6.RELEASE</version>
       </dependency>
       <dependency>
           <groupId>org.springframework</groupId>
           <artifactId>spring-orm</artifactId>
           <version>3.0.6.RELEASE</version>
       </dependency>
       <dependency>
           <groupId>org.aspectj</groupId>
           <artifactId>aspectjrt</artifactId>
           <version>1.6.1</version>
       </dependency>
       <dependency>
           <groupId>aspectj</groupId>
           <artifactId>aspectjweaver</artifactId>
           <version>1.5.3</version>
       </dependency>
       <dependency>
           <groupId>cglib</groupId>
           <artifactId>cglib</artifactId>
           <version>2.1_2</version>
       </dependency>

       <!-- https://mvnrepository.com/artifact/com.mchange/c3p0 -->
       <dependency>
           <groupId>com.mchange</groupId>
           <artifactId>c3p0</artifactId>
           <version>0.9.5.2</version>
       </dependency>
       <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
       <dependency>
           <groupId>mysql</groupId>
           <artifactId>mysql-connector-java</artifactId>
           <version>5.1.37</version>
       </dependency>

       <!-- https://mvnrepository.com/artifact/dom4j/dom4j -->
       <dependency>
           <groupId>dom4j</groupId>
           <artifactId>dom4j</artifactId>
           <version>1.6.1</version>
       </dependency>
       <!-- https://mvnrepository.com/artifact/commons-lang/commons-lang -->
       <dependency>
           <groupId>commons-lang</groupId>
           <artifactId>commons-lang</artifactId>
           <version>2.6</version>
       </dependency>

测试用spring.xml

<beans xmlns="http://www.springframework.org/schema/beans"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
      xmlns:context="http://www.springframework.org/schema/context"
      xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
      xsi:schemaLocation="http://www.springframework.org/schema/beans
   	 http://www.springframework.org/schema/beans/spring-beans.xsd
    	 http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/tx
    	 http://www.springframework.org/schema/tx/spring-tx.xsd">

   <bean id="userService" class="com.wtk.mvcframework.service.impl.UserServiceImpl"></bean>

</beans>

核心类，该类用于创建对象

package com.wtk.mvcframework.xml.spring;


import org.apache.commons.lang.StringUtils;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import java.io.InputStream;
import java.util.List;

public class WTKClassPathXmlApplicationContext {
   //读取xml地址
   private String xmlPath;
   public WTKClassPathXmlApplicationContext(String xmlPath){
       this.xmlPath = xmlPath;
   }
   public Object getBean(String beanId) throws Exception {
       if (StringUtils.isEmpty(beanId)){
           throw new  Exception("beanid不能为空");
       }
       //解析XML
       List<Element> readerXml = readerXml();
       if (readerXml==null||readerXml.isEmpty()){
           throw new  Exception("readerXml不能为空");
       }
       //2使用方法参数beanid查找
       String calssName= findByElementClass(readerXml,beanId);
       if(StringUtils.isEmpty(calssName)){
           throw new  Exception("该bean对象没有配置class地址");
       }
       return newInstance(calssName);
       //使用反射机制初始化
   }

   //使用方法参数beanid查找配置文件中bean节点的id信息是否一致。
   public String findByElementClass(List<Element> readerXml,String beanId){
       for (Element element : readerXml){
           //获取属性信息
           String xmlBeanid = element.attributeValue("id");
           if (StringUtils.isEmpty(xmlBeanid)){
               continue;
           }
           if(beanId.equals(xmlBeanid)){
               String xmlClass = element.attributeValue("class");
               //获取class地址信息，使用反射初始化

               return xmlClass;
           }
       }
       return null;
   }

   //通过反射机制创建对象  初始化
   public Object newInstance(String className) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
       Class<?> classInfo = Class.forName(className);
       return  classInfo.newInstance();
   }

   //解析xml
   public List<Element> readerXml() throws DocumentException {
       //解析xml节点信息
       SAXReader saxReader = new SAXReader();
       Document document = saxReader.read(getResourceAsStream(xmlPath));
       //读取根节点信息，
       Element rootElement = document.getRootElement();
       // 读取子节点 返回泛型集合
       List<Element> elements = rootElement.elements();

       return elements;


   }
   //获取当前上下文路径
   public InputStream getResourceAsStream(String xmlPath){
      InputStream inputStream = this.getClass().getClassLoader().getResourceAsStream(xmlPath);
      return inputStream;
   }
}

package com.wtk.mvcframework.entity;

public class User {

 private Integer id;
 private String userName;

 public Integer getId() {
 	return id;
 }

 public void setId(Integer id) {
 	this.id = id;
 }

 public String getUserName() {
 	return userName;
 }

 public void setUserName(String userName) {
 	this.userName = userName;
 }

}

package com.wtk.mvcframework.service;

//user 服务层
public interface UserService {

  public void add();

  public void del();
}

package com.wtk.mvcframework.service.impl;


//user 服务层

import com.wtk.mvcframework.dao.UserDao;
import com.wtk.mvcframework.service.UserService;

public class UserServiceImpl implements UserService {


  public void add() {
  	System.out.println("xml实现IOC....");
  }
  // 方法执行完毕之后，才会提交事务

  public void del() {
  	// TODO Auto-generated method stub

  }

  public UserServiceImpl(){
      System.out.println("通过反射机制创建对象。。。");
  }
}

测试类

package com.wtk.mvcframework.xml.spring;

import com.wtk.mvcframework.entity.User;
import com.wtk.mvcframework.service.UserService;

public class TestSpring {
    public static void main(String[] args) throws Exception {
        System.out.println("1");
        WTKClassPathXmlApplicationContext app =  new WTKClassPathXmlApplicationContext("spring.xml");
        System.out.println("2");
        UserService bean = (UserService) app.getBean("userService");
        System.out.println("3");
        bean.add();
        System.out.println(bean);
    }

}

效果图