《四 spring原始碼》手寫springioc框架

手寫SpringIOCXML版本

/**
 * 手寫Spring專題 XML方式注入bean
 * 
 * 
 *
 */
public class ClassPathXmlApplicationContext {
    // xml路徑地址
    private String xmlPath;

    public ClassPathXmlApplicationContext(String xmlPath) {
        this.xmlPath = xmlPath;
    }

    public Object getBean(String beanId) throws Exception {
        // 1. 讀取配置檔案
        List<Element> elements = readerXml();
        if (elements == null) {
            throw new Exception("該配置檔案沒有子元素");
        }
        // 2. 使用beanId查詢對應的class地址
        String beanClass = findXmlByIDClass(elements, beanId);
        if (StringUtils.isEmpty(beanClass)) {
            throw new Exception("未找到對應的class地址");
        }
        // 3. 使用反射機制初始化，物件
        Class<?> forName = Class.forName(beanClass);
        return forName.newInstance();
    }

    // 讀取配置檔案資訊
    public List<Element> readerXml() throws DocumentException {
        SAXReader saxReader = new SAXReader();
        if (StringUtils.isEmpty(xmlPath)) {
            new Exception("xml路徑為空...");
        }
        Document read = saxReader.read(getClassXmlInputStream(xmlPath));
        // 獲取根節點資訊
        Element rootElement = read.getRootElement();
        // 獲取子節點
        List<Element> elements = rootElement.elements();
        if (elements == null || elements.isEmpty()) {
            return null;
        }
        return elements;
    }

    // 使用beanid查詢該Class地址
    public String findXmlByIDClass(List<Element> elements, String beanId) throws Exception {
        for (Element element : elements) {
            // 讀取節點上是否有value
            String beanIdValue = element.attributeValue("id");
            if (beanIdValue == null) {
                throw new Exception("使用該beanId為查詢到元素");
            }
            if (!beanIdValue.equals(beanId)) {
                continue;
            }
            // 獲取Class地址屬性
            String classPath = element.attributeValue("class");
            if (!StringUtils.isEmpty(classPath)) {
                return classPath;
            }
        }
        return null;
    }

    // 讀取xml配置檔案
    public InputStream getClassXmlInputStream(String xmlPath) {
        InputStream resourceAsStream = getClass().getClassLoader().getResourceAsStream(xmlPath);
        return resourceAsStream;
    }

}

手寫SpringIOC註解版本

基本思路：    掃包+反射

// 1.使用反射機制獲取該包下所有的類已經存在bean的註解類

 // 2.使用Java反射機制初始化物件

// 3.使用beanID查詢查詢對應bean物件                  ---------------@resource

 // 4.使用反射讀取類的屬性,賦值資訊

/**
 * 手寫Spring專題 註解版本注入bean
 * 
 * 
 *
 */
@SuppressWarnings({ "rawtypes", "unchecked" })
public class ClassPathXmlApplicationContext {
    // 掃包範圍
    private String packageName;
    ConcurrentHashMap<String, Object> initBean = null;

    public ClassPathXmlApplicationContext(String packageName) {
        this.packageName = packageName;
    }

    // 使用beanID查詢物件
    public Object getBean(String beanId) throws Exception {
        // 1.使用反射機制獲取該包下所有的類已經存在bean的註解類
        List<Class> listClassesAnnotation = findClassExisService();
        if (listClassesAnnotation == null || listClassesAnnotation.isEmpty()) {
            throw new Exception("沒有需要初始化的bean");
        }
        // 2.使用Java反射機制初始化物件
        initBean = initBean(listClassesAnnotation);
        if (initBean == null || initBean.isEmpty()) {
            throw new Exception("初始化bean為空!");
        }
        // 3.使用beanID查詢查詢對應bean物件
        Object object = initBean.get(beanId);
        // 4.使用反射讀取類的屬性,賦值資訊
        attriAssign(object);
        return object;
    }

    // 使用反射讀取類的屬性,賦值資訊         @resource實現
    public void attriAssign(Object object) throws IllegalArgumentException, IllegalAccessException {
        // 1.獲取類的屬性是否存在 獲取bean註解
        Class<? extends Object> classInfo = object.getClass();
        Field[] declaredFields = classInfo.getDeclaredFields();
        for (Field field : declaredFields) {
            // 屬性名稱
            String name = field.getName();
            // 2.使用屬性名稱查詢bean容器賦值
            Object bean = initBean.get(name);
            if (bean != null) {
                // 私有訪問允許訪問
                field.setAccessible(true);
                // 給屬性賦值
                field.set(object, bean);
                continue;
            }
        }

    }

    // 使用反射機制獲取該包下所有的類已經存在bean的註解類
    public List<Class> findClassExisService() throws Exception {
        // 1.使用反射機制獲取該包下所有的類
        if (StringUtils.isEmpty(packageName)) {
            throw new Exception("掃包地址不能為空!");
        }
        // 2.使用反射技術獲取當前包下所有的類
        List<Class<?>> classesByPackageName = ClassUtil.getClasses(packageName);
        // 3.存放類上有bean注入註解
        List<Class> exisClassesAnnotation = new ArrayList<Class>();
        // 4.判斷該類上屬否存在註解
        for (Class classInfo : classesByPackageName) {
            ExtService extService = (ExtService) classInfo.getDeclaredAnnotation(ExtService.class);
            if (extService != null) {
                exisClassesAnnotation.add(classInfo);
                continue;
            }
        }
        return exisClassesAnnotation;
    }

    // 初始化bean物件
    public ConcurrentHashMap<String, Object> initBean(List<Class> listClassesAnnotation)
            throws InstantiationException, IllegalAccessException {
        ConcurrentHashMap concurrentHashMap = new ConcurrentHashMap<String, Object>();
        for (Class classInfo : listClassesAnnotation) {
            // 初始化物件
            Object newInstance = classInfo.newInstance();
            // 獲取父類名稱
            String beanId = toLowerCaseFirstOne(classInfo.getSimpleName());
            concurrentHashMap.put(beanId, newInstance);
        }
        return concurrentHashMap;
    }

    // 首字母轉小寫
    public static String toLowerCaseFirstOne(String s) {
        if (Character.isLowerCase(s.charAt(0)))
            return s;
        else
            return (new StringBuilder()).append(Character.toLowerCase(s.charAt(0))).append(s.substring(1)).toString();
    }

}

 

常用反射工具類

public class ClassUtil {

    /**
     * 取得某個介面下所有實現這個介面的類
     */
    public static List<Class> getAllClassByInterface(Class c) {
        List<Class> returnClassList = null;

        if (c.isInterface()) {
            // 獲取當前的包名
            String packageName = c.getPackage().getName();
            // 獲取當前包下以及子包下所以的類
            List<Class<?>> allClass = getClasses(packageName);
            if (allClass != null) {
                returnClassList = new ArrayList<Class>();
                for (Class classes : allClass) {
                    // 判斷是否是同一個介面
                    if (c.isAssignableFrom(classes)) {
                        // 本身不加入進去
                        if (!c.equals(classes)) {
                            returnClassList.add(classes);
                        }
                    }
                }
            }
        }

        return returnClassList;
    }

    /*
     * 取得某一類所在包的所有類名 不含迭代
     */
    public static String[] getPackageAllClassName(String classLocation, String packageName) {
        // 將packageName分解
        String[] packagePathSplit = packageName.split("[.]");
        String realClassLocation = classLocation;
        int packageLength = packagePathSplit.length;
        for (int i = 0; i < packageLength; i++) {
            realClassLocation = realClassLocation + File.separator + packagePathSplit[i];
        }
        File packeageDir = new File(realClassLocation);
        if (packeageDir.isDirectory()) {
            String[] allClassName = packeageDir.list();
            return allClassName;
        }
        return null;
    }

    /**
     * 從包package中獲取所有的Class
     * 
     * @param pack
     * @return
     */
    public static List<Class<?>> getClasses(String packageName) {

        // 第一個class類的集合
        List<Class<?>> classes = new ArrayList<Class<?>>();
        // 是否迴圈迭代
        boolean recursive = true;
        // 獲取包的名字 並進行替換
        String packageDirName = packageName.replace('.', '/');
        // 定義一個列舉的集合 並進行迴圈來處理這個目錄下的things
        Enumeration<URL> dirs;
        try {
            dirs = Thread.currentThread().getContextClassLoader().getResources(packageDirName);
            // 迴圈迭代下去
            while (dirs.hasMoreElements()) {
                // 獲取下一個元素
                URL url = dirs.nextElement();
                // 得到協議的名稱
                String protocol = url.getProtocol();
                // 如果是以檔案的形式儲存在伺服器上
                if ("file".equals(protocol)) {
                    // 獲取包的物理路徑
                    String filePath = URLDecoder.decode(url.getFile(), "UTF-8");
                    // 以檔案的方式掃描整個包下的檔案 並新增到集合中
                    findAndAddClassesInPackageByFile(packageName, filePath, recursive, classes);
                } else if ("jar".equals(protocol)) {
                    // 如果是jar包檔案
                    // 定義一個JarFile
                    JarFile jar;
                    try {
                        // 獲取jar
                        jar = ((JarURLConnection) url.openConnection()).getJarFile();
                        // 從此jar包 得到一個列舉類
                        Enumeration<JarEntry> entries = jar.entries();
                        // 同樣的進行迴圈迭代
                        while (entries.hasMoreElements()) {
                            // 獲取jar裡的一個實體 可以是目錄 和一些jar包裡的其他檔案 如META-INF等檔案
                            JarEntry entry = entries.nextElement();
                            String name = entry.getName();
                            // 如果是以/開頭的
                            if (name.charAt(0) == '/') {
                                // 獲取後面的字串
                                name = name.substring(1);
                            }
                            // 如果前半部分和定義的包名相同
                            if (name.startsWith(packageDirName)) {
                                int idx = name.lastIndexOf('/');
                                // 如果以"/"結尾 是一個包
                                if (idx != -1) {
                                    // 獲取包名 把"/"替換成"."
                                    packageName = name.substring(0, idx).replace('/', '.');
                                }
                                // 如果可以迭代下去 並且是一個包
                                if ((idx != -1) || recursive) {
                                    // 如果是一個.class檔案 而且不是目錄
                                    if (name.endsWith(".class") && !entry.isDirectory()) {
                                        // 去掉後面的".class" 獲取真正的類名
                                        String className = name.substring(packageName.length() + 1, name.length() - 6);
                                        try {
                                            // 新增到classes
                                            classes.add(Class.forName(packageName + '.' + className));
                                        } catch (ClassNotFoundException e) {
                                            e.printStackTrace();
                                        }
                                    }
                                }
                            }
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

        return classes;
    }

    /**
     * 以檔案的形式來獲取包下的所有Class
     * 
     * @param packageName
     * @param packagePath
     * @param recursive
     * @param classes
     */
    public static void findAndAddClassesInPackageByFile(String packageName, String packagePath, final boolean recursive,
            List<Class<?>> classes) {
        // 獲取此包的目錄 建立一個File
        File dir = new File(packagePath);
        // 如果不存在或者 也不是目錄就直接返回
        if (!dir.exists() || !dir.isDirectory()) {
            return;
        }
        // 如果存在 就獲取包下的所有檔案 包括目錄
        File[] dirfiles = dir.listFiles(new FileFilter() {
            // 自定義過濾規則 如果可以迴圈(包含子目錄) 或則是以.class結尾的檔案(編譯好的java類檔案)
            public boolean accept(File file) {
                return (recursive && file.isDirectory()) || (file.getName().endsWith(".class"));
            }
        });
        // 迴圈所有檔案
        for (File file : dirfiles) {
            // 如果是目錄 則繼續掃描
            if (file.isDirectory()) {
                findAndAddClassesInPackageByFile(packageName + "." + file.getName(), file.getAbsolutePath(), recursive,
                        classes);
            } else {
                // 如果是java類檔案 去掉後面的.class 只留下類名
                String className = file.getName().substring(0, file.getName().length() - 6);
                try {
                    // 新增到集合中去
                    classes.add(Class.forName(packageName + '.' + className));
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}