SpringIOC控制反转

1、SpringIOC理论

1.UserDao接口
2.UserDaoImopl实现类
3.UserService业务接口
4.UserServiceImpl业务实现类

在我们之前的业务中，用户的需求可能会影响我们原来的代码，我们需要根据用户的需求去修改源代码！如果程序代码量十分大，修改一次的成本代价十分昂贵！

我们使用一个set接口实现

private UserDao userDao;

//利用set进行动态实现值得注入！
public void setUserDao(UserDao userDao){
	this.userDao=userDao;
}

• 之前程序是主动创建对象，控制权在程序员手上！
• 使用了set注入后，程序不再具有主动性，而是变成了被动的接收对象

这种思想，从本质上解决了问题，我们程序员不用再去管理对象的创建。系统的耦合性大大降低，可以更加专注在业务的是线上！这是IOC的原型！

IOC本质

控制反转loC(Inversion of Control),是一种设计思想，DI(依赖注入)是实现IoC的一种方法，也有人认为DI只是loC的另一种说法。 没有IoC的程序中, 我们使用面向对象编程，对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，个人认为所谓控制反转就是:获得依赖对象的方式反转了。

Animal类

package com.jialidun.pojo;

public class Animal{
	private String str;
	
	public String getStr(){
		return str;
	}
	
	public void setStr(String str){
		this.str=str;
	}
	@Override
	public String toString(){
		return "Animal{" +
				"str'"+str+'\''+
				'}' ;
		
	}



}

spring2.5之前，需要xml文件配置

<!--
使用Spring来创建对象，在Spring这些都成为Bean

类型 变量名 = new 类型();
Animal animal = new Animal();
bean = 对象 new Hello();

id = 变量名
class = new 的对象;
property 相当于给对象中的属性设置一个值！
-->
	<bean id="hello" class="com.jialidun.pojo.Animal">
		<property name="str" value="Spring"/>
	</bean>

思考问题？

• Animal对象是谁创建的？
  Animal对象是由Spring创建的
• Animal对象的属性是怎么设置的？
  Animal的属性是由Spring容器设置的

这个过程就叫控制反转：
控制：谁来控制对象的创建，传统应用程序的对象是由程序本身控制创建的，使用Spring后，对象是由Spring来创建的
反转：程序本身不创建对象，而变成被动的接收对象
依赖注入：就是利用set方法来进行注入的
IOC是一种编程思想，由主动的编程编程被动的接收
可以通过newClassPathXmlApplicationContext去浏览一下底层源码

所谓的IOC，对象由Spring来创建，管理，装配！
IOC基础
新建一个空白的maven项目

分析实现

我们用原来的方式写一段代码
1、先写一个UserDao接口

public interface UserDao {
    public void getUser();
}

2、再去写Dao的实现类

public class UserDaoImpl implements UserDao {
    @Override
    public void getUser() {
        System.out.println("获取用户数据");
    }
}

3、然后再去写UserService接口

public interface UserService {
    public void getUser();
}

4、最后写Service的实现类

public class UserServiceImpl implements UserService {
    private UserDao userDao = new UserDaoImpl();
 
    @Override
    public void getUser() {
        userDao.getUser();
    }
}

5、测试一下

@Test
public void test(){
    UserService service = new UserServiceImpl();
    service.getUser();
}

这是我们原来的方式，修改一下，把UserDao的实现类增加一个

public class UserDaoMySqlImpl implements UserDao {
    @Override
    public void getUser() {
        System.out.println("MySql获取用户数据");
    }
}

紧接着我们要去使用MySql的话 , 我们就需要去service实现类里面修改对应的实现

public class UserServiceImpl implements UserService {
    private UserDao userDao = new UserDaoMySqlImpl();
 
    @Override
    public void getUser() {
        userDao.getUser();
    }
}

在假设, 我们再增加一个Userdao的实现类 .

public class UserDaoOracleImpl implements UserDao {
    @Override
    public void getUser() {
        System.out.println("Oracle获取用户数据");
    }
}

那么我们要使用Oracle , 又需要去service实现类里面修改对应的实现 . 假设我们的这种需求非常大 , 这种方式就根本不适用了, 甚至反人类对吧 , 每次变动 , 都需要修改大量代码 . 这种设计的耦合性太高了, 牵一发而动全身 .

那我们如何去解决呢 ?
我们可以在需要用到他的地方 , 不去实现它 , 而是留出一个接口 , 利用set , 我们去代码里修改下

public class UserServiceImpl implements UserService {
    private UserDao userDao;
    // 利用set实现
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
 
    @Override
    public void getUser() {
        userDao.getUser();
    }
}

现在去我们的测试类里 , 进行测试 ;

@Test
public void test(){
    UserServiceImpl service = new UserServiceImpl();
    service.setUserDao( new UserDaoMySqlImpl() );
    service.getUser();
    //那我们现在又想用Oracle去实现呢
    service.setUserDao( new UserDaoOracleImpl() );
    service.getUser();
}

以前所有东西都是由程序去进行控制创建 , 而现在是由我们自行控制创建对象 , 把主动权交给了调用者 . 程序不用去管怎么创建,怎么实现了 . 它只负责提供一个接口 .

这种思想 , 从本质上解决了问题 , 我们程序员不再去管理对象的创建了 , 更多的去关注业务的实现 . 耦合性大大降低 . 这也就是IOC的原型 !

<bean id="mysqlImpl" class="com.jialidun.dao.UserDaoMysqlImpl"/>
<bean id="oracleImpl" class="com.jialidun.dao.UserDaoOracleImpl"/>
<bean id="sqlserverImpl" class="com.jialidun.dao.UserDaosqlServerImpl"/>
<bean id="UserServiceImpl" class="com.jialidun.service.UserServiceImpl">
	<!--
	ref：引用Spring容器中创建好的对象
	value：具体的值，基本数据类型
	-->
	<property name="userDao" ref="SqlserverImpl">
</bean>

测试：

package com.jialidun.service.UserServiceImpl;

public class Test{
	
	//获取ApplicationContext：拿到Spring容器
	ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

UserServiceImpl userServiceImpl = (UserServiceImpl)context.getBean("UserServiceImpl");

	userServiceImpl.getUser();


}