Base64, AES, RSA,SM2,SM4 对称加密、非对称加密

最新推荐文章于 2025-11-24 16:00:00 发布
原创 最新推荐文章于 2025-11-24 16:00:00 发布 · 813 阅读 · 8 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #安全 #密码学

Base64, AES, RSA,SM2,SM4 对称加密、非对称加密

文章末尾附完整代码示例

加密技术概述

  • 对称加密
    • 使用同一把密钥进行加解密。代表算法：AES、SM4。
    • 优点：速度快、适合大数据量加密。
    • 缺点：密钥分发困难，易被截获后脱密。
  • 非对称加密
    • 使用公钥加密、私钥解密（或反之用于签名）。代表算法：RSA、SM2。
    • 优点：无需共享私钥，便于密钥交换与签名验签。
    • 缺点：速度慢，不适合直接加密大数据。
  • 典型应用场景与对比
    • 数据传输：对称加密加密数据，非对称加密加密对称密钥（混合加密）。
    • 数字签名：非对称加密（私钥签名、公钥验签）。
    • 批量文件/数据库加密：对称加密。
    • 密钥交换：非对称加密。

Base64编码原理

  • 编码规则与字符集
    • 将每 3 字节（24 位）拆成 4 组，每组 6 位，对应 64 个字符集（A–Z、a–z、0–9、+、/），末尾用 = 填充。
  • 用途
    • 传输兼容性：把二进制数据转为可打印文本，避免传输过程中的字符集问题。
    • 注意：Base64 不是加密，仅编码；常与加密算法的输出搭配使用（如密文 Base64 化）。

对称加密技术

AES（高级加密标准）

  • 算法特点
    • 分组密码。常用密钥长度：128/192/256 位（即 16/24/32 字节）。
  • 工作模式
    • 常见：ECB、CBC、GCM 等。
  • 应用场景
    • 文件/数据库加密、TLS（历史）、应用层数据保护。
  • 常见坑
    • 密钥长度不合法：需为 16/24/32 字节，否则抛出 IllegalArgumentException。
    • 密文编码不匹配：Base64 与 Hex 不可混用。

SM4（国密算法）

  • 算法背景
    • 中国商用密码标准，分组长度与密钥长度均为 128 位。
  • 与 AES 对比
    • 安全强度与实现复杂度均相近，SM4在国内合规场景更常用。
  • 适用领域
    • 政务、金融、信创与国产化生态。

非对称加密技术

RSA 算法

  • 数学基础
    • 基于大整数分解困难问题。
  • 密钥生成
    • 随机生成大素数对 p、q，计算 n=pq 与 φ(n)，选择 e 并求 d，使 ed≡1 (mod φ(n))，得到公钥(n,e)与私钥(n,d)。
  • 典型用途
    • 密钥交换（加密对称密钥）、数字签名（私钥签名、公钥验签）。

SM2（国密算法）

  • 基于 ECC
    • 椭圆曲线密码学（ECC），以较短密钥提供与 RSA 同等级别的安全性。
  • 对比 RSA
    • 通常在相同安全级别下具有更短密钥与更好性能。
  • 中国标准应用
    • 电子认证、金融、区块链、政务系统等。

安全实践建议

  • 混合加密方案
    • 用对称算法（AES/SM4）加密业务数据；用非对称算法（RSA/SM2）加密对称密钥；传输对称密钥密文与数据密文。
  • 国密合规性
    • 金融、政务、信创等场景优先选用 SM 系列算法（SM2/SM3/SM4）。
  • 密钥管理
    • 不硬编码到源码。
    • 使用 KMS/HSM/密钥托管服务或安全配置中心；按角色最小化访问权限；定期轮换与吊销；全链路加密与审计。
  • 模式与参数
    • 避免 ECB；优先 GCM（带认证）。妥善管理 IV/Nonce（随机、唯一、不可复用）。

性能与安全性权衡

  • 选择标准
    • 速度：AES/SM4 > SM2 ≈ ECC > RSA。
    • 安全强度：取决于密钥长度、模式、填充与实现。
    • 标准/合规：按行业规范（如国密）与国际标准（FIPS、NIST、ISO）。
  • 未来趋势：抗量子
    • 关注 NIST 甄选的 PQC（如 Kyber、Dilithium），并为“混合密钥协商”做技术储备。

示例代码

工具类(依赖hutool-crypto)

<dependency>
    <groupId>cn.hutool</groupId>
    <artifactId>hutool-crypto</artifactId>
    <version>5.8.22</version>
</dependency>

Code

import cn.hutool.core.codec.Base64;
import cn.hutool.core.util.ArrayUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.crypto.SecureUtil;
import cn.hutool.crypto.SmUtil;
import cn.hutool.crypto.asymmetric.KeyType;
import cn.hutool.crypto.asymmetric.RSA;
import cn.hutool.crypto.asymmetric.SM2;

import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.Map;


public class EncryptUtils {
    /**
     * 公钥
     */
    public static final String PUBLIC_KEY = "publicKey";
    /**
     * 私钥
     */
    public static final String PRIVATE_KEY = "privateKey";

    /**
     * Base64加密
     *
     * @param data 待加密数据
     * @return 加密后字符串
     */
    public static String encryptByBase64(String data) {
        return Base64.encode(data, StandardCharsets.UTF_8);
    }

    /**
     * Base64解密
     *
     * @param data 待解密数据
     * @return 解密后字符串
     */
    public static String decryptByBase64(String data) {
        return Base64.decodeStr(data, StandardCharsets.UTF_8);
    }

    /**
     * AES加密
     *
     * @param data     待加密数据
     * @param password 秘钥字符串
     * @return 加密后字符串, 采用Base64编码
     */
    public static String encryptByAes(String data, String password) {
        if (StrUtil.isBlank(password)) {
            throw new IllegalArgumentException("AES需要传入秘钥信息");
        }
        // aes算法的秘钥要求是16位、24位、32位
        int[] array = {16, 24, 32};
        if (!ArrayUtil.contains(array, password.length())) {
            throw new IllegalArgumentException("AES秘钥长度要求为16位、24位、32位");
        }
        return SecureUtil.aes(password.getBytes(StandardCharsets.UTF_8)).encryptBase64(data, StandardCharsets.UTF_8);
    }

    /**
     * AES加密
     *
     * @param data     待加密数据
     * @param password 秘钥字符串
     * @return 加密后字符串, 采用Hex编码
     */
    public static String encryptByAesHex(String data, String password) {
        if (StrUtil.isBlank(password)) {
            throw new IllegalArgumentException("AES需要传入秘钥信息");
        }
        // aes算法的秘钥要求是16位、24位、32位
        int[] array = {16, 24, 32};
        if (!ArrayUtil.contains(array, password.length())) {
            throw new IllegalArgumentException("AES秘钥长度要求为16位、24位、32位");
        }
        return SecureUtil.aes(password.getBytes(StandardCharsets.UTF_8)).encryptHex(data, StandardCharsets.UTF_8);
    }

    /**
     * AES解密
     *
     * @param data     待解密数据
     * @param password 秘钥字符串
     * @return 解密后字符串
     */
    public static String decryptByAes(String data, String password) {
        if (StrUtil.isBlank(password)) {
            throw new IllegalArgumentException("AES需要传入秘钥信息");
        }
        // aes算法的秘钥要求是16位、24位、32位
        int[] array = {16, 24, 32};
        if (!ArrayUtil.contains(array, password.length())) {
            throw new IllegalArgumentException("AES秘钥长度要求为16位、24位、32位");
        }
        return SecureUtil.aes(password.getBytes(StandardCharsets.UTF_8)).decryptStr(data, StandardCharsets.UTF_8);
    }

    /**
     * sm4加密
     *
     * @param data     待加密数据
     * @param password 秘钥字符串
     * @return 加密后字符串, 采用Base64编码
     */
    public static String encryptBySm4(String data, String password) {
        if (StrUtil.isBlank(password)) {
            throw new IllegalArgumentException("SM4需要传入秘钥信息");
        }
        // sm4算法的秘钥要求是16位长度
        int sm4PasswordLength = 16;
        if (sm4PasswordLength != password.length()) {
            throw new IllegalArgumentException("SM4秘钥长度要求为16位");
        }
        return SmUtil.sm4(password.getBytes(StandardCharsets.UTF_8)).encryptBase64(data, StandardCharsets.UTF_8);
    }

    /**
     * sm4加密
     *
     * @param data     待加密数据
     * @param password 秘钥字符串
     * @return 加密后字符串, 采用Base64编码
     */
    public static String encryptBySm4Hex(String data, String password) {
        if (StrUtil.isBlank(password)) {
            throw new IllegalArgumentException("SM4需要传入秘钥信息");
        }
        // sm4算法的秘钥要求是16位长度
        int sm4PasswordLength = 16;
        if (sm4PasswordLength != password.length()) {
            throw new IllegalArgumentException("SM4秘钥长度要求为16位");
        }
        return SmUtil.sm4(password.getBytes(StandardCharsets.UTF_8)).encryptHex(data, StandardCharsets.UTF_8);
    }

    /**
     * sm4解密
     *
     * @param data     待解密数据
     * @param password 秘钥字符串
     * @return 解密后字符串
     */
    public static String decryptBySm4(String data, String password) {
        if (StrUtil.isBlank(password)) {
            throw new IllegalArgumentException("SM4需要传入秘钥信息");
        }
        // sm4算法的秘钥要求是16位长度
        int sm4PasswordLength = 16;
        if (sm4PasswordLength != password.length()) {
            throw new IllegalArgumentException("SM4秘钥长度要求为16位");
        }
        return SmUtil.sm4(password.getBytes(StandardCharsets.UTF_8)).decryptStr(data, StandardCharsets.UTF_8);
    }

    /**
     * 产生sm2加解密需要的公钥和私钥
     *
     * @return 公私钥Map
     */
    public static Map<String, String> generateSm2Key() {
        Map<String, String> keyMap = new HashMap<>(2);
        SM2 sm2 = SmUtil.sm2();
        keyMap.put(PRIVATE_KEY, sm2.getPrivateKeyBase64());
        keyMap.put(PUBLIC_KEY, sm2.getPublicKeyBase64());
        return keyMap;
    }

    /**
     * sm2公钥加密
     *
     * @param data      待加密数据
     * @param publicKey 公钥
     * @return 加密后字符串, 采用Base64编码
     */
    public static String encryptBySm2(String data, String publicKey) {
        if (StrUtil.isBlank(publicKey)) {
            throw new IllegalArgumentException("SM2需要传入公钥进行加密");
        }
        SM2 sm2 = SmUtil.sm2(null, publicKey);
        return sm2.encryptBase64(data, StandardCharsets.UTF_8, KeyType.PublicKey);
    }

    /**
     * sm2公钥加密
     *
     * @param data      待加密数据
     * @param publicKey 公钥
     * @return 加密后字符串, 采用Hex编码
     */
    public static String encryptBySm2Hex(String data, String publicKey) {
        if (StrUtil.isBlank(publicKey)) {
            throw new IllegalArgumentException("SM2需要传入公钥进行加密");
        }
        SM2 sm2 = SmUtil.sm2(null, publicKey);
        return sm2.encryptHex(data, StandardCharsets.UTF_8, KeyType.PublicKey);
    }

    /**
     * sm2私钥解密
     *
     * @param data       待加密数据
     * @param privateKey 私钥
     * @return 解密后字符串
     */
    public static String decryptBySm2(String data, String privateKey) {
        if (StrUtil.isBlank(privateKey)) {
            throw new IllegalArgumentException("SM2需要传入私钥进行解密");
        }
        SM2 sm2 = SmUtil.sm2(privateKey, null);
        return sm2.decryptStr(data, KeyType.PrivateKey, StandardCharsets.UTF_8);
    }

    /**
     * 产生RSA加解密需要的公钥和私钥
     *
     * @return 公私钥Map
     */
    public static Map<String, String> generateRsaKey() {
        Map<String, String> keyMap = new HashMap<>(2);
        RSA rsa = SecureUtil.rsa();
        keyMap.put(PRIVATE_KEY, rsa.getPrivateKeyBase64());
        keyMap.put(PUBLIC_KEY, rsa.getPublicKeyBase64());
        return keyMap;
    }

    /**
     * rsa公钥加密
     *
     * @param data      待加密数据
     * @param publicKey 公钥
     * @return 加密后字符串, 采用Base64编码
     */
    public static String encryptByRsa(String data, String publicKey) {
        if (StrUtil.isBlank(publicKey)) {
            throw new IllegalArgumentException("RSA需要传入公钥进行加密");
        }
        RSA rsa = SecureUtil.rsa(null, publicKey);
        return rsa.encryptBase64(data, StandardCharsets.UTF_8, KeyType.PublicKey);
    }

    /**
     * rsa公钥加密
     *
     * @param data      待加密数据
     * @param publicKey 公钥
     * @return 加密后字符串, 采用Hex编码
     */
    public static String encryptByRsaHex(String data, String publicKey) {
        if (StrUtil.isBlank(publicKey)) {
            throw new IllegalArgumentException("RSA需要传入公钥进行加密");
        }
        RSA rsa = SecureUtil.rsa(null, publicKey);
        return rsa.encryptHex(data, StandardCharsets.UTF_8, KeyType.PublicKey);
    }

    /**
     * rsa私钥解密
     *
     * @param data       待加密数据
     * @param privateKey 私钥
     * @return 解密后字符串
     */
    public static String decryptByRsa(String data, String privateKey) {
        if (StrUtil.isBlank(privateKey)) {
            throw new IllegalArgumentException("RSA需要传入私钥进行解密");
        }
        RSA rsa = SecureUtil.rsa(privateKey, null);
        return rsa.decryptStr(data, KeyType.PrivateKey, StandardCharsets.UTF_8);
    }
}

测试类

public static void main(String[] args) {
        // base64加密解密
        String originalText = "hello";
        System.out.println("原文: " + originalText);
        String s = EncryptUtils.encryptByBase64(originalText);
        System.out.println("base64 密文: " + s);
        System.out.println("base64 解密: " + EncryptUtils.decryptByBase64(s));
        System.out.println("==========\n");

        // aes 对称加密解密
        System.out.println("原文: " + originalText);
        String s1 = EncryptUtils.encryptByAes(originalText, "1234567890123456");
        String s2 = EncryptUtils.encryptByAesHex(originalText, "1234567890123456");
        System.out.println("aes密文: " + s1);
        System.out.println("aes hex密文: " + s2);
        System.out.println("aes 解密: " + EncryptUtils.decryptByAes(s1, "1234567890123456"));
        System.out.println("aes hex 解密: " + EncryptUtils.decryptByAes(s2, "1234567890123456"));
        System.out.println("==========\n");

        // sm4 对称加密解密
        System.out.println("原文: " + originalText);
        String s3 = EncryptUtils.encryptBySm4(originalText, "1234567890123456");
        String s4 = EncryptUtils.encryptBySm4Hex(originalText, "1234567890123456");
        System.out.println("sm4密文: " + s3);
        System.out.println("sm4 hex密文: " + s4);
        System.out.println("sm4 解密: " + EncryptUtils.decryptBySm4(s3, "1234567890123456"));
        System.out.println("sm4 hex 解密: " + EncryptUtils.decryptBySm4(s4, "1234567890123456"));
        System.out.println("==========\n");

        // sm2 非对称加密解密
        System.out.println("原文: " + originalText);
        Map<String, String> sm2Key = EncryptUtils.generateSm2Key();
        String s5 = EncryptUtils.encryptBySm2(originalText, sm2Key.get(EncryptUtils.PUBLIC_KEY));
        String s6 = EncryptUtils.encryptBySm2Hex(originalText, sm2Key.get(EncryptUtils.PUBLIC_KEY));
        System.out.println("sm2密文: " + s5);
        System.out.println("sm2 hex密文: " + s6);
        System.out.println("sm2 解密: " + EncryptUtils.decryptBySm2(s5, sm2Key.get(EncryptUtils.PRIVATE_KEY)));
        System.out.println("sm2 hex 解密: " + EncryptUtils.decryptBySm2(s6, sm2Key.get(EncryptUtils.PRIVATE_KEY)));
        System.out.println("==========\n");

        // rsa 非对称加密解密
        System.out.println("原文: " + originalText);
        Map<String, String> rsaKey = EncryptUtils.generateRsaKey();
        String s7 = EncryptUtils.encryptByRsa(originalText, rsaKey.get(EncryptUtils.PUBLIC_KEY));
        String s8 = EncryptUtils.encryptByRsaHex(originalText, rsaKey.get(EncryptUtils.PUBLIC_KEY));
        System.out.println("rsa密文: " + s7);
        System.out.println("rsa hex密文: " + s8);
        System.out.println("rsa 解密: " + EncryptUtils.decryptByRsa(s7, rsaKey.get(EncryptUtils.PRIVATE_KEY)));
        System.out.println("rsa hex 解密: " + EncryptUtils.decryptByRsa(s8, rsaKey.get(EncryptUtils.PRIVATE_KEY)));
        System.out.println("==========");
    }

结果

示例结果

java中如何使用密码学，aes/des/sm4/sm3/rsa
weixin_44933612的博客
10-25 991
java encrypt and decrypt password.for explame aes/des/sm3/sm4
aes加密算法python语言实现_python实现AES/DES/RSA/MD5/SM2/SM4/3DES加密算法模板汇总
weixin_39644750的博客
12-15 1252
都是作者累积的,且看其珍惜,大家可以尽量可以保存一下,如果转载请写好出处https://www.cnblogs.com/pythonywy一.md5加密1.简介这是一种使用非常广泛的加密方式，不可逆的,常见16位和32位一般都是md5import hashlibdata = '你好'print(hashlib.md5(data.encode(encoding="UTF-8")).hexdigest...
ec java sm2证书_SM2国密证书合法性验证
weixin_39637059的博客
12-24 954
通常我们遇到过的X509证书都是基于RSA-SHA1算法的，目前国家在大力推行国密算法，未来银行发行的IC卡也都是基于PBOC3.0支持国密算法的，因此我们来学习一下如何验证SM2国密证书的合法性。至于SM2与SM3的算法实现不在本文讨论范围之内，可以用openssl、BouncyCastle.Crypto.dll等第三方库来实现。SM2国密证书与RSA证书一样，一般内容都是以BASE64格式编码...
加解密技术基本使用指南（Base64、Hex、AES、SM4、RSA 算法）
墨鸦的博客
04-07 1万+
加解密技术基本使用指南（Base64、AES、RSA 算法）
【国密算法那点事儿】解读DES和SM4、RSA和SM2及SHA和SM3
若尘风
12-08 6万+
转载自：http://www.wtoutiao.com/a/844743.html 安全是智能卡的核心，而算法是安全的基础。 国密算法由国家密码局发布，包含SM1\ SM2\ SM3\ SM4\ SSF33算法;国际算法由美国的安全局发布，是现今最通用的商用算法。今天小钞就以分组密码算法(DES和SM4)、公钥密码算法(RSA和SM2)、摘要算法(SM3)为例，和大家谈谈国际算法和
非对称加密算法（RSA、ECC、SM2）——密码学基础
初始阶段。长文本博客做模型上下文。新书《千界明彻录》（故事形式构建元思维）——胡说小说。更多思辨内容在公众号。
05-02 3059
非对称加密是现代密码学的基石，它使用一对密钥（公钥和私钥）进行加密和解密操作。与传统的对称加密不同，非对称加密解决了密钥分发的难题，为互联网安全通信奠定了基础。
非对称加密与国密SM2（上）
自学半天的大一麦克的博客
09-25 3023
非对称加密算法是一种使用成对密钥（公钥和私钥）进行加密和解密的算法。它的主要特点是加密和解密使用的不是同一个密钥，而是两个不同的密钥：一个用于加密，另一个用于解密。这与对称加密算法形成了鲜明的对比。非对称加密算法的工作原理公钥：公开发布，任何人都可以用来加密消息或验证签名。私钥：仅由密钥持有者掌握，用于解密公钥加密的消息或生成签名。在非对称加密中：1. 如果你使用公钥加密数据，那么只有拥有对应私钥的人才能解密。2. 如果你用私钥对数据进行签名，那么任何人都可以用公钥验证签名的真实性。
1.Java开源RSA/AES/SHA1/PGP/SM2/SM3/SM4加密算法介绍
编码之旅
05-22 1832
- 支持RSA(1024/2048/3072/4096)/AES(128/192/256)/SHA-1/SHA-256/SHA-512/SHA-3/MD5/PGP/HMAC-SHA256/HMAC-SHA512等国际通用的加密算法； - 支持SM2/SM3/SM4/HMAC-SM3等国密算法； - 还支持国密和国际加密算法的统一抽象与封装，并封装了国际/国密组合使用的一些实践；- 本加解密组件基于BouncyCastle做了二次封装，并已开源bq-encryptor，期待着有一天我们也有自己的国产的更优实现
7、【java数据安全】国家商用密码介绍及对称加密、非对称加密使用示例（一）
热门推荐
alanchanchn的专栏
06-21 7万+
国密即国家密码局认定的国产密码算法，即商用密码。商用密码，是指能够实现商用密码算法的加密、解密和认证等功能的技术。（包括密码算法编程技术和密码算法芯片、加密卡等的实现技术）。了保障在金融、医疗等领域保障信息传输安全，国家商用密码管理办公室制定了一系列密码标准，包括SM1（SCB2）、SM2、SM3、SM4、SM7、SM9、祖冲之密码算法（ZUC)等。SSF33、SM1、SM4、SM7是对称算法SM2、SM9是非对称算法SM3是哈希算法报文摘要与MD类似，只是算法不同。
c#实现base64 MD5 编码转换 AES RSA SM2 SM4加解密
04-04
本篇将详细介绍如何在C#中实现Base64、MD5编码转换以及AES、RSA、SM2和SM4加解密，并探讨这些技术的原理和应用。 1. **Base64编码**：Base64是一种用于将二进制数据编码为ASCII字符串的编码方式，便于在网络上传输...
加密算法工具箱, 具有RSA, ECC, SM2, 3DES, AES, SM4, SHA-1/SHA-256等功能
04-07
支持非对称算法：RSA、ECC、SM2 支持对称算法：3DES、AES、SM4、RC4 支持各种MAC算法和HMAC算法 支持摘要算法：SM3、SHA-1、SHA-256、SHA-512 支持多种MAC算法及HMAC算法 支持DUKPT 根据IPEK生成子密钥功能 ...
Java非对称加密：RSA 数据加密与解密、数字签名与验签
pan_junbiao的博客
10-28 1819
非对称加密（asymmetric cryptography），也称为公开密钥加密（public-key cryptography），是密码学中的一种重要算法。非对称加密使用一对密钥进行加密和解密操作，这两个密钥分别是公开密钥（public key）和私有密钥（private key）。公开密钥可以公开给任何人使用，而私有密钥则必须保密，只有密钥的持有者才能访问。这两个密钥之间存在数学上的联系，但不能从一个推导出另一个。
SSM企业物资管理系统h3109(程序+源码+数据库+调试部署+开发环境)带论文文档1万字以上，文末可获取，系统界面在最后面
2509_93102542的博客
11-21 762
在技术实现上，国外多采用成熟的开发框架和技术架构，注重系统的安全性、稳定性和可扩展性，同时积极融入大数据、人工智能等新技术，实现物资需求预测、智能库存优化等功能。基于此，开发一套基于SSM框架的企业物资管理系统，整合部门、员工、物资及各类业务流程管理功能，实现物资管理的数字化、规范化和高效化，成为解决企业物资管理痛点的必然需求。本课题旨在开发一套基于SSM框架的企业物资管理系统，围绕部门、员工、物资信息、物资申请、消息提醒、物资归还、物资入库、意见反馈八大核心功能模块，实现企业物资管理的全流程数字化。
Java原生网络编程-BIO与NIO
照母山挖洋芋
11-24 450
摘要：本文对比了Java原生JDK中的BIO(阻塞I/O)和NIO(非阻塞I/O)网络编程模型。BIO采用"一连接一线程"模式，存在线程资源浪费和性能瓶颈问题，可通过线程池优化为伪异步I/O模型。NIO通过Selector、Channel和Buffer三大核心组件实现非阻塞通信，支持单线程管理多个通道。重点介绍了NIO的Reactor模式、事件类型(OP_READ/OP_WRITE等)及服务端/客户端的不同关注点，展示了NIO相比BIO在高并发场景下的优势。（149字）
spring全局懒加载(default-lazy-init)导致的afterPropertiesSet不执行问题
豆豆的博客
11-21 504
Spring配置default-lazy-init="true"会导致所有Bean延迟初始化，影响afterPropertiesSet方法的执行时机。解决方案包括：1)为关键Bean显式设置lazy-init="false"；2)使用@Lazy(false)注解；3)编程式强制初始化；4)使用DependsOn控制顺序。最佳实践建议分层配置策略，核心组件立即初始化，业务组件懒加载，并通过配置文件分离和环境区分优化配置。实际应用中，Web应用的请求处理相关Bean和批处
Java集合框架实战：构建高效的企业管理系统
2402_83075343的博客
11-23 689
本文通过两个企业管理系统案例，详细解析了Java集合框架的核心应用。员工部门管理系统采用HashMap实现部门与员工的高效映射，具备智能添加、快速查询和动态统计功能；商品库存管理系统基于ArrayList实现精细化管控，包含智能录入、库存预警和价格排序等特性。文章对比了HashMap和ArrayList的特性差异，提供了集合选型的最佳实践，并探讨了系统扩展方向。这两个实战案例展示了集合框架在企业应用中的实际价值，为开发者掌握Java集合提供了实用参考。
Spring Boot 中使用 @Transactional 注解配置事务管理
2509_94007314的博客
11-21 1279
下面分别介绍一下的几个属性。
Springboot | Spring Boot 3 纯 JDBC 实现宠物管理系统增删改查（无 ORM 框架）
最新发布
张较瘦
11-24 566
本文介绍了基于Spring Boot 3和纯JDBC实现的宠物管理系统CRUD操作。通过原生JDBC方式，不使用任何ORM框架，帮助开发者深入理解底层数据库操作原理。文章详细说明了环境准备（JDK17+、Spring Boot 3.2.x、MySQL 8.0）、项目依赖配置、数据库连接设置以及表结构创建。核心实现包括：Pet实体类定义（包含id、name、breed和age字段）以及PetService服务层，利用JdbcTemplate封装增删改查操作，重点演示了如何通过PreparedStatement
2025最新 SpringCloud 教程，教程简介，笔记01
Rockandrollman的博客
11-24 46
2025最新 SpringCloud 教程，教程简介，笔记01
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值