java代碼實現簡易版IOC容器，含IOC容器實現步驟分解

一、需求

　　實現一個簡易的IOC容器，管理Bean，從IOC容器的BeanFactory中獲取實例，從而取代自己new實例的做法。

二、實現步驟分析

　　

三、具體代碼實現

　　自定義注解類 MyComponent 和 MyAutowired：

package MyIOCAndMyAop.Annotations;

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

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

package MyIOCAndMyAop.Annotations;

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

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAutowired {
    
}

 

　　MyIOC容器的實現：自己實現簡單的IOC容器，來管理bean：BeanFactory<String, Object>，String為全類名，Object為通過類加載器加載進來的Class對象反射創建的bean。

package MyIOCAndMyAop;

import java.io.File;
import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import MyIOCAndMyAop.Annotations.MyAutowired;
import MyIOCAndMyAop.Annotations.MyComponent;

public class MyIOC {

    // beanFactory 要聲明為類變量，因為它不能被GC回收：
    private static HashMap<String, Object> beanFactory = new HashMap<>();
    
    /**
     * 隨着MyIOC類被加載到內存進行初始化，就會執行其靜態代碼塊
     * @param args
     */
    static {
        init();
    }
    
    /**
     * 獲取BeanFactory
     * @return
     */
    public static HashMap<String, Object> getBeanFactory(){
        return beanFactory;
    }
    
    /**
     * 根據全類名更新BeanFactory中的bean
     * @param typeName
     * @param proxyInstance
     */
    public static void updateBeanFromBeanFactory(String typeName, Object proxyInstance) {
        beanFactory.put(typeName, proxyInstance);
    }
    
    /**
     * 通過全類名獲得對應的實例
     * @param completeClassName
     * @return
     */
    public static Object getBean(String completeClassName) {
        return beanFactory.get(completeClassName);
    }
    
    public static void init() {
        HashMap<String, Class> loadedClazzList;//<全類名, Class對象>
        try {
            //1.加載指定的類
            File file = new File("C:\\workplace\\test\\bin");//！！！這里寫死了路徑不合適，可以做改進
            loadedClazzList = loadAllClazz(file);
            
            //2.實例化並放入IOC容器中：對於那些有注解的類，做實例化
            newInstance(loadedClazzList);
            
            // 3.完成依賴注入
            autoWired();
            
            // 4.測試：找到beanFactory中的某個bean，並執行其某個方法 ===> 這里有個問題，只能執行指定的方法，所以beanFactory中的所有bean都得有這個方法，這里先這么做了，但這明顯不合理。
//            test();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    public static void test() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
        for(Map.Entry<String, Object> entry : beanFactory.entrySet()) {
//            System.out.println(entry.getKey() + " ---> ");
            Method method = entry.getValue().getClass().getMethod("test");
            method.invoke(entry.getValue());
        }
    }
    
    /**
     * 對BeanFactory中管理的所有bean完成依賴注入。
     * 交給IOC容器管理的類，需要注入成員變量，如果該成員變量是自定義的類，該類也是需要交給IOC容器管理的。
     * @throws IllegalAccessException 
     * @throws IllegalArgumentException 
     * @throws MalformedURLException 
     * @throws ClassNotFoundException 
     */
    public static void autoWired() throws IllegalArgumentException, IllegalAccessException, ClassNotFoundException, MalformedURLException {
        for(Map.Entry<String, Object> entry :  beanFactory.entrySet()) {
            Field[] fields = entry.getValue().getClass().getDeclaredFields();//！！！getFields():只能獲取到運行時類中及其父類中聲明為public的屬性；getDeclaredFields():獲取運行時類本身聲明的所有的屬性
            for(Field field : fields) {
                Annotation[] annotations = field.getAnnotations();
                for(int i = 0; i < annotations.length; i++) {
                    if(annotations[i].annotationType() == MyAutowired.class) {
                        //從beanFactory中找到相應的bean，賦值給該成員變量，以完成依賴注入。
                        Object object = beanFactory.get(field.getType().getTypeName());
//                        System.out.println(field.getType().getTypeName());//MyIOCAndMyAop.bean.Student
                        //通過Field（反射）為成員變量賦值：
                        field.setAccessible(true);
                        field.set(entry.getValue(), object);
                    }
                }
            }
        }
    }
    
    /**
     * 實例化： 放到loadedClazzlist集合中的Class對象都是需要做實例化的(加了@MyComponent注解的類)
     */
    public static void newInstance(HashMap<String, Class> loadedClazzList) throws InstantiationException, IllegalAccessException, ClassNotFoundException, MalformedURLException {
        for(Map.Entry<String, Class> entry : loadedClazzList.entrySet()) {
            beanFactory.put(entry.getKey(), entry.getValue().newInstance());
        }
    }
    
    /**
     * 加載指定路徑下的類。
     * 類加載：javase/src/classLoader/a01helloworld/A03GetExtClassLoader
     * @return 類加載器加載進來的指定路徑下的所有Class對象
     * @throws IllegalAccessException 
     * @throws InstantiationException 
     */
    public static HashMap<String, Class> loadAllClazz(File file) throws ClassNotFoundException, MalformedURLException, InstantiationException, IllegalAccessException {
        //用於存放類加載器加載進來的Class對象<全類名， Class對象>
        HashMap<String, Class> loadedClazzList = new HashMap<>();
        
        URL[] urls = new URL[]{file.toURI().toURL()};
        URLClassLoader classLoader = new URLClassLoader(urls);
        
        ArrayList<String> allCompleteClassName = getAllCompleteClassName(file);
        
        for(String element : allCompleteClassName) {
            Class<?> clazz = classLoader.loadClass(element);
            Annotation[] annotations = clazz.getAnnotations();// ！！！拿到Class對象的時候，就進行篩選出有注解的Class再放到容器中，而不是把指定路徑下的所有類都加載進來。
            for(int i = 0; i < annotations.length; i++) {
                if(annotations[i].annotationType() == MyComponent.class) {
                    loadedClazzList.put(element, clazz);//得到各個類對象了
                }
            }
        }
        return loadedClazzList;
    }
    
    /**
     * 得到allNeedLoadClassFiles中所有要加載的class文件的全類名
     */
    private static ArrayList<String> getAllCompleteClassName(File file) {
        // 所有要加載的class的全類名，如：classLoader.a02myclassloader.bean.Bean
        ArrayList<String> completeClassNames = new ArrayList<>();
        // 用於存放指定路徑下所有要加載的class文件
        ArrayList<File> allNeedLoadClassFiles = new ArrayList<File>();
        
        getAllNeedLoadClassFile(file, allNeedLoadClassFiles);
        
        for (File element : allNeedLoadClassFiles) {
            String filePath = element.getPath().replace("\\", ".");
            
            if(filePath.endsWith(".class")) {
                //filePath.indexOf("bin.")+4:"bin."之后。filePath.lastIndexOf(".class")：".class"之前，該方法是從后往前找，性能更高。
                String completeClassName = filePath.substring(filePath.indexOf("bin.")+4, filePath.lastIndexOf(".class"));
                completeClassNames.add(completeClassName);
            }
        }
        return completeClassNames;
    }
    
    /**
     * 通過遞歸獲取指定路徑下所有要加載的class文件
     * 遞歸：javase/src/recursion/A_PrintFolder
     * @param file
     */
    private static ArrayList<File> getAllNeedLoadClassFile(File file, ArrayList<File> allNeedLoadClassFiles) {
        if(!file.exists()) {//！！！這里要多一層判斷
            return allNeedLoadClassFiles;
        }
        
        if (file.isDirectory()) {//是文件夾
            File[] listFiles = file.listFiles();
            for (File element : listFiles) {
                getAllNeedLoadClassFile(element, allNeedLoadClassFiles);
            }
        } else {//是文件
            allNeedLoadClassFiles.add(file);
        }
        return allNeedLoadClassFiles;
    }
}

自己實現AOP 1.0版本，含步驟分解：https://www.cnblogs.com/laipimei/p/11137250.html

自己實現SpringAOP 2.0版本，含實現步驟分解：https://www.cnblogs.com/laipimei/p/11163377.html