什么是IOC(DI),有什么好处(java project 的spring IOC模拟)

原创 2011年01月07日 23:03:00

IOCInversion Of Control,控制反转):一个类的某个属性需要使用时,需要有本类自己初始化。而在spring类的某些属性不用自己初始化而交给了spring来管理。这样的转换就是IOC思想。SpringIOC思想是,springIOC容器在初始化的时候就根据配置对相应的对象进行初始化,并放在容器中。同时根据配置对相应类的属性进行初始化。也就是DIDependency Injection依赖注入),至此类的初始化不需要类本身负责初始化而交给了spring容器。

IOC的好处是:降低耦合性:某个类的一个属性,以前是该类自己控制,而引人Spring后,这个类的属性由Spring控制。

Spring IOC的模拟所做的事情是:在xml文件配置好相应的bean,设置注入关系。在解析xml时候对bean进行初始化同时对相应属性进行注入。

//bean工厂接口

BeanFactory.java:

package com.xie.spring;

 

public interface BeanFactory {

    public Object getBean(String name);

}

//bean工厂的实现

ClassPathXmlApplicationContext.java

 

package com.xie.spring;

 

import java.io.IOException;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

 

import org.jdom.Document;

import org.jdom.Element;

import org.jdom.JDOMException;

import org.jdom.input.SAXBuilder;

 

public class ClassPathXmlApplicationContext implements BeanFactory{

        

         private Map<String,Object> beans=new HashMap<String, Object>();

        

        

 

         public ClassPathXmlApplicationContext() throws JDOMException, IOException, InstantiationException, IllegalAccessException, ClassNotFoundException, SecurityException, NoSuchMethodException, IllegalArgumentException, InvocationTargetException {

                   SAXBuilder sb=new SAXBuilder();

                   //Document doc=sb.build("src/beans.xml");

                   Document doc=sb.build(this.getClass().getClassLoader().getResourceAsStream("beans.xml"));

                   Element root=doc.getRootElement();

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

                   for (int i = 0; i <lists.size(); i++) {

                            Element ele=lists.get(i);

                            String id=ele.getAttributeValue("id");

                            String clazz=ele.getAttributeValue("class");

                            System.out.println(id+":"+clazz);

                            Object o=Class.forName(clazz).newInstance();

                            beans.put(id, o);

                            for (Element e:(List<Element>)ele.getChildren("property")) {

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

                                String bean=e.getAttributeValue("bean");

                                     Object beanObject=beans.get(bean);

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

                                     System.out.println("methodName=:"+methodName);

                                     Method m=o.getClass().getMethod(methodName, beanObject.getClass().getInterfaces()[0]);

                                m.invoke(o, beanObject);

                            }

                   }

 

                  

                  

         }

         @Override

         public Object getBean(String name) {

           return beans.get(name);

         }

        

}

//存储对象的实体类

User.java

package com.xie.spring.modal;

 

public class User {

    private String userName;

    private String passWord;

    public String getUserName() {

       return userName;

    }

    public void setUserName(String userName) {

       this.userName = userName;

    }

    public String getPassWord() {

       return passWord;

    }

    public void setPassWord(String passWord) {

       this.passWord = passWord;

    }

      

}

//dao抽象层

UserDAO.java

package com.xie.spring.dao;

 

import com.xie.spring.modal.User;

 

public interface UserDAO {

     public void save(User u);

}

package com.xie.spring.dao;

 

import com.xie.spring.modal.User;

//dao实现层

UserDAOImpl.java

public class UserDAOImpl implements UserDAO {

 

    @Override

    public void save(User u) {

       System.out.println("A user saved !");

    }

 

}

//service接口层

UserService.java

package com.xie.spring.service;

 

import com.xie.spring.modal.User;

 

public interface UserService {

       public void add(User u);

}

//service实现层

UserServiceImpl.java

package com.xie.spring.service;

 

import com.xie.spring.dao.UserDAOImpl;

import com.xie.spring.dao.UserDAO;

import com.xie.spring.modal.User;

 

public class UserServiceImpl implements UserService {

 

   private UserDAO userDao;

  

   public UserDAO getUserDao() {

            return userDao;

     }

 

   public void setUserDao(UserDAO userDao) {

            this.userDao = userDao;

     }

 

    public void add(User u) {

        this.userDao.save(u);

    }

}

//实现类

UserServiceTest.java

package com.xie.spring.service;

 

import static org.junit.Assert.*;

 

import java.io.IOException;

import java.lang.reflect.InvocationTargetException;

 

import org.jdom.JDOMException;

import org.junit.AfterClass;

import org.junit.BeforeClass;

import org.junit.Test;

 

import com.xie.spring.BeanFactory;

import com.xie.spring.ClassPathXmlApplicationContext;

import com.xie.spring.dao.UserDAOImpl;

import com.xie.spring.modal.User;

 

public class UserServiceTest {

 

         @BeforeClass

         public static void setUpBeforeClass() throws Exception {

         }

 

         @AfterClass

         public static void tearDownAfterClass() throws Exception {

         }

 

         @Test

         public void testAdd() throws JDOMException, IOException, InstantiationException, IllegalAccessException, ClassNotFoundException, SecurityException, IllegalArgumentException, NoSuchMethodException, InvocationTargetException {

                   //fail("Not yet implemented");

                   BeanFactory bf=new ClassPathXmlApplicationContext();

                   //UserService us=new UserService();

        UserServiceImpl us=(UserServiceImpl) bf.getBean("us");

                   //UserDAO userDAO=(UserDAO) bf.getBean("u");

                   //us.setUserDao(userDAO);

                   User u=new User();

                   us.add(u);

         }

}

版权声明:本文为博主原创文章,未经博主允许不得转载。

什么是Spring,IOC是什么?DI是什么?

Spring 学习笔记 已更新今天 1.什么是Spring(面试题)(惠普的两个哥们做的spring) Spring是一个容器,可以接管各...
  • sinat_30071601
  • sinat_30071601
  • 2017年04月16日 09:19
  • 1350

Spring IoC有什么好处呢?

比如这个例子:B{ A a=new Aimpl(); //其他代码 } B{ A a; //其他代码 public void setA(A a) { t...
  • ccssddnnbbookkee
  • ccssddnnbbookkee
  • 2015年05月28日 11:20
  • 2087

如何理解IOC 依赖注入的思想(目前见过最好的对DI的描述)

1 IoC理论的背景 我们都知道,在采用面向对象方法设计的软件系统中,它的底层实现都是由N个对象组成的,所有的对象通过彼此的合作,最终实现系统的业务逻辑。 图1:软件系统中耦合的对象 如果我们打开...
  • xz0125pr
  • xz0125pr
  • 2015年10月14日 19:27
  • 2803

Java面试-Spring IOC(控制反转)和DI(依赖注入)

IOCIoc(Inversion of Control)翻译成中文就是“控制反转”,一个比较晦涩的词语。如果要真正理解这个词语,必须要用过Spring框架才行,因为Spring开启了一种新的编程方式。...
  • u010902721
  • u010902721
  • 2016年10月04日 23:18
  • 1409

Spring核心思想,IoC与DI详解(如果还不明白,放弃java吧)

1.IoC是什么? IoC(Inversion of Control)控制反转,IoC是一种新的Java编程模式,目前很多轻量级容器都在广泛使用的模式。 2.IoC解决了什么问题? 在...
  • Baple
  • Baple
  • 2016年12月15日 11:19
  • 2788

浅谈spring的Ioc和DI

很久没回来更博了,前阵子琐事多人又比较烦躁,就没过来.今天又空就回来写写的东西,今天打算浅淡一下spring核心技术:(控制反转)IOC和(依赖反转)DI.以个人的经历来看,只要你去面试并且你使用过s...
  • JY_He
  • JY_He
  • 2016年06月30日 11:33
  • 1087

Spring4的IoC和DI的区别

IoC(Inversion of Control): 控制反转(不是技术,而是思想)其思想是反转资源获取的方向。...
  • suzunshou
  • suzunshou
  • 2015年07月30日 14:49
  • 2124

sping IoC设计模式好处与劣势

Spring IOC 好处和劣势                分类:            技术文档2012-03-26 15:154225人阅读评论(0)收藏举报 iocsprin...
  • u013305082
  • u013305082
  • 2014年09月30日 13:59
  • 912

Spring的IoC DI和AOP理解

spring 的优点? 1.降低了组件之间的耦合性 ,实现了软件各层之间的解耦  2.可以使用容易提供的众多服务,如事务管理,消息服务等  3.容器提供单例模式支持  4.容器提供了AOP技术...
  • caomiao2006
  • caomiao2006
  • 2014年02月24日 16:07
  • 5526

对spring中IOC的理解和使用spring的好处

依赖注入(Dependency Injection)和控制反转(Inversion of Control)是同一个概念。具体含义是:当某个角色(可能是一个Java实例,调用者)需要另一个角色(另一个J...
  • ccssddnnbbookkee
  • ccssddnnbbookkee
  • 2015年05月28日 12:47
  • 1182
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:什么是IOC(DI),有什么好处(java project 的spring IOC模拟)
举报原因:
原因补充:

(最多只允许输入30个字)