HibernateValidation#

jsr303

对请求参数做校验

1
if(username != null && username.length >= 6)
2
{}
3

4
if(username == null || username.length < 6){
5
    return BaseRespVo.fail("参数不合法");
6
}
7
if(password == null || password.length < 6){
8
    return BaseRespVo.fail("参数不合法");
9
}
10
if(desc == null || desc.length < 6){
11
    return BaseRespVo.fail("参数不合法");
12
}

接收请求参数的时候，可以使用引用类型的对象来接收

请求参数 → 引用类型对象中的成员变量 → 对成员变量做校验 → 不同校验逻辑 → 注解

在成员变量上增加注解 → 我要给他做校验

spring-boot-starter-web

2.1.5.RELEASE不需要额外引入依赖
2.7.12 额外引入hibernate-validator依赖

1
<dependency>
2
    <groupId>org.hibernate.validator</groupId>
3
    <artifactId>hibernate-validator</artifactId>
4
</dependency>

使用#

在Handler方法的形参上增加注解 @Valid或@Validated注解

在引用类型中的成员变量上增加校验功能的注解

校验注解#

1
常见的注解 （Bean Validation 中内置的 constraint）
2
@Null   被注释的元素必须为 null
3
@NotNull    被注释的元素必须不为 null
4
@Size(max=, min=)   被注释的元素的大小必须在指定的范围内
5
@AssertTrue     被注释的元素必须为 true
6
@AssertFalse    被注释的元素必须为 false
7
@Min(value)     被注释的元素必须是一个数字，其值必须大于等于指定的最小值
8
@Max(value)     被注释的元素必须是一个数字，其值必须小于等于指定的最大值
9
@DecimalMin(value)  被注释的元素必须是一个数字，其值必须大于等于指定的最小值
10
@DecimalMax(value)  被注释的元素必须是一个数字，其值必须小于等于指定的最大值
11
@Digits (integer, fraction)     被注释的元素必须是一个数字，其值必须在可接受的范围内
12
@Past   被注释的元素必须是一个过去的日期 Date
13
@Future     被注释的元素必须是一个将来的日期
14
@Pattern(regex=,flag=)  被注释的元素必须符合指定的正则表达式
15
Hibernate Validator 附加的 constraint
16
@NotBlank(message =)   验证字符串非null，且长度必须大于0
17
@Email  被注释的元素必须是电子邮箱地址
18
@Length(min=,max=)  被注释的字符串的大小必须在指定的范围内
19
@NotEmpty   被注释的字符串的必须非空
20
@Range(min=,max=,message=)  被注释的元素必须在合适的范围内

一个成员变量上能否增加多个注解 → 可以

处理校验结果#

在形参中增加BindingResult，通过BindingResult获得处理结果

通常放在形参最前面

1
//是否有校验错误
2
//BindingResult提供的方法
3
boolean hasFieldErrors();
4

5
//获得成员变量错误
6
@Nullable
7
FieldError getFieldError();

FieldError提供的方法

1
//拿到错误的参数的值
2
@Nullable
3
public Object getRejectedValue() {
4
    return this.rejectedValue;
5
}
6
//拿到错误的参数名
7
public String getField() {
8
    return this.field;
9
}
10
//默认的消息
11
@Nullable
12
public String getDefaultMessage() {
13
    return this.defaultMessage;
14
}

1
// localhost:8083/admin/user/list
2
@RequestMapping("list")
3
//public BaseRespVo list(String username, Integer page, Integer limit, String sort, String order) {
4
public BaseRespVo list(String username, @Validated BasePageInfo info, BindingResult bindingResult) {
5
    if (bindingResult.hasFieldErrors()) {
6
        FieldError fieldError = bindingResult.getFieldError();
7
        String field = fieldError.getField();//请求参数名
8
        Object rejectedValue = fieldError.getRejectedValue();//错误的值
9
        String defaultMessage = fieldError.getDefaultMessage(); //错误的消息
10
        String msg = "请求参数" + field + "没有通过校验：值为" + rejectedValue + ";" + defaultMessage;
11
        return BaseRespVo.invalidParameter(msg);
12
    }
13

14
    CommonData<User> data =  userService.query(username,info);
15
    return BaseRespVo.ok(data);
16
}

也可以通过SpringMVC的异常处理来处理参数校验异常

参数校验错误的情况下，会抛出MethodArgumentNotValidException，可以对这个异常进行处理，在参数中传入这个异常对象

然后获取其中的相关错误信息

1
@RestControllerAdvice
2
public class ValidationControllerAdvice {
3

4
    @ExceptionHandler(MethodArgumentNotValidException.class)
5
    public BaseRespVo baseRespVo(MethodArgumentNotValidException e) {
6
        e.printStackTrace();
7
        FieldError fieldError = e.getFieldError(); //拿到校验失败的信息
8
        String field = fieldError.getField(); // 校验失败的成员变量名 → 请求参数
9
        Object rejectedValue = fieldError.getRejectedValue(); // 校验失败的值 → 请求参数的值
10
        String message = fieldError.getDefaultMessage(); // 校验消息 → 注解中的message
11
        return BaseRespVo.badArgument(field,message);
12
    }
13

14
}

阿里云API#

对象存储服务(OSS)#

对象存储服务，我们使用阿里云的对象存储服务为例

Java快速入门 (aliyun.com)

引入依赖#

1
<!-- https://mvnrepository.com/artifact/com.aliyun.oss/aliyun-sdk-oss -->
2
<dependency>
3
    <groupId>com.aliyun.oss</groupId>
4
    <artifactId>aliyun-sdk-oss</artifactId>
5
    <version>3.15.2</version>
6
</dependency>

使用demo#

这里阿里云产品文档中Java代码实现的demo

1
import com.aliyun.oss.ClientException;
2
import com.aliyun.oss.OSS;
3
import com.aliyun.oss.OSSClientBuilder;
4
import com.aliyun.oss.OSSException;
5
import java.io.ByteArrayInputStream;
6

7
public class OssDemo {
8

9
  public static void main(String[] args) throws Exception {
10
    // Endpoint以华东1（杭州）为例，其它Region请按实际情况填写。
11
    String endpoint = "https://oss-cn-hangzhou.aliyuncs.com";
12
    // 阿里云账号AccessKey拥有所有API的访问权限，风险很高。强烈建议您创建并使用RAM用户进行API访问或日常运维，请登录RAM控制台创建RAM用户。
13
    String accessKeyId = "yourAccessKeyId";
14
    String accessKeySecret = "yourAccessKeySecret";
15
    // 填写Bucket名称，例如examplebucket。
16
    String bucketName = "examplebucket";
17
    // 填写Object完整路径，例如exampledir/exampleobject.txt。Object完整路径中不能包含Bucket名称。
18
    String objectName = "exampledir/exampleobject.txt";
19

20
    // 创建OSSClient实例。
21
    OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);
22

23
    try {
24
      String content = "Hello OSS";
25
      ossClient.putObject(bucketName, objectName, new ByteArrayInputStream(content.getBytes()));
26
    } catch (OSSException oe) {
27
      System.out.println("Caught an OSSException, which means your request made it to OSS, "
28
                         + "but was rejected with an error response for some reason.");
29
      System.out.println("Error Message:" + oe.getErrorMessage());
30
      System.out.println("Error Code:" + oe.getErrorCode());
31
      System.out.println("Request ID:" + oe.getRequestId());
32
      System.out.println("Host ID:" + oe.getHostId());
33
    } catch (ClientException ce) {
34
      System.out.println("Caught an ClientException, which means the client encountered "
35
                         + "a serious internal problem while trying to communicate with OSS, "
36
                         + "such as not being able to access the network.");
37
      System.out.println("Error Message:" + ce.getMessage());
38
    } finally {
39
      if (ossClient != null) {
40
        ossClient.shutdown();
41
      }
42
    }
43
  }
44
}

个性化的信息#

这里使用上面的Demo需要大家已经开通OSS服务，也可以使用我的OSS服务，

其中有这样的几项信息

1
endpoint=oss-cn-beijing.aliyuncs.com
2
bucket=wdproject2
3
# 另外要访问OSS还需要AccessKey和AccessSecret，这个请保管好，不要泄露出去
4
accessKey=LTAI5t8gpxPTCR6W58RnZq4u
5
accessSecret=mVPbpbxia0JQotb7HyJAREV8QUuq8h

接着我们利用这些值，上传一下d:/tmp/ikun.jpeg

1
import com.aliyun.oss.ClientException;
2
import com.aliyun.oss.OSS;
3
import com.aliyun.oss.OSSClientBuilder;
4
import com.aliyun.oss.OSSException;
5
import com.aliyun.oss.model.PutObjectResult;
6

7
import java.io.File;
8
import java.io.FileInputStream;
9
import java.util.UUID;
10

11
public class Demo {
12

13
  public static void main(String[] args) throws Exception {
14
    // Endpoint以华东1（杭州）为例，其它Region请按实际情况填写。
15
    String endpoint = "oss-cn-beijing.aliyuncs.com";
16
    // 阿里云账号AccessKey拥有所有API的访问权限，风险很高。强烈建议您创建并使用RAM用户进行API访问或日常运维，请登录RAM控制台创建RAM用户。
17
    String accessKeyId = "LTAI5t8gpxPTCR6W58RnZq4u";
18
    String accessKeySecret = "mVPbpbxia0JQotb7HyJAREV8QUuq8h";
19
    // 填写Bucket名称，例如examplebucket。
20
    String bucketName = "wdproject2";
21

22
    String path = "d:/tmp";
23
    String fileName = "ikun.jpeg";
24

25
    // 填写Object完整路径，例如exampledir/exampleobject.txt。Object完整路径中不能包含Bucket名称。
26
    String suffix = fileName.substring(fileName.lastIndexOf("."));//ikun.jpeg suffix=.jpeg
27
    String objectName = UUID.randomUUID().toString() + suffix;
28

29
    // 创建OSSClient实例。
30
    OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);
31
    FileInputStream inputStream = null;
32
    try {
33
      inputStream = new FileInputStream(new File(path, fileName));
34
      // 保存在哪个bucket、保存的文件名、输入流
35
      PutObjectResult putObjectResult = ossClient.putObject(bucketName, objectName, inputStream);
36
    } catch (OSSException oe) {
37
      System.out.println("Caught an OSSException, which means your request made it to OSS, "
38
                         + "but was rejected with an error response for some reason.");
39
      System.out.println("Error Message:" + oe.getErrorMessage());
40
      System.out.println("Error Code:" + oe.getErrorCode());
41
      System.out.println("Request ID:" + oe.getRequestId());
42
      System.out.println("Host ID:" + oe.getHostId());
43
    } catch (ClientException ce) {
44
      System.out.println("Caught an ClientException, which means the client encountered "
45
                         + "a serious internal problem while trying to communicate with OSS, "
46
                         + "such as not being able to access the network.");
47
      System.out.println("Error Message:" + ce.getMessage());
48
    } finally {
49
      if (ossClient != null) {
50
        ossClient.shutdown();
51
      }
52
      if (inputStream != null) {
53
        inputStream.close();
54
      }
55
    }
56
  }
57
}

那么我们后面方便使用可以封装为方法

封装#

上传file，我们使用SpringMVC的Handler接收为MultipartFile，然后获得inputStream来完成上传，该方法的返回值为上传结果和访问的URL，当然大家也可以自己封装

1
@Service
2
public class OssServiceImpl implements OssService{
3

4
  @Override
5
  public OssPutResult save(MultipartFile file)  {
6
    String endpoint = "oss-cn-beijing.aliyuncs.com";
7
    String accessKeyId = "LTAI5t8gpxPTCR6W58RnZq4u";
8
    String accessKeySecret = "mVPbpbxia0JQotb7HyJAREV8QUuq8h";
9
    String bucketName = "wdproject2";
10
    String urlPrefix = "https://" + bucketName + "." + endpoint;
11

12
    String fileName = file.getOriginalFilename();
13

14
    String suffix = fileName.substring(fileName.lastIndexOf("."));
15
    String objectName = UUID.randomUUID().toString() + suffix;
16

17
    // 创建OSSClient实例。
18
    OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);
19
    InputStream inputStream = null;
20
    PutObjectResult putObjectResult = null;
21
    try {
22
      inputStream = file.getInputStream();
23
      // 保存在哪个bucket、保存的文件名、输入流
24
      putObjectResult = ossClient.putObject(bucketName, objectName, inputStream);
25
    } catch (OSSException oe) {
26
      System.out.println("Caught an OSSException, which means your request made it to OSS, "
27
                         + "but was rejected with an error response for some reason.");
28
      System.out.println("Error Message:" + oe.getErrorMessage());
29
      System.out.println("Error Code:" + oe.getErrorCode());
30
      System.out.println("Request ID:" + oe.getRequestId());
31
      System.out.println("Host ID:" + oe.getHostId());
32
    } catch (ClientException ce) {
33
      System.out.println("Caught an ClientException, which means the client encountered "
34
                         + "a serious internal problem while trying to communicate with OSS, "
35
                         + "such as not being able to access the network.");
36
      System.out.println("Error Message:" + ce.getMessage());
37
    } catch (IOException e) {
38
      e.printStackTrace();
39
    } finally {
40
      if (ossClient != null) {
41
        ossClient.shutdown();
42
      }
43
      if (inputStream != null) {
44
        try {
45
          inputStream.close();
46
        } catch (IOException e) {
47
          e.printStackTrace();
48
        }
49
      }
50
    }
51
    String accessUrl = urlPrefix + "/" + objectName;
52
    return new OssPutResult(putObjectResult, accessUrl);
53
  }
54
}

封装的OssPutResult大家可以按需封装自己需要的值

1
@Data
2
@AllArgsConstructor
3
@NoArgsConstructor
4
public class OssPutResult {
5
    PutObjectResult result;
6
    String url;
7
}

短信服务(SMS)#

通过阿里云提供的短信服务可以发送验证码

SendSms_短信服务_API调试-阿里云OpenAPI开发者门户 (aliyun.com)

1
【阿里云】尊敬的139310186@qq.com，截止至2023-04-20...

引入依赖#

1
<dependency>
2
  <groupId>com.aliyun</groupId>
3
  <artifactId>alibabacloud-dysmsapi20170525</artifactId>
4
  <version>2.0.23</version>
5
</dependency>

使用Demo#

1
import com.aliyun.auth.credentials.Credential;
2
import com.aliyun.auth.credentials.provider.StaticCredentialProvider;
3
import com.aliyun.core.http.HttpClient;
4
import com.aliyun.core.http.HttpMethod;
5
import com.aliyun.core.http.ProxyOptions;
6
import com.aliyun.httpcomponent.httpclient.ApacheAsyncHttpClientBuilder;
7
import com.aliyun.sdk.service.dysmsapi20170525.models.*;
8
import com.aliyun.sdk.service.dysmsapi20170525.*;
9
import com.google.gson.Gson;
10
import darabonba.core.RequestConfiguration;
11
import darabonba.core.client.ClientOverrideConfiguration;
12
import darabonba.core.utils.CommonUtil;
13
import darabonba.core.TeaPair;
14

15
//import javax.net.ssl.KeyManager;
16
//import javax.net.ssl.X509TrustManager;
17
import java.net.InetSocketAddress;
18
import java.time.Duration;
19
import java.util.*;
20
import java.util.concurrent.CompletableFuture;
21

22
public class SmsDemo {
23

24
  public static void main(String[] args) throws Exception {
25

26

27
    // Configure Credentials authentication information, including ak, secret, token
28
    StaticCredentialProvider provider = StaticCredentialProvider.create(Credential.builder()
29
                                                                        .accessKeyId("LTAI5t8gpxPTCR6W58RnZq4u")
30
                                                                        .accessKeySecret("mVPbpbxia0JQotb7HyJAREV8QUuq8h")
31
                                                                        //.securityToken("<your-token>") // use STS token
32
                                                                        .build());
33

34
    // Configure the Client
35
    AsyncClient client = AsyncClient.builder()
36
      .region("cn-qingdao") // Region ID
37
      //.httpClient(httpClient) // Use the configured HttpClient, otherwise use the default HttpClient (Apache HttpClient)
38
      .credentialsProvider(provider)
39
      //.serviceConfiguration(Configuration.create()) // Service-level configuration
40
      // Client-level configuration rewrite, can set Endpoint, Http request parameters, etc.
41
      .overrideConfiguration(
42
      ClientOverrideConfiguration.create()
43
      .setEndpointOverride("dysmsapi.aliyuncs.com")
44
      //.setConnectTimeout(Duration.ofSeconds(30))
45
    )
46
      .build();
47

48
    // Parameter settings for API request
49
    SendSmsRequest sendSmsRequest = SendSmsRequest.builder()
50
      .phoneNumbers("18675730267")
51
      .signName("王道训练营")
52
      .templateCode("SMS_173765187")
53
      .templateParam("{\"code\":\"1234\"}")
54
      // Request-level configuration rewrite, can set Http request parameters, etc.
55
      // .requestConfiguration(RequestConfiguration.create().setHttpHeaders(new HttpHeaders()))
56
      .build();
57

58
    // Asynchronously get the return value of the API request
59
    CompletableFuture<SendSmsResponse> response = client.sendSms(sendSmsRequest);
60
    // Synchronously get the return value of the API request
61
    SendSmsResponse resp = response.get();
62
    System.out.println(new Gson().toJson(resp));
63
    // Asynchronous processing of return values
64
    /*response.thenAccept(resp -> {
65
            System.out.println(new Gson().toJson(resp));
66
        }).exceptionally(throwable -> { // Handling exceptions
67
            System.out.println(throwable.getMessage());
68
            return null;
69
        });*/
70

71
    // Finally, close the client
72
    client.close();
73
  }
74
}

192.168.5.127:8080/validation/code?mobile=xxx

个性化的信息#

这里使用上面的Demo需要大家已经开通短信服务，也可以使用我的短信服务

1
# signName或使用stone4j
2
signName=王道训练营
3
templateCode = SMS_173765187
4
# 另外要访问短信服务还需要AccessKey和AccessSecret，这个请保管好，不要泄露出去
5
accessKey=LTAI5t8gpxPTCR6W58RnZq4u
6
accessSecret=mVPbpbxia0JQotb7HyJAREV8QUuq8h

封装#

发送验证码，可以生成验证码之后发送；也可以让其方法自动生成验证码，然后返回值返回验证码信息

1
@Service
2
public class SmsServiceImpl implements SmsService{
3
  @Override
4
  public String send(String mobile, String code) {
5
    String accessKeyId = "LTAI5t8gpxPTCR6W58RnZq4u";
6
    String accessKeySecret = "mVPbpbxia0JQotb7HyJAREV8QUuq8h";
7
    String signName = "王道训练营";
8
    String templateCode = "SMS_173765187";
9
    StaticCredentialProvider provider = StaticCredentialProvider.create(Credential.builder()
10
                                                                        .accessKeyId(accessKeyId)
11
                                                                        .accessKeySecret(accessKeySecret)
12
                                                                        .build());
13

14
    AsyncClient client = AsyncClient.builder()
15
      .region("cn-qingdao") // Region ID
16
      .credentialsProvider(provider)
17
      .overrideConfiguration(
18
      ClientOverrideConfiguration.create()
19
      .setEndpointOverride("dysmsapi.aliyuncs.com")
20
    )
21
      .build();
22

23
    String templateParam = "{\"code\":\"" + code + "\"}";
24
    SendSmsRequest sendSmsRequest = SendSmsRequest.builder()
25
      .phoneNumbers(mobile)
26
      .signName(signName)
27
      .templateCode(templateCode)
28
      .templateParam(templateParam)
29
      .build();
30

31
    CompletableFuture<SendSmsResponse> response = client.sendSms(sendSmsRequest);
32
    SendSmsResponse resp = null;
33
    try {
34
      resp = response.get();
35
    } catch (InterruptedException e) {
36
      e.printStackTrace();
37
    } catch (ExecutionException e) {
38
      e.printStackTrace();
39
    }
40
    String jsonResult = new Gson().toJson(resp);
41
    System.out.println(jsonResult);
42
    client.close();
43
    return jsonResult;
44
  }
45

46
  @Override
47
  public SmsSendResult sendValidationCode(String mobile) {
48
    // 生成验证码
49
    SecureRandom random = new SecureRandom();
50
    String code = String.valueOf(random.nextInt(899999) + 100000);
51
    String jsonResult = this.send(mobile, code);
52
    return new SmsSendResult(jsonResult,code);
53
  }
54
}

整合#

在前面的OssService中和SmsService中我们分别使用了一些值

其中有两个部分都包含的AccessKeyId和AccessKeySecret
也有两部分个性化的内容
- OSS中的bucket和endPoint、urlPrefix
- SMS中的signName和templateCode

而我们是在方法中写的是常量值

1
public OssPutResult save(MultipartFile file)  {
2
    String endpoint = "oss-cn-beijing.aliyuncs.com";
3
    String accessKeyId = "LTAI5t8gpxPTCR6W58RnZq4u";
4
    String accessKeySecret = "mVPbpbxia0JQotb7HyJAREV8QUuq8h";
5
    String bucketName = "wdproject2";
6
    String urlPrefix = "https://" + bucketName + "." + endpoint;
7
}
8
public String send(String mobile, String code) {
9
    String accessKeyId = "LTAI5t8gpxPTCR6W58RnZq4u";
10
    String accessKeySecret = "mVPbpbxia0JQotb7HyJAREV8QUuq8h";
11
    String signName = "王道训练营";
12
    String templateCode = "SMS_173765187";
13
}

既然我们使用的是SpringBoot那么我们其实是可以使用配置文件来管理这些值的

比如我们创建一个application-aliyun.yml我们在其中提供对应的值，提供的值我们直接给容器中的组件使用，我们可以考虑使用Properties组件来接收这些值

1
@Component
2
@ConfigurationProperties("wd.aliyun")
3
@Data
4
public class WdAliyunProperties {
5
  String accessKeyId;//wd.aliyun.access-key-id
6
  String accessKeySecret;//wd.aliyun.access-key-secret
7
  Oss oss;
8
  Sms sms;
9

10
  @Data
11
  public static class Oss {
12
    String bucket; //wd.aliyun.oss.bucket
13
    String endPoint;
14
    String urlPrefix;
15
  }
16

17
  @Data
18
  public static class Sms {
19
    String signName;
20
    String templateCode;
21
  }
22
}

我们就可以在配置文件中提供值

1
wd:
2
  aliyun:
3
    access-key-id: LTAI5t8gpxPTCR6W58RnZq4u
4
    access-key-secret: mVPbpbxia0JQotb7HyJAREV8QUuq8h
5
    oss:
6
      bucket: wdproject2
7
      end-point: oss-cn-beijing.aliyuncs.com
8
      url-prefix: https://${wd.aliyun.oss.bucket}.${wd.aliyun.oss.end-point}
9
    sms:
10
      sign-name: 王道训练营
11
      template-code: SMS_173765187

那么我们在容器中的其他组件中就可以引入对应的值

1
@Service
2
public class OssServiceImpl implements OssService{
3
    @Autowired
4
    WdAliyunProperties aliyunProperties;
5
    @Override
6
    public OssPutResult save(MultipartFile file)  {
7
        String accessKeyId = aliyunProperties.getAccessKeyId();
8
        String accessKeySecret = aliyunProperties.getAccessKeySecret();
9
        String endpoint = aliyunProperties.getOss().getEndPoint();
10
        String bucketName = aliyunProperties.getOss().getBucket();
11
        String urlPrefix = aliyunProperties.getOss().getUrlPrefix();
12
    }
13
}

Encrypt/Decrypt#

常用加密算法#

常见的加密算法可以分成三类，对称加密算法，非对称加密算法和Hash算法

1、任何密码、密文都是可以被破解的； 2、密码和密文只需要证明是计算上安全即可，即满足破解密文的花费远远大于所加密信息的价值，且破解密文所花费的时间远远多于信息的有效时间； 3、任何密码系统都要假设敌人已经知道你的加密算法；

介绍#

对称加密#

指加密和解密使用相同密钥的加密算法。对称加密算法的优点在于加解密的高速度和使用长密钥时的难破解性。对称加密算法的安全性取决于加密密钥的保存情况，但要求企业中每一个持有密钥的人都保守秘密是不可能的，他们通常会有意无意的把密钥泄漏出去——如果一个用户使用的密钥被入侵者所获得，入侵者便可以读取该用户密钥加密的所有文档，如果整个企业共用一个加密密钥，那整个企业文档的保密性便无从谈起。常见的对称加密算法：DES、3DES、DESX、Blowfish、IDEA、RC4、RC5、RC6和AES

非对称加密#

指加密和解密使用不同密钥的加密算法，也称为公私钥加密。假设两个用户要加密交换数据，双方交换公钥，使用时一方用对方的公钥加密，另一方即可用自己的私钥解密。非对称加密的缺点是加解密速度要远远慢于对称加密，在某些极端情况下，甚至能比对称加密慢上1000倍。常见的非对称加密算法：RSA、ECC（移动设备用）、Diffie-Hellman、El Gamal、DSA（数字签名用）

Hash算法#

Hash算法特别的地方在于它是一种单向算法，用户可以通过Hash算法对目标信息生成一段特定长度的唯一的Hash值，却不能通过这个Hash值重新获得目标信息。因此Hash算法常用在不可还原的密码存储、信息完整性校验等。散列是信息的提炼，通常其长度要比信息小得多，且为一个固定长度。加密性强的散列一定是不可逆的，这就意味着通过散列结果，无法推出任何部分的原始信息。**任何输入信息的变化，哪怕仅一位，都将导致散列结果的明显变化，这称之为雪崩效应。**散列还应该是防冲突的，即找不出具有相同散列结果的两条信息。具有这些特性的散列结果就可以用于验证信息是否被修改。常见的Hash算法：MD2、MD4、MD5、HAVAL、SHA、SHA-1、HMAC、HMAC-MD5、HMAC-SHA1

具体算法#

MD5#

Message Digest Algorithm 5

（中文名为消息摘要算法第五版）为计算机安全领域广泛使用的一种散列函数，用以提供消息的完整性保护。该算法的文件号为RFC 1321（R.Rivest,MIT Laboratory for Computer Science and RSA Data Security Inc. April 1992）

Hash算法，过程不可逆

1、抗修改性：对原数据进行任何改动，哪怕只修改1个字节，所得到的MD5值都有很大区别。 2、强抗碰撞：已知原数据和其MD5值，想找到一个具有相同MD5值的数据（即伪造数据）是非常困难的。（不可逆） 3、压缩性：任意长度的数据，算出的MD5值长度都是固定的。128bit 4、容易计算：从原数据计算出MD5值很容易。

MD5的作用是让大容量信息在用数字签名软件签署私人密钥前被”压缩”成一种保密的格式（就是把一个任意长度的字节串变换成一定长的十六进制数字串）。 MD5的典型应用是对一段信息（Message）产生信息摘要（Message-Digest），以防止被篡改。

举例百度网盘

MD5工具的使用

1
public static String getMd5(String content){
2
  //先获得正文的字节
3
  byte[] bytes = content.getBytes();
4
  try {
5
    MessageDigest md5 = MessageDigest.getInstance("md5");
6
    //将正文的字节转换成md5的字节
7
    StringBuffer sb = new StringBuffer();
8
    byte[] digestBytes = md5.digest(bytes);
9
    for (byte digestByte : digestBytes) {
10
      int i = digestByte & 0xff;
11

12
      String s = Integer.toHexString(i);
13
      if (s.length() == 1){
14
        sb.append(0);
15
      }
16
      sb.append(s);
17
    }
18
    return sb.toString();
19

20
  } catch (NoSuchAlgorithmException e) {
21
    e.printStackTrace();
22
  }
23

24

25
  return "";
26
}
27
// 也可以处理文件
28
public static String getFileMd5(File file){
29
  try {
30
    FileInputStream fileInputStream = new FileInputStream(file);
31
    byte[] bytes = new byte[1024];
32
    int length = 0;
33
    MessageDigest md5 = MessageDigest.getInstance("md5");
34

35
    while ((length = fileInputStream.read(bytes,0,1024)) > 0){
36
      md5.update(bytes,0,length);
37
    }
38
    byte[] digestBytes = md5.digest();
39

40
    StringBuffer sb = new StringBuffer();
41
    for (byte digestByte : digestBytes) {
42
      int i = digestByte & 0xff;
43

44
      String s = Integer.toHexString(i);
45
      if (s.length() == 1){
46
        sb.append(0);
47
      }
48
      sb.append(s);
49
    }
50
    return sb.toString();
51

52
  } catch (FileNotFoundException e) {
53
    e.printStackTrace();
54
  } catch (IOException e) {
55
    e.printStackTrace();
56
  } catch (NoSuchAlgorithmException e) {
57
    e.printStackTrace();
58
  }
59
  return "";
60
}

是否有破解问题？加盐

1
//sault盐
2
public static String getMd5(String content,String sault){
3
  //实现了加盐
4
  content = content + "{!"+ sault + "abc";
5
  byte[] bytes = content.getBytes();
6
  try {
7
    MessageDigest md5 = MessageDigest.getInstance("md5");
8
    //将正文的字节转换成md5的字节
9
    StringBuffer sb = new StringBuffer();
10
    byte[] digestBytes = md5.digest(bytes);
11
    for (byte digestByte : digestBytes) {
12
      int i = digestByte & 0xff;
13

14
      String s = Integer.toHexString(i);
15
      if (s.length() == 1){
16
        sb.append(0);
17
      }
18
      sb.append(s);
19
    }
20
    return sb.toString();
21

22
  } catch (NoSuchAlgorithmException e) {
23
    e.printStackTrace();
24
  }
25

26

27
  return "";
28
}

AES#

Advanced Encryption Standard 在密码学中又称Rijndael加密法，是美国联邦政府采用的一种区块加密标准。这个标准用来替代原先的DES，已经被多方分析且广为全世界所使用。 2006年，高级加密标准已然成为对称密钥加密中最流行的算法之一。 AES是一个迭代、对称的分组密码，它的密匙长度分为3种：128位，192位和256位，可以对128位的数据块进行加密和解密。

使用加密和解密使用同一个密码

1
public class AESUtil {
2
  private static final String KEY_ALGORITHM = "AES";
3
  //密码模式(算法/模式/填充)
4
  private static final String DEFAULT_CIPHER_ALGORITHM = "AES/ECB/PKCS5Padding";//默认的加密算法
5

6
  /**
7
     * AES 加密操作
8
     *
9
     * @param content 待加密内容
10
     * @param password 加密密码
11
     * @return 返回Base64转码后的加密数据
12
     */
13
  public static String encrypt(String content, String password) {
14
    try {
15
      Cipher cipher = Cipher.getInstance(DEFAULT_CIPHER_ALGORITHM);// 创建密码器
16
      cipher.init(Cipher.ENCRYPT_MODE, getSecretKey(password));// 初始化为加密模式的密码器
17
      //byte[] byteContent = content.getBytes();
18
      byte[] byteContent = content.getBytes("utf-8");
19

20
      byte[] result = cipher.doFinal(byteContent);// 加密
21
      //String encode = new BASE64Encoder().encode(result);
22
      //String encode = Base64Util.encode(result);
23
      String encode = Base64.encodeBase64String(result);
24
      return encode;//通过Base64转码返回
25
    } catch (Exception ex) {
26
      Logger.getLogger(AESUtil.class.getName()).log(Level.SEVERE, null, ex);
27
    }
28

29
    return null;
30
  }
31

32
  /**
33
     * AES 解密操作
34
     *
35
     * @param content 密文
36
     * @param password 秘钥
37
     * @return
38
     */
39
  public static String decrypt(String content, String password) {
40

41
    try {
42
      //实例化
43
      Cipher cipher = Cipher.getInstance(DEFAULT_CIPHER_ALGORITHM);
44

45
      //使用密钥初始化，设置为解密模式
46
      cipher.init(Cipher.DECRYPT_MODE, getSecretKey(password));
47

48
      //执行操作
49
      byte[] bytes = Base64.decodeBase64(content);
50
      //byte[] bytes = Base64Util.decode(content);
51
      //byte[] bytes = new BASE64Decoder().decodeBuffer(content);
52
      System.err.println("bytes 数组长度：" + bytes.length);
53
      byte[] result = cipher.doFinal(bytes);
54

55

56
      return new String(result, "utf-8");
57
    } catch (Exception ex) {
58
      Logger.getLogger(AESUtil.class.getName()).log(Level.SEVERE, null, ex);
59
    }
60

61
    return null;
62
  }
63

64

65
  /**
66
     * 生成加密秘钥
67
     *
68
     * @return
69
     */
70
  private static SecretKeySpec getSecretKey(final String password) {
71
    //返回生成指定算法密钥生成器的 KeyGenerator 对象
72
    KeyGenerator kg = null;
73

74
    try {
75
      kg = KeyGenerator.getInstance(KEY_ALGORITHM);
76

77
      //AES 要求密钥长度为 128
78
      kg.init(128, new SecureRandom(password.getBytes()));
79

80
      //生成一个密钥
81
      SecretKey secretKey = kg.generateKey();
82

83
      return new SecretKeySpec(secretKey.getEncoded(), KEY_ALGORITHM);// 转换为AES专用密钥
84
    } catch (NoSuchAlgorithmException ex) {
85
      Logger.getLogger(AESUtil.class.getName()).log(Level.SEVERE, null, ex);
86
    }
87

88
    return null;
89
  }
90

91
}

RSA#

RSA加密算法是一种非对称加密算法。在公开密钥加密和电子商业中RSA被广泛使用。RSA是1977年由罗纳德·李维斯特（Ron Rivest）、阿迪·萨莫尔（Adi Shamir）和伦纳德·阿德曼（Leonard Adleman）一起提出的。当时他们三人都在麻省理工学院工作。RSA就是他们三人姓氏开头字母拼在一起组成的。

总结：公钥和私钥是成对的，它们互相解密。公钥加密，私钥解密。私钥数字签名，公钥验证。

质数1、质数2、乘积

1
public class RSAUtil {
2
  /**
3
     * 加密算法RSA
4
     */
5
  public static final String KEY_ALGORITHM = "RSA";
6

7
  /**
8
     * 签名算法
9
     */
10
  public static final String SIGNATURE_ALGORITHM = "MD5withRSA";
11

12
  /**
13
     * 获取公钥的key
14
     */
15
  private static final String PUBLIC_KEY = "RSAPublicKey";
16

17
  /**
18
     * 获取私钥的key
19
     */
20
  private static final String PRIVATE_KEY = "RSAPrivateKey";
21

22
  /**
23
     * RSA最大加密明文大小
24
     */
25
  private static final int MAX_ENCRYPT_BLOCK = 117;
26

27
  /**
28
     * RSA最大解密密文大小
29
     */
30
  private static final int MAX_DECRYPT_BLOCK = 128;
31

32
  /**
33
     * <p>
34
     * 生成密钥对(公钥和私钥)
35
     * </p>
36
     *
37
     * @return
38
     * @throws Exception
39
     */
40
  public static Map<String, Object> genKeyPair() throws Exception {
41
    KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
42
    keyPairGen.initialize(1024);
43
    KeyPair keyPair = keyPairGen.generateKeyPair();
44
    RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
45
    RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
46
    Map<String, Object> keyMap = new HashMap<String, Object>(2);
47
    keyMap.put(PUBLIC_KEY, publicKey);
48
    keyMap.put(PRIVATE_KEY, privateKey);
49
    return keyMap;
50
  }
51

52
  /**
53
     * <p>
54
     * 用私钥对信息生成数字签名
55
     * </p>
56
     *
57
     * @param data 已加密数据
58
     * @param privateKey 私钥(BASE64编码)
59
     *
60
     * @return
61
     * @throws Exception
62
     */
63
  public static String sign(byte[] data, String privateKey) throws Exception {
64
    byte[] keyBytes = Base64Util.decode(privateKey);
65
    PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
66
    KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
67
    PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);
68
    Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
69
    signature.initSign(privateK);
70
    signature.update(data);
71
    return Base64Util.encode(signature.sign());
72
  }
73

74
  /**
75
     * <p>
76
     * 校验数字签名
77
     * </p>
78
     *
79
     * @param data 已加密数据
80
     * @param publicKey 公钥(BASE64编码)
81
     * @param sign 数字签名
82
     *
83
     * @return
84
     * @throws Exception
85
     *
86
     */
87
  public static boolean verify(byte[] data, String publicKey, String sign)
88
    throws Exception {
89
    byte[] keyBytes = Base64Util.decode(publicKey);
90
    X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
91
    KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
92
    PublicKey publicK = keyFactory.generatePublic(keySpec);
93
    Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
94
    signature.initVerify(publicK);
95
    signature.update(data);
96
    return signature.verify(Base64Util.decode(sign));
97
  }
98

99
  /**
100
     * <P>
101
     * 私钥解密
102
     * </p>
103
     *
104
     * @param encryptedData 已加密数据
105
     * @param privateKey 私钥(BASE64编码)
106
     * @return
107
     * @throws Exception
108
     */
109
  public static byte[] decryptByPrivateKey(byte[] encryptedData, String privateKey)
110
    throws Exception {
111
    byte[] keyBytes = Base64Util.decode(privateKey);
112
    PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
113
    KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
114
    Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
115
    Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
116
    cipher.init(Cipher.DECRYPT_MODE, privateK);
117
    int inputLen = encryptedData.length;
118
    ByteArrayOutputStream out = new ByteArrayOutputStream();
119
    int offSet = 0;
120
    byte[] cache;
121
    int i = 0;
122
    // 对数据分段解密
123
    while (inputLen - offSet > 0) {
124
      if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
125
        cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
126
      } else {
127
        cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
128
      }
129
      out.write(cache, 0, cache.length);
130
      i++;
131
      offSet = i * MAX_DECRYPT_BLOCK;
132
    }
133
    byte[] decryptedData = out.toByteArray();
134
    out.close();
135
    return decryptedData;
136
  }
137

138
  /**
139
     * <p>
140
     * 公钥解密
141
     * </p>
142
     *
143
     * @param encryptedData 已加密数据
144
     * @param publicKey 公钥(BASE64编码)
145
     * @return
146
     * @throws Exception
147
     */
148
  public static byte[] decryptByPublicKey(byte[] encryptedData, String publicKey)
149
    throws Exception {
150
    byte[] keyBytes = Base64Util.decode(publicKey);
151
    X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
152
    KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
153
    Key publicK = keyFactory.generatePublic(x509KeySpec);
154
    Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
155
    cipher.init(Cipher.DECRYPT_MODE, publicK);
156
    int inputLen = encryptedData.length;
157
    ByteArrayOutputStream out = new ByteArrayOutputStream();
158
    int offSet = 0;
159
    byte[] cache;
160
    int i = 0;
161
    // 对数据分段解密
162
    while (inputLen - offSet > 0) {
163
      if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
164
        cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
165
      } else {
166
        cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
167
      }
168
      out.write(cache, 0, cache.length);
169
      i++;
170
      offSet = i * MAX_DECRYPT_BLOCK;
171
    }
172
    byte[] decryptedData = out.toByteArray();
173
    out.close();
174
    return decryptedData;
175
  }
176

177
  /**
178
     * <p>
179
     * 公钥加密
180
     * </p>
181
     *
182
     * @param data 源数据
183
     * @param publicKey 公钥(BASE64编码)
184
     * @return
185
     * @throws Exception
186
     */
187
  public static byte[] encryptByPublicKey(byte[] data, String publicKey)
188
    throws Exception {
189
    byte[] keyBytes = Base64Util.decode(publicKey);
190
    X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
191
    KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
192
    Key publicK = keyFactory.generatePublic(x509KeySpec);
193
    // 对数据加密
194
    Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
195
    cipher.init(Cipher.ENCRYPT_MODE, publicK);
196
    int inputLen = data.length;
197
    ByteArrayOutputStream out = new ByteArrayOutputStream();
198
    int offSet = 0;
199
    byte[] cache;
200
    int i = 0;
201
    // 对数据分段加密
202
    while (inputLen - offSet > 0) {
203
      if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
204
        cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
205
      } else {
206
        cache = cipher.doFinal(data, offSet, inputLen - offSet);
207
      }
208
      out.write(cache, 0, cache.length);
209
      i++;
210
      offSet = i * MAX_ENCRYPT_BLOCK;
211
    }
212
    byte[] encryptedData = out.toByteArray();
213
    out.close();
214
    return encryptedData;
215
  }
216

217
  /**
218
     * <p>
219
     * 私钥加密
220
     * </p>
221
     *
222
     * @param data 源数据
223
     * @param privateKey 私钥(BASE64编码)
224
     * @return
225
     * @throws Exception
226
     */
227
  public static byte[] encryptByPrivateKey(byte[] data, String privateKey)
228
    throws Exception {
229
    byte[] keyBytes = Base64Util.decode(privateKey);
230
    PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
231
    KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
232
    Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
233
    Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
234
    cipher.init(Cipher.ENCRYPT_MODE, privateK);
235
    int inputLen = data.length;
236
    ByteArrayOutputStream out = new ByteArrayOutputStream();
237
    int offSet = 0;
238
    byte[] cache;
239
    int i = 0;
240
    // 对数据分段加密
241
    while (inputLen - offSet > 0) {
242
      if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
243
        cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
244
      } else {
245
        cache = cipher.doFinal(data, offSet, inputLen - offSet);
246
      }
247
      out.write(cache, 0, cache.length);
248
      i++;
249
      offSet = i * MAX_ENCRYPT_BLOCK;
250
    }
251
    byte[] encryptedData = out.toByteArray();
252
    out.close();
253
    return encryptedData;
254
  }
255

256
  /**
257
     * <p>
258
     * 获取私钥
259
     * </p>
260
     *
261
     * @param keyMap 密钥对
262
     * @return
263
     * @throws Exception
264
     */
265
  public static String getPrivateKey(Map<String, Object> keyMap)
266
    throws Exception {
267
    Key key = (Key) keyMap.get(PRIVATE_KEY);
268
    return Base64Util.encode(key.getEncoded());
269
  }
270

271
  /**
272
     * <p>
273
     * 获取公钥
274
     * </p>
275
     *
276
     * @param keyMap 密钥对
277
     * @return
278
     * @throws Exception
279
     */
280
  public static String getPublicKey(Map<String, Object> keyMap)
281
    throws Exception {
282
    Key key = (Key) keyMap.get(PUBLIC_KEY);
283
    return Base64Util.encode(key.getEncoded());
284
  }
285
}

HibernateValidation#

使用#

校验注解#

处理校验结果#

阿里云API#

对象存储服务(OSS)#

引入依赖#

使用demo#

个性化的信息#

封装#

短信服务(SMS)#

引入依赖#

使用Demo#

个性化的信息#

封装#

整合#

Encrypt/Decrypt#

常用加密算法#

介绍#

对称加密#

非对称加密#

Hash算法#

具体算法#

MD5#

AES#

RSA#

文章分享

文章目录

Java Web 开发：项目二补充知识

HibernateValidation#

使用#

校验注解#

处理校验结果#

阿里云API#

对象存储服务(OSS)#

引入依赖#

使用demo#

个性化的信息#

封装#

短信服务(SMS)#

引入依赖#

使用Demo#

个性化的信息#

封装#

整合#

Encrypt/Decrypt#

常用加密算法#

介绍#

对称加密#

非对称加密#

Hash算法#

具体算法#

MD5#

AES#

RSA#

文章分享

文章目录