要想实现IOC控制反转，从中获取想要的对象，需要有以下条件：

1. 想要获取对象的类或者接口和接口的实现类
2. 创建对象的Spring容器
3. 用来获取容器中指定对象的类的对象
4. 用来使用从容器中获的对象的类。

解释如下：
第一，如，我们目的是想获取出类ClassA的classa，而ClassA是InterfaceA接口的实现类；
第二，那我们就需要从容器中获取，容器就是Spring配置文件xxx.xml文件，xxx.xml文件自定义是applicationContext.xml文件，也可以自定义名字，但一定得是文件；在xml文件容器中，我们需要根据规则写配置创建classa对象的代码；
第三，然后我们要加载该xml文件，用来加载Spring容器文件的类的接口是ApplicationContext接口，它有两个子实现类，分别是FileSystemXmlApplicationContext和ClassPathXmlApplicationContext，这两个类都可以用来加载xxx.xml文件，该文件被加载后就会创建出classa对象放在容器中等待被获；而获取方式就是通过刚刚加载xml后FileSystemXmlApplicationContext对象或lassPathXmlApplicationContext对象调用getBean()方法获取classa对象。
第四，知道如何获取classa对象后，我我们可以在其他类中获取并使用。

下面，我们用代码实现一下SpringIOC反转控制，我们现在的目的是利用IOC的方式获取类ClassA的对象classa，并使用classa对象。（ClassA是InterfaceA接口的实现类）

用eclipse创建maven工程（需要在eclipse导入maven插件，eclipse中也有自带maven插件），工程名为testspringIOCDI，利用maven中的pom.xml文件导入Spring框架所需要的jar包。在pom.xml文件导包(spring、jdk)：

     <!-- 建立依赖 -->
   <dependencies>
       <!-- 导入spring核心jar -->
       <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.1.6.RELEASE</version>
       </dependency>
   </dependencies>
   
  <!-- 配置1.8jdk的环境 -->
  <build>
    <plugins>
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-compiler-plugin</artifactId>
         <configuration>
           <soure>1.8</soure>
           <target>1.8</target>
               <!--设置字符集 -->
           <ceEncoding>UTF-8</ceEncoding>
         </configuration>
       </plugin>
     </plugins>
  </build>

在容器文件/src/main/resources目录下建立SpringIOC.xml文件

在SpringIOC.xml中引入dtd规则（dtd规则任何java版本都适用，高版本java一般需要schema规则引入）。

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN"
			"https://www.springframework.org/dtd/spring-beans-2.0.dtd">
   <beans>

  </beans>

SpringIOC.xml中内容解释：

//InterfaceA接口
package testspringIOCDI.ioc;
public interface InterfaceA {
   public String getInfo();
	 public void method();
}

//创建InterfaceA的实现类ClassA
package testspringIOCDI.ioc;
public class ClassA implements InterfaceA {
	public ClassA(){}
	public String getInfo() {
		// TODO Auto-generated method stub
		return "企业管理系统模块：实现公告发布、修改、删除等操作";
	}
	 public void method(){
		 System.out.println("I'm classA");		 
	 }
}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN"
			"https://www.springframework.org/dtd/spring-beans-2.0.dtd">
<beans>
 <description>SpringIOC</description>
  <bean id="classa" class="testspringIOCDI.ioc.ClassA"></bean>
 <!--  id 唯一标识，class 提供类，必须包含无参构造，相当于 ClassA classa=new ClassA(); -->
</beans>

一个bean标签就是创建一个对象。

创建ClassA类的测试类IOCTest，用来测试获取并使用classa对象。
IOCTes类：

package testspringIOCDI.ioc;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;

/**
 * @author CenterLogo
 *create date :2019年4月25日 下午5:42:28
 */
@SuppressWarnings("unused")
public class IOCTest {
	/**
	 * Test method for {@link testspringIOCDI.ioc.ClassA#getInfo()}.
	 */
	@Test
	public void testGetInfo() {
	//通过（加载）xml容器获取上下文实例//通过规则指定xml文件
		ApplicationContext context=new FileSystemXmlApplicationContext("/src/main/resources/SpringIOC.xml");
		
		//方式一：根据xml中配置的ID获取的对象（ID唯一），返回Object需要强转类型
		InterfaceA ia=(InterfaceA) context.getBean("classa");
		System.out.println("方式一"+ia.getInfo());
		
	//方式二：根据ID，指定接口类型的类型获取对象（不需要强转类型）
		InterfaceA ia2=context.getBean("classa",InterfaceA.class);
		System.out.println("方式二："+ia2.getInfo());
		
	//方式三：根据接口类型获取对象（xml配置只有一个实现类的情况下）
		InterfaceA ia3=context.getBean(InterfaceA.class);
		System.out.println("方式三："+ia3.getInfo());
		context=null;//释放处理
	}
}

测试结果为：

方式一企业管理系统模块：实现公告发布、修改、删除等操作
方式二：企业管理系统模块：实现公告发布、修改、删除等操作
方式三：企业管理系统模块：实现公告发布、修改、删除等操作

是不是感觉使用IOC获取对象很很麻烦，还不如new简单？其实，你有没有发现，在这个案例里，在测试类中获取到classa对象只能看interface接口，而看不到ClassA类，这就体现了IOC的一个特点之一，即安全性强！，而且，降低了耦合，使配置和代码形成了分离。