java实现数据隔离

最新推荐文章于 2024-06-13 08:37:22 发布
最新推荐文章于 2024-06-13 08:37:22 发布
阅读量234 收藏
点赞数 1
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/later_home/article/details/136968133
版权 
package com.nuzar.fcms.common.core.interceptor.mybatis;

import com.baomidou.mybatisplus.core.plugins.InterceptorIgnoreHelper;
import com.baomidou.mybatisplus.core.toolkit.*;
import com.baomidou.mybatisplus.extension.parser.JsqlParserSupport;
import com.baomidou.mybatisplus.extension.plugins.inner.InnerInterceptor;
import com.baomidou.mybatisplus.extension.toolkit.PropertyMapper;
import com.nuzar.cloud.mapper.handler.DataScopeHandler;
import lombok.Data;
import net.sf.jsqlparser.expression.*;
import net.sf.jsqlparser.expression.operators.conditional.AndExpression;
import net.sf.jsqlparser.expression.operators.conditional.OrExpression;
import net.sf.jsqlparser.expression.operators.relational.*;
import net.sf.jsqlparser.schema.Column;
import net.sf.jsqlparser.schema.Table;
import net.sf.jsqlparser.statement.delete.Delete;
import net.sf.jsqlparser.statement.insert.Insert;
import net.sf.jsqlparser.statement.select.*;
import net.sf.jsqlparser.statement.update.Update;
import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.executor.statement.StatementHandler;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.SqlCommandType;
import org.apache.ibatis.session.ResultHandler;
import org.apache.ibatis.session.RowBounds;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.*;

/**
 * @description: <p>
 *
 * </p>
 * @author: ZhangZh
 * @time: 2023/5/30
 */
@Data
public class TermCodeInterceptor extends JsqlParserSupport implements InnerInterceptor {
    private TemrCodeHandler temrCodeHandler;

    @Override
    public void beforeQuery(Executor executor, MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
        if (InterceptorIgnoreHelper.willIgnoreTenantLine(ms.getId())) return;
        PluginUtils.MPBoundSql mpBs = PluginUtils.mpBoundSql(boundSql);
        mpBs.sql(parserSingle(mpBs.sql(), null));
    }

    @Override
    public void beforePrepare(StatementHandler sh, Connection connection, Integer transactionTimeout) {
        PluginUtils.MPStatementHandler mpSh = PluginUtils.mpStatementHandler(sh);
        MappedStatement ms = mpSh.mappedStatement();
        SqlCommandType sct = ms.getSqlCommandType();
//        if (sct == SqlCommandType.INSERT || sct == SqlCommandType.UPDATE || sct == SqlCommandType.DELETE) {
        if (sct == SqlCommandType.UPDATE || sct == SqlCommandType.DELETE) {
            if (InterceptorIgnoreHelper.willIgnoreTenantLine(ms.getId())) return;
            PluginUtils.MPBoundSql mpBs = mpSh.mPBoundSql();
            mpBs.sql(parserMulti(mpBs.sql(), null));
        }
    }

    @Override
    protected void processSelect(Select select, int index, String sql, Object obj) {
        processSelectBody(select.getSelectBody());
        List<WithItem> withItemsList = select.getWithItemsList();
        if (!CollectionUtils.isEmpty(withItemsList)) {
            withItemsList.forEach(this::processSelectBody);
        }
    }

    protected void processSelectBody(SelectBody selectBody) {
        if (selectBody == null) {
            return;
        }
        if (selectBody instanceof PlainSelect) {
            processPlainSelect((PlainSelect) selectBody);
        } else if (selectBody instanceof WithItem) {
            WithItem withItem = (WithItem) selectBody;
            processSelectBody(withItem.getSubSelect().getSelectBody());
        } else {
            SetOperationList operationList = (SetOperationList) selectBody;
            List<SelectBody> selectBodys = operationList.getSelects();
            if (CollectionUtils.isNotEmpty(selectBodys)) {
                selectBodys.forEach(this::processSelectBody);
            }
        }
    }

    @Override
    protected void processInsert(Insert insert, int index, String sql, Object obj) {
        return;
    }

    /**
     * update 语句处理
     */
    @Override
    protected void processUpdate(Update update, int index, String sql, Object obj) {
        final Table table = update.getTable();
        if (temrCodeHandler.ignoreTable(table.getName())) {
            // 过滤退出执行
            return;
        }
        update.setWhere(this.andExpression(table, update.getWhere()));
    }

    /**
     * delete 语句处理
     */
    @Override
    protected void processDelete(Delete delete, int index, String sql, Object obj) {
        if (temrCodeHandler.ignoreTable(delete.getTable().getName())) {
            // 过滤退出执行
            return;
        }
        delete.setWhere(this.andExpression(delete.getTable(), delete.getWhere()));
    }

    /**
     * delete update 语句 where 处理
     */
    protected BinaryExpression andExpression(Table table, Expression where) {
        //获得where条件表达式
        InExpression inExpression = new InExpression();
        inExpression.setLeftExpression(this.getAliasColumn(table));
        inExpression.setRightItemsList(temrCodeHandler.getTermCodeList());
        if (null != where) {
            if (where instanceof OrExpression) {
                return new AndExpression(inExpression, new Parenthesis(where));
            } else {
                return new AndExpression(inExpression, where);
            }
        }
        return new AndExpression(inExpression, null);
    }


    /**
     * 处理 insert into select
     * <p>
     * 进入这里表示需要 insert 的表启用了多租户,则 select 的表都启动了
     *
     * @param selectBody SelectBody
     */
    protected void processInsertSelect(SelectBody selectBody) {
        PlainSelect plainSelect = (PlainSelect) selectBody;
        FromItem fromItem = plainSelect.getFromItem();
        if (fromItem instanceof Table) {
            // fixed gitee pulls/141 duplicate update
            processPlainSelect(plainSelect);
            appendSelectItem(plainSelect.getSelectItems());
        } else if (fromItem instanceof SubSelect) {
            SubSelect subSelect = (SubSelect) fromItem;
            appendSelectItem(plainSelect.getSelectItems());
            processInsertSelect(subSelect.getSelectBody());
        }
    }

    /**
     * 追加 SelectItem
     *
     * @param selectItems SelectItem
     */
    protected void appendSelectItem(List<SelectItem> selectItems) {
        if (CollectionUtils.isEmpty(selectItems)) return;
        if (selectItems.size() == 1) {
            SelectItem item = selectItems.get(0);
            if (item instanceof AllColumns || item instanceof AllTableColumns) return;
        }
        selectItems.add(new SelectExpressionItem(new Column(temrCodeHandler.getTermCodeColumn())));
    }

    /**
     * 处理 PlainSelect
     */
    protected void processPlainSelect(PlainSelect plainSelect) {
        FromItem fromItem = plainSelect.getFromItem();
        Expression where = plainSelect.getWhere();
        processWhereSubSelect(where);
        if (fromItem instanceof Table) {
            Table fromTable = (Table) fromItem;
            if (!temrCodeHandler.ignoreTable(fromTable.getName())) {
                //#1186 github
                plainSelect.setWhere(builderExpression(where, fromTable));
            }
        } else {
            processFromItem(fromItem);
        }
        //#3087 github
        List<SelectItem> selectItems = plainSelect.getSelectItems();
        if (CollectionUtils.isNotEmpty(selectItems)) {
            selectItems.forEach(this::processSelectItem);
        }
        List<Join> joins = plainSelect.getJoins();
        if (CollectionUtils.isNotEmpty(joins)) {
            processJoins(joins);
        }
    }

    /**
     * 处理where条件内的子查询
     * <p>
     * 支持如下:
     * 1. in
     * 2. =
     * 3. >
     * 4. <
     * 5. >=
     * 6. <=
     * 7. <>
     * 8. EXISTS
     * 9. NOT EXISTS
     * <p>
     * 前提条件:
     * 1. 子查询必须放在小括号中
     * 2. 子查询一般放在比较操作符的右边
     *
     * @param where where 条件
     */
    protected void processWhereSubSelect(Expression where) {
        if (where == null) {
            return;
        }
        if (where instanceof FromItem) {
            processFromItem((FromItem) where);
            return;
        }
        if (where.toString().indexOf("SELECT") > 0) {
            // 有子查询
            if (where instanceof BinaryExpression) {
                // 比较符号 , and , or , 等等
                BinaryExpression expression = (BinaryExpression) where;
                processWhereSubSelect(expression.getLeftExpression());
                processWhereSubSelect(expression.getRightExpression());
            } else if (where instanceof InExpression) {
                // in
                InExpression expression = (InExpression) where;
                ItemsList itemsList = expression.getRightItemsList();
                if (itemsList instanceof SubSelect) {
                    processSelectBody(((SubSelect) itemsList).getSelectBody());
                }
            } else if (where instanceof ExistsExpression) {
                // exists
                ExistsExpression expression = (ExistsExpression) where;
                processWhereSubSelect(expression.getRightExpression());
            } else if (where instanceof NotExpression) {
                // not exists
                NotExpression expression = (NotExpression) where;
                processWhereSubSelect(expression.getExpression());
            } else if (where instanceof Parenthesis) {
                Parenthesis expression = (Parenthesis) where;
                processWhereSubSelect(expression.getExpression());
            }
        }
    }

    protected void processSelectItem(SelectItem selectItem) {
        if (selectItem instanceof SelectExpressionItem) {
            SelectExpressionItem selectExpressionItem = (SelectExpressionItem) selectItem;
            if (selectExpressionItem.getExpression() instanceof SubSelect) {
                processSelectBody(((SubSelect) selectExpressionItem.getExpression()).getSelectBody());
            } else if (selectExpressionItem.getExpression() instanceof Function) {
                processFunction((Function) selectExpressionItem.getExpression());
            }
        }
    }

    /**
     * 处理函数
     * <p>支持: 1. select fun(args..) 2. select fun1(fun2(args..),args..)<p>
     * <p> fixed gitee pulls/141</p>
     *
     * @param function
     */
    protected void processFunction(Function function) {
        ExpressionList parameters = function.getParameters();
        if (parameters != null) {
            parameters.getExpressions().forEach(expression -> {
                if (expression instanceof SubSelect) {
                    processSelectBody(((SubSelect) expression).getSelectBody());
                } else if (expression instanceof Function) {
                    processFunction((Function) expression);
                }
            });
        }
    }

    /**
     * 处理子查询等
     */
    protected void processFromItem(FromItem fromItem) {
        if (fromItem instanceof SubJoin) {
            SubJoin subJoin = (SubJoin) fromItem;
            if (subJoin.getJoinList() != null) {
                processJoins(subJoin.getJoinList());
            }
            if (subJoin.getLeft() != null) {
                processFromItem(subJoin.getLeft());
            }
        } else if (fromItem instanceof SubSelect) {
            SubSelect subSelect = (SubSelect) fromItem;
            if (subSelect.getSelectBody() != null) {
                processSelectBody(subSelect.getSelectBody());
            }
        } else if (fromItem instanceof ValuesList) {
            logger.debug("Perform a subquery, if you do not give us feedback");
        } else if (fromItem instanceof LateralSubSelect) {
            LateralSubSelect lateralSubSelect = (LateralSubSelect) fromItem;
            if (lateralSubSelect.getSubSelect() != null) {
                SubSelect subSelect = lateralSubSelect.getSubSelect();
                if (subSelect.getSelectBody() != null) {
                    processSelectBody(subSelect.getSelectBody());
                }
            }
        }
    }

    /**
     * 处理 joins
     *
     * @param joins join 集合
     */
    private void processJoins(List<Join> joins) {
        //对于 on 表达式写在最后的 join，需要记录下前面多个 on 的表名
        Deque<Table> tables = new LinkedList<>();
        for (Join join : joins) {
            // 处理 on 表达式
            FromItem fromItem = join.getRightItem();
            if (fromItem instanceof Table) {
                Table fromTable = (Table) fromItem;
                // 获取 join 尾缀的 on 表达式列表
                Collection<Expression> originOnExpressions = join.getOnExpressions();
                // 正常 join on 表达式只有一个，立刻处理
                if (originOnExpressions.size() == 1) {
                    processJoin(join);
                    continue;
                }
                // 当前表是否忽略
                boolean needIgnore = temrCodeHandler.ignoreTable(fromTable.getName());
                // 表名压栈，忽略的表压入 null，以便后续不处理
                tables.push(needIgnore ? null : fromTable);
                // 尾缀多个 on 表达式的时候统一处理
                if (originOnExpressions.size() > 1) {
                    Collection<Expression> onExpressions = new LinkedList<>();
                    for (Expression originOnExpression : originOnExpressions) {
                        Table currentTable = tables.poll();
                        if (currentTable == null) {
                            onExpressions.add(originOnExpression);
                        } else {
                            onExpressions.add(builderExpression(originOnExpression, currentTable));
                        }
                    }
                    join.setOnExpressions(onExpressions);
                }
            } else {
                // 处理右边连接的子表达式
                processFromItem(fromItem);
            }
        }
    }

    /**
     * 处理联接语句
     */
    protected void processJoin(Join join) {
        if (join.getRightItem() instanceof Table) {
            Table fromTable = (Table) join.getRightItem();
            if (temrCodeHandler.ignoreTable(fromTable.getName())) {
                // 过滤退出执行
                return;
            }
            // 走到这里说明 on 表达式肯定只有一个
            Collection<Expression> originOnExpressions = join.getOnExpressions();
            List<Expression> onExpressions = new LinkedList<>();
            onExpressions.add(builderExpression(originOnExpressions.iterator().next(), fromTable));
            join.setOnExpressions(onExpressions);
        }
    }

    /**
     * 处理条件
     */
    protected Expression builderExpression(Expression currentExpression, Table table) {
        if (this.getTemrCodeHandler().getTermCodeList() == null && this.getTemrCodeHandler().getTermCodeColumn() == null) {
            return currentExpression;
        } else {
            InExpression inExpression = new InExpression();
            inExpression.setLeftExpression(this.getAliasColumn(table));
            inExpression.setRightItemsList(temrCodeHandler.getTermCodeList());
            if (currentExpression == null) {
                return inExpression;
            }
            if (currentExpression instanceof OrExpression) {
                return new AndExpression(new Parenthesis(currentExpression), inExpression);
            } else {
                return new AndExpression(currentExpression, inExpression);
            }
        }
    }

    /**
     * 租户字段别名设置
     * <p>tenantId 或 tableAlias.tenantId</p>
     *
     * @param table 表对象
     * @return 字段
     */
    protected Column getAliasColumn(Table table) {
        StringBuilder column = new StringBuilder();
        if (table.getAlias() != null) {
            column.append(table.getAlias().getName()).append(StringPool.DOT);
        }
        column.append(temrCodeHandler.getTermCodeColumn());
        return new Column(column.toString());
    }

//    @Override
//    public void setProperties(Properties properties) {
//        PropertyMapper.newInstance(properties).whenNotBlank("temrCodeHandler",
//                ClassUtils::newInstance, this::settemrCodeHandler);
//    }

    public interface TemrCodeHandler {
        default String getTermCodeColumn() {
            return "term_code";
        }
        default boolean ignoreTable(String tableName) {
            return false;
        }
        ItemsList getTermCodeList();
    }
}

拦截器

fcms:
  tenant:
    enable: true
  idgen:
    enabled: true
  mybatis:
    dbSupportAutoKey: true  #mysql启用此配置
    tenant:
      enable: true
      ignore-tenant-type: port,terminal #忽略的客户类型代码
    term:
      enable: true
      include-tables:
        - STD_SCHEDULES
        - STD_VOYAGES
        - STD_BERTHES
        - WEB_PAS_PLANS
        - CBS_CHARGE_BILLS
        - CBS_CHARGE_INVOICES
        - CBS_INVOICELIST_VW
        - CBS_INCOME_CAMT_VW
      ignore-tables:
        - STD_REF_CODES
        - DUAL
      term-column: TERM_CODE
      tenant-channel-type: TERM_CODE
      suit-tenant-type: terminal #适用的客户类型代码
      permit-all-code: default,SUPER,LJ,HFG #拥有所有数据权限的客户代码
package com.nuzar.fcms.common.core.config;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;

import java.util.List;

/**
 * @description: <p>
 *
 * </p>
 * @author: ZhangZh
 * @time: 2023/5/30
 */
@ConfigurationProperties(
        prefix = "fcms.mybatis"
)
@Data
public class FcmsMybatisProperties {

    public static final String PREFIX = "fcms.mybatis";
    private Term term;
    private Tenant tenant;
    private Boolean dbSupportAutoKey = false; // 数据库是否支持自动主键，oracle false, mysql true

    @Data
    public static class Tenant {
        private Boolean enable = false;
        private List<String> ignoreTenantType;
    }

    @Data
    public static class Term {
        private Boolean enable = false;
        private String termColumn = "term_code";
        private List<String> includeTables;
        private List<String> ignoreTables;
        private List<String> tenantChannelType;
        private List<String> suitTenantType;
        private List<String> permitAllCode;
    }
}

    @Bean
    public FcmsMybatisInterceptor fcmsMybatisPlusInterceptor(final FcmsMybatisProperties mybatisProperties, final NuzarMybatisConfig mybatisConfig, final EnvSupplier envSupplier, MybatisPlusInterceptor mybatisPlusInterceptor) {
        FcmsMybatisInterceptor interceptor = new FcmsMybatisInterceptor(mybatisProperties);
        interceptor.init(mybatisConfig, envSupplier, mybatisPlusInterceptor);
        return interceptor;
    }
package com.nuzar.fcms.common.core.interceptor.mybatis;

import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.handler.TenantLineHandler;
import com.baomidou.mybatisplus.extension.plugins.inner.InnerInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.TenantLineInnerInterceptor;
import com.nuzar.cloud.common.exception.BizException;
import com.nuzar.cloud.common.utils.CollectionUtils;
import com.nuzar.cloud.property.NuzarMybatisConfig;
import com.nuzar.cloud.service.EnvSupplier;
import com.nuzar.common.security5.common.util.SecurityUtils;
import com.nuzar.fcms.common.core.business.utils.TermUtils;
import com.nuzar.fcms.common.core.business.utils.Utils;
import com.nuzar.fcms.common.core.config.FcmsMybatisProperties;
import com.nuzar.fcms.common.core.context.MybatisTenantContext;
import lombok.extern.slf4j.Slf4j;
import net.sf.jsqlparser.expression.Expression;
import net.sf.jsqlparser.expression.StringValue;
import net.sf.jsqlparser.expression.operators.relational.ExpressionList;
import net.sf.jsqlparser.expression.operators.relational.ItemsList;

import java.util.LinkedList;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;

/**
 * @description: <p>
 *
 * </p>
 * @author: ZhangZh
 * @time: 2023/5/30
 */
@Slf4j
public class FcmsMybatisInterceptor {

    private FcmsMybatisProperties mybatisProperties;

    public FcmsMybatisInterceptor(FcmsMybatisProperties mybatisProperties) {
        this.mybatisProperties = mybatisProperties;
    }

    public void init(final NuzarMybatisConfig mybatisConfig, final EnvSupplier envSupplier, MybatisPlusInterceptor mybatisPlusInterceptor) {
        // 替换原TenantLineInnerInterceptor
        TenantListLineInnerInterceptor tenantLineInnerInterceptor = new TenantListLineInnerInterceptor();
        if (mybatisConfig.getTenant().getEnabled() && mybatisProperties.getTenant().getEnable()) {
            tenantLineInnerInterceptor.setTenantListHandler(new TenantListLineInnerInterceptor.TenantListHandler() {
                public ItemsList getTenantIdList() {
//                    List<String> tenantIdList = new ArrayList<>();
                    try {
                        String tenantId = SecurityUtils.getTenant();
                        return new ExpressionList(Utils.getComposedTenantIdList(tenantId).stream()
                                .map(StringValue::new).collect(Collectors.toList()));
                    } catch (Exception e) {
                        log.error(e.getMessage());
                        throw new BizException("租户权限加载失败");
                    }
                }
            });

            tenantLineInnerInterceptor.setTenantLineHandler(new TenantLineHandler() {

                public String getTenantIdColumn() {
                    return mybatisConfig.getTenant().getTenantColumn();
                }

                public boolean ignoreTable(String tableName) {

                    //是否忽略租户
                    if (Objects.nonNull(MybatisTenantContext.get())){
                        log.info("是否做租户隔离:{}",MybatisTenantContext.get());
                        return MybatisTenantContext.get();
                    }


                    if (mybatisConfig.getTenant().getPermitAllCode() != null
                            && mybatisConfig.getTenant().getPermitAllCode().contains(envSupplier.supply())
                            || Utils.isAdminTenant(SecurityUtils.getTenant())) {
                        return true;
                    } else if (mybatisConfig.getTenant().getIncludeTables() != null) {
                        return mybatisConfig.getTenant().getIncludeTables() == null
                                || !mybatisConfig.getTenant().getIncludeTables().contains(tableName);
                    } else if (mybatisConfig.getTenant().getIgnoreTables() == null) {
                        return false;
                    } else {
                        return mybatisConfig.getTenant().getIgnoreTables() != null
                                && mybatisConfig.getTenant().getIgnoreTables().contains(tableName);
                    }
                }

                public Expression getTenantId() {
                    return new StringValue(envSupplier.supply());
                }
            });
        }
        TermCodeInterceptor termCodeInterceptor = new TermCodeInterceptor();
        if (mybatisProperties.getTerm().getEnable()) {
            log.info(mybatisProperties.getTerm().toString());
            termCodeInterceptor.setTemrCodeHandler(new TermCodeInterceptor.TemrCodeHandler() {
                @Override
                public ItemsList getTermCodeList() {
                    List<String> list = TermUtils.getTermScopeList();
                    if (CollectionUtils.isEmpty(list)) {
                        list.add("default");
                    }
                    return new ExpressionList(list.stream()
                            .map(StringValue::new).collect(Collectors.toList()));
                }

                @Override
                public String getTermCodeColumn() {
                    return mybatisProperties.getTerm().getTermColumn()!=null ? mybatisProperties.getTerm().getTermColumn()
                            : TermCodeInterceptor.TemrCodeHandler.super.getTermCodeColumn();
                }

                @Override
                public boolean ignoreTable(String tableName) {
                    if (mybatisProperties.getTerm().getPermitAllCode() != null
                            && mybatisProperties.getTerm().getPermitAllCode().contains(envSupplier.supply())){
                        return true;
                    } else if (mybatisProperties.getTerm().getIncludeTables()!=null) {
                        return !(mybatisProperties.getTerm().getIncludeTables().contains(tableName)
                                && TermUtils.suitTenantTypeForScope(mybatisProperties.getTerm().getSuitTenantType()));
                    } else if (mybatisProperties.getTerm().getIncludeTables()!=null) {
                        return mybatisProperties.getTerm().getIgnoreTables().contains(tableName)
                                || !TermUtils.suitTenantTypeForScope(mybatisProperties.getTerm().getSuitTenantType());
                    }
                    return !TermUtils.suitTenantTypeForScope(mybatisProperties.getTerm().getSuitTenantType());
                }

//                private boolean suitTenantType(List<String> suitTenantTypes) {
//                    if (CollectionUtils.isEmpty(suitTenantTypes)) {
//                        return true;
//                    }
//                    List<String> tenantTypes = Utils.getTenantTypes(SecurityUtils.getTenant());
//                    return tenantTypes.stream().anyMatch(t->{
//                        return suitTenantTypes.contains(t);
//                    });
//                }
            });
        }
        // 原顺序添加interceptors，最后加上termCodeInterceptor
        List<InnerInterceptor> interceptors = new LinkedList<>(mybatisPlusInterceptor.getInterceptors());
        int i = 0;
        for (;i<interceptors.size();i++) {
            InnerInterceptor interceptor = interceptors.get(i);
            if (interceptor instanceof TenantLineInnerInterceptor) {
                break;
            }
        }
        if (i<interceptors.size()) {
            interceptors.set(i, tenantLineInnerInterceptor);
            mybatisPlusInterceptor.setInterceptors(interceptors);
            if (mybatisProperties.getTerm().getEnable()) {
                interceptors.add(i, termCodeInterceptor);
            }
        } else if (mybatisProperties.getTerm().getEnable()) {
            interceptors.add(0, termCodeInterceptor);
        }
        // 数据库兼容性keyGenerator拦截处理
        mybatisPlusInterceptor.addInnerInterceptor(new KeyGeneratorResetInterceptor(mybatisProperties));
    }
}

yoo pur tur
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java如何实现消费数据隔离？
wdj_yyds的博客
02-17 3947
我是3y，一年CRUD经验用十年的markdown程序员????????‍????常年被誉为优质八股文选手 今天继续更新austin项目，如果还没看过该系列的同学可以点开我的历史文章回顾下，在看的过程中不要忘记了点赞哟！建议不要漏了或者跳着看，不然这篇就看不懂了，之前写过的知识点和业务我就不再赘述啦。 今天要实现的是handler模块的消费数据隔离。在聊这个之前，先看下之前的实现是怎么样的。 austin-api接收到了请求之后，将请求发往Kafka，topicName为austin。而在au
java后台数据隔离实现方式
01-26
配置角色的隔离方式：所有数据、本部门数据、本部门及其以下部门部署、自定义数据、本人数据； 通过aop实现。可以根据实际需求修改； 包含配置流程和所需的所有java和xml文件；
20190123——傻子 Java解释器模式
寄蜉蝣于天地，渺沧海之一粟。
01-23 153
解释器模式提供了一种评估计算语言语法或表达式的方法，这种类型的模式属于行为模式。这种模式涉及实现了一个表达式接口，它告诉解释一个指定的上下文。此模式用于SQL解析，符号处理引擎等。 实现实例 我们将创建一个借口而Expression并在这个具体的类实现这个Expression接口，定义了一个TerminalExpression类，用作所讨论的上下文的主解释器，其他的类，orExpression和A...
java.lang.NoSuchMethodError: net.sf.jsqlparser.statement.select.WithItem.getSubSelect()
qq_38513286的博客
10-11 337
【代码】java.lang.NoSuchMethodError: net.sf.jsqlparser.statement.select.WithItem.getSubSelect()
JSqlParser入门系列(5)-JSqlParser之SelectBody
记录知识、锤炼自我
11-08 3957
SelectBody接口 Select对象 在之前的案例中，我们尝试解析了各种SQL语句，比如以下代码，将一个查询语句解析为了Select对象： String SQL002 = "SELECT t1.a , t1.b FROM tab1 AS t1 JOIN tab2 t2 ON t1.user_id = t2.user_id"; // 多表SQL // 1. Select select = (Select) CCJSqlParserUtil.par
Statement和Expression的用法
qingmuluoyang的博客
07-18 4680
简单的描叙：       1.Statement 对象表示基本语句，其中将单个方法应用于某一目标和一组参数，以返回结果，比如 "a.setFoo(b)"。注意，此示例使用名称来指示目标及其参数，statement 对象不需要名称空间，可以使用值本身构造。statement 对象将指定方法与其环境相关联，作为值的简单集合：目标和参数值数组                       2.Ex
关于mongodb的对每天产生新数据的分组查询问题,涉及mongoTemplate的andExpression表达式
叶叶叶叶大爷的博客
07-16 6059
需求:    现有一个记录表,表中每天有新数据生成, 其中有个一字段是date 类型的'createAt', 目前要做一个折线统计来统计每天新增记录的走向.问题所在:    mongodb存的日期是国际事件,和中国时间存在八小时的时差(北京为东八区).低版本的mongodb没有支持对时区的处理,采用的是$add函数,好了,放一段代码吧,心累:TypedAggregation&lt;Post&gt;...
Java ThreadLocal | 实现线程之间数据隔离
阳光大男孩！！！的博客
01-27 1637
前言 ThreadLocal的作用主要是做线程之间的数据隔离，原理 ???? 在于每个线程保留一份自己的数据，所以数据对别的线程而言是相对隔离的，在多线程环境下，能够防止自己的变量被其它线程篡改。 简单使用一下 public class Test { public static void main(String[] args) { // 声明ThreadLocal ThreadLocal<String> threadLocal = new ThreadLo
基于mybatis-plus实现多租户级别的数据隔离
04-07
基于idea+maven创建工程； 采用mysql+mybatis-plus+druid实现； 解包配置数据库后，即可运行示例；
基于Java的云平台居家隔离健康监测系统设计源码
06-07
该系统利用Java语言开发，旨在为居家隔离人员提供实时健康监测服务，通过云平台实现数据的集中管理和分析，支持体温监测、健康状况上报、健康咨询等功能。项目结构清晰，代码注释详尽，易于理解和集成，适用于疫情...
java-新冠疫情数据统计系统.zip
04-09
java语言实现新冠疫情数据统计系统 系统复现参考地址：https://blog.csdn.net/weixin_43042683/article/details/130035778?spm=1001.2014.3001.5501 主要的页面和功能： 1.系统首页，包括目前确诊人数，治愈率，现存...
Java项目基于Springboot实现的新冠病毒密接者跟踪系统
05-30
跨部门协作：系统支持多部门间的数据共享和协作，如与医疗机构、社区服务中心等建立数据接口，实现信息的快速传递和共享。 隐私保护：系统严格遵守数据保护法规，对用户隐私信息进行加密处理，确保在追踪管理过程中...
简单的项目部署脚本（转载）
u010230019的博客
06-09 592
有些项目团队喜欢使用docker启动java服务,那么我们同样可以将上述脚本稍做改造,来实现基于shell+docker的简单项目部署能力。可以将核心节点的错误或者失败内容通过webhook发送到对应的告警平台,比如钉钉、飞书机器人等。把~/.ssh/id_rsa.pub内容添加到远程仓库的ssh秘钥中。执行start.sh脚本打包部署。start.sh脚本内容。
Java——简单图书管理系统
m0_74100417的博客
06-09 1209
数据类型变量iffor数组方法类和对象封装继承多态抽象类和接口今天就是把上述知识点全部都用起来 图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理
修改菜品——后端Java
weixin_53717695的博客
06-09 395
修改菜品——后端Java
java.lang.reflect.Type是什么
yuchangyuan5237的博客
06-12 365
通过 java.lang.reflect.Type 接口及其实现，Java 提供了一个强大的机制，用于在运行时检查和操作类型信息。这在编写通用库、框架和工具时特别有用，因为它允许你处理泛型类型和其他复杂类型结构。
（Javascript）AI数字人mp4转canvas播放并去除背景绿幕
lx_nhs的博客
06-12 370
去除前：去除后： 3、可能会出现的报错 （1）视频路径跨域问题：解决：vue开启代理
Spring Boot集成antlr实现词法和语法分析
最新发布
HBLOG
06-13 563
Antlr4 是一款强大的语法生成器工具，可用于读取、处理、执行和翻译结构化的文本或二进制文件。基本上是当前 Java 语言中使用最为广泛的语法生成器工具。Twitter搜索使用ANTLR进行语法分析，每天处理超过20亿次查询；Hadoop生态系统中的Hive、Pig、数据仓库和分析系统所使用的语言都用到了ANTLR；Lex Machina将ANTLR用于分析法律文本；Oracle公司在SQL开发者IDE和迁移工具中使用了ANTLR；NetBeans公司的IDE使用ANTLR来解析C++；
java 如何实现数据权限隔离
04-19
Java实现数据权限隔离的方法可以有多种，以下是一些常见的方式： 1. 自定义注解：可以通过自定义注解，在数据访问层的方法上加上注解，根据注解的取值来判断数据的权限，从而控制访问的数据范围。 2. 动态 SQL：可以根据当前登录用户的角色或者权限，动态构造 SQL 语句，只查询出该用户有权限访问的数据。 3. 数据过滤器：可以通过在数据访问层或者业务层增加数据过滤器，来对业务逻辑进行二次过滤，只允许该用户访问自己有权限的数据。 需要注意的是，以上方法都需要结合业务规则进行实现，并进行适当调整，以满足具体业务的需求。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值