本身寫一個java的mvc框架吧（五）

時間  2019-12-13
標籤 本身 一個 java mvc 框架 欄目 Java 简体版
原文   原文鏈接

本身寫一個mvc框架吧（五）

給框架添加註解的支持

一段廢話

上一章原本是說這一章要寫視圖處理的部分，可是因爲我在測試代碼的時候須要頻繁的修改配置文件，太麻煩了。因此這一章先把支持註解的功能加上，這樣就不須要常常地修改配置文件了。java

至於視圖處理的地方，就仍是先用json吧，找時間再寫。git

項目地址在：https://github.com/hjx601496320/aMvc 。github

測試代碼在：https://github.com/hjx601496320/amvc-test 。web

怎麼寫呢？

由於在以前寫代碼的時候，我把每一個類要作的事情分的比較清楚，因此在添加這個功能的時候寫起來仍是比較簡單的，須要修改的地方也比較小。json

這一章裏咱們須要乾的事情有：mvc

  1. 定義一個註解，標識某一個class中的被添加註解的方法是一個UrlMethodMapping。app

  2. 修改配置文件，添加須要掃描的package。框架

  3. 寫一個方法，根據package中值找到其中全部的class。ide

  4. 在UrlMethodMapping的工廠類UrlMethodMappingFactory中新加一個根據註解建立UrlMethodMapping的方法。函數

  5. 在Application中的init()方法中，根據是否開啓註解支持，執行新的工廠類方法。

  6. 完了。

    多麼簡單呀～～～

如今開始寫

定義一個註解Request

關於怎樣自定義注這件事，你們能夠上網搜一下，比較簡單。我這裏只是簡單的說一下。我先把代碼貼出來：

import com.hebaibai.amvc.RequestType;
import java.lang.annotation.*;

/**
 * 表示這個類中的，添加了@Request註解的method被映射爲一個http地址。
 *
 * @author hjx
 */
@Documented
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface Request {

    /**
     * 請求類型
     * 支持GET，POST，DELETE，PUT
     *
     * @return
     */
    RequestType[] type() default {RequestType.GET, RequestType.POST, RequestType.DELETE, RequestType.PUT};

    /**
     * 請求地址
     * 添加在class上時，會將value中的值添加在其餘方法上的@Request.value()的值前，做爲基礎地址。
     *
     * @return
     */
    String value() default "/";
}

定義一個註解，須要用到一下幾個東西：

1：@interface：說明這個類是一個註解。

2：@Retention：註解的保留策略，有這麼幾個取值範圍：

代碼 說明
@Retention(RetentionPolicy.SOURCE) 註解僅存在於源碼中
@Retention(RetentionPolicy.CLASS) 註解會在class字節碼文件中存在
@Retention(RetentionPolicy.RUNTIME) 註解會在class字節碼文件中存在，運行時能夠經過反射獲取到

由於咱們在程序中須要取到自定義的註解，因此使用：RetentionPolicy.RUNTIME。

3：@Target：做用目標，表示註解能夠添加在什麼地方，取值範圍有：

代碼 說明
@Target(ElementType.TYPE) 接口、類、枚舉、註解
@Target(ElementType.FIELD) 字段、枚舉的常量
@Target(ElementType.METHOD) 方法
@Target(ElementType.PARAMETER) 方法參數
@Target(ElementType.CONSTRUCTOR) 構造函數
@Target(ElementType.LOCAL_VARIABLE) 局部變量
@Target(ElementType.ANNOTATION_TYPE) 註解
@Target(ElementType.PACKAGE) 包

3：@Documented：這個主要是讓自定義註解保留在文檔中，沒啥實際意義，通常都給加上。

4：default：是給註解中的屬性（看起來像是一個方法，也可能就是一個方法，可是我就是叫屬性，略略略～～～）一個默認值。

上面大體上講了一下怎麼定義一個註解，如今註解寫完了，講一下這個註解的用處吧。

首先這個註解能夠加在class和method上。加在class上的時候表示這個類中會有method將要被處理成爲一個UrlMethodMapping，而後其中的value屬性將做爲這個class中全部UrlMethodMapping的基礎地址，type屬性不起做用。加在method上的時候，就是說明這個method將被處理成一個UrlMethodMapping，註解的兩個屬性發揮其正常的做用。

註解寫完了，下面把配置文件改一改吧。

修改框架的配置文件

只須要添加一個屬性就行了，修改完的配置文件這個樣子：

{
  "annotationSupport": true,
  "annotationPackage": "com.hebaibai.demo.web",
//  "mapping": [
//    {
//      "url": "/index",
//      "requestType": [
//        "get"
//      ],
//      "method": "index",
//      "objectClass": "com.hebaibai.demo.web.IndexController",
//      "paramTypes": [
//        "java.lang.String",
//        "int"
//      ]
//    }
//  ]
}

1：annotationSupport 值是true的時候表示開啓註解。

2：annotationPackage 表示須要掃描的包的路徑。

3：由於開了註解支持，爲了防止重複註冊 UrlMethodMapping，因此我把下面的配置註釋掉了。

寫一個包掃描的方法

這個方法須要將項目中jar文件和文件夾下全部符合條件的class找到，會用到遞歸，代碼在ClassUtils.java中，由三個方法構成，分別是：

1：void getClassByPackage(String packageName, Set classes);

這個方法接收兩個參數，一個是包名packageName，一個是一個空的Set (不是null)，在方法執行完畢會將包下的全部class填充進Set中。這裏主要是判斷了一下這個包中有那些類型的文件，並根據文件類型分別處理。

注意：若是是jar文件的類型，獲取到的filePath是這樣的：

file:/home/hjx/idea-IU/lib/idea_rt.jar!/com

須要去掉頭和尾，而後就能夠吃了，雞肉味！嘎嘣脆～～ 處理以後的是這個樣子：

/home/hjx/idea-IU/lib/idea_rt.jar

下面是方法代碼：

/**
 * 從給定的報名中找出全部的class
 *
 * @param packageName
 * @param classes
 */
@SneakyThrows({IOException.class})
public static void getClassByPackage(String packageName, Set<Class> classes) {
    Assert.notNull(classes);
    String packagePath = packageName.replace(DOT, SLASH);
    Enumeration<URL> resources = ClassUtils.getClassLoader().getResources(packagePath);
    while (resources.hasMoreElements()) {
        URL url = resources.nextElement();
        //文件類型
        String protocol = url.getProtocol();
        String filePath = URLDecoder.decode(url.getFile(), CHARSET_UTF_8);
        if (TYPE_FILE.equals(protocol)) {
            getClassByFilePath(packageName, filePath, classes);
        }
        if (TYPE_JAR.equals(protocol)) {
            //截取文件的路徑
            filePath = filePath.substring(filePath.indexOf(":") + 1, filePath.indexOf("!"));
            getClassByJarPath(packageName, filePath, classes);
        }
    }
}

2：void getClassByFilePath(String packageName, String filePath, Set classes)

將文件夾中的所有符合條件的class找到，用到遞歸。須要將class文件的絕對路徑截取成class的全限定名，代碼這個樣子：

/**
 * 在文件夾中遞歸找出該文件夾中在package中的class
 *
 * @param packageName
 * @param filePath
 * @param classes
 */
static void getClassByFilePath(
    String packageName,
    String filePath,
    Set<Class> classes
) {
    File targetFile = new File(filePath);
    if (!targetFile.exists()) {
        return;
    }
    if (targetFile.isDirectory()) {
        File[] files = targetFile.listFiles();
        for (File file : files) {
            String path = file.getPath();
            getClassByFilePath(packageName, path, classes);
        }
    } else {
        //若是是一個class文件
        boolean trueClass = filePath.endsWith(CLASS_MARK);
        if (trueClass) {
            //提取完整的類名
            filePath = filePath.replace(SLASH, DOT);
            int i = filePath.indexOf(packageName);
            String className = filePath.substring(i, filePath.length() - 6);
            //不是一個內部類
            boolean notInnerClass = className.indexOf("$") == -1;
            if (notInnerClass) {
                //根據類名加載class對象
                Class aClass = ClassUtils.forName(className);
                if (aClass != null) {
                    classes.add(aClass);
                }
            }
        }
    }
}

3：void getClassByJarPath(String packageName, String filePath, Set classes)

將jar文件中的所有符合條件的class找到。沒啥說的，下面是代碼：

/**
 * 在jar文件中找出該文件夾中在package中的class
 *
 * @param packageName
 * @param filePath
 * @param classes
 */
@SneakyThrows({IOException.class})
static void getClassByJarPath(
    String packageName,
    String filePath,
    Set<Class> classes
) {
    JarFile jarFile = new URLJarFile(new File(filePath));
    Enumeration<JarEntry> entries = jarFile.entries();
    while (entries.hasMoreElements()) {
        JarEntry jarEntry = entries.nextElement();
        String jarEntryName = jarEntry.getName().replace(SLASH, DOT);
        //在package下的class
        boolean trueClass = jarEntryName.endsWith(CLASS_MARK) && jarEntryName.startsWith(packageName);
        //不是一個內部類
        boolean notInnerClass = jarEntryName.indexOf("$") == -1;
        if (trueClass && notInnerClass) {
            String className = jarEntryName.substring(0, jarEntryName.length() - 6);
            System.out.println(className);
            //根據類名加載class對象
            Class aClass = ClassUtils.forName(className);
            if (aClass != null) {
                classes.add(aClass);
            }
        }
    }
}

這樣，獲取包名下的class就寫完了～

修改UrlMethodMappingFactory

這裏新添加一個方法：

List getUrlMethodMappingListByClass(Class aClass) ，將掃描包以後獲取到的Class對象做爲參數，返回一個UrlMethodMapping集合就行了。代碼以下：

/**
 * 經過解析Class 獲取映射
 *
 * @param aClass
 * @return
 */
public List<UrlMethodMapping> getUrlMethodMappingListByClass(Class<Request> aClass) {
    List<UrlMethodMapping> mappings = new ArrayList<>();
    Request request = aClass.getDeclaredAnnotation(Request.class);
    if (request == null) {
        return mappings;
    }
    String basePath = request.value();
    for (Method classMethod : aClass.getDeclaredMethods()) {
        UrlMethodMapping urlMethodMapping = getUrlMethodMappingListByMethod(classMethod);
        if (urlMethodMapping == null) {
            continue;
        }
        //將添加在class上的Request中的path做爲基礎路徑
        String url = UrlUtils.makeUrl(basePath + "/" + urlMethodMapping.getUrl());
        urlMethodMapping.setUrl(url);
        mappings.add(urlMethodMapping);
    }
    return mappings;
}

/**
 * 經過解析Method 獲取映射
 * 註解Request不存在時跳出
 *
 * @param method
 * @return
 */
private UrlMethodMapping getUrlMethodMappingListByMethod(Method method) {
    Request request = method.getDeclaredAnnotation(Request.class);
    if (request == null) {
        return null;
    }
    Class<?> declaringClass = method.getDeclaringClass();
    String path = request.value();
    for (char c : path.toCharArray()) {
        Assert.isTrue(c != ' ', declaringClass + "." + method.getName() + "請求路徑異常：" + path + " ！");
    }
    return getUrlMethodMapping(
            path,
            request.type(),
            declaringClass,
            method,
            method.getParameterTypes()
    );
}

在這裏校驗了一下註解Request中的value的值，若是中間有空格的話會拋出異常。UrlUtils.makeUrl() 這個方法主要是將url中的多餘」/」去掉，代碼長這個樣子：

private static final String SLASH = "/";

/**
 * 處理url
 * 1：去掉鏈接中相鄰並重復的「/」,
 * 2：連接開頭沒有「/」,則添加。
 * 3：連接結尾有「/」，則去掉。
 *
 * @param url
 * @return
 */
public static String makeUrl(@NonNull String url) {
    char[] chars = url.toCharArray();
    StringBuilder newUrl = new StringBuilder();
    if (!url.startsWith(SLASH)) {
        newUrl.append(SLASH);
    }
    for (int i = 0; i < chars.length; i++) {
        if (i != 0 && chars[i] == chars[i - 1] && chars[i] == '/') {
            continue;
        }
        if (i == chars.length - 1 && chars[i] == '/') {
            continue;
        }
        newUrl.append(chars[i]);
    }
    return newUrl.toString();
}

這樣經過註解獲取UrlMethodMapping的工廠方法就寫完了，下面開始修改加載框架的代碼。

修改Application中的init

這裏由於添加了一種使用註解方式獲取UrlMethodMapping的方法，因此新建一個方法：

void addApplicationUrlMappingByAnnotationConfig(JSONObject configJson) 。在這裏獲取框架配置中的包名以及作一些配置上的校驗，代碼以下：

/**
 * 使用註解來加載UrlMethodMapping
 *
 * @param configJson
 */
private void addApplicationUrlMappingByAnnotationConfig(JSONObject configJson) {
    String annotationPackage = configJson.getString(ANNOTATION_PACKAGE_NODE);
    Assert.notNull(annotationPackage, ANNOTATION_PACKAGE_NODE + NOT_FIND);
    //獲取添加了@Request的類
    Set<Class> classes = new HashSet<>();
    ClassUtils.getClassByPackage(annotationPackage, classes);
    Iterator<Class> iterator = classes.iterator();
    while (iterator.hasNext()) {
        Class aClass = iterator.next();
        List<UrlMethodMapping> mappings = urlMethodMappingFactory.getUrlMethodMappingListByClass(aClass);
        if (mappings.size() == 0) {
            continue;
        }
        for (UrlMethodMapping mapping : mappings) {
            addApplicationUrlMapping(mapping);
        }
    }
}

以後把先前寫的讀取json配置生成urlMappin的代碼摘出來，單獨寫一個方法：

void addApplicationUrlMappingByJsonConfig(JSONObject configJson)，這樣使代碼中的每一個方法的功能都獨立出來，看起來比較整潔，清楚。代碼以下：

/**
 * 使用文件配置來加載UrlMethodMapping
 * 配置中找不到的話不執行。
 *
 * @param configJson
 */
private void addApplicationUrlMappingByJsonConfig(JSONObject configJson) {
    JSONArray jsonArray = configJson.getJSONArray(MAPPING_NODE);
    if (jsonArray == null || jsonArray.size() == 0) {
        return;
    }
    for (int i = 0; i < jsonArray.size(); i++) {
        UrlMethodMapping mapping = urlMethodMappingFactory.getUrlMethodMappingByJson(jsonArray.getJSONObject(i));
        addApplicationUrlMapping(mapping);
    }
}

最後只要吧init()稍微修改一下就行了，修改完以後是這樣的：

/**
 * 初始化配置
 */
@SneakyThrows(IOException.class)
protected void init() {
    String configFileName = applicationName + ".json";
    InputStream inputStream = ClassUtils.getClassLoader().getResourceAsStream(configFileName);
    byte[] bytes = new byte[inputStream.available()];
    inputStream.read(bytes);
    String config = new String(bytes, "utf-8");
    //應用配置
    JSONObject configJson = JSONObject.parseObject(config);

    //TODO:生成對象的工廠類（先默認爲每次都new一個新的對象）
    this.objectFactory = new AlwaysNewObjectFactory();
    //TODO:不一樣的入參名稱獲取類（當前默認爲asm）
    urlMethodMappingFactory.setParamNameGetter(new AsmParamNameGetter());
    //經過文件配置加載
    addApplicationUrlMappingByJsonConfig(configJson);
    //是否開啓註解支持
    Boolean annotationSupport = configJson.getBoolean(ANNOTATION_SUPPORT_NODE);
    Assert.notNull(annotationSupport, ANNOTATION_SUPPORT_NODE + NOT_FIND);
    if (annotationSupport) {
        addApplicationUrlMappingByAnnotationConfig(configJson);
    }
}

這裏只是根據配置作了一下判斷就行了。這樣就寫完了。

最後

是否是很簡單啊～～～
關於視圖處理的部分看看下一章再寫吧～～～

最新修改一下

沒人看，不寫了。等我先給我本身的小網站框架換成本身寫的再說。
中間這個框架可能會常常行的修改～

完

拜拜～～

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程