2. 程式人生 > >第十八篇：JAVA加密解密之DH（Diffie-Hellman）演算法

第十八篇：JAVA加密解密之DH（Diffie-Hellman）演算法

阿新 • • 發佈：2019-02-15

DH演算法簡介

Diffie-Hellman演算法(D-H演算法)，金鑰一致協議。是由公開金鑰密碼體制的奠基人Diffie和Hellman所提出的一種思想。簡單的說就是允許兩名使用者在公開媒體上交換資訊以生成”一致”的、可以共享的金鑰。換句話說，就是由甲方產出一對金鑰（公鑰、私鑰），乙方依照甲方公鑰產生乙方金鑰對（公鑰、私鑰）。以此為基線，作為資料傳輸保密基礎，同時雙方使用同一種對稱加密演算法構建本地金鑰（SecretKey）對資料加密。這樣，在互通了本地金鑰（SecretKey）演算法後，甲乙雙方公開自己的公鑰，使用對方的公鑰和剛才產生的私鑰加密資料，同時可以使用對方的公鑰和自己的私鑰對資料解密。不單單是甲乙雙方兩方，可以擴充套件為多方共享資料通訊，這樣就完成了網路互動資料的安全通訊！該演算法源於中國的同餘定理——中國餘數定理。

  1. 甲方構建金鑰對兒，將公鑰公佈給乙方，將私鑰保留；雙方約定資料加密演算法；乙方通過甲方公鑰構建金鑰對兒，將公鑰公佈給甲方，將私鑰保留。
  2. 甲方使用私鑰、乙方公鑰、約定資料加密演算法構建本地金鑰，然後通過本地金鑰加密資料，傳送給乙方加密後的資料；乙方使用私鑰、甲方公鑰、約定資料加密演算法構建本地金鑰，然後通過本地金鑰對資料解密。
  3. 乙方使用私鑰、甲方公鑰、約定資料加密演算法構建本地金鑰，然後通過本地金鑰加密資料，傳送給甲方加密後的資料；甲方使用私鑰、乙方公鑰、約定資料加密演算法構建本地金鑰，然後通過本地金鑰對資料解密。

DH演算法實現

package com.jianggujin.codec;

import
 
 java.security.KeyPair;

/**
 * 金鑰對
 * 
 * @author jianggujin
 *
 */
public class HQKeyPair
{
   private byte[] privateKey;
   private byte[] publicKey;

   public HQKeyPair()
   {
   }

   public HQKeyPair(KeyPair keyPair)
   {
      this.privateKey = keyPair.getPrivate().getEncoded();
      this.publicKey = keyPair.getPublic().getEncoded();
   }

   public
 
 HQKeyPair(byte[] privateKey, byte[] publicKey)
   {
      this.privateKey = privateKey;
      this.publicKey = publicKey;
   }

   public byte[] getPrivateKey()
   {
      return privateKey;
   }

   public void setPrivateKey(byte[] privateKey)
   {
      this.privateKey = privateKey;
   }

   public byte[] getPublicKey()
   {
      return publicKey;
   }

   public void setPublicKey(byte[] publicKey)
   {
      this.publicKey = publicKey;
   }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
package com.jianggujin.codec;

import java.security.InvalidAlgorithmParameterException;
import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.PublicKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

import javax.crypto.Cipher;
import javax.crypto.KeyAgreement;
import javax.crypto.SecretKey;
import javax.crypto.interfaces.DHPublicKey;
import javax.crypto.spec.DHParameterSpec;

/**
 * Diffie-Hellman演算法(D-H演算法)，金鑰一致協議。是由公開金鑰密碼體制的奠基人Diffie和Hellman所提出的一種思想。
 * 
 * @author jianggujin
 * 
 */
public class HQDH
{
   private static HQDH dh = new HQDH();

   public static HQDH getInstance()
   {
      return dh;
   }

   private HQDH()
   {
   }

   /**
    * 對稱演算法
    * 
    * @author jianggujin
    *
    */
   public static enum HQDHSymmetricalAlgorithm
   {
      DES("DES"), DESede("DESede");
      private String name;

      private HQDHSymmetricalAlgorithm(String name)
      {
         this.name = name;
      }

      public String getName()
      {
         return this.name;
      }
   }

   private final String ALGORITHM = "DH";

   /**
    * 初始化甲方金鑰
    * 
    * @return
    * @throws NoSuchAlgorithmException
    */
   public HQKeyPair initPartyAKey() throws NoSuchAlgorithmException
   {
      return initPartyAKey(1024);
   }

   /**
    * 初始化甲方金鑰
    * 
    * @param keySize
    * @return
    * @throws NoSuchAlgorithmException
    */
   public HQKeyPair initPartyAKey(int keySize) throws NoSuchAlgorithmException
   {
      KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(ALGORITHM);
      keyPairGen.initialize(1024);
      KeyPair keyPair = keyPairGen.generateKeyPair();
      return new HQKeyPair(keyPair);
   }

   /**
    * 初始化乙方金鑰
    * 
    * @param partyAPublicKey
    *           甲方公鑰
    * @return
    * @throws NoSuchAlgorithmException
    * @throws InvalidKeySpecException
    * @throws InvalidAlgorithmParameterException
    * @throws Exception
    */
   public HQKeyPair initPartyBKey(byte[] partyAPublicKey) throws Exception
   {
      X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(partyAPublicKey);
      KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);
      PublicKey pubKey = keyFactory.generatePublic(x509KeySpec);

      // 由甲方公鑰構建乙方金鑰
      DHParameterSpec dhParamSpec = ((DHPublicKey) pubKey).getParams();

      KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(keyFactory.getAlgorithm());
      keyPairGenerator.initialize(dhParamSpec);

      KeyPair keyPair = keyPairGenerator.generateKeyPair();

      return new HQKeyPair(keyPair);
   }

   public byte[] encrypt(byte[] data, byte[] publicKey, byte[] privateKey, HQDHSymmetricalAlgorithm algorithm)
         throws Exception
   {
      return encrypt(data, publicKey, privateKey, algorithm.getName());
   }

   public byte[] encrypt(byte[] data, byte[] publicKey, byte[] privateKey, String algorithm) throws Exception
   {
      // 生成本地金鑰
      SecretKey secretKey = getSecretKey(publicKey, privateKey, algorithm);

      // 資料加密
      Cipher cipher = Cipher.getInstance(secretKey.getAlgorithm());
      cipher.init(Cipher.ENCRYPT_MODE, secretKey);

      return cipher.doFinal(data);
   }

   public byte[] decrypt(byte[] data, byte[] publicKey, byte[] privateKey, HQDHSymmetricalAlgorithm algorithm)
         throws Exception
   {
      return decrypt(data, publicKey, privateKey, algorithm.getName());
   }

   public byte[] decrypt(byte[] data, byte[] publicKey, byte[] privateKey, String algorithm) throws Exception
   {
      // 生成本地金鑰
      SecretKey secretKey = getSecretKey(publicKey, privateKey, algorithm);
      // 資料解密
      Cipher cipher = Cipher.getInstance(secretKey.getAlgorithm());
      cipher.init(Cipher.DECRYPT_MODE, secretKey);

      return cipher.doFinal(data);
   }

   private SecretKey getSecretKey(byte[] publicKey, byte[] privateKey, String algorithm) throws Exception
   {
      KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);
      X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(publicKey);
      PublicKey pubKey = keyFactory.generatePublic(x509KeySpec);

      PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(privateKey);
      Key priKey = keyFactory.generatePrivate(pkcs8KeySpec);

      KeyAgreement keyAgree = KeyAgreement.getInstance(keyFactory.getAlgorithm());
      keyAgree.init(priKey);
      keyAgree.doPhase(pubKey, true);

      // 生成本地金鑰
      SecretKey secretKey = keyAgree.generateSecret(algorithm);

      return secretKey;
   }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
  • 161
  • 162
  • 163
  • 164
  • 165
  • 166
  • 167
  • 168
  • 169
  • 170
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
  • 161
  • 162
  • 163
  • 164
  • 165
  • 166
  • 167
  • 168
  • 169
  • 170

測試程式碼：

import org.junit.Test;

import com.jianggujin.codec.HQBase64;
import com.jianggujin.codec.HQDH;
import com.jianggujin.codec.HQDH.HQDHSymmetricalAlgorithm;
import com.jianggujin.codec.HQKeyPair;

public class DHTest
{
   HQDH dh = HQDH.getInstance();
   HQBase64 base64 = HQBase64.getInstance();

   @Test
   public void encode() throws Exception
   {
      byte[] data = "jianggujin".getBytes();
      HQKeyPair keyPairA = dh.initPartyAKey();
      System.err.println("甲方私鑰：" + base64.encodeToString(keyPairA.getPrivateKey()));
      System.err.println("甲方公鑰：" + base64.encodeToString(keyPairA.getPublicKey()));
      HQKeyPair keyPairB = dh.initPartyBKey(keyPairA.getPublicKey());
      System.err.println("乙方私鑰：" + base64.encodeToString(keyPairB.getPrivateKey()));
      System.err.println("乙方公鑰：" + base64.encodeToString(keyPairB.getPublicKey()));

      HQDHSymmetricalAlgorithm[] algorithms = HQDHSymmetricalAlgorithm.values();
      for (HQDHSymmetricalAlgorithm algorithm : algorithms)
      {
         System.err.println("=========================================");
         System.err.println(algorithm);
         byte[] result = dh.encrypt(data, keyPairB.getPublicKey(), keyPairA.getPrivateKey(), algorithm);
         System.err.println("加密：" + base64.encodeToString(result));
         System.err.println(
               "解密：" + new String(dh.decrypt(result, keyPairA.getPublicKey(), keyPairB.getPrivateKey(), algorithm)));
      }
   }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35

測試結果： 
甲方私鑰：MIIBZwIBADCCARsGCSqGSIb3DQEDATCCAQwCgYEA/X9TgR11EilS30qcLuzk5/YRt1I870QAwx4/gLZRJmlFXUAiUftZPY1Y+r/F9bow9subVWzXgTuAHTRv8mZgt2uZUKWkn5/oBHsQIsJPu6nX/rfGG/g7V+fGqKYVDwT7g/bTxR7DAjVUE1oWkTL2dfOuK2HXKu/yIgMZndFIAccCgYEA9+GghdabPd7LvKtcNrhXuXmUr7v6OuqC+VdMCz0HgmdRWVeOutRZT+ZxBxCBgLRJFnEj6EwoFhO3zwkyjMim4TwWeotUfI0o4KOuHiuzpnWRbqN/C/ohNWLx+2J6ASQ7zKTxvqhRkImog9/hWuWfBpKLZl6Ae1UlZAFMO/7PSSoCAgIABEMCQQD+Kk/ll/S6Dq9R7psW2CNiSDdsRaWcuuB9RXHcjMmL6YszlOTqIMr4RKx+FP/oUBO+AIruC3KOgPFH6EF5zvUl 
甲方公鑰：MIIBpzCCARsGCSqGSIb3DQEDATCCAQwCgYEA/X9TgR11EilS30qcLuzk5/YRt1I870QAwx4/gLZRJmlFXUAiUftZPY1Y+r/F9bow9subVWzXgTuAHTRv8mZgt2uZUKWkn5/oBHsQIsJPu6nX/rfGG/g7V+fGqKYVDwT7g/bTxR7DAjVUE1oWkTL2dfOuK2HXKu/yIgMZndFIAccCgYEA9+GghdabPd7LvKtcNrhXuXmUr7v6OuqC+VdMCz0HgmdRWVeOutRZT+ZxBxCBgLRJFnEj6EwoFhO3zwkyjMim4TwWeotUfI0o4KOuHiuzpnWRbqN/C/ohNWLx+2J6ASQ7zKTxvqhRkImog9/hWuWfBpKLZl6Ae1UlZAFMO/7PSSoCAgIAA4GFAAKBgQDYLzkZU3n6Qv1osUpy0NvjVuSQcvcrTGyROq4ks7gYtu/js/Rw39H4id0TAGol3uUj/I3QQ8Ojwon26N23pmUXrvt+hVj6IsN/EuO6QazmXs1PZwLZeA+7t7uOsW9J9Vk9QCHujb4WIKlsZwpIk3/Ll1q2wtlYgAQ8FzLDBwvesA== 
乙方私鑰：MIIBZwIBADCCARsGCSqGSIb3DQEDATCCAQwCgYEA/X9TgR11EilS30qcLuzk5/YRt1I870QAwx4/gLZRJmlFXUAiUftZPY1Y+r/F9bow9subVWzXgTuAHTRv8mZgt2uZUKWkn5/oBHsQIsJPu6nX/rfGG/g7V+fGqKYVDwT7g/bTxR7DAjVUE1oWkTL2dfOuK2HXKu/yIgMZndFIAccCgYEA9+GghdabPd7LvKtcNrhXuXmUr7v6OuqC+VdMCz0HgmdRWVeOutRZT+ZxBxCBgLRJFnEj6EwoFhO3zwkyjMim4TwWeotUfI0o4KOuHiuzpnWRbqN/C/ohNWLx+2J6ASQ7zKTxvqhRkImog9/hWuWfBpKLZl6Ae1UlZAFMO/7PSSoCAgIABEMCQQCbq4VyWTHlIbhxqIMAsycz+J6wyxs41MsehQhZC1dv4z9BHzDDBtRG5JDgDMEh2ABkLKO0sXyZSzsW34442GPN 
乙方公鑰：MIIBpjCCARsGCSqGSIb3DQEDATCCAQwCgYEA/X9TgR11EilS30qcLuzk5/YRt1I870QAwx4/gLZRJmlFXUAiUftZPY1Y+r/F9bow9subVWzXgTuAHTRv8mZgt2uZUKWkn5/oBHsQIsJPu6nX/rfGG/g7V+fGqKYVDwT7g/bTxR7DAjVUE1oWkTL2dfOuK2HXKu/yIgMZndFIAccCgYEA9+GghdabPd7LvKtcNrhXuXmUr7v6OuqC+VdMCz0HgmdRWVeOutRZT+ZxBxCBgLRJFnEj6EwoFhO3zwkyjMim4TwWeotUfI0o4KOuHiuzpnWRbqN/C/ohNWLx+2J6ASQ7zKTxvqhRkImog9/hWuWfBpKLZl6Ae1UlZAFMO/7PSSoCAgIAA4GEAAKBgF1+TvPiAefyWJJ2Or7TNGlk/oiT94pUyMrdXmSpgdf4AOwB9MgvZQvmlwx+hKrEFBKKcdUnfsZffdj2XzlMx46IWErUT9+NfbaLfuMTRmH8ZMdfXxHckoJzcC6CFrVR2DoDkzM2BCUrEy7ArxFoWoL27xsIcb1PC+4wNV1ah8JQ 
========================================= 
DES 
加密：Oxk3L0a0C990XyyWvj5Mlg== 
解密：jianggujin 
========================================= 
DESede 
加密：VtrJvgsxnAY7cd3alRUwPA== 
解密：jianggujin

相關推薦

第十八篇：JAVA加密解密之DH（Diffie-Hellman）演算法

DH演算法簡介 Diffie-Hellman演算法(D-H演算法)，金鑰一致協議。是由公開金鑰密碼體制的奠基人Diffie和Hellman所提出的一種思想。簡單的說就是允許兩名使用者在公開媒體上交換資訊以生成”一致”的、可以共享的金鑰。換句話說，就是由甲方產出一對金鑰（

JAVA加密解密之DH（Diffie-Hellman）演算法

DH演算法簡介 Diffie-Hellman演算法(D-H演算法)，金鑰一致協議。是由公開金鑰密碼體制的奠基人Diffie和Hellman所提出的一種思想。簡單的說就是允許兩名使用者在公開媒體上交換資訊以生成”一致”的、可以共享的金鑰。換句話說，就是由甲方產出

第十八篇：Django進級

則表達式 djang clas 路由分發 路由 數據 分發 django數據庫 fbv 一、Django工程創建 二、Django 的 CBV和FBV 三、模板語言循環字典 四、Django基於正則表達式的URL 五、Django對應的路由名稱 六、Django路由分發 七

精通Spring Boot——第十八篇：自定義認證流程

前兩篇簡單介紹了一下使用Spring Security 使用Http Basic登入，以及Spring Security如何自定義登入邏輯。這篇文章主要介紹如何使用handler來定義認證相關的流程。 先做一些自定義的操作，如配置自定義登入頁，配置登入請求URL等。 當我們使用Spring Security時

Spring Boot 基礎系列教程 | 第十八篇：使用Flyway來管理資料庫版本

推薦 Spring Boot/Cloud 視訊： 如果沒有讀過上面內容的讀者，有興趣的可以一閱。在前面的使用JdbcTemplate一文中，主要通過spring提供的JdbcTemplate實現對使用者表的增刪改查操作。在實現這個例子的時候，我們事先在MySQ

Java程式設計思想 第十八章：Java I/O

I/O源端與之通訊的接收端：檔案、控制檯、網路連結等。 通訊方式：順序、隨機存取、緩衝、二進位制、按字元、按行、按字等。 1. File類 File（檔案）既能代表一個特定檔名稱，又能代表一個目錄下的一組檔案的名稱。如果是檔案集，可以對此集合呼叫list()方法，

跟我學SpringCloud | 第十八篇：微服務 Docker 化之基礎環境

1. 容器化 Docker 的橫空出世，給了容器技術帶來了質的飛躍，Docker 標準化了服務的基礎設施，統一了應用的打包分發，部署以及作業系統相關類庫等，解決了測試生產部署時環境差異的問題。對於運維來講，由於映象的不可變性，更容易進行服務部署和回滾操作。利用各種第三方容器管理平臺，實現一鍵部署、動態伸縮

SpringBoot | 第十八章：web應用開發之WebJars使用

前言 前面一章節我們主要講解了關於檔案上傳的兩種方式。本章節繼續web開發的相關知識點。通常對於web開發而言，像js、css、images等靜態資源版本管理是比較混亂的，比如Jquery、Bootstrap、Vue.js可能各個前端框架所依賴的自個元件的版本都不盡相同，一

OpenCV學習第十二篇：帶透明通道影象合成（縮放，旋轉，和ROI）

第一步：獲取素材圖片 Mat src, dst; src = imread("F:/識圖/底圖.PNG", 1); dst = imread("logo", -1); 【ps：這裡需要注意的是透明度圖片獲取，後面的引數帶-1】 第二

SQL Server索引進階第十一篇：索引碎片分析與解決（上）

索引設計是資料庫設計中比較重要的一個環節，對資料庫的效能其中至關重要的作用，但是索引的設計卻又不是那麼容易的事情，效能也不是那麼輕易就獲取到的，很多的技術人員因為不恰當的建立索引，最後使得其效果適得其反，可以說“成也索引，敗也索引”。 相關有關索引碎片的問題，大家應該是聽過不少，也許也很多的朋友

一起來學SpringBoot | 第十九篇：輕鬆搞定資料驗證（一）

SpringBoot是為了簡化Spring應用的建立、執行、除錯、部署等一系列問題而誕生的產物，自動裝配的特性讓我們可以更好的關注業務本身而不是外部的XML配置，我們只需遵循規範，引入相關的依賴就可以輕易的搭建出一個 WEB 工程 對於任何一個

跟我學SpringCloud | 第十五篇：微服務利劍之APM平臺（一）Skywalking

目錄 SpringCloud系列教程 | 第十五篇：微服務利劍之APM平臺（一）Skywalking 1. Skywalking概述 2. Skywalking主要功能 3. Skywalking主要特性

跟我學SpringCloud | 第十六篇：微服務利劍之APM平臺（二）Pinpoint

目錄 SpringCloud系列教程 | 第十六篇：微服務利劍之APM平臺（二）Pinpoint 1. Pinpoint概述 2. Pinpoint主要特性 3. Pinpoint優勢 4.

輕輕鬆鬆學習SpringBoot2：第二十五篇： Spring Boot和Mongodb整合（完整版）

今天主要講的是Spring Boot和Mongodb整合我們先來回顧一下前面章節的相關內容前面我們講了SpringBoot和mysql整合，並且講了操作資料庫的幾種方式自動生成表資料庫操作操作篇回到正題，mongodb的安裝在這就不累述了，win版本的去官網下載，然後一直下一

Java加密解密之MAC（訊息認證碼）

上一篇帖子，我們講了訊息摘要（數字摘要），它是把一個文字/檔案 通過摘要函式（hash函式）計算出一個結果。然後把文字/檔案和摘要結果一同發給接受者 接受者接收到檔案之後，也進行摘要，把兩個摘要結果進行對比。如果一致就說明文字/檔案和摘要是一致的 但是，這裡有個問題，假設A

SM2演算法第二十七篇： openssl庫中的BIGNUM（超讚）

openssl庫中的BIGNUM，處理大數比較好，可以用在很多方面。 BIGNUM是一個typedef的結構，可以直接使用。但一般來說，使用它的指標結構。如：BIGNUM *p; BIGNUM的建立與釋放 函式原型 解釋 示例 BIGNUM * BN_new (voi

第八篇：grub加密

grub.conf 進入 nbsp 單用戶 密碼 第八篇 方法 ima bsp 1.grub加密是為了阻止在開機時用戶進入單用戶模式，任意鍵進入下圖，【e】進入修改init值=1 加密方法： （1）比如密碼123456,生成它的密文方法： （2）在/etc/grub.

Python全棧開發之路 【第十八篇】：Ajax技術

加載 完全 三種 請求 技術 當前頁 n) let 保存 Ajax技術 Ajax = 異步 JavaScript 和 XML。 Ajax 是一種在無需重新加載整個網頁的情況下，能夠更新部分網頁的技術。 1、jQuery的load()方法 jQuery load()方法是簡單

“全棧2019”Java第十八章：一元運算子

難度 初級 學習時間 10分鐘 適合人群 零基礎 開發語言 Java 開發環境 JDK v11 IntelliJ IDEA v2018.3 文章原文連結 “全棧2019”Java第十八章：一元運算子 下一章 “全棧2019”Java第十九章：關係運算符、條件運算子和三元

Python之路【第十八篇】：Web框架們

 Python的WEB框架 Bottle Bottle是一個快速、簡潔、輕量級的基於WSIG的微型Web框架，此框架只由一個 .py 檔案，除了Python的標準庫外，其不依賴任何其他模組。 ? 1 2 3 4