IOC(Inverse of control):控制反转;其实就是一个装对象的容器,以前我们在controller中调用service中的方法,都要先new 一个service对象,这样不符合模式设计的六大法则中的依赖倒置原则,为了处理这个问题,可以把各层创建对象的工作让spring来完成,spring创建对象都把它放在ioc中

DI:依赖注入:其实与IOC是一回事,只是从不同的角度来看待问题的

实现IOC/DI的技术有:

          1.setter注入(最常用)

          2.构造方法注入(使用它时,要注意空构造器必须存在)

3.接口注入

          4.Annotation注入

模拟spring ioc

beans.xml配置

<?xml version="1.0" encoding="UTF-8"?>
<beans>
  <!-- ioc 对象的容器 service dao controller 内的所有对象
    1:beans.xml写完
    2:解析beans.xml 生成配置文件中配置的各个对象
        了解新的解析工具
    3:完成对象间的属性注入
    4:初始化容器 完成 UserAction内的调用
  -->
  <bean id="userAction" class="com.cdsxt.action.UserAction" >
    <!-- name:对应action类内属性的值 ref:对应bean元素的id的值-->
    <property name="userDao" ref="userDao" />
  </bean>
  <bean id="userDao" class="com.cdsxt.dao.impl.UserDaoImpl" ></bean>
</beans>

Action:

public class UserAction {
  private UserDao userDao;
  public void add(){
    System.out.println("=======UserDao=======");
    userDao.add();
  }
  public static void main(String[] args) {
    UserAction userAction = (UserAction)IocContainner.get("userAction");
    System.out.println(userAction);
    UserDao userDao =(UserDao)IocContainner.get("userDao");
    System.out.println(userDao);
    userAction.add();
  }
  public UserDao getUserDao() {
    return userDao;
  }
  public void setUserDao(UserDao userDao) {
    this.userDao = userDao;
  }
}

Dao:

public interface UserDao {
  public void add();
}

public class UserDaoImpl implements UserDao{

  @Override
  public void add() {
    System.out.println("======UserDao=======");
  }
}

IOC容器:

/**
* 初始化容器
* @author Administrator
*
*/
public class IocContainner {
  private static final Map<String,Object> iocMap = new HashMap<String,Object>();
  static{
    try {
      initIocMap();
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
  public static void initIocMap() throws Exception{
    //Java and Xml binding
    JAXBContext jc= JAXBContext.newInstance(Beans.class);
    Unmarshaller um =jc.createUnmarshaller();
    Beans bs =(Beans)um.unmarshal(new File("src/beans.xml"));
    for(Bean b:bs.getBeanList()){
      Class c = Class.forName(b.getClassPath());
      iocMap.put(b.getId(), c.newInstance());
      System.out.println("++++++++"+b.getId());
    }
    //完成属性注入
    /*
    * 思路:遍历所有的对象,判断那个对象有属性
    * 找到有属性的, 获取name和ref 的值
    * name有了 就可以弄设定器 反射调用
    */
    for(Bean b:bs.getBeanList()){
      List<Property> proList = b.getProList();
      if(proList!=null&&proList.size()>0){
        for(Property pro:proList){
          Object obj = iocMap.get(b.getId());
          Class clazz = obj.getClass();
          String name = pro.getName();
          String ref = pro.getRef();
          System.out.println(ref);
          Field field =clazz.getDeclaredField(name);
          String setter = "set"+name.substring(0, 1).toUpperCase()+name.substring(1);
          Method setMethod = clazz.getDeclaredMethod(setter,field.getType());
          setMethod.invoke(obj,iocMap.get(ref));
          System.out.println(iocMap.get(ref)+"-----+++-----");
        }
      }
    }

  }
  public static Object get(String key){
    return iocMap.get(key);
  }
}

以下为xmlmodel

@XmlRootElement
public class Beans {
  private List<Bean> beanList;
  @XmlElement(name="bean")
  public List<Bean> getBeanList() {
    return beanList;
  }

  public void setBeanList(List<Bean> beanList) {
    this.beanList = beanList;
  }

}

public class Bean {
  private String id;
  private String classPath;
  private List<Property> proList;
  @XmlAttribute
  public String getId() {
    return id;
  }
  public void setId(String id) {
    this.id = id;
  }
  @XmlAttribute(name="class")
    public String getClassPath() {
    return classPath;
  }
  public void setClassPath(String classPath) {
    this.classPath = classPath;
  }
  @XmlElement(name="property")
  public List<Property> getProList() {
    return proList;
  }
  public void setProList(List<Property> proList) {
    this.proList = proList;
  }
}

public class Property {
  private String name;
  private String ref;
  @XmlAttribute
  public String getName() {
    return name;
  }
  public void setName(String name) {
    this.name = name;
  }
  @XmlAttribute
  public String getRef() {
    return ref;
  }
  public void setRef(String ref) {
    this.ref = ref;
  }
}

spring中的IOC/DI的知识点的更多相关文章

  1. Spring中的IOC\DI\AOP等概念的简单学习

    IoC(Inversion of Control,控制反转).这是spring的核心,贯穿始终, 所谓IoC,对于spring框架来说,就是由spring来负责控制对象的生命周期和对象间的关系.Spr ...

  2. 用IDEA详解Spring中的IoC和DI(挺透彻的,点进来看看吧)

    用IDEA详解Spring中的IoC和DI 一.Spring IoC的基本概念 控制反转(IoC)是一个比较抽象的概念,它主要用来消减计算机程序的耦合问题,是Spring框架的核心.依赖注入(DI)是 ...

  3. 理解Spring中的IoC和DI

    什么是IoC和DI IoC(Inversion of Control 控制反转):是一种面向对象编程中的一种设计原则,用来减低计算机代码之间的耦合度.其基本思想是:借助于"第三方" ...

  4. 详谈 Spring 中的 IOC 和 AOP

    这篇文章主要讲 Spring 中的几个点,Spring 中的 IOC,AOP,下一篇说说 Spring 中的事务操作,注解和 XML 配置. Spring 简介 Spring 是一个开源的轻量级的企业 ...

  5. Spring中的IOC

    在学习spring的时候,最常听到的词应该就是IOC和AOP了,以下,我从我的角度再次理解一下Spring里的IOC和AOP. IOC简单介绍 IoC(InversionofControl):IoC就 ...

  6. Spring中的IOC示例

    Spring中的IOC示例 工程的大概内容是: 一个人在中国时用中国话问候大家,在国外时用英语问候大家. 其中, IHelloMessage是接口,用来定义输出问候信息 public interfac ...

  7. 理解Spring中的IOC和AOP

    我们是在使用Spring框架的过程中,其实就是为了使用IOC,依赖注入和AOP,面向切面编程,这两个是Spring的灵魂. 主要用到的设计模式有工厂模式和代理模式 IOC就是典型的工厂模式,通过ses ...

  8. 浅谈Spring中的IOC容器

    一.IOC.DI基本概念 IoC(Inversion of Control)控制反转指的是把对象的创建,初始化,销毁等工作交给容器来做.由容器控制对象的生命周期(传统方式中是由我们程序员主动创建对象. ...

  9. 十七、Spring框架(IOC/DI)

    一.Spring框架 Spring是一个基于IOC和AOP的结构J2EE系统的框架. 1.IOC反转控制是Spring的基础(Inversion Of Control).也就是说创建对象由以前的程序员 ...

随机推荐

  1. js中的substring

    "ABCDEFG".substring(2,3) 结果为"C"

  2. idea 和eclipse的debug调试快捷键对比

    IntelliJ Idea 常用快捷键列表 Ctrl+Shift + Enter,语句完成“!”,否定完成,输入表达式时按 “!”键Ctrl+E,最近的文件Ctrl+Shift+E,最近更改的文件Sh ...

  3. jenkins2.0以后的版本提供自动部署和远程部署功能?

    metting result comment: 持续集成:dev上使用 持续部署:在dev/uat/prod上使用 1.指定时间自动构建--发布第二天挂了?每次构建需要重新编译?qa和uat使用同一套 ...

  4. MVC Html辅助方法DropDownList的简单使用、连接MYSQL数据库用自定义model类接收

    附上启发链接:https://www.cnblogs.com/CreateMyself/p/5424894.html [HttpGet] public ActionResult Edit(int id ...

  5. redis下操作String

    redis操作string string是redis最基本的类型 最大能存储512MB数据 string类型是二进制安全的,即可以为任何数据,比如数字.图片.序列化对象等 基本命令 设置 设置键值 s ...

  6. CopyOnWriteList-JDK1.8

    CopyOnWrite,一个写时复制的技术来保证并发操作的安全,使用这种技术的前提是读大于写. 读读之间相容, 写写之间互斥, 读写操作相容. 实现方法: 在对底层数据进行写的时候,把底层数据复制一份 ...

  7. SimpleDateFormat线程不安全

    http://www.cnblogs.com/peida/archive/2013/05/31/3070790.html dateUtil替换

  8. JAVA给图片添加水印

    package com.test; import org.junit.Test; import javax.imageio.ImageIO; import java.awt.*; import jav ...

  9. Maven私服仓库类型

    1. 代理仓库(Proxy Repository) 顾名思义是代理第三方仓库的,如: maven-central nuget.org-proxy 版本策略(Version Policy): Relea ...

  10. Maven运行的方式

    1.运行父工程(父工程将各个子模块聚合到一起) 2.直接运行子模块(Web工程)