devbox
小小林熬夜学编程
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Spring Boot2 使用 License 实现系统软件版权许可认证_de.schlichtherle.license

作者：小小林熬夜学编程 | 2024-06-02 18:32:14

赞

踩

de.schlichtherle.license

一 License 简介

License即版权许可证，一般用于收费软件给付费用户提供的访问许可证明。根据应用部署位置的不同，一般可以分为以下两种情况讨论：

  • 应用部署在开发者自己的云服务器上。这种情况下用户通过账号登录的形式远程访问，因此只需要在账号登录的时候校验目标账号的有效期、访问权限等信息即可。
  • 应用部署在客户的内网环境。因为这种情况开发者无法控制客户的网络环境，也不能保证应用所在服务器可以访问外网，因此通常的做法是使用服务器许可文件，在客户应用启动的时候加载证书，然后在登录或者其他关键操作的地方校验证书的有效性。

二 License文件生成服务端

Spring Boot2 使用 TrueLicense 为客户生成 License 许可文件，创建微服务项目名称： cloud-license-serve，版本：2.3.0

2.1 pom.xml

  1.         <!-- License -->
  2.         <dependency>
  3.             <groupId>de.schlichtherle.truelicense</groupId>
  4.             <artifactId>truelicense-core</artifactId>
  5.             <version>1.33</version>
  6.         </dependency>
  7.  
  8.         <dependency>
  9.             <groupId>net.sourceforge.nekohtml</groupId>
  10.             <artifactId>nekohtml</artifactId>
  11.             <version>1.9.18</version>
  12.         </dependency>

2.2 application.properties

  1. server.port=8081
  2.  
  3. #启用优雅关机
  4. server.shutdown=graceful
  5. #缓冲10秒
  6. spring.lifecycle.timeout-per-shutdown-phase=10s
  7.  
  8. #License相关配置
  9. license.licensePath=D:/workspace/gitee/spring-boot2-license/license/license.lic

2.3 License参数类

  1. package com.modules.entity;
  2.  
  3. import com.fasterxml.jackson.annotation.JsonFormat;
  4. import com.modules.entity.LicenseCheckModel;
  5.  
  6. import java.io.Serializable;
  7. import java.util.Date;
  8.  
  9. /**
  10.  * License生成类需要的参数
  11.  *
  12.  */
  13. public class LicenseCreatorParam implements Serializable {
  14.  
  15.     private static final long serialVersionUID = -7793154252684580872L;
  16.     /**
  17.      * 证书subject
  18.      */
  19.     private String subject;
  20.  
  21.     /**
  22.      * 密钥别称
  23.      */
  24.     private String privateAlias;
  25.  
  26.     /**
  27.      * 密钥密码（需要妥善保管，不能让使用者知道）
  28.      */
  29.     private String keyPass;
  30.  
  31.     /**
  32.      * 访问秘钥库的密码
  33.      */
  34.     private String storePass;
  35.  
  36.     /**
  37.      * 证书生成路径
  38.      */
  39.     private String licensePath;
  40.  
  41.     /**
  42.      * 密钥库存储路径
  43.      */
  44.     private String privateKeysStorePath;
  45.  
  46.     /**
  47.      * 证书生效时间
  48.      */
  49.     @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
  50.     private Date issuedTime = new Date();
  51.  
  52.     /**
  53.      * 证书失效时间
  54.      */
  55.     @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
  56.     private Date expiryTime;
  57.  
  58.     /**
  59.      * 用户类型
  60.      */
  61.     private String consumerType = "user";
  62.  
  63.     /**
  64.      * 用户数量
  65.      */
  66.     private Integer consumerAmount = 1;
  67.  
  68.     /**
  69.      * 描述信息
  70.      */
  71.     private String description = "";
  72.  
  73.     /**
  74.      * 额外的服务器硬件校验信息
  75.      */
  76.     private LicenseCheckModel licenseCheckModel;
  77.  
  78.     public String getSubject() {
  79.         return subject;
  80.     }
  81.  
  82.     public void setSubject(String subject) {
  83.         this.subject = subject;
  84.     }
  85.  
  86.     public String getPrivateAlias() {
  87.         return privateAlias;
  88.     }
  89.  
  90.     public void setPrivateAlias(String privateAlias) {
  91.         this.privateAlias = privateAlias;
  92.     }
  93.  
  94.     public String getKeyPass() {
  95.         return keyPass;
  96.     }
  97.  
  98.     public void setKeyPass(String keyPass) {
  99.         this.keyPass = keyPass;
  100.     }
  101.  
  102.     public String getStorePass() {
  103.         return storePass;
  104.     }
  105.  
  106.     public void setStorePass(String storePass) {
  107.         this.storePass = storePass;
  108.     }
  109.  
  110.     public String getLicensePath() {
  111.         return licensePath;
  112.     }
  113.  
  114.     public void setLicensePath(String licensePath) {
  115.         this.licensePath = licensePath;
  116.     }
  117.  
  118.     public String getPrivateKeysStorePath() {
  119.         return privateKeysStorePath;
  120.     }
  121.  
  122.     public void setPrivateKeysStorePath(String privateKeysStorePath) {
  123.         this.privateKeysStorePath = privateKeysStorePath;
  124.     }
  125.  
  126.     public Date getIssuedTime() {
  127.         return issuedTime;
  128.     }
  129.  
  130.     public void setIssuedTime(Date issuedTime) {
  131.         this.issuedTime = issuedTime;
  132.     }
  133.  
  134.     public Date getExpiryTime() {
  135.         return expiryTime;
  136.     }
  137.  
  138.     public void setExpiryTime(Date expiryTime) {
  139.         this.expiryTime = expiryTime;
  140.     }
  141.  
  142.     public String getConsumerType() {
  143.         return consumerType;
  144.     }
  145.  
  146.     public void setConsumerType(String consumerType) {
  147.         this.consumerType = consumerType;
  148.     }
  149.  
  150.     public Integer getConsumerAmount() {
  151.         return consumerAmount;
  152.     }
  153.  
  154.     public void setConsumerAmount(Integer consumerAmount) {
  155.         this.consumerAmount = consumerAmount;
  156.     }
  157.  
  158.     public String getDescription() {
  159.         return description;
  160.     }
  161.  
  162.     public void setDescription(String description) {
  163.         this.description = description;
  164.     }
  165.  
  166.     public LicenseCheckModel getLicenseCheckModel() {
  167.         return licenseCheckModel;
  168.     }
  169.  
  170.     public void setLicenseCheckModel(LicenseCheckModel licenseCheckModel) {
  171.         this.licenseCheckModel = licenseCheckModel;
  172.     }
  173.  
  174.     @Override
  175.     public String toString() {
  176.         return "LicenseCreatorParam{" +
  177.                 "subject='" + subject + '\'' +
  178.                 ", privateAlias='" + privateAlias + '\'' +
  179.                 ", keyPass='" + keyPass + '\'' +
  180.                 ", storePass='" + storePass + '\'' +
  181.                 ", licensePath='" + licensePath + '\'' +
  182.                 ", privateKeysStorePath='" + privateKeysStorePath + '\'' +
  183.                 ", issuedTime=" + issuedTime +
  184.                 ", expiryTime=" + expiryTime +
  185.                 ", consumerType='" + consumerType + '\'' +
  186.                 ", consumerAmount=" + consumerAmount +
  187.                 ", description='" + description + '\'' +
  188.                 ", licenseCheckModel=" + licenseCheckModel +
  189.                 '}';
  190.     }
  191. }
  1. package com.modules.entity;
  2.  
  3. import java.io.Serializable;
  4. import java.util.List;
  5.  
  6. /**
  7.  * 自定义需要校验的License参数
  8.  *
  9.  */
  10. public class LicenseCheckModel implements Serializable{
  11.  
  12.     private static final long serialVersionUID = 8600137500316662317L;
  13.     /**
  14.      * 可被允许的IP地址
  15.      */
  16.     private List<String> ipAddress;
  17.  
  18.     /**
  19.      * 可被允许的MAC地址
  20.      */
  21.     private List<String> macAddress;
  22.  
  23.     /**
  24.      * 可被允许的CPU序列号
  25.      */
  26.     private String cpuSerial;
  27.  
  28.     /**
  29.      * 可被允许的主板序列号
  30.      */
  31.     private String mainBoardSerial;
  32.  
  33.     public List<String> getIpAddress() {
  34.         return ipAddress;
  35.     }
  36.  
  37.     public void setIpAddress(List<String> ipAddress) {
  38.         this.ipAddress = ipAddress;
  39.     }
  40.  
  41.     public List<String> getMacAddress() {
  42.         return macAddress;
  43.     }
  44.  
  45.     public void setMacAddress(List<String> macAddress) {
  46.         this.macAddress = macAddress;
  47.     }
  48.  
  49.     public String getCpuSerial() {
  50.         return cpuSerial;
  51.     }
  52.  
  53.     public void setCpuSerial(String cpuSerial) {
  54.         this.cpuSerial = cpuSerial;
  55.     }
  56.  
  57.     public String getMainBoardSerial() {
  58.         return mainBoardSerial;
  59.     }
  60.  
  61.     public void setMainBoardSerial(String mainBoardSerial) {
  62.         this.mainBoardSerial = mainBoardSerial;
  63.     }
  64.  
  65.     @Override
  66.     public String toString() {
  67.         return "LicenseCheckModel{" +
  68.                 "ipAddress=" + ipAddress +
  69.                 ", macAddress=" + macAddress +
  70.                 ", cpuSerial='" + cpuSerial + '\'' +
  71.                 ", mainBoardSerial='" + mainBoardSerial + '\'' +
  72.                 '}';
  73.     }
  74. }

2.4 添加抽象类AbstractServerInfos，用户获取服务器的硬件信息

  1. package com.modules.license;
  2.  
  3. import com.modules.entity.LicenseCheckModel;
  4. import lombok.extern.slf4j.Slf4j;
  5.  
  6. import java.net.InetAddress;
  7. import java.net.NetworkInterface;
  8. import java.net.SocketException;
  9. import java.util.ArrayList;
  10. import java.util.Enumeration;
  11. import java.util.List;
  12.  
  13. /**
  14.  * 用于获取客户服务器的基本信息，如：IP、Mac地址、CPU序列号、主板序列号等
  15.  *
  16.  */
  17. @Slf4j
  18. public abstract class AbstractServerInfos {
  19.  
  20.     /**
  21.      * 组装需要额外校验的License参数
  22.      * @since 1.0.0
  23.      * @return demo.LicenseCheckModel
  24.      */
  25.     public LicenseCheckModel getServerInfos(){
  26.         LicenseCheckModel result = new LicenseCheckModel();
  27.  
  28.         try {
  29.             result.setIpAddress(this.getIpAddress());
  30.             result.setMacAddress(this.getMacAddress());
  31.             result.setCpuSerial(this.getCPUSerial());
  32.             result.setMainBoardSerial(this.getMainBoardSerial());
  33.         }catch (Exception e){
  34.             log.error("获取服务器硬件信息失败",e);
  35.         }
  36.  
  37.         return result;
  38.     }
  39.  
  40.     /**
  41.      * 获取IP地址
  42.      * @return java.util.List<java.lang.String>
  43.      */
  44.     protected abstract List<String> getIpAddress() throws Exception;
  45.  
  46.     /**
  47.      * 获取Mac地址
  48.      * @return java.util.List<java.lang.String>
  49.      */
  50.     protected abstract List<String> getMacAddress() throws Exception;
  51.  
  52.     /**
  53.      * 获取CPU序列号
  54.      * @return java.lang.String
  55.      */
  56.     protected abstract String getCPUSerial() throws Exception;
  57.  
  58.     /**
  59.      * 获取主板序列号
  60.      * @return java.lang.String
  61.      */
  62.     protected abstract String getMainBoardSerial() throws Exception;
  63.  
  64.     /**
  65.      * 获取当前服务器所有符合条件的InetAddress
  66.      * @return java.util.List<java.net.InetAddress>
  67.      */
  68.     protected List<InetAddress> getLocalAllInetAddress() throws Exception {
  69.         List<InetAddress> result = new ArrayList<>(4);
  70.  
  71.         // 遍历所有的网络接口
  72.         for (Enumeration networkInterfaces = NetworkInterface.getNetworkInterfaces(); networkInterfaces.hasMoreElements(); ) {
  73.             NetworkInterface iface = (NetworkInterface) networkInterfaces.nextElement();
  74.             // 在所有的接口下再遍历IP
  75.             for (Enumeration inetAddresses = iface.getInetAddresses(); inetAddresses.hasMoreElements(); ) {
  76.                 InetAddress inetAddr = (InetAddress) inetAddresses.nextElement();
  77.  
  78.                 //排除LoopbackAddress、SiteLocalAddress、LinkLocalAddress、MulticastAddress类型的IP地址
  79.                 if(!inetAddr.isLoopbackAddress() /*&& !inetAddr.isSiteLocalAddress()*/
  80.                         && !inetAddr.isLinkLocalAddress() && !inetAddr.isMulticastAddress()){
  81.                     result.add(inetAddr);
  82.                 }
  83.             }
  84.         }
  85.         return result;
  86.     }
  87.  
  88.     /**
  89.      * 获取某个网络接口的Mac地址
  90.      * @param
  91.      * @return void
  92.      */
  93.     protected String getMacByInetAddress(InetAddress inetAddr){
  94.         try {
  95.             byte[] mac = NetworkInterface.getByInetAddress(inetAddr).getHardwareAddress();
  96.             StringBuffer stringBuffer = new StringBuffer();
  97.             for(int i=0;i<mac.length;i++){
  98.                 if(i != 0) {
  99.                     stringBuffer.append("-");
  100.                 }
  101.                 //将十六进制byte转化为字符串
  102.                 String temp = Integer.toHexString(mac[i] & 0xff);
  103.                 if(temp.length() == 1){
  104.                     stringBuffer.append("0" + temp);
  105.                 }else{
  106.                     stringBuffer.append(temp);
  107.                 }
  108.             }
  109.             return stringBuffer.toString().toUpperCase();
  110.         } catch (SocketException e) {
  111.             e.printStackTrace();
  112.             log.error("获取某个网络接口的Mac地址异常", e.getMessage());
  113.         }
  114.         return null;
  115.     }
  116. }

获取客户Linux服务器的基本信息

  1. package com.modules.license;
  2.  
  3. import org.apache.commons.lang3.StringUtils;
  4.  
  5. import java.io.BufferedReader;
  6. import java.io.InputStreamReader;
  7. import java.net.InetAddress;
  8. import java.util.List;
  9. import java.util.stream.Collectors;
  10.  
  11. /**
  12.  * 用于获取客户Linux服务器的基本信息
  13.  *
  14.  */
  15. public class LinuxServerInfos extends AbstractServerInfos {
  16.  
  17.     @Override
  18.     protected List<String> getIpAddress() throws Exception {
  19.         List<String> result = null;
  20.  
  21.         //获取所有网络接口
  22.         List<InetAddress> inetAddresses = getLocalAllInetAddress();
  23.  
  24.         if(inetAddresses != null && inetAddresses.size() > 0){
  25.             result = inetAddresses.stream().map(InetAddress::getHostAddress).distinct().map(String::toLowerCase).collect(Collectors.toList());
  26.         }
  27.  
  28.         return result;
  29.     }
  30.  
  31.     @Override
  32.     protected List<String> getMacAddress() throws Exception {
  33.         List<String> result = null;
  34.  
  35.         //1. 获取所有网络接口
  36.         List<InetAddress> inetAddresses = getLocalAllInetAddress();
  37.  
  38.         if(inetAddresses != null && inetAddresses.size() > 0){
  39.             //2. 获取所有网络接口的Mac地址
  40.             result = inetAddresses.stream().map(this::getMacByInetAddress).distinct().collect(Collectors.toList());
  41.         }
  42.  
  43.         return result;
  44.     }
  45.  
  46.     @Override
  47.     protected String getCPUSerial() throws Exception {
  48.         //序列号
  49.         String serialNumber = "";
  50.  
  51.         //使用dmidecode命令获取CPU序列号
  52.         String[] shell = {"/bin/bash","-c","dmidecode -t processor | grep 'ID' | awk -F ':' '{print $2}' | head -n 1"};
  53.         Process process = Runtime.getRuntime().exec(shell);
  54.         process.getOutputStream().close();
  55.  
  56.         BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
  57.  
  58.         String line = reader.readLine().trim();
  59.         if(StringUtils.isNotBlank(line)){
  60.             serialNumber = line;
  61.         }
  62.  
  63.         reader.close();
  64.         return serialNumber;
  65.     }
  66.  
  67.     @Override
  68.     protected String getMainBoardSerial() throws Exception {
  69.         //序列号
  70.         String serialNumber = "";
  71.  
  72.         //使用dmidecode命令获取主板序列号
  73.         String[] shell = {"/bin/bash","-c","dmidecode | grep 'Serial Number' | awk -F ':' '{print $2}' | head -n 1"};
  74.         Process process = Runtime.getRuntime().exec(shell);
  75.         process.getOutputStream().close();
  76.  
  77.         BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
  78.  
  79.         String line = reader.readLine().trim();
  80.         if(StringUtils.isNotBlank(line)){
  81.             serialNumber = line;
  82.         }
  83.  
  84.         reader.close();
  85.         return serialNumber;
  86.     }
  87. }

获取客户Windows服务器的基本信息

  1. package com.modules.license;
  2.  
  3. import java.net.InetAddress;
  4. import java.util.List;
  5. import java.util.Scanner;
  6. import java.util.stream.Collectors;
  7.  
  8. /**
  9.  * 用于获取客户Windows服务器的基本信息
  10.  *
  11.  */
  12. public class WindowsServerInfos extends AbstractServerInfos {
  13.  
  14.     @Override
  15.     protected List<String> getIpAddress() throws Exception {
  16.         List<String> result = null;
  17.  
  18.         //获取所有网络接口
  19.         List<InetAddress> inetAddresses = getLocalAllInetAddress();
  20.  
  21.         if(inetAddresses != null && inetAddresses.size() > 0){
  22.             result = inetAddresses.stream().map(InetAddress::getHostAddress).distinct().map(String::toLowerCase).collect(Collectors.toList());
  23.         }
  24.  
  25.         return result;
  26.     }
  27.  
  28.     @Override
  29.     protected List<String> getMacAddress() throws Exception {
  30.         List<String> result = null;
  31.  
  32.         //1. 获取所有网络接口
  33.         List<InetAddress> inetAddresses = getLocalAllInetAddress();
  34.  
  35.         if(inetAddresses != null && inetAddresses.size() > 0){
  36.             //2. 获取所有网络接口的Mac地址
  37.             result = inetAddresses.stream().map(this::getMacByInetAddress).distinct().collect(Collectors.toList());
  38.         }
  39.  
  40.         return result;
  41.     }
  42.  
  43.     @Override
  44.     protected String getCPUSerial() throws Exception {
  45.         //序列号
  46.         String serialNumber = "";
  47.  
  48.         //使用WMIC获取CPU序列号
  49.         Process process = Runtime.getRuntime().exec("wmic cpu get processorid");
  50.         process.getOutputStream().close();
  51.         Scanner scanner = new Scanner(process.getInputStream());
  52.  
  53.         if(scanner.hasNext()){
  54.             scanner.next();
  55.         }
  56.  
  57.         if(scanner.hasNext()){
  58.             serialNumber = scanner.next().trim();
  59.         }
  60.  
  61.         scanner.close();
  62.         return serialNumber;
  63.     }
  64.  
  65.     @Override
  66.     protected String getMainBoardSerial() throws Exception {
  67.         //序列号
  68.         String serialNumber = "";
  69.  
  70.         //使用WMIC获取主板序列号
  71.         Process process = Runtime.getRuntime().exec("wmic baseboard get serialnumber");
  72.         process.getOutputStream().close();
  73.         Scanner scanner = new Scanner(process.getInputStream());
  74.  
  75.         if(scanner.hasNext()){
  76.             scanner.next();
  77.         }
  78.  
  79.         if(scanner.hasNext()){
  80.             serialNumber = scanner.next().trim();
  81.         }
  82.  
  83.         scanner.close();
  84.         return serialNumber;
  85.     }
  86. }

注：这里使用了模板方法模式，将不变部分的算法封装到抽象类，而基本方法的具体实现则由子类来实现。

2.5 自定义LicenseManager，用于增加额外的服务器硬件信息校验

  1. package com.modules.license;
  2.  
  3. import com.modules.entity.LicenseCheckModel;
  4. import de.schlichtherle.license.*;
  5. import de.schlichtherle.xml.GenericCertificate;
  6. import lombok.extern.slf4j.Slf4j;
  7. import org.apache.commons.lang3.StringUtils;
  8.  
  9. import java.beans.XMLDecoder;
  10. import java.io.BufferedInputStream;
  11. import java.io.ByteArrayInputStream;
  12. import java.io.UnsupportedEncodingException;
  13. import java.util.Date;
  14. import java.util.List;
  15.  
  16. /**
  17.  * 自定义LicenseManager，用于增加额外的服务器硬件信息校验
  18.  *
  19.  */
  20. @Slf4j
  21. public class CustomLicenseManager extends LicenseManager{
  22.  
  23.     //XML编码
  24.     private static final String XML_CHARSET = "UTF-8";
  25.     //默认BUFSIZE
  26.     private static final int DEFAULT_BUFSIZE = 8 * 1024;
  27.  
  28.     public CustomLicenseManager() {
  29.  
  30.     }
  31.  
  32.     public CustomLicenseManager(LicenseParam param) {
  33.         super(param);
  34.     }
  35.  
  36.     /**
  37.      * 复写create方法
  38.      * @param
  39.      * @return byte[]
  40.      */
  41.     @Override
  42.     protected synchronized byte[] create(
  43.             LicenseContent content,
  44.             LicenseNotary notary)
  45.             throws Exception {
  46.         initialize(content);
  47.         this.validateCreate(content);
  48.         final GenericCertificate certificate = notary.sign(content);
  49.         return getPrivacyGuard().cert2key(certificate);
  50.     }
  51.  
  52.     /**
  53.      * 复写install方法，其中validate方法调用本类中的validate方法，校验IP地址、Mac地址等其他信息
  54.      * @param
  55.      * @return de.schlichtherle.license.LicenseContent
  56.      */
  57.     @Override
  58.     protected synchronized LicenseContent install(
  59.             final byte[] key,
  60.             final LicenseNotary notary)
  61.             throws Exception {
  62.         final GenericCertificate certificate = getPrivacyGuard().key2cert(key);
  63.  
  64.         notary.verify(certificate);
  65.         final LicenseContent content = (LicenseContent)this.load(certificate.getEncoded());
  66.         this.validate(content);
  67.         setLicenseKey(key);
  68.         setCertificate(certificate);
  69.  
  70.         return content;
  71.     }
  72.  
  73.     /**
  74.      * 复写verify方法，调用本类中的validate方法，校验IP地址、Mac地址等其他信息
  75.      * @param
  76.      * @return de.schlichtherle.license.LicenseContent
  77.      */
  78.     @Override
  79.     protected synchronized LicenseContent verify(final LicenseNotary notary)
  80.             throws Exception {
  81.         GenericCertificate certificate = getCertificate();
  82.  
  83.         // Load license key from preferences,
  84.         final byte[] key = getLicenseKey();
  85.         if (null == key){
  86.             throw new NoLicenseInstalledException(getLicenseParam().getSubject());
  87.         }
  88.  
  89.         certificate = getPrivacyGuard().key2cert(key);
  90.         notary.verify(certificate);
  91.         final LicenseContent content = (LicenseContent)this.load(certificate.getEncoded());
  92.         this.validate(content);
  93.         setCertificate(certificate);
  94.  
  95.         return content;
  96.     }
  97.  
  98.     /**
  99.      * 校验生成证书的参数信息
  100.      * @param content 证书正文
  101.      */
  102.     protected synchronized void validateCreate(final LicenseContent content)
  103.             throws LicenseContentException {
  104.         final LicenseParam param = getLicenseParam();
  105.  
  106.         final Date now = new Date();
  107.         final Date notBefore = content.getNotBefore();
  108.         final Date notAfter = content.getNotAfter();
  109.         if (null != notAfter && now.after(notAfter)){
  110.             throw new LicenseContentException("证书失效时间不能早于当前时间");
  111.         }
  112.         if (null != notBefore && null != notAfter && notAfter.before(notBefore)){
  113.             throw new LicenseContentException("证书生效时间不能晚于证书失效时间");
  114.         }
  115.         final String consumerType = content.getConsumerType();
  116.         if (null == consumerType){
  117.             throw new LicenseContentException("用户类型不能为空");
  118.         }
  119.     }
  120.  
  121.  
  122.     /**
  123.      * 复写validate方法，增加IP地址、Mac地址等其他信息校验
  124.      * @param content LicenseContent
  125.      */
  126.     @Override
  127.     protected synchronized void validate(final LicenseContent content)
  128.             throws LicenseContentException {
  129.         //1. 首先调用父类的validate方法
  130.         super.validate(content);
  131.  
  132.         //2. 然后校验自定义的License参数
  133.         //License中可被允许的参数信息
  134.         LicenseCheckModel expectedCheckModel = (LicenseCheckModel) content.getExtra();
  135.         //当前服务器真实的参数信息
  136.         LicenseCheckModel serverCheckModel = getServerInfos();
  137.  
  138.         if(expectedCheckModel != null && serverCheckModel != null){
  139.             //校验IP地址
  140.             if(!checkIpAddress(expectedCheckModel.getIpAddress(),serverCheckModel.getIpAddress())){
  141.                 throw new LicenseContentException("当前服务器的IP没在授权范围内");
  142.             }
  143.  
  144.             //校验Mac地址
  145.             if(!checkIpAddress(expectedCheckModel.getMacAddress(),serverCheckModel.getMacAddress())){
  146.                 throw new LicenseContentException("当前服务器的Mac地址没在授权范围内");
  147.             }
  148.  
  149.             //校验主板序列号
  150.             if(!checkSerial(expectedCheckModel.getMainBoardSerial(),serverCheckModel.getMainBoardSerial())){
  151.                 throw new LicenseContentException("当前服务器的主板序列号没在授权范围内");
  152.             }
  153.  
  154.             //校验CPU序列号
  155.             if(!checkSerial(expectedCheckModel.getCpuSerial(),serverCheckModel.getCpuSerial())){
  156.                 throw new LicenseContentException("当前服务器的CPU序列号没在授权范围内");
  157.             }
  158.         }else{
  159.             throw new LicenseContentException("不能获取服务器硬件信息");
  160.         }
  161.     }
  162.  
  163.  
  164.     /**
  165.      * 重写XMLDecoder解析XML
  166.      * @param encoded XML类型字符串
  167.      * @return java.lang.Object
  168.      */
  169.     private Object load(String encoded){
  170.         BufferedInputStream inputStream = null;
  171.         XMLDecoder decoder = null;
  172.         try {
  173.             inputStream = new BufferedInputStream(new ByteArrayInputStream(encoded.getBytes(XML_CHARSET)));
  174.  
  175.             decoder = new XMLDecoder(new BufferedInputStream(inputStream, DEFAULT_BUFSIZE),null,null);
  176.  
  177.             return decoder.readObject();
  178.         } catch (UnsupportedEncodingException e) {
  179.             e.printStackTrace();
  180.         } finally {
  181.             try {
  182.                 if(decoder != null){
  183.                     decoder.close();
  184.                 }
  185.                 if(inputStream != null){
  186.                     inputStream.close();
  187.                 }
  188.             } catch (Exception e) {
  189.                 log.error("XMLDecoder解析XML失败",e.getMessage());
  190.             }
  191.         }
  192.  
  193.         return null;
  194.     }
  195.  
  196.     /**
  197.      * 获取当前服务器需要额外校验的License参数
  198.      * @return demo.LicenseCheckModel
  199.      */
  200.     private LicenseCheckModel getServerInfos(){
  201.         //操作系统类型
  202.         String osName = System.getProperty("os.name").toLowerCase();
  203.         AbstractServerInfos abstractServerInfos = null;
  204.  
  205.         //根据不同操作系统类型选择不同的数据获取方法
  206.         if (osName.startsWith("windows")) {
  207.             abstractServerInfos = new WindowsServerInfos();
  208.         } else if (osName.startsWith("linux")) {
  209.             abstractServerInfos = new LinuxServerInfos();
  210.         }else{//其他服务器类型
  211.             abstractServerInfos = new LinuxServerInfos();
  212.         }
  213.  
  214.         return abstractServerInfos.getServerInfos();
  215.     }
  216.  
  217.     /**
  218.      * 校验当前服务器的IP/Mac地址是否在可被允许的IP范围内<br/>
  219.      * 如果存在IP在可被允许的IP/Mac地址范围内，则返回true
  220.      * @return boolean
  221.      */
  222.     private boolean checkIpAddress(List<String> expectedList,List<String> serverList){
  223.         if(expectedList != null && expectedList.size() > 0){
  224.             if(serverList != null && serverList.size() > 0){
  225.                 for(String expected : expectedList){
  226.                     if(serverList.contains(expected.trim())){
  227.                         return true;
  228.                     }
  229.                 }
  230.             }
  231.  
  232.             return false;
  233.         }else {
  234.             return true;
  235.         }
  236.     }
  237.  
  238.     /**
  239.      * 校验当前服务器硬件（主板、CPU等）序列号是否在可允许范围内
  240.      * @return boolean
  241.      */
  242.     private boolean checkSerial(String expectedSerial,String serverSerial){
  243.         if(StringUtils.isNotBlank(expectedSerial)){
  244.             if(StringUtils.isNotBlank(serverSerial)){
  245.                 if(expectedSerial.equals(serverSerial)){
  246.                     return true;
  247.                 }
  248.             }
  249.  
  250.             return false;
  251.         }else{
  252.             return true;
  253.         }
  254.     }
  255.  
  256. }

2.6 最后是License生成类，用于生成License证书

  1. package com.modules.license;
  2.  
  3. import com.modules.entity.LicenseCreatorParam;
  4. import de.schlichtherle.license.*;
  5. import lombok.extern.slf4j.Slf4j;
  6.  
  7. import javax.security.auth.x500.X500Principal;
  8. import java.io.File;
  9. import java.text.MessageFormat;
  10. import java.util.prefs.Preferences;
  11.  
  12. /**
  13.  * License生成类
  14.  *
  15.  */
  16. @Slf4j
  17. public class LicenseCreator {
  18.  
  19.     private final static X500Principal DEFAULT_HOLDER_AND_ISSUER = new X500Principal("CN=localhost, OU=localhost, O=localhost, L=SH, ST=SH, C=CN");
  20.     private LicenseCreatorParam param;
  21.  
  22.     public LicenseCreator(LicenseCreatorParam param) {
  23.         this.param = param;
  24.     }
  25.  
  26.     /**
  27.      * 生成License证书
  28.      * @return boolean
  29.      */
  30.     public boolean generateLicense(){
  31.         try {
  32.             LicenseManager licenseManager = new CustomLicenseManager(initLicenseParam());
  33.             LicenseContent licenseContent = initLicenseContent();
  34.  
  35.             licenseManager.store(licenseContent,new File(param.getLicensePath()));
  36.  
  37.             return true;
  38.         }catch (Exception e){
  39.             log.error(MessageFormat.format("证书生成失败：{0}",param),e.getMessage());
  40.             return false;
  41.         }
  42.     }
  43.  
  44.     /**
  45.      * 初始化证书生成参数
  46.      * @return de.schlichtherle.license.LicenseParam
  47.      */
  48.     private LicenseParam initLicenseParam(){
  49.         Preferences preferences = Preferences.userNodeForPackage(LicenseCreator.class);
  50.  
  51.         //设置对证书内容加密的秘钥
  52.         CipherParam cipherParam = new DefaultCipherParam(param.getStorePass());
  53.  
  54.         KeyStoreParam privateStoreParam = new CustomKeyStoreParam(LicenseCreator.class
  55.                 ,param.getPrivateKeysStorePath()
  56.                 ,param.getPrivateAlias()
  57.                 ,param.getStorePass()
  58.                 ,param.getKeyPass());
  59.  
  60.         LicenseParam licenseParam = new DefaultLicenseParam(param.getSubject()
  61.                 ,preferences
  62.                 ,privateStoreParam
  63.                 ,cipherParam);
  64.  
  65.         return licenseParam;
  66.     }
  67.  
  68.     /**
  69.      * 设置证书生成正文信息
  70.      * @return de.schlichtherle.license.LicenseContent
  71.      */
  72.     private LicenseContent initLicenseContent(){
  73.         LicenseContent licenseContent = new LicenseContent();
  74.         licenseContent.setHolder(DEFAULT_HOLDER_AND_ISSUER);
  75.         licenseContent.setIssuer(DEFAULT_HOLDER_AND_ISSUER);
  76.  
  77.         licenseContent.setSubject(param.getSubject());
  78.         licenseContent.setIssued(param.getIssuedTime());
  79.         licenseContent.setNotBefore(param.getIssuedTime());
  80.         licenseContent.setNotAfter(param.getExpiryTime());
  81.         licenseContent.setConsumerType(param.getConsumerType());
  82.         licenseContent.setConsumerAmount(param.getConsumerAmount());
  83.         licenseContent.setInfo(param.getDescription());
  84.  
  85.         //扩展校验服务器硬件信息
  86.         licenseContent.setExtra(param.getLicenseCheckModel());
  87.  
  88.         return licenseContent;
  89.     }
  90.  
  91. }

2.7 添加一个生成证书的Controller

这个Controller对外提供了两个RESTful接口，分别是 [获取服务器硬件信息] 和 [生成证书]，这样做不安全，可以自己写测试类。

  1. package com.modules.controller;
  2.  
  3. import com.modules.entity.LicenseCheckModel;
  4. import com.modules.entity.LicenseCreatorParam;
  5. import com.modules.license.*;
  6. import org.apache.commons.lang3.StringUtils;
  7. import org.springframework.beans.factory.annotation.Value;
  8. import org.springframework.http.MediaType;
  9. import org.springframework.web.bind.annotation.RequestBody;
  10. import org.springframework.web.bind.annotation.RequestMapping;
  11. import org.springframework.web.bind.annotation.RequestParam;
  12. import org.springframework.web.bind.annotation.RestController;
  13.  
  14. import java.util.HashMap;
  15. import java.util.Map;
  16.  
  17. /**
  18.  *
  19.  * 用于生成证书文件，不能放在给客户部署的代码里
  20.  * @since 1.0.0
  21.  */
  22. @RestController
  23. @RequestMapping("/license")
  24. public class LicenseCreatorController {
  25.  
  26.     /**
  27.      * 证书生成路径
  28.      */
  29.     @Value("${license.licensePath}")
  30.     private String licensePath;
  31.  
  32.     /**
  33.      * 获取服务器硬件信息
  34.      * @param osName 操作系统类型，如果为空则自动判断
  35.      * @return com.ccx.models.license.LicenseCheckModel
  36.      */
  37.     @RequestMapping(value = "/getServerInfos",produces = {MediaType.APPLICATION_JSON_UTF8_VALUE})
  38.     public LicenseCheckModel getServerInfos(@RequestParam(value = "osName",required = false) String osName) {
  39.         //操作系统类型
  40.         if(StringUtils.isBlank(osName)){
  41.             osName = System.getProperty("os.name");
  42.         }
  43.         osName = osName.toLowerCase();
  44.  
  45.         AbstractServerInfos abstractServerInfos = null;
  46.  
  47.         //根据不同操作系统类型选择不同的数据获取方法
  48.         if (osName.startsWith("windows")) {
  49.             abstractServerInfos = new WindowsServerInfos();
  50.         } else if (osName.startsWith("linux")) {
  51.             abstractServerInfos = new LinuxServerInfos();
  52.         }else{//其他服务器类型
  53.             abstractServerInfos = new LinuxServerInfos();
  54.         }
  55.         return abstractServerInfos.getServerInfos();
  56.     }
  57.  
  58.     /**
  59.      * 生成证书
  60.      * @param param 生成证书需要的参数，如：{"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":"这是证书描述信息","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"}}
  61.      * @return java.util.Map<java.lang.String,java.lang.Object>
  62.      */
  63.     @RequestMapping(value = "/generateLicense",produces = {MediaType.APPLICATION_JSON_UTF8_VALUE})
  64.     public Map<String,Object> generateLicense(@RequestBody LicenseCreatorParam param) {
  65.         Map<String,Object> resultMap = new HashMap<>(2);
  66.  
  67.         if(StringUtils.isBlank(param.getLicensePath())){
  68.             param.setLicensePath(licensePath);
  69.         }
  70.  
  71.         LicenseCreator licenseCreator = new LicenseCreator(param);
  72.         boolean result = licenseCreator.generateLicense();
  73.  
  74.         if(result){
  75.             resultMap.put("result","ok");
  76.             resultMap.put("msg",param);
  77.         }else{
  78.             resultMap.put("result","error");
  79.             resultMap.put("msg","证书文件生成失败！");
  80.         }
  81.         return resultMap;
  82.     }
  83. }

2.8 使用JDK自带的 keytool 工具生成公私钥证书库

 假如我们设置公钥库密码为：public_password1234，私钥库密码为：private_password1234，创建目录，在目录地址输入cmd，文件生成命令如下：

  1. #生成命令
  2. keytool -genkeypair -keysize 1024 -validity 3650 -alias "privateKey" -keystore "privateKeys.keystore" -storepass "public_password1234" -keypass "private_password1234" -dname "CN=localhost, OU=localhost, O=localhost, L=SH, ST=SH, C=CN"
  3.  
  4. #导出命令
  5. keytool -exportcert -alias "privateKey" -keystore "privateKeys.keystore" -storepass "public_password1234" -file "certfile.cer"
  6.  
  7. #导入命令
  8. keytool -import -alias "publicCert" -file "certfile.cer" -keystore "publicCerts.keystore" -storepass "public_password1234"

上述命令执行完成之后，会在当前路径下生成三个文件，分别是：privateKeys.keystore、publicCerts.keystore、certfile.cer。其中文件certfile.cer不再需要可以删除，文件privateKeys.keystore用于当前的 cloud-license-serve 项目给客户生成license文件，而文件publicCerts.keystore则随应用代码部署到客户服务器，用户解密license文件并校验其许可信息。

2.9 为客户生成license文件

将 cloud-license-serve 项目部署到客户服务器，通过以下接口获取服务器的硬件信息（等license文件生成后需要删除这个项目。当然也可以通过命令手动获取客户服务器的硬件信息，然后在开发者自己的电脑上生成license文件），使用postman 测试。

获取服务器硬件信息


生成简单证书

  1. {
  2. 	"subject": "license_demo",
  3. 	"privateAlias": "privateKey",
  4. 	"keyPass": "private_password1234",
  5. 	"storePass": "public_password1234",
  6. 	"licensePath": "D:/workspace/gitee/spring-boot2-license/license/license.lic",
  7. 	"privateKeysStorePath": "D:/workspace/gitee/spring-boot2-license/license/privateKeys.keystore",
  8. 	"issuedTime": "2021-05-14 00:00:01",
  9. 	"expiryTime": "2021-05-14 11:21:00",
  10. 	"consumerType": "User",
  11. 	"consumerAmount": 1,
  12. 	"description": "这是证书描述信息"
  13. }

生成复杂证书
  1. {
  2. 	"subject": "license_demo",
  3. 	"privateAlias": "privateKey",
  4. 	"keyPass": "private_password1234",
  5. 	"storePass": "public_password1234",
  6. 	"licensePath": "D:/workspace/gitee/spring-boot2-license/license/license.lic",
  7. 	"privateKeysStorePath": "D:/workspace/gitee/spring-boot2-license/license/privateKeys.keystore",
  8. 	"issuedTime": "2021-05-14 00:00:01",
  9. 	"expiryTime": "2021-05-14 23:59:59",
  10. 	"consumerType": "User",
  11. 	"consumerAmount": 1,
  12. 	"description": "这是证书描述信息",
  13. 	  "ipAddress": [
  14.         "172.16.1.126",
  15.         "192.168.56.1"
  16.     ],
  17.     "macAddress": [
  18.         "00-E1-4C-68-07-B5",
  19.         "0A-00-27-00-00-10"
  20.     ],
  21.     "cpuSerial": "178BFBFF00860F01",
  22.     "mainBoardSerial": "BBDW0820AG001635"
  23. }

三 客户部署的应用中添加License校验

创建微服务项目名称： cloud-license-client，版本：2.3.0，模拟给客户部署的应用。

3.1 pom.xml

  1.         <!-- License -->
  2.         <dependency>
  3.             <groupId>de.schlichtherle.truelicense</groupId>
  4.             <artifactId>truelicense-core</artifactId>
  5.             <version>1.33</version>
  6.         </dependency>
  7.  
  8.         <dependency>
  9.             <groupId>net.sourceforge.nekohtml</groupId>
  10.             <artifactId>nekohtml</artifactId>
  11.             <version>1.9.18</version>
  12.         </dependency>

3.2 application.properties

  1. server.port=8082
  2.  
  3. #启用优雅关机
  4. server.shutdown=graceful
  5. #缓冲10秒
  6. spring.lifecycle.timeout-per-shutdown-phase=10s
  7.  
  8. #License相关配置
  9. license.subject=license_demo
  10. license.publicAlias=publicCert
  11. license.storePass=public_password1234
  12. license.licensePath=D:/workspace/gitee/spring-boot2-license/license/license.lic
  13. license.publicKeysStorePath=D:/workspace/gitee/spring-boot2-license/license/publicCerts.keystore

3.3 License校验类

  1. package com.modules.license;
  2.  
  3. import com.modules.entity.LicenseVerifyParam;
  4. import de.schlichtherle.license.*;
  5. import lombok.extern.slf4j.Slf4j;
  6.  
  7. import java.io.File;
  8. import java.text.DateFormat;
  9. import java.text.MessageFormat;
  10. import java.text.SimpleDateFormat;
  11. import java.util.prefs.Preferences;
  12.  
  13. /**
  14.  * License校验类
  15.  */
  16. @Slf4j
  17. public class LicenseVerify {
  18.     /**
  19.      * 安装License证书
  20.      */
  21.     public synchronized LicenseContent install(LicenseVerifyParam param){
  22.         LicenseContent result = null;
  23.         DateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  24.  
  25.         //1. 安装证书
  26.         try{
  27.             LicenseManager licenseManager = LicenseManagerHolder.getInstance(initLicenseParam(param));
  28.             licenseManager.uninstall();
  29.  
  30.             result = licenseManager.install(new File(param.getLicensePath()));
  31.             log.info(MessageFormat.format("证书安装成功，证书有效期：{0} - {1}",format.format(result.getNotBefore()),format.format(result.getNotAfter())));
  32.         }catch (Exception e){
  33.             log.error("证书安装失败！",e);
  34.         }
  35.  
  36.         return result;
  37.     }
  38.  
  39.     /**
  40.      * 校验License证书
  41.      * @return boolean
  42.      */
  43.     public boolean verify(){
  44.         LicenseManager licenseManager = LicenseManagerHolder.getInstance(null);
  45.         DateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  46.  
  47.         //2. 校验证书
  48.         try {
  49.             LicenseContent licenseContent = licenseManager.verify();
  50. //            System.out.println(licenseContent.getSubject());
  51.  
  52.             log.info(MessageFormat.format("证书校验通过，证书有效期：{0} - {1}",format.format(licenseContent.getNotBefore()),format.format(licenseContent.getNotAfter())));
  53.             return true;
  54.         }catch (Exception e){
  55.             log.error("证书校验失败！",e);
  56.             return false;
  57.         }
  58.     }
  59.  
  60.     /**
  61.      * 初始化证书生成参数
  62.      * @param param License校验类需要的参数
  63.      * @return de.schlichtherle.license.LicenseParam
  64.      */
  65.     private LicenseParam initLicenseParam(LicenseVerifyParam param){
  66.         Preferences preferences = Preferences.userNodeForPackage(LicenseVerify.class);
  67.  
  68.         CipherParam cipherParam = new DefaultCipherParam(param.getStorePass());
  69.  
  70.         KeyStoreParam publicStoreParam = new CustomKeyStoreParam(LicenseVerify.class
  71.                 ,param.getPublicKeysStorePath()
  72.                 ,param.getPublicAlias()
  73.                 ,param.getStorePass()
  74.                 ,null);
  75.  
  76.         return new DefaultLicenseParam(param.getSubject()
  77.                 ,preferences
  78.                 ,publicStoreParam
  79.                 ,cipherParam);
  80.     }
  81.  
  82. }

3.4 添加Listener，用于在项目启动的时候安装License证书

  1. package com.modules.license;
  2.  
  3. import com.modules.entity.LicenseVerifyParam;
  4. import lombok.extern.slf4j.Slf4j;
  5. import org.apache.commons.lang3.StringUtils;
  6. import org.springframework.beans.factory.annotation.Value;
  7. import org.springframework.context.ApplicationContext;
  8. import org.springframework.context.ApplicationListener;
  9. import org.springframework.context.event.ContextRefreshedEvent;
  10. import org.springframework.stereotype.Component;
  11.  
  12. /**
  13.  * 在项目启动时安装证书
  14.  */
  15. @Slf4j
  16. @Component
  17. public class LicenseCheckListener implements ApplicationListener<ContextRefreshedEvent> {
  18.  
  19.     /**
  20.      * 证书subject
  21.      */
  22.     @Value("${license.subject}")
  23.     private String subject;
  24.  
  25.     /**
  26.      * 公钥别称
  27.      */
  28.     @Value("${license.publicAlias}")
  29.     private String publicAlias;
  30.  
  31.     /**
  32.      * 访问公钥库的密码
  33.      */
  34.     @Value("${license.storePass}")
  35.     private String storePass;
  36.  
  37.     /**
  38.      * 证书生成路径
  39.      */
  40.     @Value("${license.licensePath}")
  41.     private String licensePath;
  42.  
  43.     /**
  44.      * 密钥库存储路径
  45.      */
  46.     @Value("${license.publicKeysStorePath}")
  47.     private String publicKeysStorePath;
  48.  
  49.     @Override
  50.     public void onApplicationEvent(ContextRefreshedEvent event) {
  51.         //root application context 没有parent
  52.         ApplicationContext context = event.getApplicationContext().getParent();
  53.         if(context == null){
  54.             if(StringUtils.isNotBlank(licensePath)){
  55.                 log.info("++++++++ 开始安装证书 ++++++++");
  56.  
  57.                 LicenseVerifyParam param = new LicenseVerifyParam();
  58.                 param.setSubject(subject);
  59.                 param.setPublicAlias(publicAlias);
  60.                 param.setStorePass(storePass);
  61.                 param.setLicensePath(licensePath);
  62.                 param.setPublicKeysStorePath(publicKeysStorePath);
  63.  
  64.                 LicenseVerify licenseVerify = new LicenseVerify();
  65.                 //安装证书
  66.                 licenseVerify.install(param);
  67.  
  68.                 log.info("++++++++ 证书安装结束 ++++++++");
  69.             }
  70.         }
  71.     }
  72. }

3.5 添加拦截器，用于在登录的时候校验License证书

  1. package com.modules.common.config;
  2.  
  3. import com.modules.license.LicenseCheckInterceptor;
  4. import org.springframework.context.annotation.Configuration;
  5. import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
  6. import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
  7.  
  8. import javax.annotation.Resource;
  9.  
  10. /**
  11.  * @Description: 拦截器配置
  12.  */
  13. @Configuration
  14. public class InterceptorConfig implements WebMvcConfigurer {
  15.  
  16.     @Resource
  17.     private LicenseCheckInterceptor licenseCheckInterceptor;
  18.  
  19.     @Override
  20.     public void addInterceptors(InterceptorRegistry registry) {
  21.  
  22.         //添加要拦截的url
  23.         registry.addInterceptor(licenseCheckInterceptor)
  24.                 // 拦截的路径
  25.                 .addPathPatterns("/**");
  26.                 // 放行的路径
  27. //                .excludePathPatterns("/admin/login");
  28.     }
  29. }

3.6 模拟登陆LoginController

  1. package com.modules.controller;
  2.  
  3. import lombok.extern.slf4j.Slf4j;
  4. import org.springframework.stereotype.Controller;
  5. import org.springframework.web.bind.annotation.*;
  6.  
  7. import java.text.MessageFormat;
  8. import java.util.HashMap;
  9. import java.util.Map;
  10.  
  11. /**
  12.  * 登录
  13.  */
  14. @Slf4j
  15. @CrossOrigin
  16. @RestController
  17. public class LoginController {
  18.  
  19.     /**
  20.      * 模拟登录验证
  21.      * @param loginName 用户名
  22.      * @param password 密码
  23.      */
  24.     @GetMapping(value = "login")
  25.     public Map<String,Object> test(@RequestParam(required = true) String loginName, @RequestParam(required = true) String password){
  26.         Map<String,Object> result = new HashMap<>(1);
  27.         log.info(MessageFormat.format("登录名称：{0}，密码：{1}",loginName,password));
  28.         //模拟登录
  29.         log.info("模拟登录被拦截检查证书可用性");
  30.         result.put("code",200);
  31.         return result;
  32.     }
  33. }

3.7 测试

3.7.1 验证失败测试

在客户项目启动时，验证许可证可使用性，如果验证报错则验证失败，调用接口会被拦截（只要在拦截范围内），进行许可证不可用提示。

3.7.2 验证成功测试

在客户项目启动时，验证许可证可使用性，如果验证成功，调用接口不会被拦截，系统正常操作。

四 源码

码云源码地址：https://gitee.com/lichao12/spring-boot2-license

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小小林熬夜学编程/article/detail/663850
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号