扫码关注官方微信

扫码下载APP
返回顶部
首页 > 资讯 > 后端开发 > Python >使用mybatis拦截器处理敏感字段
  • 801

0
分享到

使用mybatis拦截器处理敏感字段

2024-04-02 19:04:59 801人浏览 薄情痞子

Python 官方文档：入门教程 => 点击学习

摘要

目录mybatis拦截器处理敏感字段前言思路解析代码趟过的坑（敲黑板重点）mybatis Excutor 拦截器的使用这里假设一个场景实现过程的关键步骤和代码重点mybatis拦截器

mybatis拦截器处理敏感字段

前言

由于公司业务要求，需要在不影响已有业务上对 数据库中已有数据的敏感字段加密解密，个人解决方案利用mybatis的拦截器加密解密敏感字段

思路解析

  • 利用注解标明需要加密解密的entity类对象以及其中的数据
  • mybatis拦截Executor.class对象中的query,update方法
  • 在方法执行前对parameter进行加密解密，在拦截器执行后，解密返回的结果

代码

1、配置拦截器(interceptor后为自己拦截器的包路径)


<plugins>
  <plugin interceptor="com.GitHub.miemiedev.mybatis.paginator.OffsetLimitInterceptor">
   <property name="dialectClass" value="com.github.miemiedev.mybatis.paginator.dialect.oracleDialect" />
  </plugin>
  <plugin interceptor="com.XXX.XXXX.service.encryptinfo.DaoInterceptor" />
 </plugins>

2、拦截器的实现

特别注意：因为Dao方法参数有可能单一参数，多参数map形式，以及entity对象参数类型，所以不通类型需有不通的处理方式（本文参数 单一字符串和entity对象，返回的结果集 List<?> 和entity）

后续在拦截器中添加了相应的开关，控制参数是否加密查询，解密已实现兼容


package com.ips.fpms.service.encryptinfo;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import com.xxx.xxx.dao.WhiteListDao;
import com.xxx.xxx.entity.db.WhiteListEntity;
import com.xxx.xxx.service.util.springBeanUtils;
import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.plugin.Interceptor;
import org.apache.ibatis.plugin.Intercepts;
import org.apache.ibatis.plugin.Invocation;
import org.apache.ibatis.plugin.Plugin;
import org.apache.ibatis.plugin.Signature;
import org.apache.ibatis.session.ResultHandler;
import org.apache.ibatis.session.RowBounds;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.xxx.xxx.annotation.EncryptField;
import com.xxx.xxx.annotation.EncryptMethod;
import com.xxx.xxx.common.utils.CloneUtil;
import com.xxx.core.psfp.common.support.JSONUtils;
import com.xxx.xxx.service.util.CryptPojoUtils;
@Intercepts({
    @Signature(type=Executor.class,method="update",args={MappedStatement.class,Object.class}),
    @Signature(type=Executor.class,method="query",args={MappedStatement.class,Object.class,RowBounds.class,ResultHandler.class})
})
public class EncryptDaoInterceptor implements Interceptor{
	private final Logger logger = LoggerFactory.getLogger(EncryptDaoInterceptor.class);
	private WhiteListDao whiteListDao;
	static int MAPPED_STATEMENT_INDEX = 0;
	static int PARAMETER_INDEX = 1;
	static int ROWBOUNDS_INDEX = 2;
	static int RESULT_HANDLER_INDEX = 3;
	static String ENCRYPTFIELD = "1";
	static String DECRYPTFIELD = "2";
	private static final String ENCRYPT_KEY = "encry146local";
	private static final String ENCRYPT_NUM = "146";
	private static boolean ENCRYPT_SWTICH = true;
	
	private boolean getFuncSwitch(){
		if(whiteListDao == null){
			whiteListDao = SpringBeanUtils.getBean("whiteListDao",WhiteListDao.class);
		}
		try{
			WhiteListEntity entity = whiteListDao.selectOne(ENCRYPT_KEY,ENCRYPT_NUM);
			if(entity!=null && "1".equals(entity.getFlag())){
				ENCRYPT_SWTICH = true;
			}else{
				ENCRYPT_SWTICH = false;
			}
		}catch (Exception e){
			logger.error(this.getClass().getName()+".getFuncSwitch 白名单查询异常,默认本地数据加密关闭[]：",e.getStackTrace());
			return false;
		}
		return ENCRYPT_SWTICH;
	}
	
	private boolean isWhiteList(String statementid){
		boolean result = false;
		String whiteStatementid = "com.ips.fpms.dao.WhiteListDao.selectOne";
		if(whiteStatementid.indexOf(statementid)!=-1){
			result = true;
		}
		return result;
	}
	@Override
	public Object intercept(Invocation invocation) throws Throwable {
		logger.info("EncryptDaoInterceptor.intercept开始执行==> ");
		MappedStatement statement = (MappedStatement) invocation.getArgs()[MAPPED_STATEMENT_INDEX];
		Object parameter = invocation.getArgs()[PARAMETER_INDEX];
		logger.info(statement.getId()+"未加密参数串:"+jsonUtils.object2jsonString(CloneUtil.deepClone(parameter)));
		
		if(!isWhiteList(statement.getId()) && getFuncSwitch()){
			parameter = encryptParam(parameter, invocation);
			logger.info(statement.getId()+"加密后参数:"+JsonUtils.object2jsonString(CloneUtil.deepClone(parameter)));
		}
		invocation.getArgs()[PARAMETER_INDEX] = parameter;
		Object returnValue = invocation.proceed();
		logger.info(statement.getId()+"未解密结果集:"+JsonUtils.object2jsonString(CloneUtil.deepClone(returnValue)));
		returnValue = decryptReslut(returnValue, invocation);
		logger.info(statement.getId()+"解密后结果集:"+JsonUtils.object2jsonString(CloneUtil.deepClone(returnValue)));
		logger.info("EncryptDaoInterceptor.intercept执行结束==> ");
		return returnValue;
	}
	
	public Object decryptReslut(Object returnValue,Invocation invocation){
		MappedStatement statement = (MappedStatement) invocation.getArgs()[MAPPED_STATEMENT_INDEX];
		if(returnValue!=null){
	       	 if(returnValue instanceof ArrayList<?>){
	       		 List<?> list = (ArrayList<?>) returnValue;
	       		 List<Object> newList  = new ArrayList<Object>();
	       		 if (1 <= list.size()){
	       			 for(Object object:list){
	       				 Object obj = CryptPojoUtils.decrypt(object);
	       				 newList.add(obj);
	       			 }
	       			 returnValue = newList;
	       		 }
	       	 }else if(returnValue instanceof Map){
	       		String[] fields = getEncryFieldList(statement,DECRYPTFIELD);
	       		if(fields!=null){
	       			returnValue = CryptPojoUtils.getDecryptMapValue(returnValue,fields);
	       		}
	       	 }else{
	       		 returnValue = CryptPojoUtils.decrypt(returnValue);
	       	 }
        }
		return returnValue;
	}
	
	public Object encryptParam(Object parameter,Invocation invocation){
		MappedStatement statement = (MappedStatement) invocation.getArgs()[MAPPED_STATEMENT_INDEX];
		try {
			if(parameter instanceof String){
				if(isEncryptStr(statement)){
					parameter = CryptPojoUtils.encryptStr(parameter);
				}
			}else if(parameter instanceof Map){
				String[] fields = getEncryFieldList(statement,ENCRYPTFIELD);
				if(fields!=null){
					parameter = CryptPojoUtils.getEncryptMapValue(parameter,fields);
				}
			}else{
				parameter = CryptPojoUtils.encrypt(parameter);
			}
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
			logger.info("EncryptDaoInterceptor.encryptParam方法异常==> " + e.getMessage());
		}
		return parameter;
	}
	@Override
	public Object plugin(Object target) {
		return Plugin.wrap(target, this);
	}
	@Override
	public void setProperties(Properties properties) {
	}
	
	private String[] getEncryFieldList(MappedStatement statement,String type){
		String[] strArry = null;
		Method method = getDaoTargetMethod(statement);
		Annotation annotation =method.getAnnotation(EncryptMethod.class);
		if(annotation!=null){
			if(type.equals(ENCRYPTFIELD)){
				String encryString = ((EncryptMethod) annotation).encrypt();
				if(!"".equals(encryString)){
					strArry =encryString.split(",");
				}
			}else if(type.equals(DECRYPTFIELD)){
				String encryString = ((EncryptMethod) annotation).decrypt();
				if(!"".equals(encryString)){
					strArry =encryString.split(",");
				}
			}else{
				strArry = null;
			}
		}
		return strArry;
	}
	
	private Method getDaoTargetMethod(MappedStatement mappedStatement){
		Method method = null;
		try {
			String namespace = mappedStatement.getId();
		    String className = namespace.substring(0,namespace.lastIndexOf("."));
		    String methedName= namespace.substring(namespace.lastIndexOf(".") + 1,namespace.length());
			Method[] ms = Class.forName(className).getMethods();
			for(Method m : ms){
		        if(m.getName().equals(methedName)){
		        	method = m;
		        	break;
		        }
			}
		} catch (SecurityException e) {
			e.printStackTrace();
			logger.info("EncryptDaoInterceptor.getDaoTargetMethod方法异常==> " + e.getMessage());
			return method;
			
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
			logger.info("EncryptDaoInterceptor.getDaoTargetMethod方法异常==> " + e.getMessage());
			return method;
		}
		return method;
	}
	
	private boolean isEncryptStr(MappedStatement mappedStatement) throws ClassNotFoundException{
		boolean reslut = false;
		try {
				Method m = getDaoTargetMethod(mappedStatement);
	        	m.setAccessible(true);
	        	Annotation[][] parameterAnnotations = m.getParameterAnnotations();
		        	 if (parameterAnnotations != null && parameterAnnotations.length > 0) { 
		        		 for (Annotation[] parameterAnnotation : parameterAnnotations) {  
		        	         for (Annotation annotation : parameterAnnotation) {  
		        	          if (annotation instanceof EncryptField) {  
		        	        	  reslut = true;
		        	          }
		        	      }
		        	 }
	        	 }
		} catch (SecurityException e) {
			e.printStackTrace();
			logger.info("EncryptDaoInterceptor.isEncryptStr异常：==> " + e.getMessage());
			reslut = false;
		}
		return reslut;
	}
}

2、注解的entity对象


//是否需要加密解密对象
@EncryptDecryptClass
public class MerDealInfoRequest extends PagingReqMsg {
//属性定义
 @EncryptField
    @DecryptField
    private String cardNo;
}

3、dao方法中的单一参数


List<Dealer> selectDealerAndMercode(@EncryptField String idcardno);

4、封装的工具类(EncryptDecryptUtil.decryptStrValue 解密方法 EncryptDecryptUtil.decryptStrValue 加密方法)


package com.xxx.xxx.service.util;
import java.lang.reflect.Field;
import java.util.ArrayList;
import org.apache.commons.lang.StringUtils;
import org.apache.pdfbox.Encrypt;
import org.apache.poi.ss.fORMula.functions.T;
import com.xxx.xxx.annotation.DecryptField;
import com.xxx.xxx.annotation.EncryptDecryptClass;
import com.xxx.xxx.annotation.EncryptField;
import com.xxx.xxx.common.utils.EncryptDecryptUtil;
public class CryptPojoUtils {
	 
    public static <T> T encrypt(T t) {
    	if(isEncryptAndDecrypt(t)){
	        Field[] declaredFields = t.getClass().getDeclaredFields();
	        try {
	            if (declaredFields != null && declaredFields.length > 0) {
	                for (Field field : declaredFields) {
	                    if (field.isAnnotationPresent(EncryptField.class) && field.getType().toString().endsWith("String")) {
	                        field.setAccessible(true);
	                        String fieldValue = (String) field.get(t);
	                        if (StringUtils.isNotEmpty(fieldValue)) {
	    	                    field.set(t, EncryptDecryptUtil.encryStrValue(fieldValue) );
	                        }
	                        field.setAccessible(false);
	                    }
	                }
	            }
	        } catch (IllegalAccessException e) {
	            throw new RuntimeException(e);
	        }
    	}
        return t;
    }
    
    public static <T> T EncryptStr(T t){
    	if(t instanceof String){
    		t = (T) EncryptDecryptUtil.encryStrValue((String) t);
    	}
    	return t;
    }
    
    public static <T> T decrypt(T t) {
    	if(isEncryptAndDecrypt(t)){
	        Field[] declaredFields = t.getClass().getDeclaredFields();
	        try {
	            if (declaredFields != null && declaredFields.length > 0) {
	                for (Field field : declaredFields) {
	                    if (field.isAnnotationPresent(DecryptField.class) && field.getType().toString().endsWith("String")) {
	                        field.setAccessible(true);
	                        String fieldValue = (String)field.get(t);
	                        if(StringUtils.isNotEmpty(fieldValue)) {
	                            field.set(t, EncryptDecryptUtil.decryptStrValue(fieldValue));
	                        }
	                    }
	                }
	            }
	        } catch (IllegalAccessException e) {
	            throw new RuntimeException(e);
	        }
        }
         return t;
    }
    
    public static <T> Boolean isEncryptAndDecrypt(T t){
    	Boolean reslut = false;
    	if(t!=null){
    		Object object = t.getClass().getAnnotation(EncryptDecryptClass.class);
        	if(object != null){
        		reslut = true;
        	}
    	}
		return reslut;
    }
}

趟过的坑（敲黑板重点）

1、在实现上述功能后的测试中，其中select查询方法的参数在加密成功后，但是Executor执行器执行方法参数依旧为未加密的参数，找各路大神都没有解决的思路，最后发现项目中引用了开源的分页插件， OffsetLimitInterceptor拦截器把参数设置成为final的，所以自定义拦截器没有修改成功这个sql参数；

解决办法：自定义拦截器放到这个拦截器后，自定义拦截器先执行就可以了


<plugins>
     //就是这个拦截器 
  <plugin interceptor="com.github.miemiedev.mybatis.paginator.OffsetLimitInterceptor">
   <property name="dialectClass" value="com.github.miemiedev.mybatis.paginator.dialect.OracleDialect" />
  </plugin>
  <plugin interceptor="com.ips.fpms.service.encryptinfo.DaoInterceptor" />
 </plugins>

public Object intercept(final Invocation invocation) throws Throwable {
        final Executor executor = (Executor) invocation.getTarget();
        final Object[] queryArgs = invocation.getArgs();
        final MappedStatement ms = (MappedStatement)queryArgs[MAPPED_STATEMENT_INDEX];
        //拦截器把参数设置成为final的，所以自定义拦截器没有修改到这个参数
        final Object parameter = queryArgs[PARAMETER_INDEX];
        final RowBounds rowBounds = (RowBounds)queryArgs[ROWBOUNDS_INDEX];
        final PageBounds pageBounds = new PageBounds(rowBounds);
        final int offset = pageBounds.getOffset();
        final int limit = pageBounds.getLimit();
        final int page = pageBounds.getPage();
        .....省略代码....
        }

2、数据库存量数据处理

在添加拦截器后，必须对数据库的存量数据进行处理，如果不进行处理，查询参数已经加密，但是数据依旧是明文，会导致查询条件不匹配

mybatis Excutor 拦截器的使用

这里要讲的巧妙用法是用来实现在拦截器中执行额外 MyBatis 现有方法的用法。

并且会提供一个解决拦截Executor时想要修改MappedStatement时解决并发的问题。

这里假设一个场景

实现一个拦截器，记录 MyBatis 所有的 insert,update,delete 操作，将记录的信息存入数据库。

这个用法在这里就是将记录的信息存入数据库。

实现过程的关键步骤和代码

1.首先在某个 Mapper.xml 中定义好了一个往日志表中插入记录的方法，假设方法为id="insertSqlLog"。

2.日志表相关的实体类为SqlLog.

3.拦截器签名：


@Intercepts({@org.apache.ibatis.plugin.Signature(
    type=Executor.class, 
    method="update", 
    args={MappedStatement.class, Object.class})})
public class SqlInterceptor implements Interceptor

4.接口方法简单实现：


public Object intercept(Invocation invocation) throws Throwable {
    Object[] args = invocation.getArgs();
    MappedStatement ms = (MappedStatement) args[0];
    Object parameter = args[1];
    SqlLog log = new SqlLog();
    Configuration configuration = ms.getConfiguration();
    Object target = invocation.getTarget();
    StatementHandler handler = configuration.newStatementHandler((Executor) target, ms, 
              parameter, RowBounds.DEFAULT, null, null);
    BoundSql boundSql = handler.getBoundSql();
    //记录SQL
    log.setSqlclause(boundSql.getSql());
    //执行真正的方法
    Object result = invocation.proceed();
    //记录影响行数
    log.setResult(Integer.valueOf(Integer.parseInt(result.toString())));
    //记录时间
    log.setWhencreated(new Date());
    //TODO 还可以记录参数，或者单表id操作时，记录数据操作前的状态
    //获取insertSqlLog方法
    ms = ms.getConfiguration().getMappedStatement("insertSqlLog");
    //替换当前的参数为新的ms
    args[0] = ms;
    //insertSqlLog 方法的参数为 log
    args[1] = log;
    //执行insertSqlLog方法
    invocation.proceed();
    //返回真正方法执行的结果
    return result;
}

重点

MappedStatement是一个共享的缓存对象，这个对象是存在并发问题的，所以几乎任何情况下都不能去修改这个对象（通用Mapper除外），想要对MappedStatement做修改该怎么办呢？

并不难，Executor中的拦截器方法参数中都有MappedStatement ms，这个ms就是后续方法执行要真正用到的MappedStatement，这样一来，问题就容易解决了，根据自己的需要，深层复制MappedStatement对象中自己需要修改的属性，然后修改这部分属性，之后将修改后的ms通过上面代码中args[0]=ms这种方式替换原有的参数，这样就能实现对ms的修改而且不会有并发问题了。

这里日志的例子就是一个更简单的应用，并没有创建ms，只是获取了一个新的ms替换现有的ms，然后去执行。

以上为个人经验，希望能给大家一个参考，也希望大家多多支持编程网。

您可能感兴趣的文档:

--结束END--

本文标题: 使用mybatis拦截器处理敏感字段

本文链接: https://lsjlt.com/news/136445.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com    QQ/279061341

猜你喜欢
  • 使用mybatis拦截器处理敏感字段
    目录mybatis拦截器处理敏感字段前言思路解析代码趟过的坑（敲黑板重点）mybatis Excutor 拦截器的使用这里假设一个场景实现过程的关键步骤和代码重点mybatis拦截器...
    99+
    2024-04-02
  • mybatis-plus 拦截器敏感字段加解密的实现
    目录背景一、查询拦截器二、插入和更新拦截器三、注解背景 数据库在保存数据时，对于某些敏感数据需要脱敏或者加密处理，如果一个一个的去加显然工作量大而且容易出错，这个时候可以考虑使用拦截...
    99+
    2024-04-02
  • mybatis-plus拦截器敏感字段加解密的实现方法是什么
    本篇内容主要讲解“mybatis-plus拦截器敏感字段加解密的实现方法是什么”，感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷，实用性强。下面就让小编来带大家学习“mybatis-plus拦截器敏感字段加解密的实现方法是什么”吧!背景...
    99+
    2023-06-25
  • MyBatis-Plus拦截器对敏感数据实现加密
    目录一、定义注解二、定义拦截器类做课程项目petstore时遇到需要加密属性的问题，而MyBatis-Plus为开发者提供了拦截器的相关接口，用于与数据库交互的过程中实现特定功能，本...
    99+
    2024-04-02
  • MyBatis拦截器的原理与使用
    目录一、拦截对象和接口实现示例二、拦截器注册的三种方式        1.XML注册  &n...
    99+
    2024-04-02
  • mybatis拦截器怎么使用
    今天小编给大家分享一下mybatis拦截器怎么使用的相关知识点，内容详细，逻辑清晰，相信大部分人都还太了解这方面的知识，所以分享这篇文章给大家参考一下，希望大家阅读完这篇文章后有所收获，下面我们一起来了解一下吧。mybatis实战之拦截器在...
    99+
    2023-07-05
  • mybatis-plus拦截器、字段填充器、类型处理器、表名替换、SqlInjector(联合主键处理)
    目录组件介绍表名处理器字段填充器类型处理器补充最近有个练手的小例子，大概就是配置两个数据源，从一个数据源读取数据写到另一个数据源，虽然最后做了出来，但是不支持事务。。。就当是对myb...
    99+
    2024-04-02
  • 阿里云服务器敏感字符处理技巧
    在使用阿里云服务器时，可能会遇到各种敏感字符，这些字符可能会影响服务器的正常运行。因此，了解并掌握处理敏感字符的技巧是非常重要的。本文将详细介绍阿里云服务器中敏感字符的处理方法，帮助用户更好地使用阿里云服务器。 阿里云服务器提供了多种敏感字...
    99+
    2023-12-10
    阿里 字符 敏感
  • java 使用过滤器实现登录拦截处理
    目录滤器实现登录拦截处理一、什么是过滤器二、工作原理及生命周期三、过滤器使用filter简易实现登录功能拦截LoginFlitercontroller结果图滤器实现登录拦截处理 一、...
    99+
    2024-04-02
  • SpringBoot整合Mybatis自定义拦截器不起作用的处理方案
    目录SpringBoot整合Mybatis自定义拦截器不起作用1. 原始的读取mybatis-config.xml文件2. 与SpringBoot容器整合2.1 mybatis的自动...
    99+
    2024-04-02
  • 如何使用Java MyBatis拦截器提高工作效率
    小编给大家分享一下如何使用Java MyBatis拦截器提高工作效率，相信大部分人都还不怎么了解，因此分享这篇文章给大家参考一下，希望大家阅读完这篇文章后大有收获，下面让我们一起去了解一下吧！场景：在后端服务开发时，现在很流行的框...
    99+
    2023-06-29
  • MyBatis-Plus 使用拦截器实现数据权限控制
    前言背景 平时开发中遇到根据当前用户的角色，只能查看数据权限范围的数据需求。列表实现方案有两种，一是在开发初期就做好判断赛选，但如果这个需求是中途加的，或不希望每个接口都加一遍，就可以方案二加拦截器的...
    99+
    2023-09-07
    mybatis java
  • 使用MyBatis返回其它类对象的字段处理
    目录MyBatis返回其它类对象的字段处理需求此时两种处理方式MyBatis返回自定义字段接收1、有时候需要查询的返回的结果不是javaBean的属性2、DAO接口3、后台取值MyB...
    99+
    2024-04-02
  • 如何使用 PHP 函数安全地处理敏感数据？
    如何安全处理 php中的敏感数据要安全地处理php中的敏感数据，需进行以下步骤：加密：将明文转换为不可读的密文。散列：生成固定长度的代码，即使原始数据发生细微变化也会改变。验证用户输入：...
    99+
    2024-04-24
    数据安全 php 敏感数据
  • Spring中拦截器的原理与使用方法
    这篇文章主要讲解了“Spring中拦截器的原理与使用方法”，文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着小编的思路慢慢深入，一起来研究和学习“Spring中拦截器的原理与使用方法”吧！1.Spring中的拦截器在web开发中，拦截...
    99+
    2023-07-02
  • SpringMVC拦截器和异常处理器使用示例超详细讲解
    目录拦截器1、拦截器的配置2、拦截器的三个抽象方法3、多个拦截器的执行顺序异常处理器1、基于配置的异常处理2、基于注解的异常处理拦截器 1、拦截器的配置 SpringMVC中的拦截器...
    99+
    2024-04-02
  • angular如何使用拦截器统一处理http请求和响应
    这篇文章给大家分享的是有关angular如何使用拦截器统一处理http请求和响应的内容。小编觉得挺实用的，因此分享给大家做个参考，一起跟随小编过来看看吧。想使用angularjs里的htpp向后台发送请求,...
    99+
    2024-04-02
  • 一文了解Spring中拦截器的原理与使用
    目录1.Spring中的拦截器1.1HandlerInterceptor拦截器1.2 MethodInterceptor拦截器2.二者的区别1.Spring中的拦截器 在web开发中...
    99+
    2024-04-02
  • Java操作MyBatis-Plus通过自定义拦截器对mysql字段以注解形式实现自动加解密
    一.需求背景 跟大学室友闲谈时，了解到他公司正在做项目内对数据库敏感字段实现自动加解密的需求，使用的技术是Springboot，Mybatis-Plus,MySql等技术栈，加密算法是用的AES，密钥是放在华为云，这里实现一个阉割版的dem...
    99+
    2023-09-06
    mybatis mysql java
  • MySql中怎么使用json_extract函数处理json字段
    这篇“MySql中怎么使用json_extract函数处理json字段”文章的知识点大部分人都不太理解，所以小编给大家总结了以下内容，内容详细，步骤清晰，具有一定的借鉴价值，希望大家阅读完这篇文章能有所收获，下面我们一起来看看这篇“MySq...
    99+
    2023-06-30
软考高级职称资格查询
热门wiki
近期文章
推荐阅读
热门问答
热门标签
编程网，编程工程师的家园，是目前国内优秀的开源技术社区之一，形成了由开源软件库、代码分享、资讯、协作翻译、讨论区和博客等几大频道内容，为IT开发者提供了一个发现、使用、并交流开源技术的平台。

  • 官方手机版

  • 微信公众号

  • 商务合作