关键词：
软件151 张鑫栋
一、IOC的意思是控件反转也就是由容器控制程序之间的关系，把控件权交给了外部容器，之前的写法，由程序代码直接操控，而现在控制权由应用代码中转到了外部容器，控制权的转移是所谓反转。DI（Dependency Injection，依赖注入）。IoC的一个重点是在系统运行中，动态的向某个对象提供它所需要的其他对象。这一点是通过DI（Dependency Injection，依赖注入）来实现的。
IOC实现的原理:
定义DAO接口和接口的实现类
package com.dao;
public interface PersonDAO {
public void save();
}
package com.dao.impl;
import com.dao.PersonDAO;
public class PersonDaoImpl implements PersonDAO {
@Override
public void save() {
System.out.println("保存");
}
}
创建一个Junit测试类
package com.test;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.dao.PersonDAO;
import com.myUtil.MyClassPathXmlApplicationContext;
import com.service.PersonService;
public class PersonTest {
@Test
public void instanceSpring1(){
/*
* spring 的实现
*/
//IOC
ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml");
PersonDAO pd = (PersonDAO) ac.getBean("personDAO");
pd.save();
//DI
PersonService ps = (PersonService) ac.getBean("personService");
ps.save();
}
@Test
public void instanceSpring2(){
/**
* 我的实现
*/
MyClassPathXmlApplicationContext mac = new MyClassPathXmlApplicationContext("beans.xml");
PersonDAO mpd = (PersonDAO) mac.getBean("personDAO");
mpd.save();
//DI
PersonService ps = (PersonService) mac.getBean("personService");
ps.save();
}
}
方法instanceSpring1为Spring中的实现用ClassPathXmlApplicationContext类，要实现IOC的原理要定义自己的MyClassPathXmlApplicationContext首先读出beans.xml中的配置信息，通过反射机制实现bean,最后注入所需要的bean。
package com.myUtil;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
public class MyClassPathXmlApplicationContext {
// xml所有的属性
private ArrayList<BeanDefinition> beanDefinitions = new ArrayList<BeanDefinition>();
// xml中所有的bean
private Map<String, Object> sigletons = new HashMap<String, Object>();
public MyClassPathXmlApplicationContext(String file) {
readXml(file);
instanceBeans();
instanceObject();
}
/**
* 注入
*/
private void instanceObject() {
for (BeanDefinition beanDefinition : beanDefinitions) {
//判断有没有注入属性
if (beanDefinition.getProperty() != null) {
Object bean = sigletons.get(beanDefinition.getId());
if (bean != null) {
try {
//得到被注入bean的所有的属性
PropertyDescriptor[] ps = Introspector.getBeanInfo(bean.getClass()).getPropertyDescriptors();
//得到所有的注入bean属性
for(PropertyDefinition propertyDefinition:beanDefinition.getProperty()){
for(PropertyDescriptor propertyDescriptor:ps){
if(propertyDescriptor.getName().equals(propertyDefinition.getName())){
Method setter = propertyDescriptor.getWriteMethod();//获取set方法
if(setter!=null){
setter.setAccessible(true);//得到private权限
//注入属性
setter.invoke(bean, sigletons.get(propertyDefinition.getRef()));
}
break;
}
}
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} }
} }
/**
* 实例所有的bean
*/
private void instanceBeans() {
for (int i = 0; i < beanDefinitions.size(); i++) {
BeanDefinition bd = beanDefinitions.get(i);
try {
try {
if (bd.getClassName() != null
&& !bd.getClassName().equals(""))
sigletons.put(bd.getId(), Class.forName(
bd.getClassName()).newInstance());
} catch (InstantiationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} }
/**
* 读xml
* @param file
*/
private void readXml(String file) {
try {
SAXReader reader = new SAXReader(); // 使用SAX方式解析XML
URL xmlPath = this.getClass().getClassLoader().getResource(file);
Document doc = reader.read(xmlPath);
Element root = doc.getRootElement(); // 取得根节点
List<Element> beans = root.elements();
for (Element element : beans) {
String id = element.attributeValue("id");// id;
String clazz = element.attributeValue("class");
BeanDefinition bd = new BeanDefinition(id, clazz);
// 读取子元素
if (element.hasContent()) {
List<Element> propertys = element.elements();
for (Element property : propertys) {
String name = property.attributeValue("name");
String ref = property.attributeValue("ref");
PropertyDefinition pd = new PropertyDefinition(name,
ref);
bd.getProperty().add(pd);
} }
beanDefinitions.add(bd);
}
} catch (Exception e) {
// TODO: handle exception
}
}
/**
* 通过名字得到bean
* @param str
* @return
*/
public Object getBean(String str) {
return sigletons.get(str);
} }
读取所的bean实体
package com.myUtil;
import java.util.ArrayList;
import java.util.List;
public class BeanDefinition {
private String id;
private String className;
private List<PropertyDefinition> property = new ArrayList<PropertyDefinition>();
public BeanDefinition(String id, String className) {
super();
this.id = id;
this.className = className;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getClassName() {
return className;
}
public void setClassName(String className) {
this.className = className;
}
public List<PropertyDefinition> getProperty() {
return property;
}
public void setProperty(List<PropertyDefinition> property) {
this.property = property;
}
}
注入属性实体
[java] view plain copy
package com.myUtil;
public class PropertyDefinition {
private String name;
private String ref;
public PropertyDefinition(String name, String ref) {
this.name = name;
this.ref = ref;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getRef() {
return ref;
}
public void setRef(String ref) {
this.ref = ref;
}
}
业务接口和实现类
package com.service;
public interface PersonService {
public void save();
}
[java] view plain copy
package com.service.impl;
import com.dao.PersonDAO;
import com.service.PersonService;
public class PersonServiceImpl implements PersonService{
private PersonDAO pdo;
public PersonDAO getPdo() {
return pdo;
}
public void setPdo(PersonDAO pdo) {
this.pdo = pdo;
}
@Override
public void save() {
pdo.save();
}
}
beans.xml配置
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
<bean id="personDAO" class="com.dao.impl.PersonDaoImpl"></bean>
<bean id="personService" class="com.service.impl.PersonServiceImpl">
<property name="pdo" ref="personDAO"></property>
</bean>
</beans>
springioc(di)
软件152刘昊翰一、IOC（DI） 概念IOC（InversionofControl，控制倒转）Ioc意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制。 DI—DependencyInjection，即“依赖注入”：组件之间依赖关系由容器在... 查看详情
springioc（di）
1什么是IOCIOC—InversionofControl，即“控制反转”，不是什么技术，而是一种设计思想。在Java开发中，Ioc意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制。2IOC和DIDI—DependencyInjection，即&ld... 查看详情
springioc和di
(1)什么是IOC(InversionOfControl控制反转)?对象之间的依赖关系应该由容器来建立。 (2)什么是DI(DependencyInjection依赖注入)?容器可以通过调用set方法或者构造器来建立对象之间的依赖关系。 注：IOC是目标，DI是手段。 (3)... 查看详情
关于springioc(di-依赖注入)
...时间回顾了Spring的内容，在此顺带记录一下，本篇主要与springIOC相关，这篇博文适合初学者也适合spring有过开发经验的工程师，前者可用于全面了解SpringIOC的知识点，后者且过目进而查漏补缺，ok~，以下是主要内容： SpringIOC... 查看详情
springioc/di
前言假设项目层次划分包括logic层和dao层，logic层调用dao层完成业务逻辑，dao层一般与数据库交互。定义两个组件，TestLogic和TestDao，分别操作接口ILogic和IDao，这样程序开发时需要考虑怎样管理这两个组件。传统方式这种方式中，... 查看详情
springioc(di)和aop
IOC（InversionofControl，控制倒转）Ioc意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制。DI—DependencyInjection，即“依赖注入”：组件之间依赖关系由容器在运行期决定，形象的说，即由容器动态的将某... 查看详情
spring的学习二（springioc和di,aop简介）
一:SpringIoc,DI,AOP简介IOC控制反转：将原本在程序中手动创建对象的控制权，交由Spring框架来管理 原理：读取标注或者配置文件，看看Shoe依赖的是哪个Source，拿到类名使用反射的API，基于类... 查看详情
springioc（控制反转）及di（依赖注入）
什么是ioc（控制反转） IOC是一种设计思想，用来降低代码与程序之间的耦合程度，把两个直接相关的事物把直接相关的部分交给第三方作为中转从而降低了耦合性，方便后期维护。控制反转也称依赖注入，因为IoC确实不... 查看详情
springioc—基于xml的di(总结)(代码片段)
前言控制反转（IoC，InversionofControl），是一个概念，是一种思想，其实现方式多种多样。当前比较流行的实现方式是依赖注入。应用广泛。Ioc的技术实现：DI（依赖注入）：DependencyInjection... 查看详情
springioc—基于注解的di（总结）(代码片段)
基于注解的DI使用spring提供的注解，完成java对象创建，属性赋值。先总结：1.创建对象的注解@Component：普通java对象@Respository：dao对象，持久层对象，表示对象能访问数据库。@Service：service... 查看详情
对springioc容器di的理解
1.IOC是什么？IOC（控制反转）是一种管理bean的容器，它的本质是对象工厂（接口）。在应用程序中的组件需要获取资源时，传统的方式是组件主动从容器中获取所需的资源，在这种模式下，开发人员需要知道具体容器中资源的获... 查看详情
springioc基于xml的di详细配置全解两万字(代码片段)
详细介绍了SpringIoC基于XML的DI详细配置全解。前面的文章SpringIOC容器的概念以及基于XML的IoC装配中，我们学习了IoC容器的概念以及依赖注入的两种方式，现在我们来看看一些更详细的配置。本文基于Spring5.2.8，案例基... 查看详情
面试常问springioc，不得不会。
广义的IOCIoC(InversionofControl)控制反转，即“不用打电话过来，我们会打给你”。两种实现：依赖查找（DL）和依赖注入（DI）。IOC和DI、DL的关系（这个DL，Avalon和EJB就是使用的这种方式实现的IoC）：DL已经被抛弃，因为他需要用户... 查看详情
关于springioc(di-依赖注入),你需要知道的案例版
自己做的demo：链接:https://pan.baidu.com/s/1GrNT7tL2E2MrWHOw7-jamA提取码:jvbk Bean的延长加载在某些情况下，我们可能希望把bean的创建延迟到使用阶段，以免消耗不必要的内存，Spring也非常自愿地支持了延迟bean的初始化。因此可以... 查看详情
如何理解springioc
...上的一些技术大牛们对Spring框架的IOC的理解以及谈谈我对SpringIoc的理解。一、开涛对Ioc的讲解原文 开涛的博客 1.IoC是什么Ioc—InversionofCo 查看详情
springioc实验
软件151朱实友（1）基于XML的配置元数据的基本结构<?xmlversion="1.0"encoding="UTF-8"?><beansxmlns="http://www.springframework.org/schema/beans" 查看详情
谈谈对springioc的理解
...上的一些技术大牛们对Spring框架的IOC的理解以及谈谈我对SpringIoc的理解。一、对SpringIoc的理解。1.1、IoC是什么Ioc—InversionofControl，即“控制反转 查看详情
一文解析springioc面试中常问的那些核心题！
广义的IOCIoC(InversionofControl)控制反转，即“不用打电话过来，我们会打给你”。两种实现：依赖查找（DL）和依赖注入（DI）。IOC和DI、DL的关系（这个DL，Avalon和EJB就是使用的这种方式实现的IoC）：DL已经被抛弃，因为他需要用户... 查看详情