空安全编程的典范：Java 8中的安全应用指南

07-16 1139阅读

文章目录

- 一、Base64 编码解码
- - 1.1 基本的编码和解码
  - 1.2 URL 和文件名安全的编码解码器
  - 1.3 MIME Base64编码和解码
  - 二、Optional类
  - 三、Nashorn JavaScript
    一、Base64 编码解码
    
    1.1 基本的编码和解码
    1. Base64 编码：
      - 使用 Base64.getEncoder().encodeToString(originalInput.getBytes()) 对原始字符串进行编码。
      - Base64.getEncoder() 返回一个 Base64.Encoder 实例，调用 encodeToString() 方法将原始字符串的字节数组编码为Base64字符串。
      - Base64 解码：
        使用 Base64.getDecoder().decode(encodedString) 对Base64编码后的字符串进行解码。
        Base64.getDecoder() 返回一个 Base64.Decoder 实例，调用 decode() 方法将Base64编码后的字符串解码为原始的字节数组。
        使用 new String(decodedBytes) 将解码后的字节数组转换为字符串。
        注意事项：
        在实际应用中，确保使用相同的编码和解码方法，以避免数据损坏或不正确的解码结果。
        Java 8 中的 java.util.Base64 类提供了方便且高效的Base64编码和解码功能，适用于处理字符串数据的安全传输和存储。
```
public static void main(String[] args) {
        // 原始字符串
        String originalInput = "Hello World!";
        // 编码为Base64
        String encodedString = Base64.getEncoder().encodeToString(originalInput.getBytes());
        System.out.println("Encoded string: " + encodedString);
        // 解码Base64
        byte[] decodedBytes = Base64.getDecoder().decode(encodedString);
        String decodedString = new String(decodedBytes);
        System.out.println("Decoded string: " + decodedString);
    }
// 输出
Encoded string: SGVsbG8gV29ybGQh
Decoded string: Hello World!
```
    1.2 URL 和文件名安全的编码解码器
    1. URL 和文件名安全的 Base64 编码：
      - 使用 Base64.getUrlEncoder().encodeToString(originalInput.getBytes("utf-8")) 对原始字符串进行URL和文件名安全的Base64编码。
      - Base64.getUrlEncoder() 返回一个 Base64.Encoder 实例，调用 encodeToString() 方法将原始字符串的字节数组编码为URL和文件名安全的Base64字符串。
      - URL 和文件名安全的 Base64 解码：
        使用 Base64.getUrlDecoder().decode(encodedString) 对URL和文件名安全的Base64编码后的字符串进行解码。
        Base64.getUrlDecoder() 返回一个 Base64.Decoder 实例，调用 decode() 方法将Base64编码后的字符串解码为原始的字节数组。
        使用 new String(decodedBytes, "utf-8") 将解码后的字节数组转换为字符串。
        注意事项：
        URL 和文件名安全的Base64编码会使用 - 替换 +，并且使用 _ 替换 /，以确保编码结果可以安全地在URL和文件名中使用。
        如果使用的是不同的字符集编码（例如 utf-8），请确保在编码和解码过程中使用相同的字符集，以避免数据损坏或不正确的解码结果。
```
public static void main(String[] args) throws UnsupportedEncodingException {
        // 原始字符串
        String originalInput = "Hello World!";
        // URL 和文件名安全的 Base64 编码
        String encodedString = Base64.getUrlEncoder().encodeToString(originalInput.getBytes("utf-8"));
        System.out.println("Encoded string (URL safe): " + encodedString);
        // 解码 URL 和文件名安全的 Base64
        byte[] decodedBytes = Base64.getUrlDecoder().decode(encodedString);
        String decodedString = new String(decodedBytes, "utf-8");
        System.out.println("Decoded string: " + decodedString);
    }
// 输出
Encoded string (URL safe): SGVsbG8gV29ybGQh
Decoded string: Hello World!
```
    1.3 MIME Base64编码和解码
    
    MIME Base64编码与普通的Base64编码在行尾添加换行符，以便在电子邮件等MIME（Multipurpose Internet Mail Extensions）环境中进行传输。
    1. MIME Base64 编码：
      - 使用 Base64.getMimeEncoder().encodeToString(originalInput.getBytes("utf-8")) 对原始字符串进行MIME Base64编码。
      - Base64.getMimeEncoder() 返回一个 Base64.Encoder 实例，调用 encodeToString() 方法将原始字符串的字节数组编码为MIME Base64字符串。
      - MIME Base64 解码：
        使用 Base64.getMimeDecoder().decode(encodedString) 对MIME Base64编码后的字符串进行解码。
        Base64.getMimeDecoder() 返回一个 Base64.Decoder 实例，调用 decode() 方法将MIME Base64编码后的字符串解码为原始的字节数组。
        使用 new String(decodedBytes, "utf-8") 将解码后的字节数组转换为字符串。
        注意事项：
        MIME Base64编码会在每行末尾添加换行符 \r\n，以便适应电子邮件等格式要求。
        如果使用的是不同的字符集编码（例如 utf-8），请确保在编码和解码过程中使用相同的字符集，以避免数据损坏或不正确的解码结果。
```
public static void main(String[] args) throws UnsupportedEncodingException {
        // 原始字符串
        String originalInput = "Hello World!";
        // MIME Base64 编码
        String encodedString = Base64.getMimeEncoder().encodeToString(originalInput.getBytes("utf-8"));
        System.out.println("Encoded string (MIME):" + encodedString);
        // 解码 MIME Base64
        byte[] decodedBytes = Base64.getMimeDecoder().decode(encodedString);
        String decodedString = new String(decodedBytes, "utf-8");
        System.out.println("Decoded string: " + decodedString);
    }
// 输出
Encoded string (MIME):SGVsbG8gV29ybGQh
Decoded string: Hello World!
```
    二、Optional类
    
    java.util.Optional 类是用来处理可能为null的值的容器。提供了一种优雅的方式来避免 NullPointerException，并且可以更清晰地表达某个值可能不存在的情况。
    1. 创建 Optional 对象
      - Optional.of(value)：如果 value 不为 null，则创建一个包含指定值的 Optional 对象；如果 value 为 null，则会抛出 NullPointerException。
      - Optional.ofNullable(value)：无论 value 是否为 null，都会创建一个对应的 Optional 对象。如果 value 是 null，则创建一个空的 Optional 对象。
      - 检查是否有值
        
        isPresent() ：检查 Optional 对象中是否包含值。
        
        获取值
        
        get()：如果 Optional 对象中有值，则返回该值；否则抛出 NoSuchElementException。
        
        处理空值
        
        orElse(defaultValue)：如果 Optional 对象中有值，则返回该值；否则返回 defaultValue。
        orElseGet(Supplier)：如果 Optional 对象中有值，则返回该值；否则调用 Supplier 提供的方法来获取默认值。
        
        条件操作
        
        ifPresent() ：在 Optional 对象非空时执行特定操作。
        
        过滤值
        
        filter() 方法过滤 Optional 对象中的值。
        
        映射值
        
        map() 或 flatMap() ：对 Optional 对象中的值进行映射操作。
```
public static void main(String[] args) {
        // 创建一个包含非空值的 Optional 对象
        Optional optional1 = Optional.of("Hello");
        System.out.println("Optional 1 value: " + optional1.get());
        // 创建一个可能为 null 的 Optional 对象
        String nullableValue = null;
        Optional optional2 = Optional.ofNullable(nullableValue);
        System.out.println("Optional 2 is present? " + optional2.isPresent());
        // 获取 Optional 对象中的值
        String value = optional1.get();
        System.out.println("Value: " + value);
        // 检查 Optional 对象中是否有值
        if (optional1.isPresent()) {
            System.out.println("Optional contains value.");
        } else {
            System.out.println("Optional is empty.");
        }
        // 使用 orElse 提供默认值
        String result1 = optional2.orElse("Default Value");
        System.out.println("Result 1: " + result1);
        // 使用 orElseGet 提供默认值
        String result2 = optional2.orElseGet(() -> {
            // 处理逻辑，返回默认值
            return "Default Value from Supplier";
        });
        System.out.println("Result 2: " + result2);
        // 如果 Optional 对象中有值，则执行操作
        optional1.ifPresent(val -> System.out.println("Value is present: " + val));
        // 过滤值
        Optional filteredOptional = optional1.filter(val -> val.startsWith("H"));
        System.out.println("Filtered Optional value: " + filteredOptional.orElse("Not found"));
        // 映射值
        Optional transformedOptional = optional1.map(val -> val.toUpperCase());
        System.out.println("Transformed Optional value: " + transformedOptional.orElse("No value"));
        // 抛出异常
        try {
            value = optional2.orElseThrow(() -> new IllegalArgumentException("Value is required."));
            System.out.println("Value: " + value);
        } catch (IllegalArgumentException e) {
            System.out.println("Exception: " + e.getMessage());
        }
    }
// 输出
Optional 1 value: Hello
Optional 2 is present? false
Value: Hello
Optional contains value.
Result 1: Default Value
Result 2: Default Value from Supplier
Value is present: Hello
Filtered Optional value: Hello
Transformed Optional value: HELLO
Exception: Value is required.
```
    三、Nashorn JavaScript
    
    Java 8 引入了 Nashorn 作为新的 JavaScript 引擎，用于替代旧版的 Rhino 引擎，可以在 Java 应用程序中执行 JavaScript 代码。Nashorn 通过优化和与 Java 的本地集成提供了更好的性能。
    1. 执行内联脚本:
```
public static void main(String[] args) throws Exception {
    // 创建 Nashorn 脚本引擎
    ScriptEngine engine = new ScriptEngineManager().getEngineByName("nashorn");
   // 执行 JavaScript 代码
    engine.eval("print('Hello Nashorn!')");
}
```
    1. 传递变量:
```
public static void main(String[] args) throws Exception {
   ScriptEngine engine = new ScriptEngineManager().getEngineByName("nashorn");
   // 将 Java 变量传递给 JavaScript
   engine.put("name", "Alice");
   engine.eval("print('Hello, ' + name + '!')");
}
```
    1. 高级特性：
      - Java 互操作性: JavaScript 代码可以直接与 Java 类和对象交互。
      - 函数式编程: Nashorn 支持 lambda 表达式和流式 API，使其更符合现代 JavaScript 标准。
      - 性能: 由于其现代化设计和优化技术，Nashorn 通常比 Rhino 更快。
```
// Java 类
public class Person {
    public String getName() {
        return "Alice";
    }
}
// JavaScript 代码
engine.eval("var person = new Person(); print(person.getName());");
```
    1. 命令行工具：
      - Nashorn 还配备了一个命令行工具 (jjs)，用于直接从终端执行 JavaScript 文件，这对于测试和调试非常有用。
```
$ jjs script.js
```
    1. 与 Java 应用程序集成:
      - 可以将 Nashorn 集成到 Java 应用程序中，用于脚本支持、规则引擎和动态行为等多种用途。
      - 提供了在 Java 的稳健性和 JavaScript 的脚本能力之间进行灵活结合的能力。
    懒惰也是天生的，勤奋需自己努力，一放松就懒了