springboot+mybatis拦截器+自定义注解实现业务数据权限控制、逻辑删除,支持多表

SpringBoot+MyBatis数据权限实战:基于拦截器的SQL动态过滤方案 数据权限是企业级应用安全架构的核心组成部分,它确保不同角色的用户在同一功能界面下只能访问授权范围内的数据。其实现原理是在数据库查询执行时动态注入过滤条件,从而在数据源头实现访问控制。这一技术对于保障系统安全、满足合规要求具有关键价值,广泛应用于金融、医疗、企业管理等对数据敏感度高的行业场景。通过MyBatis拦截器机制,可以在SQL执行前自动拼接权限条件,实现与业务逻辑的完全解耦。本文结合SpringBoot框架,深入探讨如何设计可解析的权限规则引擎,并解决多表关联、分页查询等工程实践中的典型问题,为构建健 阅读详情

对中途接手一个项目进行改造。

业务数据权限控制实现方案

数据权限控制的核心在于动态SQL过滤,通过注解和拦截器机制实现灵活配置。不同角色需支持不同字段组合的过滤规则,同时保留特殊场景的豁免机制。

注解设计

  • 表级注解标记需过滤的实体类
  • 特殊标记法支持SQL级别的豁免控制

拦截器处理逻辑

  • 解析SQL获取主表别名
  • 识别当前用户角色对应的过滤字段
  • 动态生成WHERE条件片段
  • 处理多表关联时的字段归属问题

逻辑删除技术改造方案

通过拦截器无感改造物理删除为逻辑删除,需保证查询和删除操作的行为一致性,同时避免影响现有业务逻辑。

表结构改造

  • 新增delete_flag作为逻辑删除标志字段
  • 默认值设置为0表示有效数据

删除操作拦截

  • 替换DELETE语句为UPDATE语句
  • 保留原WHERE条件确保范围准确
  • 自动设置删除标志和时间戳

查询操作增强

  • 自动追加未删除条件
  • 支持多表关联查询的场景
  • 保留特殊查询的原始性

注意事项

  • 缓存数据需同步维护删除状态
  • 唯一索引需考虑已删除数据
  • 报表统计需明确数据范围要求

代码:
1、业务数据过滤注解

/**
 * 业务数据过滤注解
 * 如果实体类字段添加了该注解,但是某些查询需要不进行业务数据过滤,可以进行以下操作:
 * 1、如果是QueryWrapper或LambdaQueryWrapper查询,可以追加【.last(CommonConstant.AND_NO_BUSINESS_DATA_AUTO)】
 * 2、如果是编写sql语句查询,可以在where条件中添加【and noBusinessDataAuto】,如果sql定义了表别名,同样添加【and noBusinessDataAuto】,不要需要在【noBusinessDataAuto】之前使用别名
 */
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface BusinessDataAuto {

    /**
     * 数据库列名
     */
    String column();

    /**
     * 登录用户为该角色列表中的一个时才进行过滤
     */
    RoleEnum[] role() default {RoleEnum.SECURITY_ADMIN,RoleEnum.INSTITUTIONAL_LEADER,RoleEnum.FIRST_LEVEL_AUDIT,RoleEnum.SECOND_LEVEL_AUDIT,RoleEnum.EXPERT};

    /**
     * 数据类型
     */
    DateTypeEnum dateType() default DateTypeEnum.USER_ID;

    /**
     * 过滤类型
     */
    QueryWrapperEnum queryType() default QueryWrapperEnum.EQ;

}

2、枚举

/**
 * 角色枚举(枚举最好不要id,这里有id是因为半途接手,历史遗留原因。)
 */
@Getter
@AllArgsConstructor
public enum RoleEnum {
    ADMIN("f6817f48af4fb3af11b9e8bf182f618b","admin", "管理员"),
    OPERATION_MAINTENANCE("1816313867255328769","operation_maintenance", "运维"),
    USER_ADMIN("1851580121292726273","user_admin", "账号管理员"),
    SECURITY_ADMIN("1816313756261462018","security_admin", "保司管理员"),
    INSTITUTIONAL_LEADER("1816313610584895489","institutional_leader", "机构负责人"),
    FIRST_LEVEL_AUDIT("1816379310624133122","first_level_audit", "一级审核人员"),
    SECOND_LEVEL_AUDIT("1828680858725187586","second_level_audit", "二级审核人员"),
    EXPERT("1816313268711370753","expert", "专家");

    private final String id;
    private final String code;
    private final String name;

    public static String getCodeByID(String id){
        for (RoleEnum e : RoleEnum.values()) {
            if (id.startsWith(e.getId())) {
                return e.getCode();
            }
        }
        return null;
    }
}


/**
 * 数据类型枚举
 */
@Getter
@AllArgsConstructor
public enum DateTypeEnum {
    // 部门ID
    DEPART_ID,
    // 部门名称
    DEPART_NAME,
    //部门编码
    DEPART_CODE,
    // 用户ID
    USER_ID,
    // 用户名称
    USER_NAME,
    //角色ID
    ROLE_ID,
    //角色名称
    ROLE_NAME,
    //角色编码
    ROLE_CODE
}

/**
 * QueryWrapper枚举
 */
@Getter
public enum QueryWrapperEnum {
    EQ(EqualsTo::new),
    NE(NotEqualsTo::new),
    GT((column, value) -> new GreaterThan().withLeftExpression(column).withRightExpression(value)),
    LT((column, value) -> new GreaterThan().withLeftExpression(value).withRightExpression(column)),
    GTE((column, value) -> new GreaterThanEquals().withLeftExpression(column).withRightExpression(value)),
    LTE((column, value) -> new GreaterThanEquals().withLeftExpression(value).withRightExpression(column)),
    LIKE((column, value) -> new LikeExpression().withLeftExpression(column).withRightExpression(value));
    //其他类型用到再添加

    private final BiFunction<Column, StringValue, Expression> operation;

    QueryWrapperEnum(BiFunction<Column, StringValue, Expression> operation) {
        this.operation = operation;
    }

    public Expression apply(String field, String value) {
        Column column = new Column(field);
        StringValue stringValue = new StringValue(value);
        return operation.apply(column, stringValue);
    }

}

3、常量

    /**
     * 逻辑删除(0:未删除,1:已删除)
     */
    String DELETE_FLAG = "delete_flag";

	/**
	 * 删除标志
	 */
	Integer DEL_FLAG_1 = 1;

	/**
	 * 未删除
	 */
	Integer DEL_FLAG_0 = 0;

    /**
     * 不进行业务数据权限过滤
     */
    String AND_NO_BUSINESS_DATA_AUTO = " and noBusinessDataAuto";
    String NO_BUSINESS_DATA_AUTO = "noBusinessDataAuto";

4、通用实体类

@Data
public class CommonEntity implements Serializable {
    private static final long serialVersionUID = 1L;

    /** 创建人 */
    @ApiModelProperty(value = "创建人")
    private String createBy;

    /** 创建日期 */
    @ApiModelProperty(value = "创建日期")
    @JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
    @DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
    private Date createTime;

    /** 更新人 */
    @ApiModelProperty(value = "更新人")
    private String updateBy;

    /** 更新日期 */
    @ApiModelProperty(value = "更新日期")
    @JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd HH:mm:ss")
    @DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")
    private Date updateTime;

    /** 逻辑删除标识(0:未删除,1:已删除) */
    @ApiModelProperty(value = "逻辑删除标识(0:未删除,1:已删除)")
    private String deleteFlag;

}

5、mybatis拦截器

/**
 * 业务过滤-mybatis拦截器
 */
@Slf4j
@Intercepts({
        @Signature(type = StatementHandler.class, method = "prepare", args = {Connection.class, Integer.class})
})
@Component
public class BusinessInterceptor implements Interceptor {

    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        StatementHandler statementHandler = (StatementHandler) invocation.getTarget();
        MetaObject metaObject = SystemMetaObject.forObject(statementHandler);
        MappedStatement mappedStatement = (MappedStatement) metaObject.getValue("delegate.mappedStatement");
        // 过滤select查询
        if (SqlCommandType.SELECT.equals(mappedStatement.getSqlCommandType())) {
            return select(invocation);
        }
        // 过滤delete操作
        if (SqlCommandType.DELETE.equals(mappedStatement.getSqlCommandType())){
            return delete(invocation);
        }
        return invocation.proceed();
    }

    @Override
    public Object plugin(Object target) {
        return Plugin.wrap(target, this);
    }

    /**
     * 查询过滤
     * 1、过滤带有BusinessDataAuto注解的实体类查询
     * 2、逻辑删除过滤
     * 3、后续可以添加其他过滤
     */
    public Object select(Invocation invocation)throws Throwable {
        StatementHandler statementHandler = (StatementHandler) invocation.getTarget();
        MetaObject metaObject = SystemMetaObject.forObject(statementHandler);
        MappedStatement mappedStatement = (MappedStatement) metaObject.getValue("delegate.mappedStatement");
        // 获取当前查询的实体类类型
        Class<?> clazz = getEntityClass(mappedStatement);
        if (clazz == null) {
            return invocation.proceed();
        }

        // 解析和修改 SQL
        BoundSql boundSql = statementHandler.getBoundSql();
        String originalSql = boundSql.getSql();
        try {
            Statement statement = CCJSqlParserUtil.parse(originalSql);
            if (statement instanceof Select) {
                Select selectStatement = (Select) statement;
                SelectBody selectBody = selectStatement.getSelectBody();
                if (selectBody instanceof PlainSelect) {
                    PlainSelect plainSelect = (PlainSelect) selectBody;
                    //主表别名,如果是以as定义的别名,这里获取的是as 别名,需要进一步处理,去除as
                    Alias mainTableAlias = plainSelect.getFromItem().getAlias();
                    String aliasName = null;
                    if (mainTableAlias != null) {
                        aliasName = mainTableAlias.getName();
                    }
                    Expression originalWhere = plainSelect.getWhere();

                    //添加逻辑删除过滤逻辑
                    originalWhere = addDeleteFlag(aliasName, plainSelect, originalWhere, clazz);

                    //添加业务数据权限过滤
                    originalWhere = addBusinessDataAuto(aliasName, plainSelect, originalWhere, clazz);

                    // 使用反射更新 BoundSql 中的 SQL
                    updateBoundSqlSql(boundSql, selectStatement.toString());
                }
            }
        } catch (JSQLParserException e) {
            throw new SQLException("解析SQL失败!", e);
        }
        return invocation.proceed();
    }

    /**
     * 将删除sql改为修改sql,物理删除改为逻辑删除
     * 条件:
     * 1、继承CommonEntity类
     * 2、后续如果有要物理删除的业务数据,又继承了CommonEntity类,可以新增一个@NoDeleteFlag注解,存在该注解的实体类不进行逻辑删除
     */
    public Object delete(Invocation invocation)throws Throwable{
        StatementHandler statementHandler = (StatementHandler) invocation.getTarget();
        BoundSql boundSql = statementHandler.getBoundSql();
        String originalSql = boundSql.getSql();
        MappedStatement mappedStatement = (MappedStatement) SystemMetaObject.forObject(statementHandler).getValue("delegate.mappedStatement");
        Class<?> clazz = getEntityClass(mappedStatement);

        try {
            Statement statement = CCJSqlParserUtil.parse(originalSql);
            if (statement instanceof Delete) {
                Delete deleteStatement = (Delete) statement;
                Expression originalWhere = deleteStatement.getWhere();

                // 构造逻辑删除的update语句
                Update updateStatement = new Update();
                updateStatement.setTable(deleteStatement.getTable());

                // 设置逻辑删除字段和值
                if (clazz != null && CommonEntity.class.isAssignableFrom(clazz)) {
                    updateStatement.addUpdateSet(new Column(CommonConstant.DELETE_FLAG), new StringValue(CommonConstant.DEL_FLAG_1.toString()));
                } else {
                    return invocation.proceed();
                }

                // 设置原来的where条件
                updateStatement.setWhere(originalWhere);

                // 更新BoundSql中的SQL
                updateBoundSqlSql(boundSql, updateStatement.toString());
            }
        } catch (JSQLParserException e) {
            log.error("解析SQL失败!", e);
            throw new RuntimeException("解析SQL失败!", e);
        }
        return invocation.proceed();
    }

    /**
     * 添加逻辑删除过滤逻辑
     * 在where条件中拼接delete_flag = 0的条件
     * 条件:
     * 1、继承CommonEntity类
     */
    public Expression addDeleteFlag(Alias alias,PlainSelect plainSelect,Expression originalWhere,Class<?> clazz){
        //判断clazz是否继承CommonEntity类
        if (!CommonEntity.class.isAssignableFrom(clazz)) {
            return originalWhere;
        }

        EqualsTo equals = new EqualsTo();
        String column = aliasName == null ? CommonConstant.DELETE_FLAG : aliasName + "." + CommonConstant.DELETE_FLAG;
        equals.setLeftExpression(new Column(column));
        equals.setRightExpression(new StringValue(CommonConstant.DEL_FLAG_0.toString()));

        if (originalWhere == null) {
            plainSelect.setWhere(equals);
        } else {
            plainSelect.setWhere(new AndExpression(originalWhere, equals));
        }

        return plainSelect.getWhere();
    }

    /**
     * 添加业务数据权限过滤
     * 条件:
     * 1、已登录
     * 2、实体类存在BusinessDataAuto注解
     * 3、原where中不存在noBusinessDataAuto条件
     */
    public Expression addBusinessDataAuto(Alias alias,PlainSelect plainSelect,Expression originalWhere,Class<?> clazz){
        // 检查是否登录,未登录不再进行业务数据权限过滤
        if (!checkLogin()) {
            return originalWhere;
        }

        //校验原where中是否存在noBusinessDataAuto条件
        if (originalWhere != null) {
            Expression newWhere = checkAndRemoveNoBusinessDataAuto(originalWhere);
            //如果原where中存在noBusinessDataAuto条件,则去除该条件,更新where条件,不再进行业务数据权限过滤
            if (!Objects.equals(originalWhere.toString(), newWhere.toString())) {
                plainSelect.setWhere(newWhere);
                return plainSelect.getWhere();
            }
        }

        // 获取实体BusinessDataAuto注解集合
        List<BusinessDataAuto> businessDataAutoList = getBusinessDataAutoList(clazz);
        if (businessDataAutoList.isEmpty()) {
            return originalWhere;
        }
        // 构建数据权限条件
        Expression dataPermissionCondition = buildDataPermissionConditions(alias,businessDataAutoList);
        if (dataPermissionCondition == null) {
            return originalWhere;
        }

        if (originalWhere == null) {
            plainSelect.setWhere(dataPermissionCondition);
        } else {
            plainSelect.setWhere(new AndExpression(originalWhere, dataPermissionCondition));
        }
        return plainSelect.getWhere();
    }

    /**
     * 获取当前查询的实体类类型
     */
    private Class<?> getEntityClass(MappedStatement mappedStatement) {
        try {
            String id = mappedStatement.getId();
            String className = id.substring(0, id.lastIndexOf("."));
            Class<?> mapperClass = Class.forName(className);
            if (!BaseMapper.class.isAssignableFrom(mapperClass)) {
                return null;
            }
            //获取带泛型的父接口
            Type[] interfaces = mapperClass.getGenericInterfaces();
            Type anInterface = interfaces[0];
            ParameterizedType paramType = (ParameterizedType) anInterface;

            //获取父接口的泛型
            Type[] actualTypeArguments = paramType.getActualTypeArguments();
            return (Class<?>) actualTypeArguments[0];
        } catch (ClassNotFoundException e) {
            log.error("获取实体类类型失败!", e);
            return null;
        }
    }

    /**
     * 判断是否登录
     */
    private boolean checkLogin() {
        try {
            SecurityUtils.getSubject().getPrincipal();
        } catch (Exception e) {
            return false;
        }
        return true;
    }

    /**
     * 获取实体类中的BusinessDataAuto注解集合
     */
    private List<BusinessDataAuto> getBusinessDataAutoList(Class<?> entityClass) {
        List<BusinessDataAuto> businessDataAutos = new ArrayList<>();
        for (Field field : entityClass.getDeclaredFields()) {
            BusinessDataAuto businessDataAuto = field.getAnnotation(BusinessDataAuto.class);
            if (businessDataAuto != null) {
                businessDataAutos.add(businessDataAuto);
            }
        }
        return businessDataAutos;
    }

    /**
     * 构建数据过滤表达式
     */
    private Expression buildDataPermissionConditions(Alias alias,List<BusinessDataAuto> businessDataAutoList) {
        Expression expression = null;

        String roleCode = LoginUtil.getRoleCode();
        // 收集数据权限条件
        for (BusinessDataAuto businessDataAuto : businessDataAutoList) {
            RoleEnum[] role = businessDataAuto.role();
            boolean flag = false;//标记是否存在符合的角色
            for (RoleEnum roleEnum : role) {
                if (roleEnum.getCode().equals(roleCode)) {
                    flag = true;
                    break;
                }
            }
            //不存在符合的角色
            if (!flag) {
                continue;
            }
            String column = aliasName == null ? businessDataAuto.column() : aliasName + "." + businessDataAuto.column();
            QueryWrapperEnum queryWrapperEnum = businessDataAuto.queryType();
            String value;
            switch (businessDataAuto.dateType()) {
                case USER_ID:
                    value = LoginUtil.getUserId();
                    break;
                case USER_NAME:
                    value = LoginUtil.getUserName();
                    break;
                case DEPART_ID:
                    value = LoginUtil.getDepartId();
                    break;
                case DEPART_CODE:
                    value = LoginUtil.getDepartCode();
                    break;
                case DEPART_NAME:
                    value = LoginUtil.getDepartName();
                    break;
                case ROLE_ID:
                    value = LoginUtil.getRoleId();
                    break;
                case ROLE_CODE:
                    value = LoginUtil.getRoleCode();
                    break;
                case ROLE_NAME:
                    value = LoginUtil.getRoleName();
                    break;
                default:
                    throw new ServiceException("错误数据类型枚举!");
            }
            expression = queryWrapperEnum.apply(column, value);
        }
        return expression;
    }

    /**
     * 校验原where中是否存在noBusinessDataAuto条件,存在则去除该条件
     */
    private static Expression checkAndRemoveNoBusinessDataAuto(Expression expression) {
        if (expression == null) {
            return null;
        }
        // 括号
        else if (expression instanceof Parenthesis) {
            Parenthesis parenthesis = (Parenthesis) expression;
            Expression parenthesisExpression = checkAndRemoveNoBusinessDataAuto(parenthesis.getExpression());
            return new Parenthesis(parenthesisExpression);
        } else
            // and
            if (expression instanceof AndExpression) {
            AndExpression andExpression = (AndExpression) expression;
            Expression left = checkAndRemoveNoBusinessDataAuto(andExpression.getLeftExpression());
            Expression right = checkAndRemoveNoBusinessDataAuto(andExpression.getRightExpression());
            if (left instanceof ItemsList || right instanceof ItemsList) {
                return new AndExpression(left, right);
            } else if (left == null) {
                return right;
            } else if (right == null) {
                return left;
            } else {
                return new AndExpression(left, right);
            }
        } else
            // or
            if (expression instanceof OrExpression) {
            OrExpression orExpression = (OrExpression) expression;
            Expression left = checkAndRemoveNoBusinessDataAuto(orExpression.getLeftExpression());
            Expression right = checkAndRemoveNoBusinessDataAuto(orExpression.getRightExpression());
            if (left instanceof ItemsList || right instanceof ItemsList) {
                return new OrExpression(left, right);
            } else if (left == null) {
                return right;
            } else if (right == null) {
                return left;
            } else {
                return new OrExpression(left, right);
            }
        } else {
            if (CommonConstant.NO_BUSINESS_DATA_AUTO.equals(expression.toString())) {
                return null;
            }
        }
        return expression;
    }

    /**
     * 修改sql
     */
    private void updateBoundSqlSql(BoundSql boundSql, String newSql) {
        try {
            Field sqlField = BoundSql.class.getDeclaredField("sql");
            sqlField.setAccessible(true);
            sqlField.set(boundSql, newSql);
        } catch (Exception e) {
            throw new RuntimeException("更新BoundSql SQL失败!", e);
        }
    }

}

6、使用示例

1、@BusinessDataAuto注解使用示例1
public class InsurancePolicy extends CommonEntity {
    private static final long serialVersionUID = 1L;

    /**
     * 出单机构id
     */
    @BusinessDataAuto(column = "issue_organ_id",role = RoleEnum.SECURITY_ADMIN,dateType = DateTypeEnum.DEPART_ID)
    private String issueOrganId;

    /**
     * 服务机构id
     */
    @BusinessDataAuto(column = "service_organ_id",role = RoleEnum.INSTITUTIONAL_LEADER,dateType = DateTypeEnum.DEPART_ID)
    private String serviceOrganId;

    /**
     * 专家id
     */
    @BusinessDataAuto(column = "specialist_id",role = RoleEnum.EXPERT)
    private String specialistId;

    ......
}

2、@BusinessDataAuto注解使用示例2
public class ExpertLog extends CommonEntity {
    private static final long serialVersionUID = 1L;

    /**
     * 所属部门
     */
    @BusinessDataAuto(column = "depart_id",dateType = DateTypeEnum.DEPART_ID)
    private java.lang.String departId;

    ......
}

3、不进行过滤查询示例1
DangerReport dangerReport = dangerReportService.getOne(new LambdaQueryWrapper<DangerReport>()
                .eq(DangerReport::getInsurancePolicyId, insuranceServiceItem.getInsurancePolicyId())
                .last(CommonConstant.AND_NO_BUSINESS_DATA_AUTO));

4、不进行过滤查询示例2
select * from danger_report where insurance_policy_id = #{insurancePolicyId} and noBusinessDataAuto 

MyBatis-Plus逻辑删除:数据不再真正删除 逻辑删除是指在数据库中并不真正删除数据,而是通过修改一个标识字段来表示该数据已被"删除"。删除方式数据状态是否可恢复安全性物理删除数据从数据库中彻底消失❌低逻辑删除数据仍保留,仅标记为已删除✅高💡核心优势防止数据被误删除导致无法恢复便于数据的恢复和审计保留历史数据,用于数据分析@Mapper@Mapper。 阅读详情

相关推荐

SpringBoot CRM系统源码全解析:从架构设计到权限控制

在现代企业级应用开发中,SpringBoot凭借其简化配置与内嵌容器特性,已成为Java后端的主流框架选择。而CRM客户关系管理系统作为典型的业务管理系统,其技术架构与权限设计往往反映了真实工程实践中的通用解决方案。基于SpringBoot构建的CRM系统通常采用MyBatis-Plus作为持久层框架,以提升CRUD开发效率;借助Spring Security与JWT实现无状态认证与RBAC权限控制,保障多角色数据安全。同时,数据权限的动态SQL隔离、客户公海机制、状态机流转等设计,也为处理复杂业务场景提供

weixin_34074740的博客 473

mybatisplus删除操作拦截器

mybatisplus 拦截器

qq_39720263的博客 1631

基于python的奥运会历史数据分析【120年】

数据分析实战案例

xff123456_的博客 3339

16-MybatisPlus 逻辑删除拦截器

logic-delete-field: delete_flag -- 删除字段。logic-delete-value: 1 -- 删除值。logic-not-delete-value: 0 -- 保留值。

weixin_68458168的博客 776

AI辅助发明专利撰写实战:30分钟高效生成高质量技术专利文档

在技术专利撰写领域,尤其是软件、算法或系统架构相关的发明专利,如何将创新的技术构思快速、规范地转化为符合《专利法》要求的申请文件,是许多开发者和技术团队面临的共同挑战。传统的人工撰写方式不仅耗时耗力,对撰写人的法律和技术双重背景要求极高,还容易因格式或术语不规范导致审查意见增多。本文将分享一套利用 AI 辅助工具,系统化、高效率地完成一篇高质量发明专利说明书撰写的实战流程。通过清晰的步骤拆解、可复制的提示词(Prompt)工程以及关键注意事项,即使是首次接触专利撰写的开发者,也能在短时间内掌握从技术方案梳理

子夜轻风 966

【AAAI 2025】轻量级特征增强新范式!FCM 模块助力小目标检测,即插即用提升模型泛化能力

本文介绍了AAAI 2025提出的轻量级特征增强新范式FCM模块,它通过显式分离并双向交互语义与空间特征,有效解决了小目标检测中特征信息失配的核心难题。该模块设计精巧,计算开销极低,能够即插即用式地嵌入YOLO等主流检测网络,显著提升模型对小目标的泛化检测能力,尤其适用于遥感、自动驾驶等对计算资源敏感的实际场景。

weixin_29056145的博客 291

【Springboot进阶】springboot+mybatis+jsqlparser实现数据权限控制

完整实现需要根据具体业务需求调整权限条件生成逻辑,建议配合单元测试验证不同场景下的SQL修改效果。

wendao76的专栏 1487

WPF 解决listview值更改时页面没有刷新

WPF 解决listview值更改时页面没有刷新。

weixin_52475977的博客 1386

mybatis逻辑删除拦截器--全局处理xml

mybatis逻辑删除拦截器--全局处理xml。

weixin_38046028的博客 1381

实验5 振幅调制(集成乘法器幅度调制电路)

目录5-1 振荡调制的基本工作原理一.振幅调制和调幅波1.普通调幅波(AM)(1)调幅波的表达式、波形(2)调幅波的频谱2.抑制载波双边带调幅(DSB)3.抑制载波单边带调幅(SSB)二.普通调幅波的产生电路三.抑制载波调幅的产生电路5-2 振幅调制实验电路 5-1 振荡调制的基本工作原理 根据电磁波理论知道,只有频率较高的振荡才能被天线有效地辐射。但是人的讲话声音变换为相应电信号的频率较低,不适于直接从天线上辐射。因此,为了传递信息,就必须将要传递的信息“记载”到高频振荡上去。这一“记载”过程称为调

胡毛毛的博客 3万+

【即插即用模块】注意力篇 | MICCAI 2023 | MFE:多尺度特征提取,告别固定感受野,猛涨2个点!

本文提出一种用于低分辨率乳腺癌病理图像超分辨率与分类的网络SHISRCNet。针对现有方法处理低分辨率图像效果差、感受野固定等问题,设计了多特征提取模块(MFE),通过多速率空洞卷积覆盖全尺度感受野(局部到全局),结合递进残差连接和动态权重融合机制,实现自适应多尺度特征增强。实验表明,该模块在超分辨率任务中PSNR提升近2个点,分类准确率显著提高。代码提供详细注释,支持即插即用,适用于各类多尺度视觉任务。

主要更新底层视觉(去噪、超分等)相关的科研内容,形式为【论文精读】+【论文复现】 208

芝法酱躺平攻略(9)——SpringBoot+mybatisplus的鉴权设计-1

SpringBoot下,使用mybatis-plus实现数据鉴权。

hataksumo的博客 616

UG二次开发GRIP创建drill工序

UG二次开发GRIP创建drill工序

qq285503851的博客 1697

SpringBoot+Vue+MyBatis+MySQL:企业级医院管理系统开发实战

企业级信息管理系统开发中,技术选型与架构设计直接决定项目的稳定性与可维护性。SpringBoot+MyBatis+MySQL这一成熟组合,配合Vue实现前后端分离,是中小型医院信息化建设的常见落地方案。通过清晰的模块划分、合理的索引优化与Redis缓存机制,有效应对高并发挂号、海量数据查询等场景。从业务架构、数据库设计到部署发布,详尽展示了一套完整的企业级开发流程。以医院管理系统为例,深入剖析SpringBoot、MyBatis、Vue等核心技术的实战应用与踩坑经验,为开发者提供可落地的工程实践参考。

weixin_30824479的博客 342

YOLOv8【第十一章:视频追踪与流处理篇·第3节】匈牙利算法(Hungarian Algorithm)与 KM 算法匹配机制详解!

🏆 本文收录于 《YOLOv8实战:从入门到深度优化》 专栏。该专栏系统复现并梳理全网各类 YOLOv8 改进与实战案例(当前已覆盖分类 / 检测 / 分割 / 追踪 / 关键点 / OBB 检测等方向),坚持持续更新 + 深度解析,质量分长期稳定在 97 分以上,可视为当前市面上 覆盖较全、更新较快、实战导向极强 的 YOLO 改进系列内容之一。

**My Coding Family** 451

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

Springboot关于Mybatis的物理删除和逻辑删除

首先介绍何为物理删除,何为逻辑删除. 物理删除即为在前端页面上点击删除按钮后,前端显示数据消失,同时在数据库里面此数据相关信息也被删除消失. 逻辑删除为在前端页面上点击删除按钮后,前端显示数据消失,但数据库里面数据依旧存在. 其实要又物理删除变为逻辑删除是十分简单是事. 首先我们在数据库里面对要操作的表增加一个字段.如图. 当为0时显示数据,当前端点击删除按钮后此字段变为1,前端此条数据记录消失. 我们只需要将Mapper.xml中删除Sql改为如图就行. ...

qq_53314126的博客 1524

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

mybatis中,怎么实现 像那种定义是否删除的通用字段,增删改查数据的时候要自动带上这个通用标识字段?在mybatis plus是是怎么实现的?

2.在mybatis-plus可以通过@TableLogic注解,来设置到字段上,自动实现逻辑删除。1.在mybatis可以使用mybatis的拦截器,在sql执行之前进行设置。

qq_21277357的博客 163

老版QQ原生表情gif动态

这是老版的QQ表情,不过全是动态的的,Windows照片查看器是不会动的,可以右击用浏览器打开查看,再说一遍是老版的,只是分享给宁愿用老版也要动态的人。

android 蓝牙通讯demo

android 下蓝牙通讯demo,实现了发现蓝牙,使能蓝牙,通过蓝牙发送消息。

安全框架SpringSecurity进阶【详解,附有图文+示例代码】

一般Web应用的需要进行认证和授权。认证原理分析:Spring Security过虑器链结构图:如果前后端分离时 则这个过滤器不能直接使用,需要自定义一个登录校验流程内置认证过滤器的核心流程:核心流程梳理如下:概念速查:登录自定义用户详情类实现在自定的这个类中去数据库查询用户信息自定义登录接口底层调用ProvideManager的方法进行认证,认证成功生成jwt,存储用户信息(存redis)在SpringSecurity配置

Java技术加油站的博客 1462

Springboot 配置文件、隐私数据脱敏的最佳实践(原理+源码)

https://blog.youkuaiyun.com/u013905744/article/details/86508236

程序员内点事 1648

springboot自定义注解+mybatis拦截器-数据权限设计

针对部分业务功能数据需要实现数据权限控制,数据关系比较复杂,有多表关联查询的场景,查阅一番资料,使用Mybatis拦截器--Interceptor,通过实现Interceptor接口,结合自定义注解,实现数据权限控制。............

qq_24473507的博客 3398

自定义注解+mybatis拦截器实现权限控制

通过自定义注解+mybaits拦截器,实现在不更改xml内容的情况下,动态添加权限sql实现权限过滤

qq_42059717的博客 2691

SpringBoot 实现假删除(逻辑删除)

当程序中运行删除操作时触发逻辑删除,从表中删除数据的操作不会生效,但需要写上删除代码。2.application.yml配置文件,配置全局逻辑删除规则 1为已删除,0为没有删除。注:如果某一张表不想跟随全局逻辑删除的规则,也可在注解上自定义。执行时优先注解的规则。逻辑删除就是在数据表中新建一个字段,删除时更改为0或1。并没有真的把数据给删掉.1.mybatis-plus版本在3.1.1以上,可省略一步配置。3.实体类绑定逻辑删除字段注解。

weixin_47009272的博客 1830

芋道源码解析之数据权限

文章首发于我的博客:https://blog.liuzijian.com/post/source-code-yudao-data-permission.html 博主和芋道源码作者及其官方开发团队无任何关联 一、引言 芋道的数据权限模块代码,涉及的类和方法很多,环环相扣,需要运行项目一步一步debu

fenfenfen520a的博客 838

一文讲透企业级权限管理:RBAC+数据权限+多租户隔离——SpringBoot+Vue3 权限体系设计全解析

深度拆解企业级权限管理体系的设计方法论。从RBAC经典四表模型到数据权限的MyBatis拦截器自动注入,从多租户套餐隔离到OAuth2无Session认证链路,完整还原一套"功能权限+数据权限+租户隔离"三位一体的权限架构。涵盖后端Spring Security校验链路、前端动态路由与按钮级权限控制,附核心代码实现与表结构设计。

RuoYi Office是基于 Spring Cloud Alibaba + Gateway + Nacos + RocketMQ + Vue3 + Vben Admin + Uniapp 构建的中小企业全业务办公一体化平台,涵盖OA 协同 1832

JAVA - Sql解析工具jsqlparser简单使用

jsqlparser地址:https://github.com/JSQLParser/JSqlParser SqlParser.jar:http://search.maven.org/remotecontent?filepath=com/github/jsqlparser/jsqlparser/0.9.1/jsqlparser-0.9.1.jar

偶尔记一下 - mybatis.io 8万+
下一篇: java设计者模式:策略模式+工厂模式
String_001
博客等级 码龄5年 16粉丝 10原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值