Spring Boot 应用中加载资源文件的最佳实践

import org.springframework.core.io.ClassPathResource;
import org.springframework.util.FileCopyUtils;
import java.io.IOException;
import java.util.Objects;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 资源加载工具类
 */
public class ResourceLoaderUtil {

    private static final Logger log = LoggerFactory.getLogger(ResourceLoaderUtil.class);

    /**
     * 从类路径加载资源文件内容并返回字符串
     *
     * @param resourcePath 资源在类路径中的相对路径，例如 "key/private.pem"
     * @return 资源文件的内容字符串，如果加载失败则返回null
     */
    public static String getResourceFileContent(String resourcePath) {
        Objects.requireNonNull(resourcePath, "Resource path cannot be null.");
        ClassPathResource resource = new ClassPathResource(resourcePath);
        try {
            // 获取资源的InputStream并使用FileCopyUtils读取为字节数组
            byte[] bytes = FileCopyUtils.copyToByteArray(resource.getInputStream());
            return new String(bytes);
        } catch(IOException ex) {
            log.error("Failed to load resource file: {}", resourcePath, ex);
            return null; // 在实际应用中，可能需要抛出自定义异常
        }
    }
}

import java.security.KeyFactory;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;

public class KeyService {

    // 假设 ResourceLoaderUtil 类在同一个项目中可访问

    /**
     * 获取公钥文件的内容
     * @return 公钥字符串
     */
    private String getPublicKeyContent() {
        // 使用 ResourceLoaderUtil 加载公钥文件
        return ResourceLoaderUtil.getResourceFileContent("key/public.pem");
    }

    /**
     * 获取私钥文件的内容
     * @return 私钥字符串
     */
    private String getPrivateKeyContent() {
        // 使用 ResourceLoaderUtil 加载私钥文件
        return ResourceLoaderUtil.getResourceFileContent("key/private.pem");
    }

    /**
     * 根据内容生成 PublicKey 对象
     * @return PublicKey 对象
     * @throws NoSuchAlgorithmException 如果算法不支持
     * @throws InvalidKeySpecException 如果密钥规范无效
     */
    public PublicKey getPublicKey() throws NoSuchAlgorithmException, InvalidKeySpecException {
        String keyContent = getPublicKeyContent();
        if (keyContent == null) {
            throw new IllegalStateException("Public key content could not be loaded.");
        }
        // 清理密钥字符串，移除头部、尾部和换行符
        String key = keyContent.replaceAll("\n", "")
                .replace("-----BEGIN PUBLIC KEY-----", "")
                .replace("-----END PUBLIC KEY-----", "");

        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(Base64.getDecoder().decode(key));

        KeyFactory kf = KeyFactory.getInstance("RSA");

        return kf.generatePublic(keySpec);
    }

    /**
     * 根据内容生成 PrivateKey 对象
     * @return PrivateKey 对象
     * @throws NoSuchAlgorithmException 如果算法不支持
     * @throws InvalidKeySpecException 如果密钥规范无效
     */
    public PrivateKey getPrivateKey() throws NoSuchAlgorithmException, InvalidKeySpecException {
        String keyContent = getPrivateKeyContent();
        if (keyContent == null) {
            throw new IllegalStateException("Private key content could not be loaded.");
        }
        // 清理密钥字符串，移除头部、尾部和换行符
        String key = keyContent.replaceAll("\n", "")
                .replace("-----BEGIN PRIVATE KEY-----", "")
                .replace("-----END PRIVATE KEY-----", "");

        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(Base64.getDecoder().decode(key));

        KeyFactory kf = KeyFactory.getInstance("RSA");

        return kf.generatePrivate(keySpec);
    }
}