keytool -exportcert -alias "privateKey" -keystore "privateKeys.keystore" -storepass "wu@2024555" -file "certfile.cer"

keytool -import -alias "publicCert" -file "certfile.cer" -keystore "publicCerts.keystore" -storepass "wu@2024555"

license:
  # 證書(shū)subject
  subject: license-test-web
  # 公鑰別稱(chēng)
  publicAlias: publicCert
  # 訪(fǎng)問(wèn)公鑰庫(kù)的密碼
  storePass: wu@2024555
  # 證書(shū)路徑
  licensePath: /data/license/license.lic
  # 公鑰路徑
  publicKeysStorePath: /data/license/publicCerts.keystore

<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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>license-client</artifactId>
    <version>1.0.0</version>
    <name>license-client</name>
    <description>license-client</description>
    <properties>
        <java.version>1.8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <spring-boot.version>2.6.13</spring-boot.version>
        <!-- Java Servlet API -->
        <javax.servlet-api>4.0.1</javax.servlet-api>
        <!-- Apache Commons系列公共庫(kù) -->
        <commons-lang3>3.7</commons-lang3>
        <commons-io>2.6</commons-io>
        <commons-codec>1.11</commons-codec>
        <!-- Apache HttpClient -->
        <httpclient>4.5.5</httpclient>
        <!-- Fastjson -->
        <fastjson>1.2.47</fastjson>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- Commons -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>${commons-lang3}</version>
        </dependency>
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>${commons-io}</version>
        </dependency>
        <dependency>
            <groupId>commons-codec</groupId>
            <artifactId>commons-codec</artifactId>
            <version>${commons-codec}</version>
        </dependency>
        <!-- Apache HttpClient -->
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>${httpclient}</version>
        </dependency>
        <!-- Fastjson -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>${fastjson}</version>
        </dependency>
        <!-- Java Servlet API -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>${javax.servlet-api}</version>
            <scope>provided</scope>
        </dependency>
        <!-- Jackson對(duì)自動(dòng)解析JSON和XML格式的支持 -->
        <dependency>
            <groupId>com.fasterxml.jackson.jaxrs</groupId>
            <artifactId>jackson-jaxrs-json-provider</artifactId>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.dataformat</groupId>
            <artifactId>jackson-dataformat-xml</artifactId>
        </dependency>
        <!-- SLF4J和LogBack -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>jcl-over-slf4j</artifactId>
        </dependency>
        <!-- License -->
        <dependency>
            <groupId>de.schlichtherle.truelicense</groupId>
            <artifactId>truelicense-core</artifactId>
            <version>1.33</version>
        </dependency>
        <dependency>
            <groupId>net.sourceforge.nekohtml</groupId>
            <artifactId>nekohtml</artifactId>
            <version>1.9.22</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>
    <dependencyManagement>
        <dependencies>
            <!-- SpringBoot的依賴(lài)配置-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>${java.version}</source>
                    <target>${java.version}</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

@Data
@AllArgsConstructor
@NoArgsConstructor
public class LicenseVerifyParam {
    /**
     * 證書(shū)subject
     */
    private String subject;
    /**
     * 公鑰別稱(chēng)
     */
    private String publicAlias;
    /**
     * 訪(fǎng)問(wèn)公鑰庫(kù)的密碼
     */
    private String storePass;
    /**
     * 證書(shū)生成路徑
     */
    private String licensePath;
    /**
     * 密鑰庫(kù)存儲(chǔ)路徑
     */
    private String publicKeysStorePath;
}

import com.example.licenseclient.core.LicenseCheckModel;
import com.example.licenseclient.serverinfo.AbstractServerInfos;
import com.example.licenseclient.serverinfo.LinuxServerInfos;
import com.example.licenseclient.serverinfo.WindowsServerInfos;
import de.schlichtherle.license.*;
import de.schlichtherle.xml.GenericCertificate;
import org.apache.commons.lang3.StringUtils;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import java.beans.XMLDecoder;
import java.io.BufferedInputStream;
import java.io.ByteArrayInputStream;
import java.io.UnsupportedEncodingException;
import java.util.Date;
import java.util.List;
/**
 * @author benjamin5
 * @Description 自定義LicenseManager，用于增加額外的服務(wù)器硬件信息校驗(yàn)
 * @createTime 2024/10/31
 */
public class CustomLicenseManager extends LicenseManager {
    private static Logger logger = LogManager.getLogger(CustomLicenseManager.class);
    //XML編碼
    private static final String XML_CHARSET = "UTF-8";
    //默認(rèn)BUFSIZE
    private static final int DEFAULT_BUFSIZE = 8 * 1024;
    public CustomLicenseManager() {
    }
    public CustomLicenseManager(LicenseParam param) {
        super(param);
    }
    /**
     * @title create
     * @description 復(fù)寫(xiě)create方法
     */
    @Override
    protected synchronized byte[] create(
            LicenseContent content,
            LicenseNotary notary)
            throws Exception {
        initialize(content);
        this.validateCreate(content);
        final GenericCertificate certificate = notary.sign(content);
        return getPrivacyGuard().cert2key(certificate);
    }
    /**
     * @title install
     * @description 復(fù)寫(xiě)install方法，其中validate方法調(diào)用本類(lèi)中的validate方法，校驗(yàn)IP地址、Mac地址等其他信息
     */
    @Override
    protected synchronized LicenseContent install(
            final byte[] key,
            final LicenseNotary notary)
            throws Exception {
        final GenericCertificate certificate = getPrivacyGuard().key2cert(key);
        System.out.println("certificate.getEncoded() = " + certificate.getEncoded());
        notary.verify(certificate);
        final LicenseContent content = (LicenseContent) this.load(certificate.getEncoded());
        this.validate(content);
        setLicenseKey(key);
        setCertificate(certificate);
        return content;
    }
    /**
     * @title verify
     * @description 復(fù)寫(xiě)verify方法，調(diào)用本類(lèi)中的validate方法，校驗(yàn)IP地址、Mac地址等其他信息
     */
    @Override
    protected synchronized LicenseContent verify(final LicenseNotary notary)
            throws Exception {
        GenericCertificate certificate = getCertificate();
        // Load license key from preferences,
        final byte[] key = getLicenseKey();
        if (null == key) {
            throw new NoLicenseInstalledException(getLicenseParam().getSubject());
        }
        certificate = getPrivacyGuard().key2cert(key);
        notary.verify(certificate);
        final LicenseContent content = (LicenseContent) this.load(certificate.getEncoded());
        this.validate(content);
        setCertificate(certificate);
        return content;
    }
    /**
     * @title validateCreate
     * @description 校驗(yàn)生成證書(shū)的參數(shù)信息
     */
    protected synchronized void validateCreate(final LicenseContent content)
            throws LicenseContentException {
        final LicenseParam param = getLicenseParam();
        final Date now = new Date();
        final Date notBefore = content.getNotBefore();
        final Date notAfter = content.getNotAfter();
        if (null != notAfter && now.after(notAfter)) {
            throw new LicenseContentException("證書(shū)失效時(shí)間不能早于當(dāng)前時(shí)間");
        }
        if (null != notBefore && null != notAfter && notAfter.before(notBefore)) {
            throw new LicenseContentException("證書(shū)生效時(shí)間不能晚于證書(shū)失效時(shí)間");
        }
        final String consumerType = content.getConsumerType();
        if (null == consumerType) {
            throw new LicenseContentException("用戶(hù)類(lèi)型不能為空");
        }
    }
    /**
     * @title validate
     * @description 復(fù)寫(xiě)validate方法，增加IP地址、Mac地址等其他信息校驗(yàn)
     */
    @Override
    protected synchronized void validate(final LicenseContent content)
            throws LicenseContentException {
        //1. 首先調(diào)用父類(lèi)的validate方法
        super.validate(content);
        //2. 然后校驗(yàn)自定義的License參數(shù)
        //License中可被允許的參數(shù)信息
        LicenseCheckModel expectedCheckModel = (LicenseCheckModel) content.getExtra();
        if (expectedCheckModel != null) {
            //當(dāng)前服務(wù)器真實(shí)的參數(shù)信息
            LicenseCheckModel serverCheckModel = getServerInfos();
            if (serverCheckModel != null) {
                //校驗(yàn)IP地址
                if (!checkIpAddress(expectedCheckModel.getIpAddress(), serverCheckModel.getIpAddress())) {
                    throw new LicenseContentException("當(dāng)前服務(wù)器的IP沒(méi)在授權(quán)范圍內(nèi)");
                }
                //校驗(yàn)Mac地址
                if (!checkIpAddress(expectedCheckModel.getMacAddress(), serverCheckModel.getMacAddress())) {
                    throw new LicenseContentException("當(dāng)前服務(wù)器的Mac地址沒(méi)在授權(quán)范圍內(nèi)");
                }
                //校驗(yàn)主板序列號(hào)
                if (!checkSerial(expectedCheckModel.getMainBoardSerial(), serverCheckModel.getMainBoardSerial())) {
                    throw new LicenseContentException("當(dāng)前服務(wù)器的主板序列號(hào)沒(méi)在授權(quán)范圍內(nèi)");
                }
                //校驗(yàn)CPU序列號(hào)
                if (!checkSerial(expectedCheckModel.getCpuSerial(), serverCheckModel.getCpuSerial())) {
                    throw new LicenseContentException("當(dāng)前服務(wù)器的CPU序列號(hào)沒(méi)在授權(quán)范圍內(nèi)");
                }
            } else {
                throw new LicenseContentException("不能獲取服務(wù)器硬件信息");
            }
        }
    }
    /**
     * @title load
     * @description 重寫(xiě)XMLDecoder解析XML
     */
    private Object load(String encoded) {
        BufferedInputStream inputStream = null;
        XMLDecoder decoder = null;
        try {
            inputStream = new BufferedInputStream(new ByteArrayInputStream(encoded.getBytes(XML_CHARSET)));
            decoder = new XMLDecoder(new BufferedInputStream(inputStream, DEFAULT_BUFSIZE), null, null);
            return decoder.readObject();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } finally {
            try {
                if (decoder != null) {
                    decoder.close();
                }
                if (inputStream != null) {
                    inputStream.close();
                }
            } catch (Exception e) {
                logger.error("XMLDecoder解析XML失敗", e);
            }
        }
        return null;
    }
    /**
     * @title getServerInfos
     * @description 獲取當(dāng)前服務(wù)器需要額外校驗(yàn)的License參數(shù)
     */
    private LicenseCheckModel getServerInfos() {
        //操作系統(tǒng)類(lèi)型
        String osName = System.getProperty("os.name").toLowerCase();
        AbstractServerInfos abstractServerInfos = null;
        //根據(jù)不同操作系統(tǒng)類(lèi)型選擇不同的數(shù)據(jù)獲取方法
        if (osName.startsWith("windows")) {
            abstractServerInfos = new WindowsServerInfos();
        } else if (osName.startsWith("linux")) {
            abstractServerInfos = new LinuxServerInfos();
        } else if (osName.startsWith("mac os")) {
            return null;
        } else {//其他服務(wù)器類(lèi)型
            abstractServerInfos = new LinuxServerInfos();
        }
        return abstractServerInfos.getServerInfos();
    }
    /**
     * @title checkIpAddress
     * @description 校驗(yàn)當(dāng)前服務(wù)器的IP/Mac地址是否在可被允許的IP范圍內(nèi)<br/>
     * 如果存在IP在可被允許的IP/Mac地址范圍內(nèi)，則返回true
     */
    private boolean checkIpAddress(List<String> expectedList, List<String> serverList) {
        if (expectedList != null && expectedList.size() > 0) {
            if (serverList != null && serverList.size() > 0) {
                for (String expected : expectedList) {
                    if (serverList.contains(expected.trim())) {
                        return true;
                    }
                }
            }
            return false;
        } else {
            return true;
        }
    }
    /**
     * @title checkSerial
     * @description 校驗(yàn)當(dāng)前服務(wù)器硬件（主板、CPU等）序列號(hào)是否在可允許范圍內(nèi)
     */
    private boolean checkSerial(String expectedSerial, String serverSerial) {
        if (StringUtils.isNotBlank(expectedSerial)) {
            if (StringUtils.isNotBlank(serverSerial)) {
                if (expectedSerial.equals(serverSerial)) {
                    return true;
                }
            }
            return false;
        } else {
            return true;
        }
    }
}

import com.example.licenseclient.custom.CustomLicenseManager;
import de.schlichtherle.license.LicenseManager;
import de.schlichtherle.license.LicenseParam;
public class LicenseManagerHolder {
    private static volatile LicenseManager LICENSE_MANAGER;
    public static LicenseManager getInstance(LicenseParam param){
        if(LICENSE_MANAGER == null){
            synchronized (LicenseManagerHolder.class){
                if(LICENSE_MANAGER == null){
                    LICENSE_MANAGER = new CustomLicenseManager(param);
                }
            }
        }
        return LICENSE_MANAGER;
    }
}

import de.schlichtherle.license.AbstractKeyStoreParam;
import java.io.*;
/**
 * @author benjamin5
 * @Description 自定義KeyStoreParam，用于將公私鑰存儲(chǔ)文件存放到其他磁盤(pán)位置而不是項(xiàng)目中
 * @createTime 2024/10/31
 */
public class CustomKeyStoreParam extends AbstractKeyStoreParam {
    /**
     * 公鑰/私鑰在磁盤(pán)上的存儲(chǔ)路徑
     */
    private String storePath;
    private String alias;
    private String storePwd;
    private String keyPwd;
    public CustomKeyStoreParam(Class clazz, String resource,String alias,String storePwd,String keyPwd) {
        super(clazz, resource);
        this.storePath = resource;
        this.alias = alias;
        this.storePwd = storePwd;
        this.keyPwd = keyPwd;
    }
    @Override
    public String getAlias() {
        return alias;
    }
    @Override
    public String getStorePwd() {
        return storePwd;
    }
    @Override
    public String getKeyPwd() {
        return keyPwd;
    }
    /**
     * 復(fù)寫(xiě)de.schlichtherle.license.AbstractKeyStoreParam的getStream()方法
     * 用于將公私鑰存儲(chǔ)文件存放到其他磁盤(pán)位置而不是項(xiàng)目中
     */
    @Override
    public InputStream getStream() throws IOException {
        final InputStream in = new FileInputStream(new File(storePath));
        if (null == in){
            throw new FileNotFoundException(storePath);
        }
        return in;
    }
}

import com.example.licenseclient.custom.CustomKeyStoreParam;
import de.schlichtherle.license.*;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import java.io.File;
import java.text.DateFormat;
import java.text.MessageFormat;
import java.text.SimpleDateFormat;
import java.util.prefs.Preferences;
/**
 * @author benjamin5
 * @Description License校驗(yàn)類(lèi)
 * @createTime 2024/10/31
 */
public class LicenseVerify {
    private static Logger logger = LogManager.getLogger(LicenseVerify.class);
    /**
     * @title install
     * @description 安裝License證書(shū)
     */
    public synchronized LicenseContent install(LicenseVerifyParam param){
        LicenseContent result = null;
        DateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //1. 安裝證書(shū)
        try{
            LicenseManager licenseManager = LicenseManagerHolder.getInstance(initLicenseParam(param));
            licenseManager.uninstall();
            result = licenseManager.install(new File(param.getLicensePath()));
            logger.info(MessageFormat.format("證書(shū)安裝成功，證書(shū)有效期：{0} - {1}",format.format(result.getNotBefore()),format.format(result.getNotAfter())));
        }catch (Exception e){
            logger.error("證書(shū)安裝失??！",e);
        }
        return result;
    }
    /**
     * @title verify
     * @description 校驗(yàn)License證書(shū)
     */
    public boolean verify(){
        LicenseManager licenseManager = LicenseManagerHolder.getInstance(null);
        DateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //2. 校驗(yàn)證書(shū)
        try {
            LicenseContent licenseContent = licenseManager.verify();
            System.out.println(MessageFormat.format("證書(shū)校驗(yàn)通過(guò)，證書(shū)有效期：{0} - {1}",format.format(licenseContent.getNotBefore()),format.format(licenseContent.getNotAfter())));
            return true;
        }catch (Exception e){
            logger.error("證書(shū)校驗(yàn)失??！",e);
            return false;
        }
    }
    /**
     * @title initLicenseParam
     * @description 初始化證書(shū)生成參數(shù)
     */
    private LicenseParam initLicenseParam(LicenseVerifyParam param){
        Preferences preferences = Preferences.userNodeForPackage(LicenseVerify.class);
        CipherParam cipherParam = new DefaultCipherParam(param.getStorePass());
        KeyStoreParam publicStoreParam = new CustomKeyStoreParam(LicenseVerify.class
                ,param.getPublicKeysStorePath()
                ,param.getPublicAlias()
                ,param.getStorePass()
                ,null);
        return new DefaultLicenseParam(param.getSubject()
                ,preferences
                ,publicStoreParam
                ,cipherParam);
    }
}

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.stereotype.Component;
/**
 * @author benjamin5
 * @Description 在項(xiàng)目啟動(dòng)時(shí)安裝證書(shū)
 * @createTime 2024/10/31
 */
@Component
public class LicenseCheckListener implements ApplicationListener<ContextRefreshedEvent> {
    private static Logger logger = LogManager.getLogger(LicenseCheckListener.class);
    /**
     * 證書(shū)subject
     */
    @Value("${license.subject}")
    private String subject;
    /**
     * 公鑰別稱(chēng)
     */
    @Value("${license.publicAlias}")
    private String publicAlias;
    /**
     * 訪(fǎng)問(wèn)公鑰庫(kù)的密碼
     */
    @Value("${license.storePass}")
    private String storePass;
    /**
     * 證書(shū)生成路徑
     */
    @Value("${license.licensePath}")
    private String licensePath;
    /**
     * 密鑰庫(kù)存儲(chǔ)路徑
     */
    @Value("${license.publicKeysStorePath}")
    private String publicKeysStorePath;
    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        //root application context 沒(méi)有parent
        ApplicationContext context = event.getApplicationContext().getParent();
        if (context == null) {
            logger.info("++++++++ 開(kāi)始安裝證書(shū) ++++++++");
            LicenseVerifyParam param = new LicenseVerifyParam();
            param.setSubject(subject);
            param.setPublicAlias(publicAlias);
            param.setStorePass(storePass);
            param.setLicensePath(licensePath);
            param.setPublicKeysStorePath(publicKeysStorePath);
            LicenseVerify licenseVerify = new LicenseVerify();
            //安裝證書(shū)
            licenseVerify.install(param);
            logger.info("++++++++ 證書(shū)安裝結(jié)束 ++++++++");
        }
    }
}

import com.alibaba.fastjson.JSON;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.web.servlet.HandlerInterceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.HashMap;
import java.util.Map;
/**
 * @author benjamin5
 * @Description 證書(shū)校驗(yàn)攔截器
 * @createTime 2024/10/31
 */
public class LicenseCheckInterceptor implements HandlerInterceptor {
    private static Logger logger = LogManager.getLogger(LicenseCheckInterceptor.class);
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        LicenseVerify licenseVerify = new LicenseVerify();
        //校驗(yàn)證書(shū)是否有效
        boolean verifyResult = licenseVerify.verify();
        if(verifyResult){
            return true;
        }else{
            response.setCharacterEncoding("UTF-8");
            response.setContentType("text/html; charset=UTF-8");
            Map<String,String> result = new HashMap<>(1);
            result.put("code","500");
            result.put("msg","您的許可證無(wú)效或過(guò)期，請(qǐng)重新申請(qǐng)！");
            response.getWriter().write(JSON.toJSONString(result));
            return false;
        }
    }
}

@Configuration
public class WebMvcConfig implements WebMvcConfigurer {
    /**
     * 添加攔截器
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new LicenseCheckInterceptor())
                .addPathPatterns("/**")
//                .excludePathPatterns("/license/generateLicense","/license/getServerInfos")
        ;
    }
}

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.example</groupId>
            <artifactId>license-client</artifactId>
            <version>1.0.0</version>
        </dependency>
    </dependencies>

@Data
public class LicenseCreatorParam implements Serializable {
    private static final long serialVersionUID = -7793154252684580872L;
    /**
     * 證書(shū)subject
     */
    private String subject;
    /**
     * 密鑰別稱(chēng)
     */
    private String privateAlias;
    /**
     * 密鑰密碼（需要妥善保管，不能讓使用者知道）
     */
    private String keyPass;
    /**
     * 訪(fǎng)問(wèn)秘鑰庫(kù)的密碼
     */
    private String storePass;
    /**
     * 證書(shū)生成路徑
     */
    private String licensePath;
    /**
     * 密鑰庫(kù)存儲(chǔ)路徑
     */
    private String privateKeysStorePath;
    /**
     * 證書(shū)生效時(shí)間
     */
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
    private Date issuedTime = new Date();
    /**
     * 證書(shū)失效時(shí)間
     */
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
    private Date expiryTime;
    /**
     * 用戶(hù)類(lèi)型
     */
    private String consumerType = "user";
    /**
     * 用戶(hù)數(shù)量
     */
    private Integer consumerAmount = 1;
    /**
     * 描述信息
     */
    private String description = "";
    /**
     * 額外的服務(wù)器硬件校驗(yàn)信息
     */
    private LicenseCheckModel licenseCheckModel;
}

import com.example.licenseclient.custom.CustomKeyStoreParam;
import com.example.licenseclient.custom.CustomLicenseManager;
import de.schlichtherle.license.*;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import javax.security.auth.x500.X500Principal;
import java.io.File;
import java.text.MessageFormat;
import java.util.prefs.Preferences;
/**
 * License生成類(lèi)
 *
 */
public class LicenseCreator {
    private static Logger logger = LogManager.getLogger(LicenseCreator.class);
    /**
     * CN=localhost：CN是Common Name的縮寫(xiě)，通常用于指定域名或IP地址
     * OU=localhost：OU是Organizational Unit的縮寫(xiě)，表示組織單位
     * O=localhost：O是Organization的縮寫(xiě)，表示組織名
     * L=SH：L是Locality的縮寫(xiě)，表示城市或地區(qū)
     * ST=SH：ST是State的縮寫(xiě)，表示州或省
     * C=CN：C是Country的縮寫(xiě)，表示國(guó)家代碼
     */
    private final static X500Principal DEFAULT_HOLDER_AND_ISSUER = new X500Principal("CN=localhost, OU=localhost, O=localhost, L=SH, ST=SH, C=CN");
    private LicenseCreatorParam param;
    public LicenseCreator(LicenseCreatorParam param) {
        this.param = param;
    }
    /**
     * 生成License證書(shū)
     * @return boolean
     */
    public boolean generateLicense(){
        try {
            LicenseManager licenseManager = new CustomLicenseManager(initLicenseParam());
            LicenseContent licenseContent = initLicenseContent();
            licenseManager.store(licenseContent,new File(param.getLicensePath()));
            return true;
        }catch (Exception e){
            logger.error(MessageFormat.format("證書(shū)生成失敗：{0}",param),e);
            return false;
        }
    }
    /**
     * 初始化證書(shū)生成參數(shù)
     * @return de.schlichtherle.license.LicenseParam
     */
    private LicenseParam initLicenseParam(){
        Preferences preferences = Preferences.userNodeForPackage(LicenseCreator.class);
        //設(shè)置對(duì)證書(shū)內(nèi)容加密的秘鑰
        CipherParam cipherParam = new DefaultCipherParam(param.getStorePass());
        KeyStoreParam privateStoreParam = new CustomKeyStoreParam(LicenseCreator.class
                ,param.getPrivateKeysStorePath()
                ,param.getPrivateAlias()
                ,param.getStorePass()
                ,param.getKeyPass());
        LicenseParam licenseParam = new DefaultLicenseParam(param.getSubject()
                ,preferences
                ,privateStoreParam
                ,cipherParam);
        return licenseParam;
    }
    /**
     * 設(shè)置證書(shū)生成正文信息
     * @return de.schlichtherle.license.LicenseContent
     */
    private LicenseContent initLicenseContent(){
        LicenseContent licenseContent = new LicenseContent();
        licenseContent.setHolder(DEFAULT_HOLDER_AND_ISSUER);
        licenseContent.setIssuer(DEFAULT_HOLDER_AND_ISSUER);
        licenseContent.setSubject(param.getSubject());
        licenseContent.setIssued(param.getIssuedTime());
        licenseContent.setNotBefore(param.getIssuedTime());
        licenseContent.setNotAfter(param.getExpiryTime());
        licenseContent.setConsumerType(param.getConsumerType());
        licenseContent.setConsumerAmount(param.getConsumerAmount());
        licenseContent.setInfo(param.getDescription());
        //擴(kuò)展校驗(yàn)服務(wù)器硬件信息
        licenseContent.setExtra(param.getLicenseCheckModel());
        return licenseContent;
    }
}

@RestController
@RequestMapping("/license")
public class LicenseCreatorController {
    /**
     * 證書(shū)生成路徑
     */
    @Value("${license.licensePath}")
    private String licensePath;
    @Value("${license.privateKeysStorePath}")
    private String privateKeysStorePath;
    @Value("${license.keyPass}")
    private String keyPass;
    @Value("${license.privateAlias}")
    private String privateAlias;
    /**
     * 生成證書(shū)
     *
     * @param param 生成證書(shū)需要的參數(shù)，如：{"subject":"ccx-models","privateAlias":"privateKey","keyPass":"5T7Zz5Y0dJFcqTxvzkH5LDGJJSGMzQ","storePass":"3538cef8e7","licensePath":"C:/Users/zifangsky/Desktop/license.lic","privateKeysStorePath":"C:/Users/zifangsky/Desktop/privateKeys.keystore","issuedTime":"2018-04-26 14:48:12","expiryTime":"2018-12-31 00:00:00","consumerType":"User","consumerAmount":1,"description":"這是證書(shū)描述信息","licenseCheckModel":{"ipAddress":["192.168.245.1","10.0.5.22"],"macAddress":["00-50-56-C0-00-01","50-7B-9D-F9-18-41"],"cpuSerial":"BFEBFBFF000406E3","mainBoardSerial":"L1HF65E00X9"}}
     *
    */
    @RequestMapping(value = "/generateLicense", produces = {MediaType.APPLICATION_JSON_UTF8_VALUE})
    public Map<String, Object> generateLicense(@RequestBody(required = true) LicenseCreatorParam param) {
        Map<String, Object> resultMap = new HashMap<>(2);
        if (StringUtils.isBlank(param.getLicensePath())) {
            param.setLicensePath(licensePath);
        }
        if(StringUtils.isBlank(param.getPrivateKeysStorePath())){
            URL url = null;
            try {
                url = ResourceUtils.getURL(privateKeysStorePath);
                param.setPrivateKeysStorePath(url.getPath());
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }
        if(StringUtils.isBlank(param.getKeyPass())){
            param.setKeyPass(keyPass);
        }
        if(StringUtils.isBlank(param.getPrivateAlias())){
            param.setPrivateAlias(privateAlias);
        }
        LicenseCreator licenseCreator = new LicenseCreator(param);
        boolean result = licenseCreator.generateLicense();
        if (result) {
            resultMap.put("result", "ok");
            resultMap.put("msg", param);
        } else {
            resultMap.put("result", "error");
            resultMap.put("msg", "證書(shū)文件生成失?。?);
        }
        return resultMap;
    }
}

server:
  port: 18099
license:
  # 生成證書(shū)存放位置，也可在生成接口參數(shù)中指定
  licensePath: /Users/wuhanxue/Downloads/license/license.lic
  # 私鑰庫(kù)文件位置
  privateKeysStorePath: classpath:key/privateKeys.keystore
  # 私鑰訪(fǎng)問(wèn)密碼
  keyPass: wu@private2024
  # 私鑰別名
  privateAlias: privateKey

<dependency>
            <groupId>com.example</groupId>
            <artifactId>license-client</artifactId>
            <version>1.0.0</version>
</dependency>

server:
  port: 1888
license:
  # 證書(shū)subject
  subject: license-test-web
  # 公鑰別稱(chēng)
  publicAlias: publicCert
  # 訪(fǎng)問(wèn)公鑰庫(kù)的密碼
  storePass: wu@2024555
  # 證書(shū)路徑
  licensePath: /Users/wuhanxue/Downloads/key/license.lic
  # 公鑰路徑
  publicKeysStorePath: /Users/wuhanxue/Downloads/key/publicCerts.keystore

@RestController
public class TestController {
    @GetMapping("test")
    public String test(){
        return "test";
    }
}

@SpringBootApplication
@ComponentScan(basePackages = {"com.example.*"})
public class LicenseTestWebApplication {
    public static void main(String[] args) {
        SpringApplication.run(LicenseTestWebApplication.class, args);
    }
}