第九站：Java黑——安全编码的坚固防线（第②篇）

4. 验证和过滤输入数据示例：使用Apache Commons Lang

对输入数据进行验证和过滤是防止多种安全漏洞的关键步骤，包括但不限于SQL注入和命令注入。Apache Commons Lang库提供了一些实用方法来帮助进行字符串操作和验证。以下是一个简单的示例，展示如何使用它来检查输入是否只包含数字和字母，从而防止不安全的字符输入：

首先，确保你的项目中已经包含了Apache Commons Lang库。如果是Maven项目，在pom.xml中加入以下依赖：

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.12.0</version>
</dependency>

然后，使用其提供的方法来验证用户输入：

import org.apache.commons.lang3.StringUtils;

public class InputValidationExample {
    public static void main(String[] args) {
        String userInput = "HelloWorld123";
        
        if (StringUtils.isAlphanumeric(userInput)) {
            System.out.println("The input is valid.");
        } else {
            System.out.println("The input contains invalid characters.");
        }
    }
}

5. 使用Spring Security进行身份验证和授权

Spring Security是一个强大的安全框架，用于处理认证（验证用户身份）和授权（控制用户访问资源的权限）。以下是一个基本的Spring Security配置示例，展示了如何设置基本的表单登录和权限控制：

首先，确保你的项目中包含了Spring Security依赖。对于Maven项目：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>

接着，配置Spring Security。在Spring Boot应用中，你可以在application.yml或application.properties中进行基本配置，或者创建一个Java配置类，例如：

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
            .antMatchers("/resources/**", "/signup", "/about").permitAll() // 公开资源
            .antMatchers("/admin/**").hasRole("ADMIN") // 管理员角色才能访问
            .anyRequest().authenticated() // 其他请求需要认证
            .and()
            .formLogin(); // 启用表单登录
    }

    // 配置用户详细信息服务等其他安全设置...
}

6. 使用HTTPS和SSL/TLS进行安全通信

在Java Web应用中，使用HTTPS协议和SSL/TLS证书可以确保数据在传输过程中的安全。以下是一个基于Spring Boot配置HTTPS连接的简要示例：

首先，你需要一个SSL证书。这可以通过购买或使用自签名证书进行测试。假设你的证书和私钥文件名为server.crt和server.key，你可以这样配置Spring Boot：

在application.properties或application.yml中：

server:
  port: 8443
  ssl:
    enabled: true
    key-store:classpath:server.p12 # 如果是PKCS12格式的密钥库
    key-store-password: yourKeystorePassword
    keyStoreType: PKCS12 # 根据你的密钥库类型调整
    keyAlias: tomcat # 密钥别名

或者，如果你直接使用.key和.crt文件：

server:
  port: 8443
  ssl:
    enabled: true
    key-store-type: PEM
    key-store:classpath:server.key
    key-password: yourPrivateKeyPassword
    trust-store:classpath:server.crt

确保你的密钥和证书文件被正确地放置在项目的类路径下，并且密码正确无误。

通过这些额外的示例，我们可以看到，从数据验证、框架集成到网络通信安全，Java应用的每个层面都需要细心考虑和配置，以构建一个全面安全的应用环境。

7. 使用Shiro进行权限控制与会话管理

Apache Shiro是一个强大且易用的安全框架，它简化了身份验证、授权、会话管理和加密等功能的实现。以下是一个基础的Shiro配置示例，展示了如何进行用户身份验证及角色权限控制：

首先，确保你的项目中包含了Shiro的依赖。对于Maven项目：

<dependency>
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-spring</artifactId>
    <version>1.9.0</version>
</dependency>

接着，配置Shiro。在Spring应用上下文中定义Shiro的配置类：

@Configuration
public class ShiroConfig {

    @Bean
    public SecurityManager securityManager(Realm realm) {
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        securityManager.setRealm(realm);
        return securityManager;
    }

    @Bean
    public Realm realm() {
        // 这里可以配置自己的Realm，用于认证和授权逻辑
        return new IniRealm("classpath:shiro.ini");
    }

    @Bean
    public ShiroFilterFactoryBean shiroFilterFactoryBean(SecurityManager securityManager) {
        ShiroFilterFactoryBean factoryBean = new ShiroFilterFactoryBean();
        factoryBean.setSecurityManager(securityManager);
        Map<String, String> filterChainDefinitionMap = new LinkedHashMap<>();
        filterChainDefinitionMap.put("/login", "anon"); // 登录页面匿名访问
        filterChainDefinitionMap.put("/logout", "logout"); // 注销操作
        filterChainDefinitionMap.put("/**", "authc"); // 其他请求需要认证
        factoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);
        return factoryBean;
    }
}

同时，你需要一个配置文件（如shiro.ini）来定义用户、角色和权限：

[users]
admin = password, admin
guest = guest, user

[roles]
admin = *
user = read, write
guest = read

8. 使用HMAC进行消息完整性验证

HMAC（Hash-based Message Authentication Code）是一种利用哈希函数和密钥来验证消息完整性的方法。在Java中，可以使用java.security包来实现。以下是一个简单的HMAC生成和验证示例：

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.util.Base64;

public class HMACExample {
    public static void main(String[] args) throws NoSuchAlgorithmException, InvalidKeyException {
        String message = "This is a secret message.";
        String key = "MySuperSecretKey";

        // 生成HMAC
        String hmac = generateHMAC(message, key);
        System.out.println("Generated HMAC: " + hmac);

        // 验证HMAC
        boolean isValid = verifyHMAC(message, key, hmac);
        System.out.println("HMAC Verification: " + isValid);
    }

    public static String generateHMAC(String data, String keyString) throws NoSuchAlgorithmException, InvalidKeyException {
        SecretKeySpec keySpec = new SecretKeySpec(keyString.getBytes(StandardCharsets.UTF_8), "HmacSHA256");
        Mac mac = Mac.getInstance("HmacSHA256");
        mac.init(keySpec);
        byte[] hmacBytes = mac.doFinal(data.getBytes(StandardCharsets.UTF_8));
        return Base64.getEncoder().encodeToString(hmacBytes);
    }

    public static boolean verifyHMAC(String originalData, String keyString, String hmacToVerify) throws NoSuchAlgorithmException, InvalidKeyException {
        String generatedHMAC = generateHMAC(originalData, keyString);
        return generatedHMAC.equals(hmacToVerify);
    }
}

9. 使用JWT（JSON Web Tokens）进行安全认证

JWT是一种常用的安全认证方式，它允许双方之间安全地传输信息。以下是一个简单的JWT生成和验证示例，使用jjwt库：

首先，添加jjwt依赖到你的项目（Maven为例）：

<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-api</artifactId>
    <version>0.11.2</version>
</dependency>
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-impl</artifactId>
    <version>0.11.2</version>
</dependency>
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-jackson</artifactId> <!-- 或 jjwt-gson 如果你使用Gson -->
    <version>0.11.2</version>
</dependency>

然后，编写JWT的生成与验证代码：

import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import io.jsonwebtoken.security.Keys;
import javax.crypto.SecretKey;

public class JWTExample {
    public static void main(String[] args) {
        // 生成密钥
        SecretKey key = Keys.secretKeyFor(SignatureAlgorithm.HS256);

        // 生成JWT
        String jwt = Jwts.builder()
                .setSubject("Alice")
                .signWith(key)
                .compact();
        System.out.println("Generated JWT: " + jwt);

        // 验证JWT
        try {
            Jwts.parserBuilder().setSigningKey(key).build().parseClaimsJws(jwt);
            System.out.println("JWT Verification: Success");
        } catch (Exception e) {
            System.out.println("JWT Verification: Failed");
        }
    }
}

以上示例覆盖了权限控制、消息完整性验证以及现代Web应用中常用的JWT认证技术，进一步丰富了Java安全编码的实践案例。

10. 实现线程池管理

在Java中，ExecutorService接口和其相关实现类提供了创建和管理线程池的能力，这对于执行大量短期异步任务非常有用。下面是一个使用线程池执行任务并优雅关闭线程池的例子：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class ThreadPoolExample {

    public static void main(String[] args) {
        // 创建固定大小的线程池
        ExecutorService executor = Executors.newFixedThreadPool(5);

        // 提交任务到线程池执行
        for (int i = 0; i < 10; i++) {
            int taskId = i;
            executor.submit(() -> {
                System.out.println("Task ID " + taskId + " is running by " + Thread.currentThread().getName());
                try {
                    Thread.sleep(1000); // 模拟耗时操作
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    System.out.println("Thread interrupted: " + e.getMessage());
                }
            });
        }

        // 关闭线程池，不再接受新任务，等待所有已提交的任务完成
        executor.shutdown();

        try {
            // 等待直到所有任务完成，最多等待1分钟
            if (!executor.awaitTermination(1, TimeUnit.MINUTES)) {
                executor.shutdownNow(); // 强制关闭，取消正在执行的任务
                System.out.println("ThreadPool did not terminate in time, forcing shutdown.");
            } else {
                System.out.println("All tasks completed.");
            }
        } catch (InterruptedException e) {
            executor.shutdownNow();
            Thread.currentThread().interrupt();
            System.out.println("Interrupted while waiting for tasks to complete.");
        }
    }
}

11. 利用CompletableFuture进行异步编程

CompletableFuture是Java 8引入的一个强大的异步编程工具，它支持非阻塞式操作和链式调用。下面是一个简单示例，展示了如何使用CompletableFuture进行异步任务处理并组合结果：

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class CompletableFutureExample {

    public static void main(String[] args) {
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
            simulateDelay(1000); // 模拟延迟
            return "Hello";
        });

        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
            simulateDelay(2000); // 模拟延迟
            return "World";
        });

        // 当两个Future都完成时，组合它们的结果
        CompletableFuture<String> combinedFuture = future1.thenCombine(future2, (s1, s2) -> s1 + " " + s2);

        try {
            // 获取最终结果
            String result = combinedFuture.get();
            System.out.println(result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }

    private static void simulateDelay(int millis) {
        try {
            Thread.sleep(millis);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

12. 使用Spring Boot实现RESTful API

Spring Boot极大简化了创建基于Spring的应用程序的过程，特别是用于开发RESTful服务。下面是一个基本的Spring Boot应用，它暴露了一个CRUD操作的REST API来管理用户资源：

首先，确保你的项目包含Spring Boot Starter Web依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

然后，创建一个简单的User实体类和对应的Repository、Service、Controller层：

// User.java
public class User {
    private Long id;
    private String name;
    // Getter & Setter
}

// UserRepository.java
public interface UserRepository extends JpaRepository<User, Long> {}

// UserService.java
@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;
    // CRUD操作方法
}

// UserController.java
@RestController
@RequestMapping("/api/users")
public class UserController {
    @Autowired
    private UserService userService;

    @GetMapping
    public List<User> getUsers() {
        return userService.getAllUsers();
    }

    @PostMapping
    public ResponseEntity<User> createUser(@RequestBody User user) {
        User savedUser = userService.createUser(user);
        return ResponseEntity.ok(savedUser);
    }

    // 更多CRUD操作的映射...
}

这些示例涵盖了从并发编程、异步处理到构建RESTful服务的多个方面，展示了Java在实际开发中的灵活性和强大功能。