1- Spring框架初步-前言（举例）

代码目录结构：

代码分层：

1. service——业务逻辑层 
2. dao（data access object）数据访问对象——数据访问层（跟数据库交互的）

下面有具体的 实现类impl包（用于放实现类（实现接口的）的）、

                      接口-UserDao（上同）

实际上是：

service层调dao层。

IOC —— 控制反转（Inversion of Control）

理解：

（以前都是通过）New的方式创建对象—— 正向

而现在不通过new了，而是等着别人给我（如通过Set的方式） —— 反向

即：原来的时候是你自己创建自己所需要的对象，而现在由别人给你所依赖的对象。

 

IOC容器 —— 放对象的地方（提前储备对象的地方）

然后IOC来控制对象。

代码示例：

dao层下的接口：UserDao

package com.zhoulz.dao;
/**
 * dao是数据访问层
 * 定义访问用户的接口，
 * 然后用实现类去实现
 */
public interface UserDao {
    public void getUser();
}

然后对应接口UserDao的3个实现类：

1）UserDaoImpl

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

2）UserDaoMysqlImpl

public class UserDaoMysqlImpl implements UserDao {
    @Override
    public void getUser() {
        System.out.println("从mysql获取数据");
    }
}

3）UserDaoOracleImpl

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

然后，业务逻辑层下的接口：UserService

package com.zhoulz.service;

/**
 * service是业务逻辑层
 * 定义用户的业务接口
 * 然后用实现类去实现
 */
public interface UserService {
    public void getUser();
}

同样，对应的实现类：UserServiceImpl

package com.zhoulz.service.impl;

import com.zhoulz.dao.UserDao;
import com.zhoulz.dao.impl.UserDaoImpl;
import com.zhoulz.dao.impl.UserDaoMysqlImpl;
import com.zhoulz.dao.impl.UserDaoOracleImpl;
import com.zhoulz.service.UserService;

/**
 重点:set方法
 */
public class UserServiceImpl implements UserService {
    //原
    //获取数据
    //private UserDao userDao = new UserDaoImpl(); //new它的实现类
    //从mysql获取数据
    //private UserDao userDao = new UserDaoMysqlImpl();
    //从oracle获取数据
    //private UserDao userDao = new UserDaoOracleImpl();

    //上面这种写法——发现：
    //每次都要改这个地方 —— 太麻烦
    //解决：
    private UserDao userDao; //这里不new了
    //然后
    public void setUserDao(UserDao userDao){
            this.userDao = userDao;
    }
    //然后再去改写测试类—— 见测试类（即主函数）

    // 总结：
    // 当在某一个实现类里面，需要（获取）当前对象的时候，
    //可以通过set的方式往里面注入具体的一个对象，而不是每一次都像上面一样去修改代码

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

最后，测试类：MyTest

package com.zhoulz.test;

import com.zhoulz.dao.impl.UserDaoImpl;
import com.zhoulz.dao.impl.UserDaoMysqlImpl;
import com.zhoulz.dao.impl.UserDaoOracleImpl;
import com.zhoulz.service.UserService;
import com.zhoulz.service.impl.UserServiceImpl;

public class MyTest {
    public static void main(String[] args) {
        //原：
        /*UserService userService = new UserServiceImpl();
        userService.getUser();*/

        //然后，测试类中这么改：
        UserServiceImpl/*这里改用具体子类*/ userService = new UserServiceImpl();

        //然后，这样写后，就随便你怎么换了

        //1、获取数据
        UserDaoImpl userDao = new UserDaoImpl();
        userService.setUserDao(userDao);
        userService.getUser();

        //2、从mysql获取数据
        UserDaoMysqlImpl userDaoMysql = new UserDaoMysqlImpl();
        userService.setUserDao(userDaoMysql);
        userService.getUser();

        //3、从oracle获取数据
        UserDaoOracleImpl userDaoOracle = new UserDaoOracleImpl();
        userService.setUserDao(userDaoOracle);
        userService.getUser();
        //其它的同理
    }
}