手寫SpringMVC

来源:https://www.cnblogs.com/yunxi520/archive/2019/12/19/12070373.html
-Advertisement-
Play Games

環境描述 idea java 8 1. POM文件 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/ ...


環境描述

idea

java 8

1. POM文件

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>org.feng</groupId>
  <artifactId>hand-springmvc</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>hand-springmvc Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>Example Domain</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
  </properties>

  <dependencies>
    <!--測試-->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>

    <!--日誌-->
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-log4j12</artifactId>
      <version>1.7.25</version>
    </dependency>
    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>1.2.17</version>
    </dependency>

    <!--servlet-->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.0.1</version>
    </dependency>
  </dependencies>

  <build>
    <finalName>hand-springmvc</finalName>
    <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
    </pluginManagement>
  </build>
</project>

 

2. log4j.properties

log4j.rootLogger=INFO, console

log4j.appender.console=org.apache.log4j.ConsoleAppender
log4j.appender.console.layout=org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=%d{HH:mm:ss,SSS} %-5p %-60c %x - %m%n

 

3. 項目目錄

核心內容是註解+servlet

註解類

org.feng.annotation.Autowired

package org.feng.annotation;

import java.lang.annotation.*;

/**
 * Created by Feng on 2019/12/16 17:58
 * CurrentProject's name is hand-springmvc
 * Autowired 用在變數上
 * @author Feng
 */
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Autowired {
    String value() default "";
}

 

org.feng.annotation.Controller

package org.feng.annotation;

import java.lang.annotation.*;

/**
 * Created by Feng on 2019/12/16 18:01
 * CurrentProject's name is hand-springmvc
 * Controller 用在類上
 * @author Feng
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Controller {
    String value() default "";
}

 

org.feng.annotation.RequestMapping

package org.feng.annotation;

import java.lang.annotation.*;

/**
 * Created by Feng on 2019/12/16 18:02
 * CurrentProject's name is hand-springmvc
 * RequestMapping可以用在類、方法上
 * @author Feng
 */
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RequestMapping {
    String value() default "";
}

 

org.feng.annotation.RequestParam

package org.feng.annotation;

import java.lang.annotation.*;

/**
 * Created by Feng on 2019/12/16 18:06
 * CurrentProject's name is hand-springmvc
 * RequestParam 用在參數上
 * @author Feng
 */
@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RequestParam {
    String value() default "";
}

 

org.feng.annotation.Service

package org.feng.annotation;

import java.lang.annotation.*;

/**
 * Created by Feng on 2019/12/16 18:05
 * CurrentProject's name is hand-springmvc
 * Service 用在類上
 * @author Feng
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Service {
    String value() default "";
}

 

核心控制器

package org.feng.servlet;
import org.feng.annotation.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.File;
import java.io.IOException;
import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * Created by Feng on 2019/12/16 17:58
 * CurrentProject's name is hand-springmvc<br>
 * 核心控制器：
 * <ul>實現思路
 *      <li>先掃描基礎包，獲取 {@code class} 文件的路徑；其實是為了獲取完整類名</li>
 *      <li>根據上邊的完整類名以及判斷是否有指定創建實例（通過有無註解和註解的類型）並保存實例到 {@code map} 中</li>
 *      <li>依賴註入變數，從實例獲得類對象，然後解析 {@code Field} 並賦值給標註了{@link Autowired}的{@code Field}</li>
 *      <li>獲取方法上的參數，通過{@link HttpServletRequest}獲取</li>
 * </ul>
 * @author Feng
 */
public class DispatcherServlet extends HttpServlet {

    /**
     * 掃描包：基本的包，掃描該路徑下的所有類
     */
    private static final String BASE_PACKAGE = "org.feng";

    private static final String WAR_NAME = "/hand_springmvc";
    /**日誌*/
    private static final Logger LOGGER = LoggerFactory.getLogger(DispatcherServlet.class);

    /**
     * 保存class文件的路徑
     */
    private List<String> classPathList = new ArrayList<>();

    /**
     * IOC容器：存放對象；使用{@link ConcurrentHashMap}保證線程安全
     */
    private Map<String, Object> beans = new ConcurrentHashMap<>(16);

    /**
     * 存放方法映射：使用{@link ConcurrentHashMap}保證線程安全<br>
     * 用於存儲方法<br>
     * {@code key = classpath + methodPath; value = method}
     */
    private Map<String, Method> handlerMap = new ConcurrentHashMap<>(16);

    /**
     * 初始化數據：
     * <ul>
     *     <li>掃描所有的類</li>
     *     <li>創建實例並存儲進 {@code beans}</li>
     *     <li>依賴註入：使用 {@code Autowired}</li>
     *     <li>拼接請求地址初始化、方法映射</li>
     * </ul>
     */
    @Override
    public void init() {
        LOGGER.info("starting scan package into classpath list");
        scanPackage(BASE_PACKAGE);
        LOGGER.info("scan package end");
        LOGGER.info("classPathList:"+classPathList);

        LOGGER.info("starting create instance into bean map");
        createInstance();
        LOGGER.info("create instance end");
        LOGGER.info("beans:" + beans);

        LOGGER.info("starting autowired field");
        autowiredField();
        LOGGER.info("autowired field end");

        LOGGER.info("starting mapping to url");
        urlMapping();
        LOGGER.info("mapping to url end");
        LOGGER.info("handler mapping:" + handlerMap);
    }

    /**
     * 方法映射
     */
    private void urlMapping() {
        beans.forEach((key, value) -> {
            Class<?> clazz = value.getClass();
            if(clazz.isAnnotationPresent(Controller.class)){
                RequestMapping requestMapping = clazz.getAnnotation(RequestMapping.class);
                String classPath = requestMapping.value();

                Method[] methods = clazz.getDeclaredMethods();
                for (Method method : methods) {
                    if(method.isAnnotationPresent(RequestMapping.class)){
                        RequestMapping requestMapping1 = method.getAnnotation(RequestMapping.class);
                        String methodPath = requestMapping1.value();
                        handlerMap.put(classPath + methodPath, method);
                    }
                }
            }
        });
    }

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) {
        this.doPost(req, resp);
    }

    /**
     * 解析調用方法後的返回值：當為String類型時，得到其是轉發還是重定向；
     * @param invokeReturn invoke方法時得到的返回值
     * @param req 請求對象
     * @param resp 響應對象
     */
    private void forwardOrRedirect(Object invokeReturn, HttpServletRequest req,
                                   HttpServletResponse resp) throws IOException, ServletException {
        final String forward = "forward:";
        final String redirect = "redirect:";

        // 當反向調用方法有返回值
        if(invokeReturn != null){
            // 返回值是字元串：解析字元串
            if(invokeReturn.getClass() == String.class){
                req.setCharacterEncoding("UTF-8");
                resp.setCharacterEncoding("UTF-8");
                String returnStr = invokeReturn.toString();

                if(returnStr.startsWith(forward)){
                    returnStr = returnStr.substring(8);
                    LOGGER.info(forward + returnStr);
                    req.getRequestDispatcher(WAR_NAME + returnStr).forward(req, resp);
                } else if(returnStr.startsWith(redirect)){
                    returnStr = returnStr.substring(9);
                    LOGGER.info(redirect + returnStr);
                    resp.sendRedirect(WAR_NAME + returnStr);
                } else {
                    LOGGER.info(redirect + returnStr);
                    resp.sendRedirect(returnStr);
                }
            }
        }
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) {
        // 請求的地址
        String uri = req.getRequestURI();
        uri = uri.replace(WAR_NAME, "");

        int index = uri.indexOf("/", 1);
        String controllerUrl = uri.substring(0, index);
        Method method = handlerMap.get(uri);
        LOGGER.info("get method " + method);

        beans.forEach((key, value) -> {
            Class<?> clazz = value.getClass();
            if(clazz.isAnnotationPresent(Controller.class)){
                RequestMapping requestMapping = clazz.getAnnotation(RequestMapping.class);
                String valueTemp = requestMapping.value();
                if(controllerUrl.equals(valueTemp)){
                    try {
                        LOGGER.info("invoking " + controllerUrl + "." + value);
                        Object invokeReturn = method.invoke(value, getArgs(req, resp, method));
                        // 控制：轉發或重定向
                        forwardOrRedirect(invokeReturn, req, resp);
                    } catch (IllegalAccessException | InvocationTargetException e) {
                        LOGGER.error("invoke error in " + controllerUrl);
                    } catch (ServletException | IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
    }


    /**
     * 解析標註有{@link RequestParam}的方法參數，並賦值
     * @param req 請求對象
     * @param resp 響應對象
     * @param method 方法對象
     * @return 賦值後的參數
     */
    private Object[] getArgs(HttpServletRequest req, HttpServletResponse resp, Method method) {
        // 拿到當前類待執行的方法參數
        Class<?>[] clazzParams = method.getParameterTypes();

        // 定義存儲參數的數組
        Object[] args = new Object[clazzParams.length];

        int argsIndex = 0;
        // 判定此 class 對象所表示的類或介面與指定的 class 參數所表示的類或介面是否相同
        // 或是否是其超類或超介面
        for (int index = 0; index < clazzParams.length; index++) {
            if(ServletRequest.class.isAssignableFrom(clazzParams[index])){
                args[argsIndex ++] = req;
            }
            if(ServletResponse.class.isAssignableFrom(clazzParams[index])){
                args[argsIndex ++] = resp;
            }

            Annotation[] annotations = method.getParameterAnnotations()[index];
            if(annotations.length > 0){
                for (Annotation annotation : annotations) {
                    if(RequestParam.class.isAssignableFrom(annotation.getClass())){
                        RequestParam requestParam = (RequestParam) annotation;
                        // 找到註解的名字
                        args[argsIndex ++] = req.getParameter(requestParam.value());
                    }
                }
            }
        }
        return args;
    }

    /**
     * 依賴註入：對帶有{@link org.feng.annotation.Autowired}的屬性賦值
     */
    private void autowiredField() {
        beans.forEach((key, value) ->{
            Class<?> clazz = value.getClass();
            if(clazz.isAnnotationPresent(Controller.class)){
                // 獲取屬性
                Field[] declaredFields = clazz.getDeclaredFields();
                for (Field declaredField : declaredFields) {
                   if(!declaredField.isAnnotationPresent(Autowired.class)){
                        continue;
                   }

                   // 當存在 Autowired 標註的屬性時
                   Autowired autowired = declaredField.getAnnotation(Autowired.class);
                   String beanName;
                   if("".equals(autowired.value())){
                       beanName = lowerFirstChar(declaredField.getType().getSimpleName());
                   } else {
                       beanName = autowired.value();
                   }

                   // 設置訪問控制許可權：原先是 private 不能訪問
                   declaredField.setAccessible(true);

                   // 自定義介面實現類：以Impl結尾，前邊拼接介面名（首字母小寫）
                   if(beanName.endsWith("Impl")){
                       beanName = beanName.replace("Impl", "");
                   }
                   if(beans.get(beanName) != null){
                       try {
                           // 給聲明的變數賦值：註入實例
                           declaredField.set(value, beans.get(beanName));
                       } catch (IllegalAccessException e) {
                           e.printStackTrace();
                       }
                   }
                }
            }
        });
    }


    /**
     * 創建實例：遍歷所有的{@code class}文件，創建需要創建的實例存儲到beans中<br>
     * 判斷：是否被指定註解標註了
     * <ul>
     *     <li>首先判斷是不是{@link org.feng.annotation.Service}註解的類，若是則判斷有沒有傳入的{@code service}名稱</li>
     *     <li>其他情況，包括是{@link org.feng.annotation.Controller}的情況，全部使用小寫類名為{@code key}</li>
     * </ul>
     */
    private void createInstance() {
        try {
            // 遍歷所有的.class文件；將需要實例化的類創建實例
            for (String classPath : classPathList) {
                Class<?> clazz = Class.forName(classPath.replace(".class", ""));

                if(clazz.isAnnotationPresent(Service.class)){
                    Service service = clazz.getAnnotation(Service.class);
                    String key = service.value();
                    // 當傳入了註解中參數時
                    if(!"".equals(key)){
                        beans.put(key, clazz.newInstance());
                        LOGGER.info("created instance by " + classPath);
                    } else {
                        // 獲取第一個介面的簡單名稱，首字母小寫
                        beans.put(lowerFirstChar(clazz.getInterfaces()[0].getSimpleName()), clazz.newInstance());
                        LOGGER.info("created instance by " + classPath);
                    }
                } else if(clazz.isAnnotationPresent(Controller.class)){
                    // 以類名小寫首字母為key
                    beans.put(lowerFirstChar(clazz.getSimpleName()), clazz.newInstance());
                    LOGGER.info("created instance by " + classPath);
                }
            }
        } catch (ClassNotFoundException | IllegalAccessException | InstantiationException e) {
            LOGGER.error("error in createInstance", e);
        }
    }

    /**
     * 將類名中的首字母小寫
     * @param simpleName 類名（不含包名）
     */
    private String lowerFirstChar(String simpleName) {
        char[] chars = simpleName.toCharArray();
        chars[0] += 32;
        return new String(chars);
    }

    /**
     * 先通過傳入的包名拼接出文件路徑:
     * <p>
     * {@code "org.feng".replace(".", "/");}
     * </p>
     * 遞歸掃描指定路徑下的所有{@code class}文件；
     * 存儲{@code class}文件路徑到集合中
     * @param basePackage 掃描包的包名
     */
    private void scanPackage(String basePackage) {

        // 將包名轉換為class文件路徑
        String resourceName = "/" + basePackage.replace(".", "/");
        URL url = this.getClass().getClassLoader().getResource(resourceName);

        // 獲取文件
        assert url != null;
        String filename = url.getFile();
        File file = new File(filename);

        // 獲取所有文件
        String[] files = file.list();
        assert files != null;
        for (String path : files) {
            File fileTemp = new File(filename + path);
            // 當前如果是目錄，遞歸掃描包
            String packageName = basePackage + "." + path;
            if(fileTemp.isDirectory()){
                scanPackage(packageName);
            } else {
                // 當掃描到文件(.class文件)，增加到類路徑集合
                classPathList.add(packageName);
                LOGGER.info("scan " + packageName + " into classpath list");
            }
        }
    }
}

 

 

測試

org.feng.service.MyService

package org.feng.service;

/**
 * Created by Feng on 2019/12/17 9:23
 * CurrentProject's name is hand-springmvc
 * @author Feng
 */
public interface MyService {
    /**
     * 說
     * @return 字元串
     */
    String say();

 

org.feng.service.impl.MyServiceImpl

package org.feng.service.impl;

import org.feng.annotation.Service;
import org.feng.service.MyService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Created by Feng on 2019/12/17 9:25
 * CurrentProject's name is hand-springmvc
 * @author Feng
 */
@Service
public class MyServiceImpl implements MyService {

    private static final Logger LOGGER = LoggerFactory.getLogger(MyServiceImpl.class);

    public MyServiceImpl(){
        LOGGER.info("no args constructor MyServiceImpl.class");
    }

    @Override
    public String say() {
        return "MyServiceImpl invoking say()";
    }
}

 

org.feng.controller.MyController

package org.feng.controller;

import org.feng.annotation.Autowired;
import org.feng.annotation.Controller;
import org.feng.annotation.RequestMapping;
import org.feng.annotation.RequestParam;
import org.feng.service.MyService;

/**
 * Created by Feng on 2019/12/17 9:27
 * CurrentProject's name is hand-springmvc
 */
@RequestMapping("/MyController")
@Controller
public class MyController {

    @Autowired
    private MyService myService;

    @RequestMapping("/say.do")
    public String say(@RequestParam("name") String name, @RequestParam("info") String info){
        System.out.println("name = " + name + ", info = " + info);
        myService.say();
        return "redirect:/index.jsp";
    }
}

 

運行

配置tomcat

運行結果：

 

 

————————————————

本人免費整理了Java高級資料，涵蓋了Java、Redis、MongoDB、MySQL、Zookeeper、Spring Cloud、Dubbo高併發分散式等教程，一共30G，需要自己領取。
傳送門：https://mp.weixin.qq.com/s/osB-BOl6W-ZLTSttTkqMPQ


您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • Dubbo環境搭建-管理控制台dubbo-admin實現服務監控
    場景 Dubbo環境搭建-ZooKeeper註冊中心： https://blog.csdn.net/BADAO_LIUMANG_QIZHI/article/details/103555470 在上面搭建好ZooKeeper註冊中心後，搭建管理控制台實現服務監控。 註： 博客： https://blo ...
  • Docker swarm實戰總結
    一、簡介 Swarm 是 Docker 官方提供的一款集群管理工具，其主要作用是把若幹台 Docker 主機抽象為一個整體，並且通過一個入口統一管理這些 Docker 主機上的各種 Docker 資源。 Docker Swarm 包含兩方面：一個企業級的 Docker 安全集群，以及一個微服務應用編 ...
  • DjangoRestFramework，認證組件、許可權組件、頻率組件、url註冊器、響應器、分頁組件
    一 認證組件 1. 局部認證組件 我們知道，我們不管路由怎麼寫的，對應的視圖類怎麼寫的，都會走到dispatch方法，進行分發， 在咱們看的APIView類中的dispatch方法的源碼中，有個self.initial(request, args, kwargs)，那麼認證、許可權、頻率這三個預設組件 ...
  • 在命令提示符下，運行Java程式時，提示"找不到或無法載入主類"
    小白：在命令提示符下，運行Java程式時，提示"找不到或無法載入主類"。 大神：運行Java程式的作用是讓Java解釋器裝載，檢驗並運行位元組碼文件（.class)。因此，在運行Java程式時，命令語句不可以輸錯。運行Java程式的命令是“java 文件名”，java後面跟空格，文件名後不能再加擴展名 ...
  • Java連載62-使用throws關鍵字處理異常
    ​一、處理異常的兩種方式 1.所有的編譯時異常，要求程式員在編寫程式階段，必須對它進行處理，如果不處理的話，編譯就會無法通過，處理異常有兩種方法：捕捉和聲明拋出。 2.捕捉：try.....catch....... 3.聲明拋出就是方法聲明的位置上使用throws關鍵字拋出異常。 4.所有Runti ...
  • tp5.1 無限極分類前臺展示
    商城前臺的多級分類展示，如圖所示，一般是三級。所以代碼只組裝到第三級。 資料庫設計，共5個欄位。level欄位是方便用來顯示級別的。pid是父級分類id，pid等於0說明它是一級分類。path欄位，舉個例子。id為8的短褲0,1,3,8 在一級分類屬於服裝（1），在二級分類屬於男裝（3），三級分類屬 ...
  • 關於繼承與多態
    關於繼承與多態的幾點總結 1、父類的所有方法都能被繼承嗎？能被重寫嗎？能表現出多態性嗎？ 1.1 非靜態方法 1.1.1 被public、default、protected修飾的非靜態方法 能被子類繼承，如果沒有被final修飾，則能被重寫，當父類引用指向子類對象時，表現出多態性。 1.1.2 被p ...
  • 這幾天加班熬夜把所有Python庫整理了一遍，非常全面！
    庫名稱簡介 Chardet 字元編碼探測器，可以自動檢測文本、網頁、xml的編碼。colorama 主要用來給文本添加各種顏色，並且非常簡單易用。Prettytable 主要用於在終端或瀏覽器端構建格式化的輸出。difflib，[Python]標準庫，計算文本差異Levenshtein，快速計算字元 ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類