Spring---IoC(控制反转)

现在很多白领上班，有一定的积蓄都会选择买车，比如W女士买了一辆奔驰，它可以作为W女士上班的工具，那如果W女士为了节能环保，需要更换出行工具，换成了自行车上班。传统的面向对象思想如下:

这种方式提高了代码的耦合度，十分不利于重构和维护

当有了IoC/DI的容器后，在客户端类中不再主动去创建这些对象了

 

下面用个例子来证明IoC的优点

 

一、编程准备

如果不会导入的包的可以看下我的spring专栏第一篇有讲解，Junit5是eclipse自带的

传送门:spring环境配置

二、贴代码

Car.java

package pojo;

public class Car {
	private double price;	//价格
	private String name;	//名字
	private String address;	//购买地址
	public double getPrice() {
		return price;
	}
	public void setPrice(double price) {
		this.price = price;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getAddress() {
		return address;
	}
	public void setAddress(String address) {
		this.address = address;
	}
	
}

Lady.java

package pojo;

public class Lady {
	String name="W女士";
	private Car car;	//关联Car对象

	public Car getCar() {
		return car;
	}

	public void setCar(Car car) {
		this.car = car;
	}
	
	public String BuyCar() {
		String buyCar= this.name+"在" + car.getAddress() +"买了一辆"+car.getName()+"花了"+car.getPrice()+"万元。"; 
        return  buyCar; 
	}
}

TestCar.java

package test;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import pojo.Car;
import pojo.Lady;
public class TestCar {
	 @Test
	    public void test(){
	        ApplicationContext context = new ClassPathXmlApplicationContext(new String[]{"applicationContext.xml"});

	        Car car = (Car) context.getBean("car");
	        System.out.println("名字："+car.getName());	//获取名字
	        System.out.println("价格："+car.getPrice());	//获取价格
	        System.out.println("地址："+car.getAddress());	//获取地址
	        
            Lady lady = ( Lady) context.getBean("buyCar");
	        System.out.println(lady.BuyCar());
	       
	    }
	}

applicationContext.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.xsd">

  
    <!-- car的bean -->
     <bean name="car" class="pojo.Car">
        <property name="name" value="奔驰"/>
        <property name="price" value="66.0"/>
        <property name="address" value="西安"/>
    </bean>
    
	<!--         buyCar的bean -->
    <bean name="buyCar" class="pojo.Lady">
	<!--    	    注入上面配置的id为car的Car对象 -->
        <property name="car" ref="car" />
    </bean>
</beans>

我们来看下运行结果：run as Junit test

那我们改变下applicationContext.xml中bean的参数呢

<?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.xsd">

  
    <!-- car的bean -->
     <bean name="car" class="pojo.Car">
        <property name="name" value="自行车"/>
        <property name="price" value="1"/>
        <property name="address" value="自行车店"/>
    </bean>
    
	<!--         buyCar的bean -->
    <bean name="buyCar" class="pojo.Lady">
	<!--    	    注入上面配置的id为car的Car对象 -->
        <property name="car" ref="car" />
    </bean>
</beans>

运行截图：

从中我们可以看到，我们不再需要用户去创建对象，而是直接由ioc的bean来分配。

IoC不是一种技术，只是一种思想，一个重要的面向对象编程的法则，它能指导我们如何设计出松耦合、更优良的程序。传统应用程序都是由我们在类内部主动创建依赖对象，从而导致类与类之间高耦合，难于测试；有了IoC容器后，把创建和查找依赖对象的控制权交给了容器，由容器进行注入组合对象，所以对象与对象之间是松散耦合，这样也方便测试，利于功能复用，更重要的是使得程序的整个体系结构变得非常灵活。