关于租户拦截器的配置,以及MybatisPlus的多租户拦截sql重写。

已于 2022-05-23 10:16:31 修改
阅读量4k 收藏 9
点赞数 3
分类专栏： 开发过程中遇到的问题和解决方案 文章标签： java 开发语言
于 2022-05-23 10:09:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/y415616231/article/details/124920757
版权

1.租户拦截器

最近的工作上面需要用到这个功能，就查了下资料，问了下同学，找到了一篇文章（https://www.jb51.net/article/236923.htm），参考了一下。这里记录一下自己的做法，并且把一些问题记录下来。

思路：让前端把租户code放到请求头里面，我们做拦截，然后把该租户code放到本地线程（ThreadLocal）里面，再去执行业务方法。执行完之后再销毁本地线程。

问题1.最开始也是做的过滤器写的拦截器，但是遇到了swagger打不开，前端看不了接口的情况，所以后面又改成了拦截器写的。

问题2.遇到了流关闭的问题（Bad Request: I/O error while reading input message; nested exception is java），解决方式是重写一下。

问题3.Long类型返回进位问题（1524695643531628546 ->1524695643531628500）

问题4.前端组件多余字段过滤问题。

下面贴代码：

1.RequestWrapper 

import com.alibaba.fastjson.JSONObject;
import org.apache.commons.codec.Charsets;
import org.apache.commons.lang3.StringUtils;

import javax.servlet.ReadListener;
import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import java.io.*;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
/**
 * @author YH
 * @ClassName RequestWrapper.java
 * @Description TODO
 * @createTime 2022年05月19日 14:38:00
 */
public class RequestWrapper extends HttpServletRequestWrapper {
    private String body;
    public RequestWrapper(HttpServletRequest request) throws IOException {
        super(request);
        StringBuilder stringBuilder = new StringBuilder();
        BufferedReader bufferedReader = null;
        try {
            InputStream inputStream = request.getInputStream();
            if (inputStream != null) {
                bufferedReader = new BufferedReader(new InputStreamReader(inputStream,"UTF-8"));
                char[] charBuffer = new char[128];
                int bytesRead = -1;
                while ((bytesRead = bufferedReader.read(charBuffer)) > 0) {
                    stringBuilder.append(charBuffer, 0, bytesRead);
                }
            } else {
                stringBuilder.append("");
            }
        } catch (IOException ex) {
            throw ex;
        } finally {
            if (bufferedReader != null) {
                try {
                    bufferedReader.close();
                } catch (IOException ex) {
                    throw ex;
                }
            }
        }
        body = stringBuilder.toString();
    }

    @Override
    public ServletInputStream getInputStream() throws IOException {
        final ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(body.getBytes("UTF-8"));
        ServletInputStream servletInputStream = new ServletInputStream() {
            @Override
            public boolean isFinished() {
                return false;
            }

            @Override
            public boolean isReady() {
                return false;
            }

            @Override
            public void setReadListener(ReadListener readListener) {

            }

            @Override
            public int read() throws IOException {
                return byteArrayInputStream.read();
            }
        };
        return servletInputStream;
    }

    @Override
    public BufferedReader getReader() throws IOException {
        return new BufferedReader(new InputStreamReader(this.getInputStream(), Charsets.UTF_8));
    }

    public String getBody() {
        return this.body;
    }

    @Override
    public String getParameter(String name) {
        return super.getParameter(name);
    }

    @Override
    public Map<String, String[]> getParameterMap() {
        return super.getParameterMap();
    }

    @Override
    public Enumeration<String> getParameterNames() {
        return super.getParameterNames();
    }

    @Override
    public String[] getParameterValues(String name) {
        return super.getParameterValues(name);
    }

    /**
     * 设置自定义post参数 //
     *
     * @param paramMaps
     * @return
     */
    public void setParamsMaps(Map paramMaps) {
        Map paramBodyMap = new HashMap();
        if (!StringUtils.isEmpty(body)) {
            paramBodyMap = JSONObject.parseObject(body, Map.class);
        }
        paramBodyMap.putAll(paramMaps);
        body = JSONObject.toJSONString(paramBodyMap);
    }
}

2.LogHttpServletRequestWrapper （）


import javax.servlet.ReadListener;
import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import java.io.*;

/**
 * @author YH
 * @ClassName LogHttpServletRequestWrapper.java
 * @Description TODO
 * @createTime 2022年05月19日 10:27:00
 */
public class LogHttpServletRequestWrapper extends HttpServletRequestWrapper {

    private final String body;

    public LogHttpServletRequestWrapper(HttpServletRequest request) {
        super(request);
        StringBuilder stringBuilder = new StringBuilder();
        BufferedReader bufferedReader = null;
        InputStream inputStream = null;
        try {
            inputStream = request.getInputStream();
            if (inputStream != null) {
                bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
                char[] charBuffer = new char[128];
                int bytesRead = -1;
                while ((bytesRead = bufferedReader.read(charBuffer)) > 0) {
                    stringBuilder.append(charBuffer, 0, bytesRead);
                }
            } else {
                stringBuilder.append("");
            }
        } catch (IOException ex) {

        } finally {
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (bufferedReader != null) {
                try {
                    bufferedReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        body = stringBuilder.toString();
    }

    @Override
    public ServletInputStream getInputStream() throws IOException {
        final ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(body.getBytes());
        ServletInputStream servletInputStream = new ServletInputStream() {
            @Override
            public boolean isFinished() {
                return false;
            }

            @Override
            public boolean isReady() {
                return false;
            }

            @Override
            public void setReadListener(ReadListener readListener) {
            }

            @Override
            public int read() throws IOException {
                return byteArrayInputStream.read();
            }
        };
        return servletInputStream;
    }

    @Override
    public BufferedReader getReader() throws IOException {
        return new BufferedReader(new InputStreamReader(this.getInputStream()));
    }

    public String getBody() {
        return this.body;
    }

}

3.TenantFilter 过滤器（这里可以预留出来，后面做跨域等一些问题的解决）

import org.springframework.stereotype.Component;
import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;

/**
 * @author YH
 * @ClassName TenantFilter.java
 * @Description TODO
 * @createTime 2022年05月19日 09:44:00
 */
@Component
public class TenantFilter implements Filter {

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        //流读过一次就关闭了,想要读取第二次就重新赋值
        LogHttpServletRequestWrapper req = new LogHttpServletRequestWrapper((HttpServletRequest) servletRequest);
        RequestWrapper requestWrapper = new RequestWrapper(req);
        filterChain.doFilter(requestWrapper, servletResponse);
    }

}

4.TenantInterceptor 拦截器（同时把无效的请求来源等一些打印出来）

import cn.hutool.extra.servlet.ServletUtil;
import cn.hutool.json.JSONUtil;
import cn.hutool.log.StaticLog;
import org.apache.commons.lang3.StringUtils;
import org.springframework.lang.Nullable;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * @author YH
 * @ClassName TenantInterceptor.java
 * @Description TODO
 * @createTime 2022年05月19日 09:44:00
 */
@Component
public class TenantInterceptor implements HandlerInterceptor {

    public static ThreadLocal<String> SCHEMA_LOCAL = new ThreadLocal<>();

    public static String getSchema() {
        String schema = SCHEMA_LOCAL.get();
        if (StringUtils.isNotEmpty(schema)) {
            return schema;
        }
        return "BASE";
    }

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        LogHttpServletRequestWrapper req = new LogHttpServletRequestWrapper(request);
        //获取租户code
        String tenantCode = req.getHeader("tenantCode");
        if (StringUtils.isEmpty(tenantCode)) {
            //封装log实体类
            StaticLog.info("请求来源： =》{}", req.getRemoteAddr());
            StaticLog.info("请求URI：{}", req.getRequestURI());
            StaticLog.info("请求方式：{}", req.getMethod());
            StaticLog.info("请求失败原因：{}", "没有租户code");
            if ("GET".equals(req.getMethod())) {
                StaticLog.info("请求参数：{}", JSONUtil.parseObj(ServletUtil.getParams(req)));
            } else {
                String substring = req.getBody().substring(0, 1);
                if ("{".equals(substring)) {
                    StaticLog.info("请求参数：{}", JSONUtil.parseObj(req.getBody()));
                }
                if ("[".equals(substring)) {
                    StaticLog.info("请求参数：{}", JSONUtil.parseArray(req.getBody()));
                }
            }
            return false;
        }
        SCHEMA_LOCAL.set(tenantCode);
        return true;
    }

    @Override
    public  void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable Exception ex) throws Exception {
        //请求完了销毁本地线程
        SCHEMA_LOCAL.remove();
    }
}

5.WebMvcConfig(放行swagger，过滤重定向，前端组件多余字段以及进位问题)


import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.module.SimpleModule;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import com.xxx.xxx.config.interceptor.TenantInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.web.servlet.config.annotation.*;

import java.util.List;

/**
 * Created by sunh on 2021/12/12.
 */
@Configuration
public class WebMvcConfig extends WebMvcConfigurationSupport {

    @Bean
    public WebMvcConfigurer webMvcConfigurer() {
        return new WebMvcConfigurer() {
            //配置跨域
            @Override
            public void addCorsMappings(CorsRegistry registry) {
                registry.addMapping("/**")     //允许的路径
                    .allowedMethods("*")     //允许的方法
                    .allowedOrigins("*")       //允许的网站
                    .allowedHeaders("*")     //允许的请求头
                    .allowCredentials(true)
                    .maxAge(3600);
            }
        };
    }

    //TODO 从这里开始 都是新增的
    @Bean
    public TenantInterceptor getTenantInterceptor() {
        return new TenantInterceptor();
    }

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry
            .addInterceptor(getTenantInterceptor())
            .addPathPatterns("/**")
            .excludePathPatterns("/login")
            //过滤异常。避免多次重定向
            .excludePathPatterns("/error")
            .excludePathPatterns("/swagger-resources/**", "/webjars/**", "/v2/**", "/swagger-ui.html/**");
        super.addInterceptors(registry);
    }
    
    @Override
    protected void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("swagger-ui.html")
            .addResourceLocations("classpath:/META-INF/resources/");
        registry.addResourceHandler("/webjars/**")
            .addResourceLocations("classpath:/META-INF/resources/webjars/");
        super.addResourceHandlers(registry);
    }


    @Override
    public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
        MappingJackson2HttpMessageConverter jackson2HttpMessageConverter = new MappingJackson2HttpMessageConverter();
        ObjectMapper objectMapper = new ObjectMapper();
        /**
         * 序列换成json时,将所有的long变成string
         * 因为js中得数字类型不能包含所有的java long值
         */
        SimpleModule simpleModule = new SimpleModule();
        simpleModule.addSerializer(Long.class, ToStringSerializer.instance);
        simpleModule.addSerializer(Long.TYPE, ToStringSerializer.instance);
        //忽略前端组件多余的字段
        objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES,false);
        objectMapper.registerModule(simpleModule);
        jackson2HttpMessageConverter.setObjectMapper(objectMapper);
        converters.add(jackson2HttpMessageConverter);
    }

6.一些pom

        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.3.10</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.47</version>
        </dependency>

2.MybatisPlus的多租户配置

在网上搜索了一下原理，是在预编译层的时候做了拦截，把租户code塞进了sql语句里面，所以这里基本上每张表都要加租户code这个字段。（我这里的字段是tenant_code/tenantCode，另外项目用到的数据库为pgsql）。

1.配置文件

import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.autoconfigure.ConfigurationCustomizer;
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.handler.TenantLineHandler;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.TenantLineInnerInterceptor;
import com.xxx.xxx.config.interceptor.TenantInterceptor;
import net.sf.jsqlparser.expression.Expression;
import net.sf.jsqlparser.expression.StringValue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.transaction.annotation.EnableTransactionManagement;

/**
 * @author YH
 * @ClassName MybatisPlusConfig.java
 * @Description TODO
 * @createTime 2021年12月15日 17:51:00
 */
@EnableTransactionManagement(proxyTargetClass = true)
@Configuration
public class MybatisPlusConfig {

    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();

        interceptor.addInnerInterceptor(new TenantLineInnerInterceptor(new TenantLineHandler() {
            //字段类型
            @Override
            public Expression getTenantId() {
                String tenantCode = TenantInterceptor.getSchema();
                return new StringValue(tenantCode);
            }
            
            //数据库字段名
            @Override
            public String getTenantIdColumn() {
                return "tenant_code";
            }
            
            // 这是 default 方法,默认返回 false 表示所有表都需要拼多租户条件
            @Override
            public boolean ignoreTable(String tableName) {
                return false;
            }
        }));
        // 如果用了分页插件注意先 add TenantLineInnerInterceptor 再 add PaginationInnerInterceptor
        // 用了分页插件必须设置 MybatisConfiguration#useDeprecatedExecutor = false
        //TODO 这里用的pgsql 所以这里做了配置项
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.POSTGRE_SQL));
        return interceptor;
    }
    @Bean
    public ConfigurationCustomizer configurationCustomizer() {
        return configuration -> configuration.setUseDeprecatedExecutor(false);
    }

}

2.pom

        <!-- mybatis plus -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.2.0</version>
        </dependency>

另外如果有sql不需要用租户区分，那么在Mapper层/dao层的方法上面加上注解@InterceptorIgnore(tenantLine = "true")就好了，（有的网上说加@SqlParser(filter = true)也行但是我没有测试）

冷宫旋
关注
专栏目录
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值