Spring Boot 開發(fā)者必看：輕松搞定許可證管控，讓項目變現(xiàn)無憂！

作者：路條編程 2025-10-09 02:20:00

本文將帶你實(shí)現(xiàn)一個基于?Spring Boot 3.x + RSA2048 非對稱加密?的許可證管理方案，覆蓋?硬件綁定、權(quán)限控制、到期驗(yàn)證?等核心能力。我們將從整體架構(gòu)、技術(shù)選型，到代碼實(shí)現(xiàn)逐步拆解，并提供完整的 API 設(shè)計，幫助開發(fā)者快速構(gòu)建商業(yè)化必備的管控體系。

在軟件產(chǎn)品逐漸走向商業(yè)化的過程中，許可證管控已經(jīng)成為必不可少的環(huán)節(jié)。無論你是在構(gòu)建企業(yè)級管理系統(tǒng)、獨(dú)立桌面應(yīng)用，還是在線化的 SaaS 服務(wù)，都需要一種可靠機(jī)制來限制授權(quán)范圍、控制功能模塊、以及設(shè)置到期時間。

缺少許可證機(jī)制，意味著你的軟件隨時可能被非法拷貝或無授權(quán)使用，直接威脅到商業(yè)收益與知識產(chǎn)權(quán)。而一個設(shè)計完善的許可證系統(tǒng)不僅能保證軟件安全，還能提供差異化定價策略，靈活支撐 按時間、按功能的付費(fèi)模式。

因此，本文將帶你實(shí)現(xiàn)一個基于 Spring Boot 3.x + RSA2048 非對稱加密 的許可證管理方案，覆蓋 硬件綁定、權(quán)限控制、到期驗(yàn)證 等核心能力。我們將從整體架構(gòu)、技術(shù)選型，到代碼實(shí)現(xiàn)逐步拆解，并提供完整的 API 設(shè)計，幫助開發(fā)者快速構(gòu)建商業(yè)化必備的管控體系。

系統(tǒng)設(shè)計思路

許可證系統(tǒng)基于 非對稱加密，核心邏輯如下：

廠商端：使用私鑰對許可證文件進(jìn)行簽名；
客戶端：使用公鑰驗(yàn)證許可證真實(shí)性；

這樣做的優(yōu)勢：

安全性高：私鑰僅存儲在廠商側(cè)，公鑰即使被泄露也無法偽造許可證；
部署靈活：支持 離線校驗(yàn)，不依賴中央服務(wù)器；
擴(kuò)展性強(qiáng)：可以靈活加上 功能點(diǎn)控制、用戶數(shù)限制 等規(guī)則。

技術(shù)選型

后端棧

Spring Boot 3.x → 快速開發(fā) Web API

Java Security API → 內(nèi)置 RSA 非對稱加密支持

Jackson → JSON 序列化和反序列化

前端棧

原生 JavaScript → 保持輕量級

TailwindCSS → 快速構(gòu)建現(xiàn)代化 UI

RESTful API → 前后端標(biāo)準(zhǔn)交互

加密算法

RSA2048 → 足夠安全的密鑰長度

SHA256withRSA → 數(shù)字簽名算法

Base64 → 簽名編碼

核心功能實(shí)現(xiàn)

以下代碼全部放在 Linux 風(fēng)格的目錄結(jié)構(gòu)中，例如：

src/main/java/com/icoderoad/license

硬件指紋獲取

硬件綁定是防止盜版的第一道防線。我們以主板序列號作為唯一標(biāo)識：

package com.icoderoad.license.util;


import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;


import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;


@Component
public class HardwareUtil {


    private static final Logger logger = LoggerFactory.getLogger(HardwareUtil.class);


    /**
     * 獲取主板序列號（Windows / Linux）
     */
    public String getMotherboardSerial() {
        String os = System.getProperty("os.name").toLowerCase();
        try {
            if (os.contains("windows")) {
                return getWindowsSerial();
            } else if (os.contains("linux")) {
                return getLinuxSerial();
            } else {
                logger.warn("不支持的系統(tǒng): {}", os);
                return "UNKNOWN";
            }
        } catch (Exception e) {
            logger.error("獲取主板序列號失敗", e);
            return "UNKNOWN";
        }
    }


    private String getWindowsSerial() throws Exception {
        Process process = Runtime.getRuntime().exec("wmic baseboard get serialnumber");
        try (BufferedReader reader = new BufferedReader(
                new InputStreamReader(process.getInputStream(), StandardCharsets.UTF_8))) {
            String line;
            while ((line = reader.readLine()) != null) {
                line = line.trim();
                if (!line.isEmpty() && !"SerialNumber".equalsIgnoreCase(line)) {
                    return line;
                }
            }
        }
        process.waitFor();
        return "UNKNOWN";
    }


    private String getLinuxSerial() throws Exception {
        Process process = Runtime.getRuntime().exec("sudo dmidecode -s baseboard-serial-number");
        try (BufferedReader reader = new BufferedReader(
                new InputStreamReader(process.getInputStream(), StandardCharsets.UTF_8))) {
            String line = reader.readLine();
            if (line != null && !line.contains("Not Specified")) {
                return line.trim();
            }
        }
        process.waitFor();
        return getLinuxSerialFromSys();
    }


    private String getLinuxSerialFromSys() {
        try {
            Process process = Runtime.getRuntime().exec("cat /sys/class/dmi/id/board_serial");
            try (BufferedReader reader = new BufferedReader(
                    new InputStreamReader(process.getInputStream(), StandardCharsets.UTF_8))) {
                String line = reader.readLine();
                return (line != null && !line.isEmpty()) ? line.trim() : "UNKNOWN";
            }
        } catch (Exception e) {
            logger.warn("讀取/sys失敗", e);
            return "UNKNOWN";
        }
    }
}

關(guān)鍵點(diǎn)：

多重策略：優(yōu)先 dmidecode，失敗則 fallback 到 /sys/class/dmi/id
異常兜底：保證失敗返回 "UNKNOWN"
統(tǒng)一編碼：避免中文亂碼

RSA 加密工具類

用于密鑰生成、簽名、驗(yàn)簽：

package com.icoderoad.license.crypto;


import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;


import java.nio.charset.StandardCharsets;
import java.security.*;
import java.security.spec.*;
import java.util.Base64;


@Component
public class RSAUtil {


    private static final Logger logger = LoggerFactory.getLogger(RSAUtil.class);
    private static final String ALGORITHM = "RSA";
    private static final String SIGN_ALGO = "SHA256withRSA";


    public KeyPair generateKeyPair() throws Exception {
        KeyPairGenerator keyGen = KeyPairGenerator.getInstance(ALGORITHM);
        keyGen.initialize(2048);
        logger.info("RSA密鑰對生成完成");
        return keyGen.generateKeyPair();
    }


    public String sign(String data, PrivateKey privateKey) throws Exception {
        Signature signature = Signature.getInstance(SIGN_ALGO);
        signature.initSign(privateKey);
        signature.update(data.getBytes(StandardCharsets.UTF_8));
        return Base64.getEncoder().encodeToString(signature.sign());
    }


    public boolean verify(String data, String sign, PublicKey publicKey) throws Exception {
        Signature signature = Signature.getInstance(SIGN_ALGO);
        signature.initVerify(publicKey);
        signature.update(data.getBytes(StandardCharsets.UTF_8));
        return signature.verify(Base64.getDecoder().decode(sign));
    }


    public PrivateKey loadPrivateKey(String pem) throws Exception {
        String key = pem.replaceAll("-----\\w+ PRIVATE KEY-----", "").replaceAll("\\s", "");
        byte[] decoded = Base64.getDecoder().decode(key);
        return KeyFactory.getInstance(ALGORITHM).generatePrivate(new PKCS8EncodedKeySpec(decoded));
    }


    public PublicKey loadPublicKey(String pem) throws Exception {
        String key = pem.replaceAll("-----\\w+ PUBLIC KEY-----", "").replaceAll("\\s", "");
        byte[] decoded = Base64.getDecoder().decode(key);
        return KeyFactory.getInstance(ALGORITHM).generatePublic(new X509EncodedKeySpec(decoded));
    }
}

許可證實(shí)體類

package com.icoderoad.license.model;


import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.annotation.JsonPropertyOrder;


import java.time.LocalDate;
import java.util.List;


@JsonPropertyOrder({"subject", "issuedTo", "hardwareId", "expireAt", "features"})
public class License {


    private String subject;
    private String issuedTo;
    private String hardwareId;


    @JsonFormat(pattern = "yyyy-MM-dd")
    private LocalDate expireAt;


    private List<String> features;
    private String signature;


    // getters, setters, toString...
}

許可證服務(wù)邏輯

負(fù)責(zé) 生成許可證 和 驗(yàn)證許可證：

package com.icoderoad.license.service;


import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.icoderoad.license.crypto.RSAUtil;
import com.icoderoad.license.model.License;
import com.icoderoad.license.util.HardwareUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;


import java.security.PrivateKey;
import java.security.PublicKey;
import java.time.LocalDate;


@Service
public class LicenseService {


    private static final Logger logger = LoggerFactory.getLogger(LicenseService.class);


    private final RSAUtil rsaUtil;
    private final HardwareUtil hardwareUtil;
    private final ObjectMapper objectMapper;


    public LicenseService(RSAUtil rsaUtil, HardwareUtil hardwareUtil, ObjectMapper objectMapper) {
        this.rsaUtil = rsaUtil;
        this.hardwareUtil = hardwareUtil;
        this.objectMapper = objectMapper;
    }


    public String generateLicense(License license, PrivateKey privateKey) throws Exception {
        if (license.getHardwareId() == null) {
            license.setHardwareId(hardwareUtil.getMotherboardSerial());
        }
        String data = objectMapper.writeValueAsString(license);
        String signature = rsaUtil.sign(data, privateKey);


        ObjectNode node = (ObjectNode) objectMapper.readTree(data);
        node.put("signature", signature);


        return objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(node);
    }


    public boolean verifyLicense(String licenseJson, PublicKey publicKey) {
        try {
            ObjectNode node = (ObjectNode) objectMapper.readTree(licenseJson);
            String signature = node.remove("signature").asText();
            License license = objectMapper.treeToValue(node, License.class);


            if (!rsaUtil.verify(objectMapper.writeValueAsString(license), signature, publicKey)) {
                return false;
            }
            if (!hardwareUtil.getMotherboardSerial().equals(license.getHardwareId())) {
                return false;
            }
            return !license.getExpireAt().isBefore(LocalDate.now());
        } catch (Exception e) {
            logger.error("驗(yàn)證失敗", e);
            return false;
        }
    }
}

REST API

package com.icoderoad.license.controller;


import com.icoderoad.license.service.LicenseService;
import org.springframework.web.bind.annotation.*;


@RestController
@RequestMapping("/api/license")
@CrossOrigin
public class LicenseController {


    private final LicenseService licenseService;


    public LicenseController(LicenseService licenseService) {
        this.licenseService = licenseService;
    }


    @PostMapping("/generate")
    public String generateLicense() {
        // 簡化演示，實(shí)際需接收請求參數(shù)
        return "生成的許可證JSON...";
    }


    @PostMapping("/verify")
    public String verifyLicense(@RequestBody String licenseJson) {
        return licenseService.verifyLicense(licenseJson, null) ? "驗(yàn)證通過" : "驗(yàn)證失敗";
    }
}