Spring之IOC详解_Java教程

学过Spring的小伙伴对于IOC一定不陌生，IOC：控制反转（Inversion of Control，英文缩写为IoC）是一个重要的面向对象编程的法则来削减计算机程序的耦合问题，也是轻量级的Spring框架的核心。控制反转一般分为两种类型，依赖注入（Dependency Injection，简称DI）和依赖查找（Dependency Lookup）。依赖注入应用比较广泛。本篇我们通过一个实例和大家简单分析一下Spring中IOC的原理，以便我们可以更好的理解Spring。

简单描述一下我们的场景，添加新用户到数据库，这里我们采用分层的方式，进行功能的实现，我们知道，开发程序一定要注意程序的可移植性，所以这里简单为大家介绍一下面向接口编程，面向接口编程就是面向抽象编程、面向规范编程，它带来的最大的好处便是解耦、增强扩展性、屏蔽变化。

Spring之IOC详解

好了下面我们开始我的业务实现，首先我们需要创建一个Model--UserDO.java

									public class UserDO {

									 private String name;

									 private String password;

									 public String getName() {

									  return name;

									 }

									 public void setName(String name) {

									  this.name = name;

									 }

									 public String getPassword() {

									  return password;

									 }

									 public void setPassword(String password) {

									  this.password = password;

									 }

									}

有了我们的用户对象，下面我们开始创建Selvect类，Selvect我们知道，使用了接收用户请求的对象，这里因为我们只是为了方便大家理解，所以我们在Selvect中模拟收到用户请求后进行相关业务逻辑处理：

									public class UserSelvect {

									 public static void main(String[] args) {

									  UserDO userDO = new UserDO();

									  BeanFactory beanFactory = new ClassPathXmlApplicationContext();//创建我们的Bean工厂

									  UserService userService = (UserService) beanFactory.getBean("userService");//通过类名来获得类对象

									  userService.add(userDO);//完成业务逻辑

									 }

									}

一般我们的业务逻辑会放在Service层进行操作，所以我能先来看一下我们的Service对象：

									public class UserService {

									 private UserDao userDao;//实例DAO对象

									 public UserDao getUserDao() {

									  return userDao;

									 }

									 //用于Bean工厂中进行DAO动态绑定

									 public void setUserDao(UserDao userDao) {

									  this.userDao = userDao;

									 }

									 //用于Selvect对象调用，进行业务逻辑处理

									 public void add(User u){

									  userDao.add(u);

									 }

									}

下面就是我们的DAO层的实现了，这里就要说明了，为了最大化提高程序的可移植性，接下来将采用接口编程的实现进行设计：

									/**

									 * DAO类只有方法定义

									 * 从而减低程序直接的耦合

									 */

									public interface UserDao {

									 public void add(User u);

									}

既然是面向接口编程，就一定需要实现接口的类：

									public class UserDaoImpl implements UserDao{

									 public void add(User u){

									  System.out.println("保存一个学生对象");

									 }

									}

好了到这里我们的基本框架已经完成，接下来就要开始重点的内容了，首先我们需要先了解一些关于xml解析的知识，在之前的博客中已经为大家介绍了过一种方式：Jdom读取XML文件，不了解的小伙伴可以先移步简单查看一下，这样接下来的内容，你才不至于感到吃力。下面我们进行我们的这个Demo的设计，首先在src目录下添加一个Spring.xml文件：

									<?xml version="1.0" encoding="UTF-8"?>

									<beans>

									 <bean id="userDao" class="com.manyiaby.daoimpl.UserDaoImpl"></bean>

									 <bean id="userService" class="com.manyiaby.service.UserService">

									  <property name="userDao" bean="userDao"></property>

									 </bean>

									</beans>

下面我们定义一个Bean工程对象，用来读取我们的Spring.xml文件，从而完成对象实例的创建，一便接下来的业务操作：

									public interface BeanFactory {

									 public Object getBean(String className);

									}

大家是不是发现我们的Bean工场也是采用接口编程的思想，接下来看一下我们的工场实现类：

									public class ClassPathXmlApplicationContext implements BeanFactory{

									 private Map<String, Object> beanMap = new HashMap<String, Object>();//用来存配置文件中的类对象

									 public ClassPathXmlApplicationContext(){

									  try {

									   SAXBuilder saxBulder = new SAXBuilder();

									   Document doc = saxBulder.build(ClassPathXmlApplicationContext.class

									     .getClassLoader().getResourceAsStream("spring.xml"));

									   Element root = doc.getRootElement();//获取根元素

									   List<Element> list = root.getChildren("bean");

									   for (Element element : list) {

									    String id = element.getAttributeValue("id");//得到beanId

									    String className = element.getAttributeValue("class");//得到Bean的类名地址

									    System.out.println(className);

									    Object object = Class.forName(className).newInstance();

									    beanMap.put(id, object);

									    if (null != element.getChild("property")) {

									     Element property = element.getChild("property");

									     String name = property.getAttributeValue("name");

									     String beanId = property.getAttributeValue("bean");

									     Object beanObject = beanMap.get(beanId);//UserDaoImpl

									     String methodName = "set" + name.substring(0, 1).toUpperCase() + name.substring(1);//setUserDao

									     System.out.println(methodName);

									     Method m = object.getClass().getMethod(methodName, beanObject.getClass().getInterfaces()[0]);//UserService的SetUserDao()方法，接收的参数为UserDao接口类

									     m.invoke(object, beanObject);//调用UserService的SetUserDao()方法，传入UserDaoImpl

									    }

									   }

									  } catch (Exception e) {

									   System.out.println("" + e);

									  }

									 }

									 //用于类调用

									 @Override

									 public Object getBean(String className) {

									  return beanMap.get(className);

									 }

									}

简单为大家介绍一下，我们通过beanMap将我们在Spring中配置的对象，通过反射机制拿到，然后放置于beanMap对象中，通过getBean方法，共外部类调用。

上面简单模拟了一下Spring中IOC的一些内容，下面咱们一起来看一下，如何通过Spring完成上面的操作，首先我们需要下载spring.jar，有了这个jar还不够，spring还依赖commons-logging.jar，好了将这两个jar包导入到我们的工程中，然后我们就来看一下如何实现使用：

									public class UserSelvect {

									 public void main() {

									  UserDO userDO = new UserDO();

									  BeanFactory beanFactory = new ClassPathXmlApplicationContext("spring.xml");

									  UserService userService = (UserService) beanFactory.getBean("userService");

									  //ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");

									  //UserService userService = (UserService) context.getBean("userService");

									  userService.add(userDO);

									 }

									}