Spring（二）：IoC理论推导

在Spring的简介中我们知道了Spring的核心是控制反转（IoC：Inverse of Control）和面向切面编程（AOP：Aspect Oriented Programming），我们不直接对IoC进行学习，而是先学习IoC的理论推导。

 

 

 这是我一个maven项目的结构。

UserDao：

package com.jms.dao;

public interface UserDao {
    void getUser();
}

UserDaoImpl:

package com.jms.dao;

public class UserDaoImpl implements UserDao{
    @Override
    public void getUser() {
        System.out.println("this is UserDaoImpl");
    }
}

UserDaoMysqlImpl:

package com.jms.dao;

public class UserDaoMysqlImpl implements UserDao{
    @Override
    public void getUser() {
        System.out.println("this is UserDaoMysqlImpl");
    }
}

UserDaoOracleImpl:

package com.jms.dao;

public class UserDaoOracleImpl implements UserDao{
    @Override
    public void getUser() {
        System.out.println("this is UserDaoOracleImpl");
    }
}

UserService:

package com.jms.service;

public interface UserService {
    void getUser();
}

UserServiceImpl:

package com.jms.service;

import com.jms.dao.UserDao;
import com.jms.dao.UserDaoImpl;

public class UserServiceImpl implements UserService{

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

这样写当用户有不同需求时我们就要去原来的代码中进行修改：

private UserDao userDao = new UserDaoImpl();

//private UserDao userDao = new UserDaoMysqlImpl();

//private UserDao userDao = new UserDaoOracleImpl();

如果代码量十分庞大，修改一次的成本代价就十分昂贵。

有没有什么办法解决呢？

我们可以用一个set方法实现：

package com.jms.service;

import com.jms.dao.UserDao;

public class UserServiceImpl implements UserService{

    private UserDao userDao;

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

    @Override
    public void getUser() {
        userDao.getUser();
    }
}

虽然只是简单的几行代码，但是发生了根本上的变化。

之前程序具有主动性，能主动控制对象，对象由程序创建；set注入后，程序不再有主动性，变为被动地接收对象。

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

这是IoC的原型。

 

（本文仅作个人学习记录用，如有纰漏敬请指正）