JPA 表租户 SQL解析实现

spring-boot jpa 实现拦截器 StatementInspector springbootjpa实现sql拦截的方式很简单,只要实现 StatementInspector 接口既可以。 package com.zsh.masterdata.config; import org.hibernate.resource.jdbc.spi.StatementInspector; public class JpaStatementInspector implements StatementInspector { private ApplicationContext ap. 阅读详情
  1. 在JPA项目中引入jsqlparser依赖
    <dependency>
          <groupId>com.github.jsqlparser</groupId>
          <artifactId>jsqlparser</artifactId>
          <version>3.1</version>
    </dependency>
  1. 编写租户拦截器TenantInterceptor
    重写hibernate提供的StatementInspector的inspect接口,参数为hibernate处理后的原始SQL,返回值为我们修改后的SQL.
import lombok.Data;
import lombok.experimental.Accessors;
import lombok.extern.slf4j.Slf4j;
import net.sf.jsqlparser.expression.BinaryExpression;
import net.sf.jsqlparser.expression.Expression;
import net.sf.jsqlparser.expression.Parenthesis;
import net.sf.jsqlparser.expression.StringValue;
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.parser.CCJSqlParserUtil;
import net.sf.jsqlparser.schema.Column;
import net.sf.jsqlparser.schema.Table;
import net.sf.jsqlparser.statement.Statement;
import net.sf.jsqlparser.statement.Statements;
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.hibernate.resource.jdbc.spi.StatementInspector;

import java.util.List;

/**
 * 参考Mybatis-Plus插件中的TenantSqlParser进行租户解析处理,其实现为使用jsqlparser对sql进行解析,拼装SQL语句
 *
 */
@Slf4j
@Data
@Accessors(chain = true)
public class TenantInterceptor implements StatementInspector {


    /**
     * 当前租户ID,从UserContext获取
     */
    private String tenantId;

    /**
     * 需进行租户解析的表名,需要注入
     */
    private List<String> tenantTables;

    /**
     * 需进行租户解析的租户字段名,本项目中为固定名称
     */
    private String tenantIdColumn = "tenant_id";


    /**
     * 重写StatementInspector的inspect接口,参数为hibernate处理后的原始SQL,返回值为我们修改后的SQL
     * @param sql
     * @return
     */
    @Override
    public String inspect(String sql) {
        try {
            /**
             * 非租户用户不进行解析
             */
            if (UserContext.current() == null || UserContext.current().getAdministrator()) {
                return null;
            }
            /**
             * 初始化需要进行租户解析的租户表
             */
            if (tenantTables == null) {
                TenantProperties bean = SpringContextUtil.getBean(TenantProperties.class);
                if (bean != null) {
                    tenantTables = bean.getTables();
                } else {
                    throw new RuntimeException("未能获取TenantProperties参数配置");
                }
            }

            /**
             * 从当前线程获取登录用户的所属租户ID
             */
            CurrentUser user = UserContext.current();
            tenantId = user.getTenantId();

            log.info("租户解析开始,原始SQL:{}", sql);
            Statements statements = CCJSqlParserUtil.parseStatements(sql);
            StringBuilder sqlStringBuilder = new StringBuilder();
            int i = 0;
            for (Statement statement : statements.getStatements()) {
                if (null != statement) {
                    if (i++ > 0) {
                        sqlStringBuilder.append(';');
                    }
                    sqlStringBuilder.append(this.processParser(statement));
                }
            }
            String newSql = sqlStringBuilder.toString();
            log.info("租户解析结束,解析后SQL:{}", newSql);
            return newSql;
        } catch (Exception e) {
            log.error("租户解析失败,解析SQL异常{}", e.getMessage());
            e.printStackTrace();
        } finally {
            tenantId = null;
        }
        return null;
    }

    private String processParser(Statement statement) {
        if (statement instanceof Insert) {
            this.processInsert((Insert) statement);
        } else if (statement instanceof Select) {
            this.processSelectBody(((Select) statement).getSelectBody());
        } else if (statement instanceof Update) {
            this.processUpdate((Update) statement);
        } else if (statement instanceof Delete) {
            this.processDelete((Delete) statement);
        }
        /**
         * 返回处理后的SQL
         */
        return statement.toString();
    }

    /**
     * select 语句处理
     */

    public void processSelectBody(SelectBody selectBody) {
        if (selectBody instanceof PlainSelect) {
            processPlainSelect((PlainSelect) selectBody);
        } else if (selectBody instanceof WithItem) {
            WithItem withItem = (WithItem) selectBody;
            if (withItem.getSelectBody() != null) {
                processSelectBody(withItem.getSelectBody());
            }
        } else {
            SetOperationList operationList = (SetOperationList) selectBody;
            if (operationList.getSelects() != null && operationList.getSelects().size() > 0) {
                operationList.getSelects().forEach(this::processSelectBody);
            }
        }
    }

    /**
     * insert 语句处理
     */

    public void processInsert(Insert insert) {
        if (tenantTables.contains(insert.getTable().getFullyQualifiedName())) {
            insert.getColumns().add(new Column(tenantIdColumn));
            if (insert.getSelect() != null) {
                processPlainSelect((PlainSelect) insert.getSelect().getSelectBody(), true);
            } else if (insert.getItemsList() != null) {
                // fixed github pull/295
                ItemsList itemsList = insert.getItemsList();
                if (itemsList instanceof MultiExpressionList) {
                    ((MultiExpressionList) itemsList).getExprList().forEach(el -> el.getExpressions().add(new StringValue(tenantId)));
                } else {
                    ((ExpressionList) insert.getItemsList()).getExpressions().add(new StringValue(tenantId));
                }
            } else {
                throw new RuntimeException("Failed to process multiple-table update, please exclude the tableName or statementId");
            }
        }
    }

    /**
     * update 语句处理
     */

    public void processUpdate(Update update) {
        final Table table = update.getTable();
        if (tenantTables.contains(table.getFullyQualifiedName())) {
            update.setWhere(this.andExpression(table, update.getWhere()));
        }
    }

    /**
     * delete 语句处理
     */

    public void processDelete(Delete delete) {
        if (tenantTables.contains(delete.getTable().getFullyQualifiedName())) {
            delete.setWhere(this.andExpression(delete.getTable(), delete.getWhere()));
        }
    }

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

    /**
     * 处理 PlainSelect
     */
    protected void processPlainSelect(PlainSelect plainSelect) {
        processPlainSelect(plainSelect, false);
    }

    /**
     * 处理 PlainSelect
     *
     * @param plainSelect ignore
     * @param addColumn   是否添加租户列,insert into select语句中需要
     */
    protected void processPlainSelect(PlainSelect plainSelect, boolean addColumn) {
        FromItem fromItem = plainSelect.getFromItem();
        if (fromItem instanceof Table) {
            Table fromTable = (Table) fromItem;
            if (tenantTables.contains(fromTable.getFullyQualifiedName())) {
                //#1186 github
                plainSelect.setWhere(builderExpression(plainSelect.getWhere(), fromTable));
                if (addColumn) {
                    plainSelect.getSelectItems().add(new SelectExpressionItem(
                            new Column(tenantIdColumn)));
                }
            }
        } else {
            processFromItem(fromItem);
        }
        List<Join> joins = plainSelect.getJoins();
        if (joins != null && joins.size() > 0) {
            joins.forEach(j -> {
                processJoin(j);
                processFromItem(j.getRightItem());
            });
        }
    }

    /**
     * 处理子查询等
     */
    protected void processFromItem(FromItem fromItem) {
        if (fromItem instanceof SubJoin) {
            SubJoin subJoin = (SubJoin) fromItem;
            if (subJoin.getJoinList() != null) {
                subJoin.getJoinList().forEach(this::processJoin);
            }
            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) {
            log.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());
                }
            }
        }
    }

    /**
     * 处理联接语句
     */
    protected void processJoin(Join join) {
        if (join.getRightItem() instanceof Table) {
            Table fromTable = (Table) join.getRightItem();
            if (tenantTables.contains(fromTable.getFullyQualifiedName())) {
                join.setOnExpression(builderExpression(join.getOnExpression(), fromTable));
            }
        }
    }

    /**
     * 处理条件:
     * 支持 getTenantHandler().getTenantId()是一个完整的表达式:tenant in (1,2)
     * 默认tenantId的表达式: LongValue(1)这种依旧支持
     */
    protected Expression builderExpression(Expression currentExpression, Table table) {
        final Expression tenantExpression = new StringValue(tenantId);
        Expression appendExpression;
        if (!(tenantExpression instanceof SupportsOldOracleJoinSyntax)) {
            appendExpression = new EqualsTo();
            ((EqualsTo) appendExpression).setLeftExpression(this.getAliasColumn(table));
            ((EqualsTo) appendExpression).setRightExpression(tenantExpression);
        } else {
            appendExpression = processTableAlias4CustomizedTenantIdExpression(tenantExpression, table);
        }
        if (currentExpression == null) {
            return appendExpression;
        }
        if (currentExpression instanceof BinaryExpression) {
            BinaryExpression binaryExpression = (BinaryExpression) currentExpression;
            doExpression(binaryExpression.getLeftExpression());
            doExpression(binaryExpression.getRightExpression());
        } else if (currentExpression instanceof InExpression) {
            InExpression inExp = (InExpression) currentExpression;
            ItemsList rightItems = inExp.getRightItemsList();
            if (rightItems instanceof SubSelect) {
                processSelectBody(((SubSelect) rightItems).getSelectBody());
            }
        }
        if (currentExpression instanceof OrExpression) {
            return new AndExpression(new Parenthesis(currentExpression), appendExpression);
        } else {
            return new AndExpression(currentExpression, appendExpression);
        }
    }

    protected void doExpression(Expression expression) {
        if (expression instanceof FromItem) {
            processFromItem((FromItem) expression);
        } else if (expression instanceof InExpression) {
            InExpression inExp = (InExpression) expression;
            ItemsList rightItems = inExp.getRightItemsList();
            if (rightItems instanceof SubSelect) {
                processSelectBody(((SubSelect) rightItems).getSelectBody());
            }
        }
    }

    /**
     * 目前: 针对自定义的tenantId的条件表达式[tenant_id in (1,2,3)],无法处理多租户的字段加上表别名
     * select a.id, b.name
     * from a
     * join b on b.aid = a.id and [b.]tenant_id in (1,2) --别名[b.]无法加上 TODO
     *
     * @param expression
     * @param table
     * @return 加上别名的多租户字段表达式
     */
    protected Expression processTableAlias4CustomizedTenantIdExpression(Expression expression, Table table) {
        //cannot add table alias for customized tenantId expression,
        // when tables including tenantId at the join table poistion
        return expression;
    }

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

}

  1. JPA拦截yml配置
spring:
  jpa:
    database: mysql
    show-sql: true
    hibernate:
      ddl-auto: update
    properties:
      hibernate:
        session_factory:
          statement_inspector: com.tba.sc.common.intercepters.TenantInterceptor
  1. 需进行租户解析的租户表
tenant:
  tables:
    sys_user
  1. 租户表配置类
@Data
@Component
@ConfigurationProperties(prefix = "tenant")
public class TenantProperties {

    /**
     * 需要进行租户解析的租户表
     */
    private List<String> tables;
}
  1. 测试


@Slf4j
@SpringBootTest(classes = SystemApplication.class)
@RunWith(SpringRunner.class)
public class TanentTest {

    @Autowired
    UserService userService;

    @Test
    public void tenantTest() {
        CurrentUser user = new CurrentUser();
        user.setId("40285b816252ff61016253008f9f0000");
        user.setTenantId("40285b816252ff61016253008f9f0001");
        user.setAdministrator(false);
        UserContext.setCurrentUser(user);
        while (true) {
            List<UserDTO> all = userService.findAll();
            all.forEach(x -> log.info(x.toString()));
        }
    }
}
  1. 说明
    关于UserContext,此类为自定义的当前用户上下文,各位需要自己实现,原理为从会话中获取当前操作用户的租户ID
Java 中实现多租户架构:数据隔离策略与实践指南 本文介绍了Java中实现多租户架构的两种主要方式:共享数据库分离Schema和共享Schema通过tenant_id字段区分数据。第一种方式通过动态切换数据库Schema实现数据隔离,适合中大型SaaS应用;第二种方式通过在表中添加tenant_id字段并自动注入查询条件,更适合租户数量大的场景。文章详细分析了两种方案的实现方法,并针对常见问题如数据越权、跨租户查询和上下文传递等提供了解决方案。同时强调了索引设计和权限控制的重要性,为开发者构建安全高效的多租户系统提供了实用指导。 阅读详情

相关推荐

多租户--EclipseLink实现

EclipseLink的介绍EclipseLink 是 Eclipse 基金会管理下的开源持久层服务项目,为 Java 开发人员与各种数据服务(比如:数据库、web services、对象XML映射(OXM)、企业信息系统(EIS)等)交互提供了一个可扩展框架,目前支持的持久层标准中包括: • Java Persistence API (JPA) • Java Architecture for

区块链领域填坑的java程序猿 4934

jpa数据拦截(oracle数据库)

善于使用工具类,封装工具类,带来不少的收获

枫叶 2323

企业级多租户系统设计与实现:架构、代码与演进路线

多租户系统一套应用系统同时服务多个客户(租户)租户之间在数据 / 配置 / 资源 / 安全上彼此隔离在控制成本的前提下,保证租户级别的数据安全与可扩展性。✔ 没有“最好的多租户方案”,只有最适合当前阶段的方案✔ 架构设计要从第一天就支持演进✔ 多租户 ≠ 加个 tenant_id ✔ 安全、缓存、异步、运维都必须“租户感知”推荐实践业务早期:共享表 + 强校验平台成熟期:混合模式高价值客户:独立数据库。

一起修行,不孤单。这里有编程语言、开发工具、学习方法论和踩坑笔记。用简单的话说复杂的事,陪你从小白到进阶。周更干货,欢迎一起成长! 676

JSqlParse解析动态Sql

思路主要类似分布式日志一样,各服务请求透传一个唯一标识,比如请求路径,然后再通过拦截器获取具体执行的Sql语句,通过解析sql来获取表及字段,从而构建映射关系。刚开始用以为自己去遍历递归,后来查到神器JSqlParse,看到Visitor设计模式实现效果,感觉真心强。对于复杂的Sql处理,各种嵌套、函数、子查询,都可解析,只要自己去实现各个具体的方法。以下是仅是解析Sql简单的例子,有的地方还需要根据自己实际需求去调整,仅供参考。同理可实现Update、Insert、Delete等Sql的解析。

mhl8519的博客 2142

jsqlparser 版本不兼容:net.sf.jsqlparser.statement.select.SelectItem 以及 select.SelectBody 解决方法

看Bug直接定位到最后面的错误提示,一开始以为是UnabletostartembeddedTomcat的基本错误,后续发现排查方向错误!问题比较复杂,不过这类问题可看:出现WebServerException:UnabletostartembeddedTomcat解决方法(全)

码农研究僧的博客 2673

SpringBoot第34讲:SpringBoot集成ShardingJDBC - 基于JPA的DB隔离多租户方案

本文是SpringBoot第34讲,主要介绍ShardingJDBC的分片算法和分片策略,并在此基础上通过SpringBoot集成ShardingJDBC的几种策略(标准分片策略,行表达式分片策略和hint分片策略)向你展示DB隔离的多租户方案

Jet_qi的博客 540

jpa基于表字段的多租户实现初版

spring.jpa.properties.hibernate.multiTenancy=DISCRIMINATOR来做发现还没有实现。最近项目重构,原有的项目基于mybatis的多租户无法使用,需要迁移的jpa上来,本来想尝试用。1.所有的租户id都是通过head参数获取的,建立拦截器放入线程的本地变量中。顾考虑使用jpa的过滤器对入库的sql进行拦截后再塞入。5.配置文件 xxx修改为自己的包名。2.存放租户id的上下文。

焱童鞋 2269

Hibernate与JPA2新特性及映射深度解析

Hibernate 是一个开源的对象关系映射(ORM)框架,它允许开发者将Java对象映射到关系数据库中。它为应用层提供了一个简单易用的API来操作数据库,从而将开发者从复杂且易错的SQL编程中解放出来。Hibernate管理数据库交互的生命周期,包括连接的获取、数据的CRUD操作(创建、读取、更新、删除)以及事务处理。// 示例:在Hibernate中创建一个简单的实体类映射@Entity@Id在上述代码中,我们定义了一个User实体类,它映射到一个名为users的数据库表。

weixin_33531560的博客 1201

Spring Boot JPA MySQL 多租户系统 Part2 - 自动建表

本文介绍了 Spring Data JPA 集成 Hibernate 在应用启动时创建数据表的过程。使用 DriverManager 为每个租户创建数据库,SchemaExport 工具为每个租户创建数据表。这些工作均在应用启动时完成,不同租户的请求到来时,可以无缝切换数据源,实现租户的数据隔离。

PeterGamp的博客 1707

5个企业级SOC平台横向对比:IBM QRadar vs Splunk vs 奇安信NGSOC

本文深度对比了IBM QRadar、Splunk和奇安信NGSOC等五大企业级SOC平台的核心能力,从架构设计、威胁检测、运营效率、成本模型和行业适配度五个维度进行解析。文章特别强调安全运营中心(SOC)在现代企业中的关键作用,并提供了实战数据和优化建议,帮助企业选择最适合自身需求的SOC解决方案。

a1b2c的博客 664

ESP32+micro-ROS机器人开发实战:轻量级ROS2嵌入式集成

ROS2是现代机器人软件栈的核心框架,其基于DDS的分布式通信与QoS保障能力为多节点协同提供基础支撑;而micro-ROS作为专为微控制器优化的ROS2兼容中间件,解决了资源受限设备(如ESP32)接入ROS2生态的关键难题。其通过分层架构将DDS通信下沉至上位机Agent,使MCU仅需运行轻量Client,大幅降低内存开销(实测<180KB)并保留标准ROS2接口语义。该方案广泛应用于教育机器人、移动底盘、传感器节点等嵌入式场景,尤其适合基于ESP-IDF开发的Wi-Fi/BLE物联网机器人系统。本文以

weixin_29025501的博客 402

多租户 SQL 自动隔离实现:从代码解析到方案探讨

本文介绍了基于SQL拦截的SaaS多租户数据隔离方案。通过TenantStatementInspector实现类自动注入租户过滤条件,支持共享数据库共享表模式,具有开发透明、实现简单等优点。但存在性能损耗、复杂SQL支持有限、手动SQL可能绕过拦截等问题。文章还探讨了优化思路,如缓存解析结果、支持注解SQL处理等,并指出该技术还可用于SQL审计、性能监控等场景。该方案适合对隔离性要求不高的小型租户场景,实际应用中需结合业务需求权衡选择。

bbw_hunter的博客 683

Proteus 8.15仿真STM32F103C8,ADC采样总为0?别急着换芯片,先检查这3个配置

本文详细解析了在Proteus 8.15中仿真STM32F103C8时ADC采样值为0的常见原因及解决方法。从供电网络配置、时钟设置到ADC参数调整,提供了系统性的排查指南,帮助开发者快速定位问题,避免不必要的硬件更换。重点关注供电网络、时钟分频和ADC配置等关键环节。

weixin_30425949的博客 366

租户隔离怎么做MYSQL_基于JPA实现SaaS多租户模式的数据存储——共享数据库,隔离数据架构...

SaaS是Software-as-a-Service(软件即服务)的简称,这边具体的解释不介绍。多租户的系统可以应用这种模式的思想,将思想融入到系统的设计之中。现在SaaS Multi-Tenant在数据存储上存在两大类共三种主要的方案,分别是:独立数据库和共享数据库,其中共享数据库又可分为共享数据库,隔离数据架构和共享数据库,共享数据架构。 具体如下:独立数据库,即一个Tenant一个Datab...

weixin_42358594的博客 1543

Claude Code 100个真实案例 - 用AI绘制CAD机械图纸(工程师看了直呼内行)

本案例展示如何使用 Claude Code 配合 Python 的 `ezdxf` 库,从零开始生成专业级 CAD 机械图纸。我们将绘制一个完整的法兰盘零件图,包含主视图、俯视图、标注尺寸、粗糙度标记和标题栏,最终生成标准 DXF 文件,可直接在 AutoCAD 或 FreeCAD 中打开编辑。

yueyeguzhuo的专栏 904

[SV]SystemVerilog状态机实现案例

本文介绍了SystemVerilog中状态机的实现方法。首先使用枚举类型定义状态(TOP_HIB、TOP_BG、TOP_LDO、TOP_NOR),然后通过三个主要任务实现状态机:1)格式化现态寄存器处理状态转换;2)描述状态转移条件,包括计时器和稳定时间判断;3)基于当前状态和输入信号确定次态。状态机在时钟边沿或复位时更新状态,实现了从休眠到正常工作状态的转换逻辑,包含电源稳定时间检测等关键功能。

元直的博客 2022

《在SaaS系统中提升JPA项目扩展性的架构实践》:模块解耦、租户隔离与混合技术策略详解

摘要:SaaS系统中JPA项目面临多租户隔离、业务定制化等挑战。建议采用领域驱动设计进行模块拆分,分离Entity与DTO,封装Repository并通过Facade接口输出。引入租户上下文注入机制实现数据隔离,结合JSON字段或分表策略支持租户定制。推荐JPA+MyBatis混合架构,JPA处理通用业务,MyBatis应对复杂查询。随着系统演进,可逐步实现模块插件化、配置驱动的扩展能力。关键策略包括模块解耦、数据层隔离和多租户支持等,结合Spring生态可构建商业化SaaS平台。

nbsaas-boot基于Request-Response的企业级快速开发框架 2150

【100%通过率】华为od 机试真题 C语言 实现【补种未成活胡杨】

近些年来,我国防沙治沙取得显著成果。某沙漠新种植N棵胡杨(编号1-N),排成一排。一个月后,有M棵胡杨未能成活。现可补种胡杨K棵,请问如何补种(只能补种,不能新种),可以得到最多的连续胡杨树?

MISAYAONE的博客 1655

基于springboot+jpa 实现多租户动态切换多数据源 - 数据隔离方案选择分库还是分表

基于springboot+jpa 实现多租户动态切换多数据源 - 数据隔离方案选择分库还是分表

鄙人kunzhi96,感恩遇见! 3106

(三)UPF之Domain Coverage Relationship(Cover、Equivalent、Independent)

整个Soc架构中一般会存在多个Power Domain,不同的Power Domain之间也存在着一定的Coverage关系。在Cadence工具中,这种。不同的Domain Coverage关系中,各个Domain存在着一定的关联()。

Mr.翟的博客 1426

工业相机,大恒,面振相机8脚电源线和I/O触发接口线,颜色和接法说明和触发软件设定

上图: 说明一下,工业相机有TTL逻辑电平触发,也有光耦触发等。 这里一般我们用电路板驱动,就用GPIO触发模式, 这里,准备了两个GPIO触发模式,为LINE2,LINE3都可以选择,然后有一个GPIO_GND 如果,你只有一个触发接口,那么如图,选两个就好了。 实际接法如图。 ...

山云的专栏 1万+

基于springboot+jpa 实现多租户动态切换多数据源 - 使用Flyway实现多数据源数据库脚本管理和迭代更新

基于springboot+jpa 实现多租户动态切换多数据源 - 使用Flyway实现多数据源数据库脚本管理和迭代更新

鄙人kunzhi96,感恩遇见! 2403

大中型超市收银系统(可直接运行)

光步前台收银系统系统功能:商品销售、商品退货、挂单、收银员权限、会员销售、单品取消、整单取消、商品查询、脱机销售、脱机数据上传,基本资料下载,开钱箱、小票打印、收款结算,支持多币种付款方式(现金、储值卡、礼券、微信等),支持多种促销。运行环境:.net 4.0登陆信息用户名:1001 密码:123456内置商品信息,商品编码可输入00001000 - 00010000,测试效果相关功能键F5 结算 F9挂单 F11商品查询 F8退货 Insert单品取消 Del整单取消 F12开钱箱F2 会员 Ctrl+Z退出系统 Home 锁屏 相关源码待公开

simplest-jpa v1.2.0如何优雅实现多租户

simplest详细文档TenantFactory 是用于生产租户 ID 的,或者说是用于获取当前租户 ID 的。

daTou 694

visio安装包

Microsoft Office Visio 是一款专业的制图软件。利用经过更新的形状、协作工具和数据链接图表,创建专业级图表以简化复杂的信息。

win10 跳过U8环境检测的IE WebControls.rar

win10 安装u8的时候 提示IE WebControls 不通过,这个工具可以欺骗u8的检查。 跳过U8环境检测的IE WebControls。提示导入失败后,重新检测通过。

MyCat之多租户的实现

多租户 概念 多租户的环境下共用相同的系统或者程序组件,并且确保各个用户数据的隔离性。 实现方案 1、独立数据库 2、共享数据库,独立Schema 3、共享数据库,共享Schema,共享数据库 具体实现 1、JPA 2、Hibernate 3、EclpseLink 4、Mycat 为什么选择Mycat? 简单 怎么实现的? 本质:数据库中间件 ...

小花生编程 3215

迈瑞BS系列全自动生化分析仪LIS协议接口手册(内含HL7和ASTM)

迈瑞BS系列全自动生化分析仪LIS协议接口手册,内含HL7和ASTM)

基于 JPA 和多租户架构支持多企业微信账号的 SaaS 后端设计

通过上述设计,系统可在单一应用实例中安全、高效地服务数千家企业微信租户,满足 SaaS 架构对数据隔离、弹性扩展和运维简化的核心要求。,其组织架构、审批流、消息模板等数据需隔离。在 SaaS 化企业微信应用中,每个客户(企业)拥有独立的。,兼顾安全性与资源利用率。

Addisoni 512
上一篇: java的ThreadLocal变量
下一篇: pa使用Example快速实现动态查询
fall_hat
博客等级 码龄10年 44粉丝 336原创
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值