spring*.xml配置文件明文加密的實現(xiàn)
更新時間：2021年01月10日 11:18:45 作者：昊狼
這篇文章主要介紹了spring*.xml配置文件明文加密的實現(xiàn)，文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧
說明：客戶要求spring*.xml中Oracle/Redis/MongoDB的IP、端口、用戶名、密碼不能明文存放，接到需求的我，很無奈，但是還是的硬著頭皮搞
系統(tǒng)架構(gòu)：spring+mvc（Oracle是用jdbc自己封裝的接口）
1.數(shù)據(jù)庫配置文件加密
原xml配置
<?xml version="1.0" encoding="utf-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd" default-autowire="byType"> <context:component-scan base-package="cn.geoff" use-default-filters="false"> <context:include-filter type="annotation" expression="org.springframework.stereotype.Service"/> </context:component-scan> <!-- Database Connection Pool --> <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close"> <property name="url" value="jdbc:oracle:thin:@192.168.100.100:1521:orcl"/> <property name="username" value="Geoff"/> <property name="password" value="123456"/> <property name="validationQuery" value="select 'x' from dual"/> ..... </bean> <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> <property name="dataSource" ref="dataSource"/> </bean> </beans>
加密實現(xiàn)過程
思路：繼承DruidDataSource，在初始化set值的時候進(jìn)行解密
/**
* 數(shù)據(jù)庫連接解密
* @author: Geoff
* @create: 2020-12-30 16:46
**/
public class DataBaseXml extends DruidDataSource {
/**
* Log4j logger
*/
private final static Logger lg = LoggerFactory.getLogger(DataBaseXml.class);
@Override
public String getUrl() {
return this.jdbcUrl;
}
@Override
public void setUrl(String jdbcUrl) {
if(GEOFF.DATA_BASE_IS_ENCRYPTION) {
lg.info("數(shù)據(jù)庫【jdbcUrl】解密初始化加載...");
try {
jdbcUrl = Encryption.decrypt(jdbcUrl, GEOFF.DATA_BASE_ENCRYPTION_KEY);
} catch (Exception e) {
lg.error("數(shù)據(jù)庫【jdbcUrl】密文解密失敗...");
e.printStackTrace();
}
}
this.jdbcUrl = jdbcUrl;
}
@Override
public String getUsername() {
return this.username;
}
@Override
public void setUsername(String username) {
if(GEOFF.DATA_BASE_IS_ENCRYPTION) {
lg.info("數(shù)據(jù)庫【username】解密初始化加載...");
try {
username = Encryption.decrypt(username, GEOFF.DATA_BASE_ENCRYPTION_KEY);
} catch (Exception e) {
lg.error("數(shù)據(jù)庫【username】密文解密失敗...");
e.printStackTrace();
}
}
this.username = username;
}
@Override
public String getPassword() {
return this.password;
}
@Override
public void setPassword(String password) {
if(GEOFF.DATA_BASE_IS_ENCRYPTION){
lg.info("數(shù)據(jù)庫【password】解密初始化加載...");
try {
password = Encryption.decrypt(password, GEOFF.DATA_BASE_ENCRYPTION_KEY);
} catch (Exception e) {
lg.error("數(shù)據(jù)庫【password】密文解密失敗...");
e.printStackTrace();
}
}
this.password = password;
}
}
修改后配置文件
<?xml version="1.0" encoding="utf-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd" default-autowire="byType"> <context:component-scan base-package="cn.GEOFF" use-default-filters="false"> <context:include-filter type="annotation" expression="org.springframework.stereotype.Service"/> </context:component-scan> <bean id="dataSource" class="cn.GEOFF.framework.core.DataBaseXml" init-method="init" destroy-method="close"> <property name="url" value="4lZ4l804zIDqOJ5Wt3VNVLZvSLSDqCuQwhg5cAbQ1VG/vx+x+pEJQ6VJmLPO+PKK"/> <property name="username" value="PFEz8V4uvb06KhQxCLvLNA=="/> <property name="password" value="mMckYd6C5fo="/> <property name="validationQuery" value="select 'x' from dual"/> ..... </bean> <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> <property name="dataSource" ref="dataSource"/> </bean> </beans>
2.Redis配置文件加密
原配置文件
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN" "http://www.springframework.org/dtd/spring-beans-2.0.dtd">
<!-- Jedis -->
<beans default-autowire="byName">
<!-- Default Pool Config -->
<bean id="defaultJedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
<property name="maxTotal" value="5"/>
<property name="maxIdle" value="2"/>
<property name="minIdle" value="2"/>
<property name="testOnBorrow" value="true"/>
<property name="testOnReturn" value="true"/>
<property name="testWhileIdle" value="true"/>
</bean>
<bean id="one" class="redis.clients.jedis.JedisPool" destroy-method="destroy">
<constructor-arg index="0" ref="defaultJedisPoolConfig"/>
<constructor-arg index="1" value="127.0.0.1" type="java.lang.String"/>
<constructor-arg index="2" value="6379" type="int"/>
<constructor-arg index="3" value="0" type="int"/>
<constructor-arg index="4" value="123456" type="java.lang.String"/>
</bean>
<bean id="two" class="redis.clients.jedis.JedisPool" destroy-method="destroy">
<constructor-arg index="0" ref="defaultJedisPoolConfig"/>
<constructor-arg index="1" value="127.0.0.1" type="java.lang.String"/>
<constructor-arg index="2" value="6379" type="int"/>
<constructor-arg index="3" value="0" type="int"/>
<constructor-arg index="4" value="123456" type="java.lang.String"/>
</bean>
<bean id="three" class="redis.clients.jedis.JedisPool" destroy-method="destroy">
<constructor-arg index="0" ref="defaultJedisPoolConfig"/>
<constructor-arg index="1" value="127.0.0.1" type="java.lang.String"/>
<constructor-arg index="2" value="6379" type="int"/>
<constructor-arg index="3" value="0" type="int"/>
<constructor-arg index="4" value="123456" type="java.lang.String"/>
</bean>
</beans>
加密實現(xiàn)思路：由于JedisPool使用構(gòu)造函數(shù)來創(chuàng)建，所以繼承JedisPool后，在調(diào)用JedisPool構(gòu)造函數(shù)的時候，調(diào)用static解密方法進(jìn)行解密
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import redis.clients.jedis.*;
/**
* redis數(shù)據(jù)庫用戶名密碼解密
* @author: Geoff
* @create: 2020-12-30 17:20
**/
public class JedisPoolXml extends JedisPool{
/**
* Log4j logger
*/
private final static Logger lg = LoggerFactory.getLogger(JedisPoolXml.class);
public JedisPoolXml(GenericObjectPoolConfig poolConfig, String host, String port, String timeout, String password) {
super(poolConfig,decryptHost(host),decryptPort(port),decryptTimeout(timeout),decryptPassword(password), 0, (String)null);
}
private JedisPoolXml(GenericObjectPoolConfig poolConfig, String host, String port,String timeout, String password, String database){
super(poolConfig,decryptHost(host),decryptPort(port),decryptTimeout(timeout),decryptPassword(password),decryptDatabase(database));
}
private static String decryptHost(String host){
if(GEOFF.DATA_BASE_IS_ENCRYPTION) {
lg.info("Redis【host】解密初始化加載...");
try {
host = Encryption.decrypt(host, GEOFF.DATA_BASE_ENCRYPTION_KEY);
} catch (Exception e) {
lg.error("Redis【host】密文解密失敗...");
e.printStackTrace();
}
}
return host;
}
private static int decryptPort(String port){
if(GEOFF.DATA_BASE_IS_ENCRYPTION) {
lg.info("Redis【port】解密初始化加載...");
try {
port = Encryption.decrypt(port, GEOFF.DATA_BASE_ENCRYPTION_KEY);
} catch (Exception e) {
lg.error("Redis【port】密文解密失敗...");
e.printStackTrace();
}
}
return Integer.parseInt(port);
}
private static int decryptTimeout(String timeout){
if(GEOFF.DATA_BASE_IS_ENCRYPTION) {
lg.info("Redis【timeout】解密初始化加載...");
try {
timeout = Encryption.decrypt(timeout, GEOFF.DATA_BASE_ENCRYPTION_KEY);
} catch (Exception e) {
lg.error("Redis【timeout】密文解密失敗...");
e.printStackTrace();
}
}
return Integer.parseInt(timeout);
}
private static String decryptPassword(String password){
if(GEOFF.DATA_BASE_IS_ENCRYPTION) {
lg.info("Redis【password】解密初始化加載...");
try {
password = Encryption.decrypt(password, GEOFF.DATA_BASE_ENCRYPTION_KEY);
} catch (Exception e) {
lg.error("Redis【password】密文解密失敗...");
e.printStackTrace();
}
}
return password;
}
private static int decryptDatabase(String database){
if(GEOFF.DATA_BASE_IS_ENCRYPTION) {
lg.info("Redis【database】解密初始化加載...");
try {
database = Encryption.decrypt(database, GEOFF.DATA_BASE_ENCRYPTION_KEY);
} catch (Exception e) {
lg.error("Redis【database】密文解密失敗...");
e.printStackTrace();
}
}
return Integer.parseInt(database);
}
}
修改后xml
<?xml version="1.0" encoding="utf-8"?> <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN" "http://www.springframework.org/dtd/spring-beans-2.0.dtd"> <!-- Jedis --> <beans default-autowire="byName"> <bean id="defaultJedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig"> <property name="maxTotal" value="5"/> <property name="maxIdle" value="2"/> <property name="minIdle" value="2"/> <property name="testOnBorrow" value="true"/> <property name="testOnReturn" value="true"/> <property name="testWhileIdle" value="true"/> </bean> <bean id="one" class="cn.GEOFF.framework.core.JedisPoolXml" destroy-method="destroy"> <constructor-arg index="0" ref="defaultJedisPoolConfig"/> <constructor-arg index="1" value="N98/M6A3acRnYMqIQEXGEg==" type="java.lang.String"/> <constructor-arg index="2" value="INDccYoGS/Y=" type="java.lang.String"/> <constructor-arg index="3" value="CXszBZysXWY=" type="java.lang.String"/> <constructor-arg index="4" value="mMckYd6C5fo=" type="java.lang.String"/> </bean> <bean id="two" class="cn.GEOFF.framework.core.JedisPoolXml" destroy-method="destroy"> <constructor-arg index="0" ref="defaultJedisPoolConfig"/> <constructor-arg index="1" value="N98/M6A3acRnYMqIQEXGEg==" type="java.lang.String"/> <constructor-arg index="2" value="INDccYoGS/Y=" type="java.lang.String"/> <constructor-arg index="3" value="CXszBZysXWY=" type="java.lang.String"/> <constructor-arg index="4" value="mMckYd6C5fo=" type="java.lang.String"/> </bean> <bean id="three" class="cn.GEOFF.framework.core.JedisPoolXml" destroy-method="destroy"> <constructor-arg index="0" ref="defaultJedisPoolConfig"/> <constructor-arg index="1" value="N98/M6A3acRnYMqIQEXGEg==" type="java.lang.String"/> <constructor-arg index="2" value="INDccYoGS/Y=" type="java.lang.String"/> <constructor-arg index="3" value="CXszBZysXWY=" type="java.lang.String"/> <constructor-arg index="4" value="mMckYd6C5fo=" type="java.lang.String"/> </bean> </beans>
3.MongoDB配置文件加密（使用的是spring-data-mognodb框架）
原xml配置
<?xml version="1.0" encoding="utf-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:mongo="http://www.springframework.org/schema/data/mongo" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/data/mongo http://www.springframework.org/schema/data/mongo/spring-mongo.xsd"> <mongo:mongo-client id="mongoClient" host="192.168.100.100" port="27017" credentials="jyzq_zsc:123456@JYZQ_ZSC"> </mongo:mongo-client> <!-- Factory --> <mongo:db-factory id="mongoDbFactory" dbname="PFEz8V4uvb06KhQxCLvLNA==" mongo-ref="mongoClient"/> <mongo:db-factory id="mongoDbFactory" dbname="JYZQ_ZSC" mongo-ref="mongoClient"/> <mongo:mapping-converter id="converter" db-factory-ref="mongoDbFactory"/> <!-- Grid FS Template --> <bean id="gridFsTemplate" class="org.springframework.data.mongodb.gridfs.GridFsTemplate"> <constructor-arg ref="mongoDbFactory"/> <constructor-arg ref="converter"/> </bean> <!-- Mongo Template --> <bean id="documentTemplate" class="org.springframework.data.mongodb.core.MongoTemplate"> <constructor-arg ref="mongoDbFactory"/> <constructor-arg ref="converter"/> </bean> </beans>
加密思路：由于項目使用的時候是獲取bean的方式來獲取MongoTemplate和mongoDbFactory的，嘗試過各種方法來繼承后加密，但是最后都不行，后面只能通過手動的方法進(jìn)行初始化，并將對應(yīng)MongoTemplate和mongoDbFactory注入到bean中
import com.mongodb.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.SimpleMongoDbFactory;
import org.springframework.data.mongodb.core.convert.DefaultDbRefResolver;
import org.springframework.data.mongodb.core.convert.MappingMongoConverter;
import org.springframework.data.mongodb.core.mapping.MongoMappingContext;
import org.springframework.data.mongodb.gridfs.GridFsTemplate;
import java.util.ArrayList;
import java.util.List;
/**
* @author: Geoff
* @create: 2020-12-31 16:15
**/
@Configuration
public class MongoDBXml {
/**
* Log4j logger
*/
private final static Logger lg = LoggerFactory.getLogger(MongoDBXml.class);
private String host;
private Integer port;
private String userName;
private String passWord;
private String dataBase;
private SimpleMongoDbFactory mongoDbFactory = null;
private MappingMongoConverter converter = null;
public String getHost() {
return host;
}
public void setHost(String host) {
this.host = decryptHost(host);
}
public Integer getPort() {
return port;
}
public void setPort(String port) {
this.port = decryptPort(port);
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = decryptUserName(userName);
}
public String getPassWord() {
return passWord;
}
public void setPassWord(String passWord) {
this.passWord = decryptPassword(passWord);
}
public String getDataBase() {
return dataBase;
}
public void setDataBase(String dataBase) {
this.dataBase = decryptDatabase(dataBase);
}
private String decryptHost(String host){
if(GEOFF.DATA_BASE_IS_ENCRYPTION) {
lg.info("MongoDB【host】解密初始化加載...");
try {
host = Encryption.decrypt(host, GEOFF.DATA_BASE_ENCRYPTION_KEY);
} catch (Exception e) {
lg.error("MongoDB【host】密文解密失敗...");
e.printStackTrace();
}
}
return host;
}
private int decryptPort(String port){
if(GEOFF.DATA_BASE_IS_ENCRYPTION) {
lg.info("MongoDB【port】解密初始化加載...");
try {
port = Encryption.decrypt(port, GEOFF.DATA_BASE_ENCRYPTION_KEY);
} catch (Exception e) {
lg.error("MongoDB【port】密文解密失敗...");
e.printStackTrace();
}
}
return Integer.parseInt(port);
}
private String decryptUserName(String userName){
if(GEOFF.DATA_BASE_IS_ENCRYPTION) {
lg.info("MongoDB【userName】解密初始化加載...");
try {
userName = Encryption.decrypt(userName, GEOFF.DATA_BASE_ENCRYPTION_KEY);
} catch (Exception e) {
lg.error("MongoDB【userName】密文解密失敗...");
e.printStackTrace();
}
}
return userName;
}
private String decryptPassword(String passWord){
if(GEOFF.DATA_BASE_IS_ENCRYPTION) {
lg.info("MongoDB【password】解密初始化加載...");
try {
passWord = Encryption.decrypt(passWord, GEOFF.DATA_BASE_ENCRYPTION_KEY);
} catch (Exception e) {
lg.error("MongoDB【password】密文解密失敗...");
e.printStackTrace();
}
}
return passWord;
}
private String decryptDatabase(String dataBase){
if(GEOFF.DATA_BASE_IS_ENCRYPTION) {
lg.info("MongoDB【database】解密初始化加載...");
try {
dataBase = Encryption.decrypt(dataBase, GEOFF.DATA_BASE_ENCRYPTION_KEY);
} catch (Exception e) {
lg.error("MongoDB【database】密文解密失敗...");
e.printStackTrace();
}
}
return dataBase;
}
public void init() {
MongoClientOptions.Builder build = new MongoClientOptions.Builder();
MongoClientOptions options = build.build();
try {
List<ServerAddress> addrs = new ArrayList<ServerAddress>();
ServerAddress serverAddress = new ServerAddress(host, port);
addrs.add(serverAddress);
MongoCredential credential = MongoCredential.createScramSha1Credential(userName, dataBase, passWord.toCharArray());
List<MongoCredential> credentials = new ArrayList<MongoCredential>();
credentials.add(credential);
MongoClient mongoClient = new MongoClient(addrs, credentials, options);
mongoDbFactory = new SimpleMongoDbFactory(mongoClient, dataBase);
DefaultDbRefResolver dbRefResolver = new DefaultDbRefResolver(mongoDbFactory);
MongoMappingContext mongoMappingContext = new MongoMappingContext();
converter = new MappingMongoConverter(dbRefResolver, mongoMappingContext);
lg.info(" mongodb客戶端創(chuàng)建成功 ");
} catch (Exception e) {
lg.info(" mongodb客戶端創(chuàng)建失敗 ");
e.printStackTrace();
}
documentTemplate();
gridFsTemplate();
}
@Bean
public MongoTemplate documentTemplate() {
if (mongoDbFactory != null && converter != null) {
lg.info("MongoTemplate初始化成功......");
MongoTemplate mongoTemplate = new MongoTemplate(mongoDbFactory, converter);
return mongoTemplate;
} else {
lg.error("MongoTemplate初始化失敗......");
return null;
}
}
@Bean
public GridFsTemplate gridFsTemplate() {
if (mongoDbFactory != null && converter != null) {
lg.info("GridFsTemplate初始化成功......");
GridFsTemplate gridFsTemplate = new GridFsTemplate(mongoDbFactory, converter);
return gridFsTemplate;
} else {
lg.error("GridFsTemplate初始化失敗......");
return null;
}
}
public void destroy(){
try {
this.mongoDbFactory.destroy();
} catch (Exception e) {
e.printStackTrace();
}
}
}
修改后配置文件
<?xml version="1.0" encoding="utf-8"?> <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN" "http://www.springframework.org/dtd/spring-beans-2.0.dtd"> <!-- mongoDB --> <beans> <bean id="mongoDBXml" class="cn.GEOFF.framework.core.MongoDBXml" init-method="init" destroy-method="destroy" > <property name="host" value="PpmNMR+X2UIVhG8gmNFFqg=="/> <property name="port" value="51QH8fifl1k="/> <property name="userName" value="yre5DufK9os6KhQxCLvLNA=="/> <property name="passWord" value="mMckYd6C5fo="/> <property name="dataBase" value="PFEz8V4uvb06KhQxCLvLNA=="/> </bean> </beans>
4.最后附上對應(yīng)的加解密類
import org.apache.commons.codec.binary.Base64;
import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
import java.security.Key;
import java.security.SecureRandom;
/**
* 加密生成token的方法
*
* @author: Geoff
* @create: 2020-12-30 17:03
**/
public class Encryption {
// 算法名稱
public static final String KEY_ALGORITHM = "DES";
// 算法名稱/加密模式/填充方式
// DES共有四種工作模式-->>ECB：電子密碼本模式、CBC：加密分組鏈接模式、CFB：加密反饋模式、OFB：輸出反饋模式
public static final String CIPHER_ALGORITHM = "DES/ECB/PKCS5Padding";
/**
* 生成密鑰key對象
*
* @param
* @return 密鑰對象
* @throws Exception
*/
private static SecretKey keyGenerator(String keyStr) throws Exception {
byte[] input = HexString2Bytes(keyStr);
DESKeySpec desKey = new DESKeySpec(input);
// 創(chuàng)建一個密匙工廠，然后用它把DESKeySpec轉(zhuǎn)換成
SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(KEY_ALGORITHM);
SecretKey securekey = keyFactory.generateSecret(desKey);
return securekey;
}
/**
* 從十六進(jìn)制字符串到字節(jié)數(shù)組轉(zhuǎn)換
*/
public static byte[] HexString2Bytes(String hexStr) {
byte[] keyBytes = hexStr.getBytes();
if (keyBytes.length == 16) {
byte[] tmpKey = new byte[24];
System.arraycopy(keyBytes, 0, tmpKey, 0, 16);
System.arraycopy(keyBytes, 0, tmpKey, 16, 8);
keyBytes = tmpKey;
}
return keyBytes;
}
/**
* 加密數(shù)據(jù)
*
* @param data 待加密數(shù)據(jù)
* @param key 密鑰
* @return 加密后的數(shù)據(jù)
*/
public static String encrypt(String data, String key) throws Exception {
Key deskey = keyGenerator(key);
// 實例化Cipher對象，它用于完成實際的加密操作
Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
SecureRandom random = new SecureRandom();
// 初始化Cipher對象，設(shè)置為加密模式
cipher.init(Cipher.ENCRYPT_MODE, deskey, random);
byte[] results = cipher.doFinal(data.getBytes());
// 執(zhí)行加密操作。加密后的結(jié)果通常都會用Base64編碼進(jìn)行傳輸
return Base64.encodeBase64String(results);
}
/**
* 解密數(shù)據(jù)
*
* @param data 待解密數(shù)據(jù)
* @param key 密鑰
* @return 解密后的數(shù)據(jù)
*/
public static String decrypt(String data, String key) throws Exception {
Key deskey = keyGenerator(key);
Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
// 初始化Cipher對象，設(shè)置為解密模式
cipher.init(Cipher.DECRYPT_MODE, deskey);
// 執(zhí)行解密操作
return new String(cipher.doFinal(Base64.decodeBase64(data)));
}
}
到此這篇關(guān)于spring*.xml配置文件明文加密的實現(xiàn)的文章就介紹到這了,更多相關(guān)spring*.xml配置文件加密內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！
相關(guān)文章
spring-cloud-gateway降級的實現(xiàn)
這篇文章主要介紹了spring-cloud-gateway降級的實現(xiàn),文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧2020-04-04
這篇文章主要介紹了java正則表達(dá)式提取數(shù)字的方法，還有去除字符串?dāng)?shù)字的方法，大家參考使用吧2013-12-12
一鍵清除maven倉庫中下載失敗的jar包的實現(xiàn)方法
這篇文章主要介紹了一鍵清除maven倉庫中下載失敗的jar包的實現(xiàn)方法，文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧2020-07-07
這篇文章主要介紹了詳解eclipse項目中.classpath文件的使用，文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧2020-10-10
關(guān)于elasticsearch的match_phrase_prefix查詢詳解
這篇文章主要介紹了關(guān)于elasticsearch的match_phrase_prefix查詢問題，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2023-03-03
這篇文章主要為大家詳細(xì)介紹了java實現(xiàn)IP地址轉(zhuǎn)換，文中示例代碼介紹的非常詳細(xì)，具有一定的參考價值，感興趣的小伙伴們可以參考一下2021-11-11
使用nexus3.X上傳本地jar包并且通過pom讀取的解決方案(全網(wǎng)最新)
這篇文章主要介紹了使用nexus3.X上傳本地jar包并且通過pom讀取的解決方案(全網(wǎng)最新),本文內(nèi)容有點長，結(jié)合圖文實例給大家講解的非常詳細(xì)，需要的朋友可以參考下2023-11-11
java基于jdbc實現(xiàn)簡單學(xué)生管理系統(tǒng)
本文主要主要介紹了java連接mysql數(shù)據(jù)庫的一個簡單學(xué)生系統(tǒng)，通過jdbc連接數(shù)據(jù)庫。文中通過示例代碼介紹的非常詳細(xì)，具有一定的參考價值，感興趣的小伙伴們可以參考一下2021-10-10
這篇文章主要為大家詳細(xì)介紹了Java實現(xiàn)簡易五子棋小游戲，文中示例代碼介紹的非常詳細(xì)，具有一定的參考價值，感興趣的小伙伴們可以參考一下2022-05-05
在Java編程中l(wèi)ong是一種數(shù)據(jù)類型,用于表示整數(shù)值,下面這篇文章主要給大家介紹了關(guān)于Java中比較Long類型是否相等的相關(guān)資料,文中通過代碼介紹的非常詳細(xì),需要的朋友可以參考下2024-05-05