一切福田，不離方寸，從心而覓，感無不通。

Category Archives: Programming Language

Asp.Net Core实战常见加密算法(C#)

先问个问题：为什么要使用加密算法？ 因为数据在网络中传输时面临4个问题： 窃听 假冒 篡改 事后否认 加密技术就是用来解决“窃听”这个问题的。通常分为两大类：对称加密和非对称加密。 对称加密 概念：对称加密就是加密和解密使用同一个密钥，通常称之为“Session Key ”，这种加密技术在当今被广泛采用，如美国政府所采用的DES加密标准就是一种典型的对称加密算法，它的Session Key长度为56bits。 优点：算法公开、计算量小、加密速度快、加密效率高。适用于需要加密大量数据的场景。 缺点：由于加解密使用同一个密钥，密钥传输的过程不安全，且容易被破解，密钥管理也比较麻烦。例如：不适用于浏览器到服务器的通信，因为密钥一旦发送到浏览器端就很容易暴露。 常见算法：AES，DES，3DES，TDEA，Blowfish，RC5，IDEA 非对称加密 概念：非对称加密就是加密和解密所使用的不是同一个密钥，通常有两个密钥，称为“公钥”和“私钥”，它们两个必需配对使用。“公钥”是指可以对外公布的，“私钥”则不能，只能由持有人一个人知道。 优点：由于加解密是用不同的密钥，私钥并不公开，这样就保证了信息在网络传输中的安全性：即使被拦截也无法解密。非常适用于客户端到服务端的数据传输。例如：支付宝的支付请求，数字签名等。 缺点：加密速度慢，比较耗资源。只适用于少量敏感信息的加密。如果加密大量消息则效率会变得低下。另外，如果动态生成公钥和私钥也比较耗资源。 常见算法：RSA，Elgamal，背包算法，Rabin，D-H，ECC   有人可能会问，上面两类加密方式怎么没有MD5？MD5……严格意义上说不是一种加密算法，因为它不能解密。它只是一种密码散列算法，只是为了校验信息用的：保证信息没有篡改。如：你下载软件或游戏时，在下载页面官方都会提供一个“MD5字符串”，你下载完成后可以用md5工具对下载到的软件md5校验，如果得到的md5串和下载页面的一致，就说明软件或游戏没有被篡改过，可放心使用。   下面我们就一块来实战几种常见的加密方式和散列算法： DES 分类：对称加密 DES全称为Data Encryption Standard，即数据加密标准，是一种使用密钥加密的块算法，1977年被美国联邦政府的国家标准局确定为联邦资料处理标准（FIPS），并授权在非密级政府通信中使用，随后该算法在国际上广泛流传开来。

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
using System;
using System.IO;
using System.Security.Cryptography;
using System.Text;
 
namespace EncryptionPractice.Utils
{
    public class DESUtils
    {
        /// <summary>
        /// 加密数据
        /// </summary>
        /// <param name="text"></param>
        /// <param name="sessionKey"></param>
        /// <returns></returns>
        public static string Encrypt(string text, string sessionKey)
        {
            try
            {
                var des = GetDESProvider(sessionKey);
                var bytes = Encoding.Default.GetBytes(text);
                using var memoryStream = GetMemoryStream(des.CreateEncryptor(), bytes);
                
                var result = new StringBuilder();
                foreach (var byteItem in memoryStream.ToArray())
                {
                    result.AppendFormat("{0:X2}", byteItem);
                }
 
                return result.ToString();
 
            } catch {
                return string.Empty;
            }
        }
 
        /// <summary>
        /// 解密数据
        /// </summary>
        /// <param name="ciphertext"></param>
        /// <param name="sessionKey"></param>
        /// <returns></returns>
        public static string Decrypt(string ciphertext, string sessionKey)
        {
            try
            {
                var length = ciphertext.Length / 2;
                var bytes = new byte[length];
                for (var i=0; i<length; i++)
                {
                    var j = Convert.ToInt32(ciphertext.Substring(i * 2, 2), 16);
                    bytes[i] = (byte) j;
                }
 
                var des = GetDESProvider(sessionKey);
                using var memoryStream = GetMemoryStream(des.CreateDecryptor(), bytes);
 
                return Encoding.Default.GetString(memoryStream.ToArray());
            }
            catch
            {
                return string.Empty;
            }
        }
 
        /// <summary>
        /// 获取DES引擎
        /// </summary>
        /// <param name="sessionKey"></param>
        /// <returns></returns>
        private static DESCryptoServiceProvider GetDESProvider(string sessionKey)
        {
            var md5Key = MD5Utils.Get32(sessionKey).Substring(8, 8);
            var des = new DESCryptoServiceProvider
            {
                Key = Encoding.ASCII.GetBytes(md5Key),
                IV = Encoding.ASCII.GetBytes(md5Key)
            };
 
            return des;
        }
 
        /// <summary>
        /// 获取内存流
        /// </summary>
        /// <param name="cryptoTransform"></param>
        /// <param name="bytes"></param>
        /// <returns></returns>
        private static MemoryStream GetMemoryStream(ICryptoTransform cryptoTransform, byte[] bytes)
        {
            var memoryStream = new MemoryStream();
            using var cryptoStream = new CryptoStream(memoryStream, cryptoTransform, CryptoStreamMode.Write);
            cryptoStream.Write(bytes, 0, bytes.Length);
            cryptoStream.FlushFinalBlock();
 
            return memoryStream;
        }
    }
}

  AES 分类：对称加密 高级加密标准（Advanced Encryption Standard，AES），又称Rijndael加密法，是美国联邦政府采用的一种区块加密标准。这个标准用来替代原先的DES（Data Encryption Standard），已经被多方分析且广为全世界所使用。

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
using System;
using System.IO;
using System.Security.Cryptography;
using System.Text;
 
namespace EncryptionPractice.Utils
{
    public class AESUtils
    {
        /// <summary>
        /// 默认Key
        /// </summary>
        const string KEY = "E10ADC3949BA59AB";
 
        /// <summary>
        /// 默认偏移量
        /// </summary>
        const string IV = "BE56E057F20F883E";
 
        /// <summary>
        /// 加密
        /// </summary>
        /// <param name="text"></param>
        /// <param name="key"></param>
        /// <param name="iv"></param>
        /// <returns></returns>
        public static string Encrypt(string text, string key = KEY, string iv = IV)
        {
            var bytes = Encoding.UTF8.GetBytes(text);
            var result = Origin(bytes, false, key, iv);
 
            return Convert.ToBase64String(result, 0, result.Length);
        }
 
        /// <summary>
        /// 解密
        /// </summary>
        /// <param name="ciphertext"></param>
        /// <param name="key"></param>
        /// <param name="iv"></param>
        /// <returns></returns>
        public static string Decrypt(string ciphertext, string key = KEY, string iv = IV)
        {
            var bytes = Convert.FromBase64String(ciphertext);
            var result = Origin(bytes, true, key, iv);
 
            if (result.Length < 1)
                return string.Empty;
 
            return Encoding.UTF8.GetString(result);
        }
 
        /// <summary>
        /// 底层方法
        /// </summary>
        /// <param name="bytes"></param>
        /// <param name="isDecrypt"></param>
        /// <param name="key"></param>
        /// <param name="iv"></param>
        /// <returns></returns>
        private static byte[] Origin(byte[] bytes, bool isDecrypt, string key = KEY, string iv = IV)
        {
            try
            {
                var keyBytes = Encoding.UTF8.GetBytes(key);
                var ivBytes = Encoding.UTF8.GetBytes(iv);
 
                var rijndaelManaged = new RijndaelManaged
                {
                    BlockSize = 128,
                    KeySize = 256,
                    FeedbackSize = 128,
                    Padding = PaddingMode.PKCS7,
                    Key = keyBytes,
                    IV = ivBytes,
                    Mode = CipherMode.CBC
                };
 
                var cryptoTransform = isDecrypt ? rijndaelManaged.CreateDecryptor() : rijndaelManaged.CreateEncryptor();
                var result = cryptoTransform.TransformFinalBlock(bytes, 0, bytes.Length);
 
                return result;
            }
            catch
            {
                return new byte[] { };
            }
        }
    }
}

  RSA 分类：非对称加密 RSA是1977年由罗纳德·李维斯特（Ron Rivest）、阿迪·萨莫尔（Adi Shamir）和伦纳德·阿德曼（Leonard Adleman）一起提出的。RSA就是他们三人姓氏开头字母拼在一起组成的。RSA公开密钥密码体制是一种使用不同的加密密钥与解密密钥，“由已知加密密钥推导出解密密钥在计算上是不可行的”密码体制。

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
using System;
using System.IO;
using System.Security.Cryptography;
using System.Text;
 
namespace EncryptionPractice.Utils
{
    public class RSAUtils
    {
        /// <summary>
        /// 加密
        /// </summary>
        /// <param name="text">明文</param>
        /// <param name="publicKey">公钥</param>
        /// <returns>密文</returns>
        public static string Encrypt(string text, string publicKey)
        {
            var blockSize = 256; // 加密块大小，越大越慢
            var bytes = Encoding.UTF8.GetBytes(text);
            var length = bytes.Length;
 
            // rsa实例
            var rsa = new RSACryptoServiceProvider();
            rsa.FromXmlString(publicKey);
 
            var offSet = 0; // 游标
            var i = 0;
            byte[] cache;
            var ms = new MemoryStream();
            while (length - offSet > 0)
            {
                var len = length - offSet > blockSize ? blockSize : length - offSet;
                var temp = new byte[len];
                Array.Copy(bytes, offSet, temp, 0, len);
                cache = rsa.Encrypt(bytes, false);
                ms.Write(cache, 0, cache.Length);
 
                i++;
                offSet = i * blockSize;
            }
 
            var cipherBytes = ms.ToArray();
            return Convert.ToBase64String(cipherBytes);
        }
 
        /// <summary>
        /// RSA解密
        /// </summary>
        /// <param name="ciphertext">密文</param>
        /// <param name="privateKey">私钥</param>
        /// <returns>明文</returns>
        public static string Decrypt(string ciphertext, string privateKey)
        {
            var blockSize = 256;
            var bytes = Convert.FromBase64String(ciphertext);
            var length = bytes.Length;
 
            // rsa实例
            var rsa = new RSACryptoServiceProvider();
            rsa.FromXmlString(privateKey);
 
            var offSet = 0; // 游标
            var i = 0;
            byte[] cache;
            var ms = new MemoryStream();
            while (length - offSet > 0)
            {
                var len = length - offSet > blockSize ? blockSize : length - offSet;
                var temp = new byte[len];
                Array.Copy(bytes, offSet, temp, 0, len);
                cache = rsa.Decrypt(temp, false);
                ms.Write(cache, 0, cache.Length);
 
                i++;
                offSet = i * blockSize;
            }
 
            var cipherBytes = ms.ToArray();
            return Encoding.UTF8.GetString(cipherBytes);
        }
    }
}

  生成公钥/密钥的方法（只适用于C#，其他编程语言使用需要转换）

1
2
3
var rsa = new RSACryptoServiceProvider();
var publicKey = rsa.ToXmlString(false);
var privateKey = rsa.ToXmlString(true);

    MD5 分类：散列算法 MD5信息摘要算法（MD5 Message-Digest Algorithm），一种被广泛使用的密码散列函数，可以产生出一个128位（16字节）的散列值（hash value），用于确保信息传输完整一致。MD5由美国密码学家罗纳德·李维斯特（Ronald Linn Rivest）设计，于1992年公开。1996年后该算法被证实存在弱点，可以被加以破解，对于需要高度安全性的数据，专家一般建议改用其他算法，如SHA-2。

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
using System;
using System.Security.Cryptography;
using System.Text;
 
namespace EncryptionPractice.Utils
{
    public class MD5Utils
    {
        /// <summary>
        /// 获取16位散列值
        /// </summary>
        /// <param name="text"></param>
        /// <returns></returns>
        public static string Get16(string text)
        {
            return Get32(text).Substring(7, 16);
        }
 
        /// <summary>
        /// 获取32位散列值
        /// </summary>
        /// <param name="text"></param>
        /// <returns></returns>
        public static string Get32(string text)
        {
            using var md5 = MD5.Create();
            var hash = md5.ComputeHash(Encoding.UTF8.GetBytes(text));
            var result = BitConverter.ToString(hash);
 
            return result.Replace("-", "").ToUpper();
        }
 
        /// <summary>
        /// 获取16位散列值 v2
        /// </summary>
        /// <param name="text"></param>
        /// <returns></returns>
        public static string Get16v2(string text)
        {
            return Get32v2(text).Substring(7, 16);
        }
 
        /// <summary>
        /// 获取32位散列值
        /// </summary>
        /// <param name="text">字符串</param>
        /// <returns></returns>
        public static string Get32v2(string text)
        {
            var md5 = new MD5CryptoServiceProvider();
            var hash = md5.ComputeHash(Encoding.Default.GetBytes(text));
 
            var resutl = new StringBuilder();
            for (int i = 0; i < hash.Length; i++)
            {
                resutl.Append(hash[i].ToString("x2"));
            }
 
            return resutl.ToString().ToUpper();
        }
 
    }
}

  SHA-2 分类：散列算法 SHA-2，名称来自于安全散列算法2（英语：Secure Hash Algorithm 2）的缩写，一种密码散列函数算法标准，由美国国家安全局研发，由美国国家标准与技术研究院（NIST）在2001年发布。属于SHA算法之一，是SHA-1的后继者。其下又可再分为六个不同的算法标准，包括了：SHA-224、SHA-256、SHA-384、SHA-512、SHA-512/224、SHA-512/256。

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
using System.Security.Cryptography;
using System.Text;
 
namespace EncryptionPractice.Utils
{
    public class SHAUtils
    {
        /// <summary>
        /// SHA256加密
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        public static string Encrypt(string data)
        {
            var bytes = Encoding.UTF8.GetBytes(data);
            var hash = SHA256.Create().ComputeHash(bytes);
 
            var result = new StringBuilder();
            for (int i = 0; i < hash.Length; i++)
            {
                result.Append(hash[i].ToString("x2"));
            }
 
            return result.ToString();
        }
 
    }
}

  欢迎转载，请注明出处：龙生时代

龙生   03 Mar 2021
View Details

JAVA版身份证获取性别、出生日期及年龄

工作中需要根据身份证获取性别、出生日期及年龄，且要还要支持15位长度的身份证号码，网上搜索了一下，经过测试好像多少存在点问题，干脆自已写一个。 CertificateNo.java

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
package com.bijian.study;  
  
import java.util.Calendar;  
import java.util.regex.Pattern;  
  
/**
* 根据身份证获取性别、出生日期、年龄，支持15、18位身份证
*/  
public class CertificateNo {  
  
    public ResultDTO parseCertificateNo(String certificateNo) {  
          
        ResultDTO resultDTO = new ResultDTO();  
        String myRegExpIDCardNo = "^\\d{6}(((19|20)\\d{2}(0[1-9]|1[0-2])(0[1-9]|[1-2][0-9]|3[0-1])\\d{3}([0-9]|x|X))|(\\d{2}(0[1-9]|1[0-2])(0[1-9]|[1-2][0-9]|3[0-1])\\d{3}))$";  
        boolean valid=Pattern.matches(myRegExpIDCardNo,certificateNo)||(certificateNo.length() == 17 && Pattern.matches(myRegExpIDCardNo,certificateNo.substring(0,15)));  
        if(!valid){  
            resultDTO.setStatueMessage("证件号码不规范!");  
            return resultDTO;  
        }  
        int idxSexStart = 16;  
        int birthYearSpan = 4;  
        //如果是15位的证件号码  
        if(certificateNo.length() == 15) {  
            idxSexStart = 14;  
            birthYearSpan = 2;  
        }  
          
        //性别  
        String idxSexStr = certificateNo.substring(idxSexStart, idxSexStart + 1);  
        int idxSex = Integer.parseInt(idxSexStr) % 2;  
        String sex = (idxSex == 1) ? "M" : "F";  
        resultDTO.setSex(sex);  
          
        //出生日期  
        String year = (birthYearSpan == 2 ? "19" : "") + certificateNo.substring(6, 6 + birthYearSpan);  
        String month = certificateNo.substring(6 + birthYearSpan, 6 + birthYearSpan + 2);  
        String day = certificateNo.substring(8 + birthYearSpan, 8 + birthYearSpan + 2);  
        String birthday = year + '-' + month + '-' + day;  
        resultDTO.setBirthday(birthday);  
          
        //年龄  
        Calendar certificateCal = Calendar.getInstance();  
        Calendar currentTimeCal = Calendar.getInstance();  
        certificateCal.set(Integer.parseInt(year), Integer.parseInt(month)-1, Integer.parseInt(day));  
        int yearAge = (currentTimeCal.get(currentTimeCal.YEAR)) - (certificateCal.get(certificateCal.YEAR));  
        certificateCal.set(currentTimeCal.get(Calendar.YEAR), Integer.parseInt(month)-1, Integer.parseInt(day));  
        int monthFloor = (currentTimeCal.before(certificateCal) ? 1 : 0);  
        resultDTO.setAge(yearAge - monthFloor);  
          
        return resultDTO;  
    }  
}

  ResultDTO.java

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
package com.bijian.study;  
  
public class ResultDTO {  
      
    private String statueMessage;  
    private String sex;  
    private String birthday;  
    private int age;  
      
    public String getStatueMessage() {  
        return statueMessage;  
    }  
    public void setStatueMessage(String statueMessage) {  
        this.statueMessage = statueMessage;  
    }  
    public String getSex() {  
        return sex;  
    }  
    public void setSex(String sex) {  
        this.sex = sex;  
    }  
    public String getBirthday() {  
        return birthday;  
    }  
    public void setBirthday(String birthday) {  
        this.birthday = birthday;  
    }  
    public int getAge() {  
        return age;  
    }  
    public void setAge(int age) {  
        this.age = age;  
    }  
      
    public String toString() {  
        String res = "";  
        if(this.statueMessage != null) {  
            res += this.statueMessage;  
        }else {  
            res += "sex:" + this.sex + ",birthday:" + this.birthday + ",age:" + this.age;  
        }  
        return res;  
    }  
}

  CertificateNoTest.java

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
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
package com.bijian.test;  
  
import junit.framework.Assert;  
  
import org.junit.Before;  
import org.junit.Test;  
  
import com.bijian.study.CertificateNo;  
import com.bijian.study.ResultDTO;  
  
/**
* 说明：
* 1.身份证信息完全是测试时随便写的，如有雷同，纯属巧合
* 2.写此测试案例的日期是2015-02-08，有测生日当天及前后的案例，后续再运行需更改
*/  
public class CertificateNoTest {  
      
    private CertificateNo certificateNo;  
    private ResultDTO resultDTO;  
      
    @Before  
    public void setUp() throws Exception {  
        certificateNo = new CertificateNo();  
    }  
  
    @Test  
    public void test_abnormality_certificateNo_of_18_digit_430522199812623535() {  
          
        resultDTO = certificateNo.parseCertificateNo("430522199812623535");  
        Assert.assertNotNull(resultDTO);    
        Assert.assertEquals("证件号码不规范!", resultDTO.getStatueMessage());    
    }  
      
    @Test  
    public void test_abnormality_certificateNo_of_18_digit_430522198813013210() {  
          
        resultDTO = certificateNo.parseCertificateNo("430522198813013210");  
        Assert.assertNotNull(resultDTO);    
        Assert.assertEquals("证件号码不规范!", resultDTO.getStatueMessage());    
    }  
      
    @Test  
    public void test_normality_certificateNo_of_18_digit_430522199812101515() {  
          
        resultDTO = certificateNo.parseCertificateNo("430522199812101515");  
        Assert.assertNotNull(resultDTO);    
        Assert.assertEquals("M", resultDTO.getSex());  
        Assert.assertEquals("1998-12-10", resultDTO.getBirthday());    
        Assert.assertEquals(16, resultDTO.getAge());    
    }  
      
    @Test  
    public void test_normality_certificateNo_of_18_digit_430522199812101595() {  
          
        resultDTO = certificateNo.parseCertificateNo("430522199812101595");  
        Assert.assertNotNull(resultDTO);    
        Assert.assertEquals("M", resultDTO.getSex());  
        Assert.assertEquals("1998-12-10", resultDTO.getBirthday());    
        Assert.assertEquals(16, resultDTO.getAge());    
    }  
      
    @Test  
    public void test_normality_certificateNo_of_18_digit_430522199812101585() {  
          
        resultDTO = certificateNo.parseCertificateNo("430522199812101585");  
        Assert.assertNotNull(resultDTO);    
        Assert.assertEquals("F", resultDTO.getSex());  
        Assert.assertEquals("1998-12-10", resultDTO.getBirthday());    
        Assert.assertEquals(16, resultDTO.getAge());    
    }  
      
    @Test  
    public void test_normality_certificateNo_of_18_digit_430522198810103212() {  
          
        resultDTO = certificateNo.parseCertificateNo("430522198810103212");  
        Assert.assertNotNull(resultDTO);    
        Assert.assertEquals("M", resultDTO.getSex());  
        Assert.assertEquals("1988-10-10", resultDTO.getBirthday());    
        Assert.assertEquals(26, resultDTO.getAge());    
    }  
      
    @Test  
    public void test_normality_certificateNo_of_18_digit_before_birthday() {  
          
        //测试的时间是2015-02-08，表明昨天刚过生日  
        resultDTO = certificateNo.parseCertificateNo("430522198802073210");  
        Assert.assertNotNull(resultDTO);    
        Assert.assertEquals("M", resultDTO.getSex());  
        Assert.assertEquals("1988-02-07", resultDTO.getBirthday());    
        Assert.assertEquals(27, resultDTO.getAge());    
    }  
      
    @Test  
    public void test_normality_certificateNo_of_18_digit_birthday() {  
          
        //测试的时间是2015-02-08，表明当天正好生日  
        resultDTO = certificateNo.parseCertificateNo("430522198802083210");  
        Assert.assertNotNull(resultDTO);    
        Assert.assertEquals("M", resultDTO.getSex());  
        Assert.assertEquals("1988-02-08", resultDTO.getBirthday());    
        Assert.assertEquals(27, resultDTO.getAge());    
    }  
      
    @Test  
    public void test_normality_certificateNo_of_18_digit_after_birthday() {  
          
        //测试的时间是2015-02-08，表明第二天才过生日  
        resultDTO = certificateNo.parseCertificateNo("430522198802093210");  
        Assert.assertNotNull(resultDTO);    
        Assert.assertEquals("M", resultDTO.getSex());  
        Assert.assertEquals("1988-02-09", resultDTO.getBirthday());    
        Assert.assertEquals(26, resultDTO.getAge());    
    }  
      
    @Test  
    public void test_abnormality_certificateNo_of_15_digit_130503671401001() {  
          
        resultDTO = certificateNo.parseCertificateNo("130503671401001");  
        Assert.assertNotNull(resultDTO);    
        Assert.assertEquals("证件号码不规范!", resultDTO.getStatueMessage());    
    }  
      
    @Test  
    public void test_normality_certificateNo_of_15_digit_430522760201356() {  
          
        resultDTO = certificateNo.parseCertificateNo("430522760201356");  
        Assert.assertNotNull(resultDTO);    
        Assert.assertEquals("F", resultDTO.getSex());  
        Assert.assertEquals("1976-02-01", resultDTO.getBirthday());    
        Assert.assertEquals(39, resultDTO.getAge());      
    }  
      
    @Test  
    public void test_normality_certificateNo_of_15_digit_130503670401001() {  
          
        resultDTO = certificateNo.parseCertificateNo("130503670401001");  
        Assert.assertNotNull(resultDTO);    
        Assert.assertEquals("M", resultDTO.getSex());  
        Assert.assertEquals("1967-04-01", resultDTO.getBirthday());    
        Assert.assertEquals(47, resultDTO.getAge());      
    }  
      
    @Test  
    public void test_normality_certificateNo_of_15_digit_370802940221002() {  
          
        resultDTO = certificateNo.parseCertificateNo("370802940221002");  
        Assert.assertNotNull(resultDTO);    
        Assert.assertEquals("F", resultDTO.getSex());  
        Assert.assertEquals("1994-02-21", resultDTO.getBirthday());    
        Assert.assertEquals(20, resultDTO.getAge());      
    }  
      
    @Test  
    public void test_normality_certificateNo_of_15_digit_370802941031331() {  
          
        resultDTO = certificateNo.parseCertificateNo("370802941031331");  
        Assert.assertNotNull(resultDTO);    
        Assert.assertEquals("M", resultDTO.getSex());  
        Assert.assertEquals("1994-10-31", resultDTO.getBirthday());    
        Assert.assertEquals(20, resultDTO.getAge());      
    }  
      
    @Test  
    public void test_normality_certificateNo_of_15_digit_before_birthday() {  
          
        //测试的时间是2015-02-08，表明昨天刚过生日  
        resultDTO = certificateNo.parseCertificateNo("370802940207331");  
        Assert.assertNotNull(resultDTO);    
        Assert.assertEquals("M", resultDTO.getSex());  
        Assert.assertEquals("1994-02-07", resultDTO.getBirthday());    
        Assert.assertEquals(21, resultDTO.getAge());      
    }  
      
    @Test  
    public void test_normality_certificateNo_of_15_digit_birthday() {  
          
        //测试的时间是2015-02-08，表明当天正好生日  
        resultDTO = certificateNo.parseCertificateNo("370802940208331");  
        Assert.assertNotNull(resultDTO);    
        Assert.assertEquals("M", resultDTO.getSex());  
        Assert.assertEquals("1994-02-08", resultDTO.getBirthday());    
        Assert.assertEquals(21, resultDTO.getAge());      
    }  
      
    @Test  
    public void test_normality_certificateNo_of_15_digit_after_birthday() {  
          
        //测试的时间是2015-02-08，表明第二天才过生日  
        resultDTO = certificateNo.parseCertificateNo("370802940209331");  
        Assert.assertNotNull(resultDTO);    
        Assert.assertEquals("M", resultDTO.getSex());  
        Assert.assertEquals("1994-02-09", resultDTO.getBirthday());    
        Assert.assertEquals(20, resultDTO.getAge());      
    }  
}

  from:https://www.iteye.com/blog/bijian1013-2184409

龙生   28 Feb 2021
View Details

Method not found: '!!0[] System.Array.Empty()'.

错误原因：程序里面没有可调用的方法（程序使用的是 .NET Framework 4.6,但是你自己的系统里面使用的不是 4.6版本）   解决方法：1.安装window sp1  ,下载地址是：https://www.microsoft.com/zh-cn/download/details.aspx?id=5842 2.安装.NET Framework 4.6  ,下载地址是 ：https://www.microsoft.com/zh-cn/download/details.aspx?id=49981 3.重启电脑，OK   from:https://www.cnblogs.com/soundcode/p/5837673.html

龙生   08 Feb 2021
View Details

创业公司开发APP用原生还是RN、weex或flutter

近半年，自己创业做在线教育，近期也打算开发自己的APP，作为一个技术出身的创业者，所以可以在开发APP时自己做技术选型​。 但想到还有很多创业者或架构师也面临类似的问题，所以把自己的思考分享给需要的人。 我的客户端经验 笔者2011年毕业于北京交大，2015年下半年开始由操作系统开发转向安卓开发，2016年在搜狐开始使用react-native开发APP。 2017年曾短期在便利蜂参与过三个RN项目的开发，然后去易鑫从事大前端团队的管理，团队开发维护的原生APP，通过搭桥嵌入H5。 2019年初在快陪练负责前端团队，以纯flutter的方式上线了一个iOS版的钢琴资讯APP，且在直播上课APP中的订单模块接入了flutter。 过去半年多，使用uni-app开发了多个跨端小程序，其中uni-app集成了weex跨端APP开发框架，可以一套代码生成h5，各种小程序以及安卓和iOS的原生APP。 不管是原生APP、还是近几年比较热门的RN、weex或flutter跨端开发APP的技术，笔者都在真实项目中使用过。 正因为都用过，所以各自的坑有都进去过，虽然因为学的东西多，导致精力分散，很多技术都是略懂，但是总结一下，相信还是能有一定参考价值的。 移动应用开发的趋势 由于对移动应用的大量需求，很多公司已经把他们应用开发的重心转移到移动应用上了，这是一个不断有更好的技术、平台和框架流入的领域。 移动行业渴望进行一场革命，以遏制移动应用程序开发过程中出现的成本高、耗时长等问题。 因此，该变革以跨平台开发的形式出现。现在，维护代码和开发应用程序对于开发人员来说变得简单且省时。 现在，跨平台应用开发正在创业公司中变得越来越流行，相继出现了多种跨端开发原生APP的技术方案。 除了weex只在阿里系的公司用得多外，react native 和 flutter目前都有大量的公司在使用，并且互相竞争，试图证明自己是跨平台移动应用的最合适的王者。 React native 是 Facebook 2015年开源的，并且很快获得了大众的欢迎。而Google 的 flutter 则是这两年才火起来的新技术，它优势是更好的性能。 不仅对于资金紧张的初创公司，即使是大公司的新项目，初期都需要快速验证产品的可行性，因此多数公司都不会选择原生开发，而是基于跨端技术。 那么对于开发者来说，应该选用哪个跨平台应用程序开发框架比较好呢？ 由于采用react native 和 flutter 的技术栈项目最多，所以本文主要分享我作为创业者在做客户端技术选型时，最后采纳的是使用RN还是flutter的过程。 react native vs flutter 环境搭建 从当前两个框架的最新版本来看，搭建原生开发环境都是比较复杂的，相对来讲，flutter要容易一些，特别是搭建Android开发环境。 编程语言 React Native 允许你使用 Javascript 开发应用程序，通过简单配置也可以使用微软维护的Typescript 语言进行开发，克服JS作为动态语言的一些不足。 由谷歌开发的 Flutter 提出了一种名为 Dart 的新编程语言。它对于开发人员来说是新手，但是那些具有 OOP 语言经验的人，比如 C ++ 和 JAVA，可以很容易地学习的。 IDE 和易于编码 如果我们讨论 React Native 的 IDE，那么它几乎支持所有领先的 IDE。然而，Flutter 受 Android studio / IntelliJ 和 visual studio 代码支持。 代码结构 Google 的 Dart 没有模板、样式和数据文件的分离，因此代码变得有点难以理解。 而 Javascript 遵循简单的代码结构，因此开发人员更清楚地理解和编写代码。 性能 因为 React Native 通过 JS […]

龙生   05 Feb 2021
View Details

Python3 环境搭建

本章节我们将向大家介绍如何在本地搭建 Python3 开发环境。 Python3 可应用于多平台包括 Windows、Linux 和 Mac OS X。 Unix (Solaris, Linux, FreeBSD, AIX, HP/UX, SunOS, IRIX, 等等。) Win 9x/NT/2000 Macintosh (Intel, PPC, 68K) OS/2 DOS (多个DOS版本) PalmOS Nokia 移动手机 Windows CE Acorn/RISC OS BeOS Amiga VMS/OpenVMS QNX VxWorks Psion Python 同样可以移植到 Java 和 .NET 虚拟机上。   Python3 下载 Python3 最新源码，二进制文档，新闻资讯等可以在 Python 的官网查看到： Python 官网：https://www.python.org/ 你可以在以下链接中下载 Python 的文档，你可以下载 HTML、PDF 和 PostScript 等格式的文档。 Python文档下载地址：https://www.python.org/doc/   Python 安装 Python 已经被移植在许多平台上（经过改动使它能够工作在不同平台上）。 您需要下载适用于您使用平台的二进制代码，然后安装 Python。 如果您平台的二进制代码是不可用的，你需要使用C编译器手动编译源代码。 编译的源代码，功能上有更多的选择性， 为 Python 安装提供了更多的灵活性。 以下是各个平台安装包的下载地址： Source Code 可用于 Linux 上的安装。 以下为不同平台上安装 Python3 的方法。 Unix & Linux 平台安装 […]

龙生   03 Feb 2021
View Details

Python3 简介

Python 是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。 Python 的设计具有很强的可读性，相比其他语言经常使用英文关键字，其他语言的一些标点符号，它具有比其他语言更有特色语法结构。 Python 是一种解释型语言： 这意味着开发过程中没有了编译这个环节。类似于PHP和Perl语言。 Python 是交互式语言： 这意味着，您可以在一个 Python 提示符 >>> 后直接执行代码。 Python 是面向对象语言: 这意味着Python支持面向对象的风格或代码封装在对象的编程技术。 Python 是初学者的语言：Python 对初级程序员而言，是一种伟大的语言，它支持广泛的应用程序开发，从简单的文字处理到 WWW 浏览器再到游戏。   Python 发展历史 Python 是由 Guido van Rossum 在八十年代末和九十年代初，在荷兰国家数学和计算机科学研究所设计出来的。 Python 本身也是由诸多其他语言发展而来的,这包括 ABC、Modula-3、C、C++、Algol-68、SmallTalk、Unix shell 和其他的脚本语言等等。 像 Perl 语言一样，Python 源代码同样遵循 GPL(GNU General Public License)协议。 现在 Python 是由一个核心开发团队在维护，Guido van Rossum 仍然占据着至关重要的作用，指导其进展。 Python 2.0 于 2000 年 10 月 16 日发布，增加了实现完整的垃圾回收，并且支持 Unicode。 Python 3.0 于 2008 年 12 月 3 日发布，此版不完全兼容之前的 Python 源代码。不过，很多新特性后来也被移植到旧的Python 2.6/2.7版本。 Python 3.0 版本，常被称为 Python 3000，或简称 Py3k。相对于 Python 的早期版本，这是一个较大的升级。 Python 2.7 被确定为最后一个 Python 2.x 版本，它除了支持 Python 2.x 语法外，还支持部分 Python 3.1 语法。   […]

龙生   03 Feb 2021
View Details

Python 3 教程

Python 的 3.0 版本，常被称为 Python 3000，或简称 Py3k。相对于 Python 的早期版本，这是一个较大的升级。为了不带入过多的累赘，Python 3.0 在设计的时候没有考虑向下兼容。 Python 介绍及安装教程我们在Python 2.X 版本的教程中已有介绍，这里就不再赘述。 你也可以点击 Python2.x与3​​.x版本区别 来查看两者的不同。 本教程主要针对 Python 3.x 版本的学习，如果你使用的是 Python 2.x 版本请移步至 Python 2.X 版本的教程。 官方宣布，2020 年 1 月 1 日， 停止 Python 2 的更新。 查看 Python 版本 我们可以在命令窗口(Windows 使用 win+R 调出 cmd 运行框)使用以下命令查看我们使用的 Python 版本：

1
python -V

  以上命令执行结果如下：

1
Python 3.3.2

  你也可以进入Python的交互式编程模式，查看版本：

1
2
3
Python 3.3.2 (v3.3.2:d047928ae3f6, May 16 2013, 00:03:43) [MSC v.1600 32 bit (Intel)] on win32
Type "copyright", "credits" or "license()" for more information.
>>>

  第一个Python3.x程序 对于大多数程序语言，第一个入门编程代码便是"Hello World！"，以下代码为使用Python输出"Hello World！"： 实例(Python 3.0+) #!/usr/bin/python3 print("Hello, World!") 运行实例 » 你可以将以上代码保存在 hello.py 文件中并使用 python 命令执行该脚本文件。

1
$ python3 hello.py

  以上命令输出结果为：

1
Hello, World!

  from:https://www.runoob.com/python3/python3-tutorial.html

龙生   03 Feb 2021
View Details

[C#]VS2017调试时Console.WriteLine无法在Output窗口输出

问题: 之前在VS2012、VS2015中,可直接在应用程序中Console.WriteLine输出信息来调试bug。最近换到VS2017后,却发现怎么也无法输出 解决: 这个问题的原因是VS2017开始已经不再使用Hosting Process模式,在Hosting Process时可以将信息输出至 Output窗口。 在VS2017及以后的版本可以使用Trace.WriteLine来将调试信息输出至Output窗口。 另外VS2017对CPU的要求也高了,我的老机器一打开没多久就出现很多ServiceHub.Host.CLR.x86.exe的进程,导致写代码卡顿,不得已换了新机器,升级到i5后没再出现卡顿现象了。一起典型的软件倒逼硬件更新的例子,诸君勿笑.   from:https://blog.csdn.net/edcvf3/article/details/104827175

龙生   28 Jan 2021
View Details

Dapper实现Like参数化

//参数直接写参数名 string Sql = "select * from [table] where field like @field"; //参数值里面加上通配符，varchar类型查询也不加单引号 var Param = new {field = "%{ParamValue}%"}; //执行查询 Dapper.Query<T>(Sql,Param);   from:https://www.cnblogs.com/tian2008/p/8491633.html

龙生   27 Jan 2021
View Details

2021最新版阿里巴巴Java性能调优速成手册强烈推荐

为什么要做性能调优？ 一款线上产品如果没有经过性能测试，那它就好比是一颗定时炸弹，你不知道它什么时候会出现问题，你也不清楚它能承受的极限在哪儿。 所以，要不要做性能调优，这个问题其实很好回答。所有的系统在开发完之后，多多少少都会有性能问题，我们首先要做的就是想办法把问题暴露出来，例如进行压力测试、模拟可能的操作场景等等，再通过性能调优去解决这些问题。 好的系统性能调优不仅仅可以提高系统的性能，还能为公司节省资源。这也是我们做性能调优的最直接的目的！所以，接下来我就给大家带来了一份“阿里巴巴lava性能调优实战(2021华山版)”想要学习的朋友们，我们就先来看看文章大概内容：（同时在文末会有笔记领取方式！大家自行解决） 主要内容 模块一 概述 为你建立两个标准。-个是性能调优标准，告诉你可以通过哪些参数去衡量系统性能;另-一个是调优过程标准，带你了解通过哪些严格的调优策略，我们可以排查性能问题，从而解决问题。 模块二 Java 编程性能调优 JDK是Java语言的基础库，熟悉JDK中各个包中的工具类，可以帮助你编写出高性能代码。这里我会从基础的数据类型讲起，涉及容器在实际应用场景中的调优，还有现在互联网系统架构中比较重要的网络通信调优。 03.字符串性能优化不容小觑，百M内存轻松存储几十G数据 05.ArrayList还是LinkedList？使用不当性能差千倍 06.Stream如何提高遍历集合效率？ 10.网络通信优化之通信协议：如何优化RPC网络通信？ 11.推荐几款常用的性能测试工具 模块三 多线程性能调优 目前大部分服务器都是多核处理器，多线程编程的应用广泛。为了保证线程的安全性，通常会用到同步锁，这会为系统埋下很多隐患;除此之外，还有多线程高并发带来的性能问题，这些都会在这个模块重点讲解。 12.多线程之锁优化（上）：深入了解Synchronized同步锁的优化方法 13.多线程之锁优化（中）：深入了解Lock 同步锁的优化方法 15.多线程调优（上）：哪些操作导致了上下文切换？ 17.并发容器的使用：识别不同场景下最优容器 模块四 JVM性能监测及调优 Java 应用程序是运行在JVM之上的，对JVM进行调优可以提升系统性能。这里重点讲解Java对象的创建和回收、内存分配等。 20. 磨刀不误砍柴工：欲知JVM调优先了解JVM内存模型 21.深入JVM即时编译器JIT，优化Java编译 22.如何优化垃圾回收机制？ 模块五 设计模式调优 在架构设计中，我们经常会用到-一些设计模式来优化架构设计。这里我将结合一-些复 杂的应用场景，分享设计优化案例。 29.生产者消费者模式：电商库存设计优化 30. 装饰器模式：如何优化电商系统中复杂的商品价格策略？ 模块六 数据库性能调优 数据库最容易成为整个系统的性能瓶颈，这里我会重点解析-一些数据库的常用调优方法。 33.MySQL调优之事务：高并发场景下的数据库事务调优 35.记一次线上SQL死锁事故：如何避免死锁？ 38.数据库参数设置优化，失之毫厘差之千里 模块七 实战演练场 以上六个模块的内容，都是基于某个点的调优，现在是时候把你前面所学都调动起来了，这里我将带你进入综合性能问题高频出现的应用场景，学习整体调优方法。 41.如何设计更优的分布式锁？ 43.如何使用缓存优化系统性能？ 最后 作者：努力向上的小芷 链接：https://juejin.cn/post/6920124384027885581 来源：掘金 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

龙生   25 Jan 2021
View Details
1 … 44 45 46 … 175

Copyright © 2025 Longsheng All rights reserved