1. IoC的定义
- IOC(Inversion of Control) ,即控制反转,不是具体的技术,而是一种思想;
- IOC意味着将你设计好的对象交给Spring容器来管理,而不是传统的在你的对象内部直接控制;
- 对于spring框架来说,就是由spring来负责控制对象的生命周期和对象间的关系。
2. 传统方式带来的问题
假设现在我们需要查询一个用户的数据,有3种方式可以查询,一种是默认查询,一种是去MySQL数据库中查询,还有一种是去Oracle数据库中查询,现在我们需要实现方法去使用不同方式进行查询
- 首先创建一个查询接口(Dao层),里面是我们需要的查询方法
public interface UserDao {
void getUser();
}
- 然后分别实现这个类,重写其中的方法
//默认读取的方法实现类
public class UserDaoImpl implements UserDao {
public void getUser() {
System.out.println("默认数据读取");
}
}
//MySQL数据库读取的方法实现类
public class UserDaoMySQLImpl implements UserDao{
public void getUser() {
System.out.println("MySQL读取用户数据");
}
}
//Oracle数据库读取的方法实现类
public class UserDaoOracleImpl implements UserDao {
public void getUser() {
System.out.println("Oracle读取用户数据");
}
}
- 接下来就是编写服务层的接口(Service层)
public interface UserService {
void getUser();
}
- 由于有3种方式,所以我们需要写3个实现类,下面以实现默认查询方法为例
public class UserServiceImpl implements UserService {
UserDao userDao = new UserDaoImpl();
//UserDao userDao = new UserDaoMySQLImpl();
//UserDao userDao = new UserDaoOracleImpl();
public void getUser() {
userDao.getUser();
}
}
- 测试方法
public class MyTest {
public static void main(String[] args) {
UserService service = new UserServiceImpl();
service.getUser();
}
}
- 出现的问题
由于上面实现的是默认查询方法的实现,所以得到的结果是“默认数据读取”,如果我们需要去MySQL中读取,则需要去Service的实现类中去修改Dao的实现方式或者另外再写一个Service的实现;如果再用Oracle实现,就要重复上述工作,这样会带来大量的重复代码,并且使得代码的功能单一,即耦合性高
3. 解决耦合性高的办法
- 由于问题主要出现在Service层的实现方面,有几个Dao就需要实现机场Service方法,而实现这些方法,唯一的区别就是Dao的实现不同,所以考虑采用Setter方法,在实现Service时动态注入Dao的值,注入我们所需要的Dao,这样便大大缓解了程序的耦合性
public class UserServiceImpl implements UserService {
private UserDao userDao;
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
public void getUser() {
userDao.getUser();
}
}
- 这样,当我们需要不同方式去查找时,就传入相应的Dao参数即可,如此便实现了动态查询的方法
public class MyTest {
public static void main(String[] args) {
UserServiceImpl userService = new UserServiceImpl();
userService.setUserDao(new UserDaoImpl());
userService.getUser();
userService.setUserDao(new UserDaoMySQLImpl());
userService.getUser();
userService.setUserDao(new UserDaoOracleImpl());
userService.getUser();
}
}
4. Spring的IoC实现
- Spring可以通过读取XML配置文件的方式去读取参数,根据参数去创建所需要的对象(SpringBean),文件名一般为
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">
<!--通过id去得到创建的对象,即所创建的对象的名字
class为所需要创建对象的路径
property为创建的类中属性名
value为属性值对应的值
ref为引用Spring中已经创建好的对象
-->
<bean id="userDaoImpl" class="com.hust.dao.UserDaoImpl"/>
<bean id="mySQLImpl" class="com.hust.dao.UserDaoMySQLImpl"/>
<bean id="oracleImpl" class="com.hust.dao.UserDaoOracleImpl"/>
<bean id="UserServiceImpl" class="com.hust.service.UserServiceImpl">
<property name="userDao" ref="userDaoImpl"/>
</bean>
<bean id="UserServiceImpl1" class="com.hust.service.UserServiceImpl">
<property name="userDao" ref="mySQLImpl"/>
</bean>
<bean id="UserServiceImpl2" class="com.hust.service.UserServiceImpl">
<property name="userDao" ref="oracleImpl"/>
</bean>
</beans>
- 通过读取XML文件来获取对象
public class MyTest {
public static void main(String[] args) {
//参数为配置文件的名称
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
UserService userServiceImpl = (UserService)context.getBean("UserServiceImpl");
userServiceImpl.getUser();
UserService userServiceImpl1 = (UserService)context.getBean("UserServiceImpl1");
userServiceImpl1.getUser();
UserService userServiceImpl2 = (UserService)context.getBean("UserServiceImpl2");
userServiceImpl2.getUser();
}
}
5. 控制反转的核心
- 控制:谁来控制对象的创建–由Spring来创建对象
- 反转:程序本身不再创建对象,而变成被动地接收对象
- 依赖注入:使用setter方法来对参数进行注入
- 只需要在XML文件在去进行修改即可实现不同的方法
- 总结:对象由Spring来创建,管理,装配