JAVA模擬Spring實現IoC過程(附源碼)

前言：本人大四學生，第一次寫博客，如果有寫得不好的地方，請大家多多指正

一、IoC(Inversion of Control)反轉控制

　　傳統開發都是需要對象就new，但這樣做有幾個問題：

 

1. 1. 效率低下，創建對象時比較耗時，我立馬要用對象，可系統說讓你等一下，創建和初始化對象需要一定的時間。　
   2. 對象關聯關系，例如：用戶有所屬部門，那創建用戶對象時，如果部門對象不存在，還得創建部門對象。
   3. 代碼耦合度較高

 

於是有人就提出了IoC控制反轉概念，干嘛我不先創建好呢？如果用戶要使用時，我都已經創建好了，用戶不就能立馬使用了？這就有點像好萊塢法則：“你別找我，我去找你”。

 

IoC不是一種技術，只是一種思想，一個重要的面向對象編程的法則，它能指導我們如何設計出松耦合、更優良的程序。傳統應用程序都是由我們在類內部主動創建依賴對象，從而導致類與類之間高耦合，難於測試；有了IoC容器后，把創建和查找依賴對象的控制權交給了容器，由容器進行注入組合對象，所以對象與對象之間是松散耦合，這樣也方便測試，利於功能復用，更重要的是使得程序的整個體系結構變得非常靈活；

 

我個人對IoC是這樣簡單理解的：

1）對象不是new出來的，而是通過反射事先創建出來的

2）既然事先創建出來，在用之前就得找個地方放起來，放哪里呢？就放在一個Map<String, Object>集合中

 

 

二、實現IoC過程中需要考慮的一些問題

•　　怎么獲取要創建的對象？

•　　怎么把目錄名轉換為類名？

•　　怎么把類名轉換為beanName？

•　　哪些類需要創建對象？怎么過濾掉不需要創建對象的類？

•　　容器中該怎么存放對象？

•　　怎么調用容器中存放的對象？

•　　設計分層結構：高內聚，低耦合（相當於專做一件事，不要把使用功能都寫在一起）

 

三、模擬Spring實現IoC

在這里簡單模擬查詢用戶信息，實際應用中更復雜，但是萬變不離其宗，弄懂原理才是重要的

 

1)架構圖

 

 

 

2)代碼結構圖

在IDEA中的結構示意圖（eclipse也差不多，我用的是IDEA）:

各包名以及文件名含義（文件名可能會和架構圖中的一些文件名不一致，因為架構圖是之前畫的，但不影響閱讀，大同小異）：

　　annotation包：用來存放注解，在本案例中需要創建對象的類為控制層類、業務層類、持久層類；所有需要3個注解，通過注解的方式來過濾掉不需要創建對象的類，Controller注解是加在控制層，Service注解加在業務層，Respository注解加在持久層；3個注解都是位於類上，保留到運行時期；

　　pojo包：設置一個pojo類，里面含有一些簡單屬性；

　　dao包：模擬持久層，由於本案例是一個簡單例子，主要用於初學者查看，所有沒有安裝數據庫，正常情況下持久層應該與數據庫進行對接，沒有安裝數據庫，所有就由持久層模擬數據庫；

　　service包：模擬業務層，業務層調用持久層；

　　controller包：模擬控制層，控制層調用業務層；

　　utils包：工具類包；

　　parse包：因為我們采用了分層結構，所以在使用之前，應當把這些組件掃描加載到一起；現在都是面向接口進行開發，這樣可以提高程序的靈活性，面向接口開發，同時也體現了JAVA的多態性；

　　Run文件就相當於整個程序的入口。

 

 

四、案例源碼

　　　　1）pojo類(User.java)

package spring.pojo;

/**
 * @Auther: 林安傑
 * @Date: 2019/9/28 19:28
 * @Description:創建pojo對象，簡單設置屬性以及get,set,toString方法
 */
public class User {
    private Integer id;
    private String name;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

 

　　　　2)注解

　　　　①Respository.java

package spring.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @Auther: 林安傑
 * @Date: 2019/9/28 19:31
 * @Description:dao層類注解
 */

@Target(ElementType.TYPE)   // 注解加在類上
@Retention(RetentionPolicy.RUNTIME) // 保留到運行時
public @interface Respository {
}

　　　　　②Service.java

package spring.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @Auther: 林安傑
 * @Date: 2019/9/28 19:33
 * @Description:業務層注解
 */

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Service {
}

　　　　　　③Controller.java

package spring.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @Auther: 林安傑
 * @Date: 2019/9/28 19:34
 * @Description:控制層注解
 */

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Controller {
}

　　　　3）持久層（UserDao.java）

package spring.dao;

import spring.annotation.Respository;
import spring.pojo.User;

import java.util.ArrayList;
import java.util.List;

/**
 * @Auther: 林安傑
 * @Date: 2019/9/28 19:36
 * @Description:dao層,模擬數據庫數據
 */

@Respository
public class UserDao {
    // 模擬查詢一條記錄，根據進行id查詢
    public User selectOne(Integer id) {
        User user = new User();
        user.setId(id);
        user.setName("林安傑");
        return user;
    }

    // 模擬查詢所有記錄
    public List<User> get() {
        // 用一個集合來存放所有對象
        List<User> userList = new ArrayList<>();

        User u1 = new User();
        u1.setId(6);
        u1.setName("linanjie");
        userList.add(u1);

        User u2 = new User();
        u2.setId(7);
        u2.setName("linlin");
        userList.add(u2);
        return userList;
    }


}

　　　　4）業務層（UserService.java）

 

 

package spring.service;

import spring.annotation.Service;
import spring.dao.UserDao;
import spring.pojo.User;

import java.util.List;

/**
 * @Auther: 林安傑
 * @Date: 2019/9/28 19:48
 * @Description:業務層，從dao層中獲取數據
 */

@Service
public class UserService {
    private UserDao userDao;    // 把dao層的對象設置為私有成員變量，才能訪問dao層中的方法（組合）

    // 關系綁定（set注入）
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    // 查詢一條記錄
    public User getOne(Integer id) {
        return userDao.selectOne(id);
    }

    // 查詢所有記錄
    public List<User> queryAll() {
        return userDao.get();
    }
}

　　　　5）控制層（UserController.java）

package spring.controller;

import spring.annotation.Controller;
import spring.pojo.User;
import spring.service.UserService;

import java.util.List;

/**
 * @Auther: 林安傑
 * @Date: 2019/9/28 19:53
 * @Description:控制層,調用業務層
 */

@Controller
public class UserController {
    private UserService userService;    // 把業務層對象設置為私有成員變量

    // set注入，實現關系綁定
    public void setUserService(UserService userService) {
        this.userService = userService;
    }

    // 查詢一條記錄
    public User getOne(Integer id) {
        return userService.getOne(id);
    }

    // 查詢多條記錄
    public List<User> queryAll() {
        return userService.queryAll();
    }
}

　　　　6）工具類

　　　　①FileUtil.java

 

package spring.utils;

import java.io.File;
import java.util.List;

/**
 * @Auther: 林安傑
 * @Date: 2019/9/28 19:58
 * @Description:文件掃描工具類
 */

public class FileUtil {
    // 掃描所有.class文件,並存入數組中
    public static List<String> getFileNameList(String dir, List<String> fileNameList) {
        File file = new File(dir);  // 把string類型轉換為file類型
        File[] files = file.listFiles();    // 遍歷當前路徑下的所有文件（遍歷出來的是：所有文件名+所有目錄名）
        for (File f :
                files) {
            if (f.isDirectory()) {  // 判斷當前文件是不是目錄，是的話就遞歸遍歷目錄中的內容
                getFileNameList(f.getAbsolutePath(), fileNameList);
            } else {
                fileNameList.add(f.getAbsolutePath());  // 不是目錄就是文件，將文件添加到數組當中
            }
        }
        return fileNameList;
    }
}

 

　　　　　②CoverUtil.java

 

package spring.utils;

import java.util.List;

/**
 * @Auther: 林安傑
 * @Date: 2019/9/28 21:30
 * @Description:統一把路徑符替換為“/”，路徑符有“//”、“\”，統一后就沒有差異性了
 */
public class CoverUtil {
    // 從存放所有class文件的fileNameList集合中取出每一個文件名（全局限定名），替換為類名形式（包名.類名）

    /**
     * @param baseDir      基准路徑
     * @param fileNameList 存放所有文件全集限定名的數組
     * @return
     */
    public static List<String> getClassNameList(String baseDir, List<String> fileNameList) {
        // 把基准路徑中的路徑符統一
        baseDir = baseDir.replace("\\", "/");
        for (int i = 0; i < fileNameList.size(); i++) {
            // 獲取數組中的元素
            String fileName = fileNameList.get(i);

            // 把元素（全集限定名）中的路徑統一
            fileName = fileName.replace("\\", "/");

            // 把全集限定名中前面一樣的基准路徑替換為空串
            fileName = fileName.replace(baseDir, "");

            // 把替換掉的字符串去掉.class后綴
            int pos = fileName.lastIndexOf(".");
            fileName = fileName.substring(0, pos);

            // 把字符串的路徑符替換為“.”
            fileName = fileName.replace("/", ".");

            // 把最終的類名繼續放回數組中
            fileNameList.set(i, fileName);
        }
        return fileNameList;
    }
}

　　　　　　③BeanNameUtil.java

package spring.utils;


/**
 * @Auther: 林安傑
 * @Date: 2019/9/28 23:06
 * @Description:把className轉換為beanName
 */
public class BeanNameUtil {
    public static String getbeanName(String className) {
        // 截取后面的類名
        int pos = className.lastIndexOf(".") + 1;
        className = className.substring(pos);
        // 類名的第一個字母小寫，后面的不變
        String beanName = className.toLowerCase().charAt(0) + className.substring(1);
        return beanName;
    }
}

　　　　7）組件掃描

　　　　　①BeanFactory.java

package spring.parse;

import java.util.List;

/**
 * @Auther: 林安傑
 * @Date: 2019/9/28 23:26
 * @Description:面對接口開發；需要設計一個接口
 */
public interface BeanFactory {
    public List<String> scan(String dir);

    public void creat(String baseDir, List<String> fileNameList) throws Exception;

    public <T> T getObject(String beanName);
}

　　　　　　②ComponentScan.java

package spring.parse;

import spring.annotation.Controller;
import spring.annotation.Respository;
import spring.annotation.Service;
import spring.utils.BeanNameUtil;
import spring.utils.CoverUtil;
import spring.utils.FileUtil;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @Auther: 林安傑
 * @Date: 2019/9/28 22:30
 * @Description:掃描所有需要的組件，並利用反射創建對象，把對象放在容器中
 */
public class ComponentScan implements BeanFactory{

    private static final Map<String, Object> beans = new HashMap<>();

    // 掃描所有class文件
    public List<String> scan(String dir) {
        List<String> fileNameList = new ArrayList<>();
        FileUtil.getFileNameList(dir, fileNameList);
        // 遍歷查看數組的內容
        for (String fileName :
                fileNameList) {
            System.out.println(fileName);
        }
        return fileNameList;
    }

    // 通過反射根據注解創建對象，並把對象放在容器中
    public void creat(String baseDir, List<String> fileNameList) throws Exception {
        List<String> classNameList = CoverUtil.getClassNameList(baseDir, fileNameList);

        // 遍歷類名數組查看內容，並根據是否有注解創建對象
        for (String className : classNameList) {
            String beanName = "";
            Class<?> clazz = Class.forName(className);
            // 獲取類上的注解
            Controller ca = clazz.getAnnotation(Controller.class);
            Service sa = clazz.getAnnotation(Service.class);
            Respository ra = clazz.getAnnotation(Respository.class);

            // 若注解不為空，就創建對象
            if (ca != null || sa != null || ra != null) {
                Object obj = clazz.newInstance();

                /*把對象存放在容器中，容器為Map鍵值對，值就是對象，key用className表示太復雜，把className轉換成beanName
                  className的形式：spring.pojo.User；beanName的形式：user；所以需要寫一個轉換的方法
                 */
                beanName = BeanNameUtil.getbeanName(className);

                // 把對象存放到容器當中
                beans.put(beanName, obj);
            }
            System.out.println(className + " | " + beanName);
        }

        // 查看容器中存放的對象
        System.out.println("\n容器中存放的對象為：");
        for (String key : beans.keySet()) {
            System.out.println(beans.get(key));
        }
    }

    // 從容器中獲取對象
    public <T> T getObject(String beanName){
        return (T) beans.get(beanName);
    }
}

　　　　8）程序入口（Run.java）

package spring;

import spring.controller.UserController;
import spring.dao.UserDao;
import spring.parse.BeanFactory;
import spring.parse.ComponentScan;
import spring.pojo.User;
import spring.service.UserService;

import java.util.List;


/**
 * @Auther: 林安傑
 * @Date: 2019/9/29 12:53
 * @Description:程序入口
 */
public class Run {
    public static void main(String[] args) throws Exception {
        // 面對接口開發，體現了多態性（向上造型）
        BeanFactory context = new ComponentScan();

        // 先掃描所有class文件
        System.out.println("第一步,掃描當前主目錄下的所有class文件：");
        // 不能把路徑寫死，可以根據API獲取路徑
        String baseDir = Run.class.getResource("/").getPath().substring(1);
        String packageDir = Run.class.getPackage().getName();
        String dir = baseDir + packageDir.replace(".", "/");
        List<String> fileNameList = context.scan(dir);

        System.out.println("\n第二步，獲得className,並且用beanName把對象存入容器中：");
        context.creat(baseDir, fileNameList);

        System.out.println("\n第三步，業務處理：");
        // 不能用new創建對象，需要從容器中獲取對象
        UserController userController = context.getObject("userController");
        UserService userService = context.getObject("userService");
        UserDao userDao = context.getObject("userDao");

        // 關系注入，調用set方法
        userController.setUserService(userService);
        userService.setUserDao(userDao);

        System.out.println("查詢一條記錄：");
        User user = userController.getOne(1);
        System.out.println(user);

        System.out.println("查詢所有記錄：");
        List<User> users = userController.queryAll();
        for (User u : users) {
            System.out.println(u);
        }
    }
}

五、運行結果

 

 

 

 

 

 

這就是本期分享的內容，大家可以相互學習