精华内容
下载资源
问答
  • react路由参数跳转后再刷新页面,参数丢失 在学习ant Pro前端框架时,遇到一个问题,从A页面传到B页面的参数,正常跳转的话,B页面显示没有问题,在这个基础上刷新B页面,会出现空白,原因是传过来的参数丢失。查阅...

    react路由参数跳转后再刷新页面,参数丢失

    在学习antd前端框架时,遇到一个问题,从A组件传到B组件的参数,正常跳转的话,B页面显示没有问题,在这个基础上刷新B页面,会出现空白,原因是传过来的参数丢失。查阅资料后,了解到有两种方法,第一种是截取url,第二种是使用sessionStorage。
    使用sessionStorage时,A组件还是正常传递参数,B组件在接收参数时,要有所改变:

    let id;  //先定义一个存储参数的变量
    if(this.props.location.query && this.props.location.query.name){  //判断是否有参数
    	id = this.props.location.query.name;
    	sessionStorage.setItem('data', id)
    }else{  //这种情况是说的刷新B页面时没有传递来的参数
    	id = sessionStorage.getItem('data'); //当state没有参数时,取sessionStorage中的参数
    }
    
    展开全文
  • methods: { research: function () { //post请求远程资源 this.$http.post( //请求的url ... //请求参数,不能以get请求方式写:{params: {userName: "root123", passWord: "root123"}} {us.
    methods: {
        research: function () {
            //post请求远程资源
            this.$http.post(
                //请求的url
                "http://www.hefeixyh.com/login.html",
                //请求参数,不能以get请求方式写:{params: {userName: "root123", passWord: "root123"}}
                {userName: "root123", passWord: "root123"},
                //解决跨域问题,不加无法跨域
                {emulateJSON: true}
            ).then(result=>{
                console.dir(result)
            }).catch(error=>{
                console.dir(error)
            });
        }
    }

    展开全文
  • 问题描述 我们在使用基于SpringCloud微服务框架时,通常会使用到token...文章目录问题描述解决方案一、常用的异步方式二、请求头参数获取方式三、解决方案1.手工创建线程2.线程池3.Async4.Feign调用5.异步 + Feign调用

    问题描述

    我们在使用基于SpringCloud微服务框架时,通常会使用到token,然后通过认证中心生产token后,所有的请求头携带该token,来验证当前请求的合法性,对于同步请求没有任何问题,当我们使用到了异步编程时,就有可能在子线程里获取不到这些请求头的参数。本篇文章针对异步+Feign调用遇见的一些问题做一个记录,避免其他人踩坑.


    解决方案

    以下解决方案主要是从目前主流的几种异步方式来提供各自的解决方案.

    一、常用的异步方式

    1. 手工创建线程(不推荐)
    2. 手工创建线程池
    3. @Async注解

    二、请求头参数获取方式

    import org.springframework.web.context.request.RequestAttributes;
    import org.springframework.web.context.request.RequestContextHolder;
    import org.springframework.web.context.request.ServletRequestAttributes;
    
    // 获取当前线程的RequestAttribute,实际上是从一个ThreadLocal里获取的
    RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
    // 转换为ServletRequest对象
    HttpServletRequest request = ((ServletRequestAttributes) requestAttributes).getRequest();
    // 获取请求头参数
    String authorization = request.getHeader("Authorization");
    

    三、解决方案

    1.手工创建线程

    方式1:

    import org.springframework.web.context.request.RequestAttributes;
    import org.springframework.web.context.request.RequestContextHolder;
    
    public void newThread(){
            // 获取主线程的requestAttribute对象
            RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
    
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    // 手工set到子线程里
                    RequestContextHolder.setRequestAttributes(requestAttributes, true);
    
                    // 执行自己的业务逻辑
    
                    // 获取请求参数
                    RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
                }
            });
        }
    

    注意点:RequestContextHolder.setRequestAttributes(requestAttributes, true);
    这个true的意思是子类是否可以继承该对象,可以查看源码发现实际上在Holder里用到了ThreadLocal的不同实现类

    // 普通的用法,根据当前线程ID可以获取到
    private static final ThreadLocal<RequestAttributes> requestAttributesHolder = new NamedThreadLocal("Request attributes");
    // 子类可以继承父类的属性
    private static final ThreadLocal<RequestAttributes> inheritableRequestAttributesHolder = new NamedInheritableThreadLocal("Request context");
    

    方式2:

    public void newThread2(){
            // 获取主线程的requestAttribute对象
            RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
            // 设置为子类可以继承
            RequestContextHolder.setRequestAttributes(requestAttributes, true);
    
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    // 执行自己的业务逻辑
    
                    // 获取请求参数
                    RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
                }
            });
        }
    

    2.线程池

    遇见线程池的思路实际上也是要将RequestAttribute传递给子线程. 所以我们在使用线程池时,封装了一层,来操作这个RequestAttribute

    public static void exec(Runnable runnable, ThreadPoolExecutor executor){
            RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
    
            CompletableFuture.runAsync(()->{
                // 手工set到子线程里
                RequestContextHolder.setRequestAttributes(requestAttributes, true);
            }, executor)
                    // 再执行业务的逻辑
                    .thenRun(runnable);
        }
    

    说明:runAsync是异步执行,thenRun是同步执行

    3.Async

    实际上@Async也是用到了线程池,默认的话是每次都会创建Thread来执行异步任务,这里不推荐使用,即使用到了自定义线程池,这里也不方便做拦截处理。所以直接Pass掉。不使用该方式开启异步任务。

    4.Feign调用

    在遇见Feign调用其他服务时同样要将请求头参数全部传递过去, 直接使用Feign拦截器即可

    import feign.RequestInterceptor;
    import feign.RequestTemplate;
    import org.springframework.web.context.request.RequestAttributes;
    import org.springframework.web.context.request.RequestContextHolder;
    import org.springframework.web.context.request.ServletRequestAttributes;
    
    import javax.servlet.http.HttpServletRequest;
    import java.util.Enumeration;
    
    @Configuration
    public class FeignRequestInterceptor implements RequestInterceptor {
        
        @Override
        public void apply(RequestTemplate requestTemplate) {
            RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
            HttpServletRequest request = ((ServletRequestAttributes) requestAttributes).getRequest();
    
            Enumeration<String> headerNames = request.getHeaderNames();
            while (headerNames.hasMoreElements()){
                String name = headerNames.nextElement();
                String value = request.getHeader(name);
                requestTemplate.header(name, value);
            }
        }
    }
    

    5.异步 + Feign调用

    有了第一步,第二步,第四步的解决方案,实际上这一步也是直接可以解决的,直接跳过

    6.异步线程里多次调用Feign接口

    前面问题我们解决后,以为就完事大吉了。可是后来我们遇见一种场景,开启一个异步线程后,顺序调用里Feign1接口,Feign2接口,当走到Feign2时,接口提示401无权限,这一看就是因为token没有传递过去,当时就奇怪了。为什么Feign没有问题呢?当执行到第二次的Feign时,跟踪执行代码发现如下

    
    @Configuration
    public class FeignRequestInterceptor implements RequestInterceptor {
        
        @Override
        public void apply(RequestTemplate requestTemplate) {
            RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
            // 这里的request还是父线程的对象,没有问题,引用都是同一个,hashCode也是同一个
            HttpServletRequest request = ((ServletRequestAttributes) requestAttributes).getRequest();
    		// 但是这里的headerNames却变成了一个新的引用
    		// 是一个空的对象,这里就是导致取不到值的原因呢
    		// 至今我还没有找到是什么地方将这个对象设置为空。还在探索中
            Enumeration<String> headerNames = request.getHeaderNames();
            while (headerNames.hasMoreElements()){
                String name = headerNames.nextElement();
                String value = request.getHeader(name);
                requestTemplate.header(name, value);
            }
        }
    }
    

    ok既然短期内找不到问题原因,我们是否可以换种思路先解决掉这个问题呢?同样还是使用ThreadLocal的基本原理,我们之前在启动异步编程时,只是设置里RequestAttribute属性,但是后面丢失了。那我们是否可以冗余一份数据,存到我们自己的ThreadLocal里,每个Feign请求前,拦截器里从2个地方获取,一是当前线程的RequestContextHolder里,二是从我们自己的ThreadLocal里取。
    代码如下:

    private static ThreadLocal<Map<String, String>> FeignHeaderCache  = new ThreadLocal<>();
    
        public static void exec(Runnable runnable, ThreadPoolExecutor executor){
            RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
    
            CompletableFuture.runAsync(()->{
                // 手工set到子线程里
                RequestContextHolder.setRequestAttributes(requestAttributes, true);
            }, executor)
                    // 线程开始时,缓存请求头参数
                    .thenRun(()->{
                        Map<String, String> map = new HashMap<>();
                        // 将RequestAttribute里的请求头放到这个map,此处代码省略
                        FeignHeaderCache.set(map);
                    })
                    // 再执行业务的逻辑
                    .thenRun(runnable)
                    // 线程结束后清楚ThreadLocal数据,防止内存溢出
                    .thenRun(() -> {
                        FeignHeaderCache.remove()
                    });
        }
    

    然后再FeignRequestInterceptor里从个ThreadLocal里获取一次即可,代码不贴了。

    总结

    该文章主要是从几种场景入手解决请求头参数传递的问题。都是作者自己在实际使用过程中遇见的一些问题。百度是很难找到类似的。
    展开全文
  • 在项目即将上线的渗透测试报告中检测出了sql注入的问题,关于这个问题的解决方案,最初的思路是写一个全局的过滤器,对所有请求的参数进行过滤拦截,如果存在和sql注入相关的特殊字符则拦截掉,具体细节展开以下讨论...

    在项目即将上线的渗透测试报告中检测出了sql注入的问题,关于这个问题的解决方案,最初的思路是写一个全局的过滤器,对所有请求的参数进行过滤拦截,如果存在和sql注入相关的特殊字符则拦截掉,具体细节展开以下讨论!

    (当然要提供一个白名单,白名单里的请求不给予过滤)

    首先提供以下白名单code.properties
    # 鉴权码
    # IDAM鉴权(多个以逗号分隔)
    authcode=32j42i3
    # 防sql注入请求白名单
    sqlverify=/ryjh/mappingGroup/updateInfo,\
      /author/Logon/loginConfigCheck,\
      /author/Logon/login,\
      /author/SAuUser/resetPwd,\
      /author/SAuUser/addUser,\
      /swagger-resources/configuration/ui,\
      /swagger-resources,\
      /doc.html
    
    第一版的过滤器如下
    /**
     * @author FanJiangFeng
     * @version 1.0.0
     * @ClassName SqlFilter.java
     * @Description 防止Sql注入过滤器,校验参数
     * @createTime 2021年01月05日 17:08:00
     */
    @Component
    @WebFilter(value = "/")
    public class SqlFilter implements Filter {
    
        //Sql注入配置文件白名单绝对路径
        @Value("${auth.authCodeUrl}")
        private String url;
    
    
        private boolean verify(String uri) throws IOException {
            Properties properties=new Properties();
            InputStream inputStream=new FileInputStream(new File(url));
            properties.load(inputStream);
            Map<String,String> codeMap=(Map)properties;
            String whiteDoc=codeMap.get("sqlverify");
            String[] strings = whiteDoc.split(",");
            boolean over=false;
            for(String s:strings){
                if(s.equals(uri)){
                    over=true;
                    break;
                }
            }
            return over;
        }
    
        @Override
        public void init(FilterConfig filterConfig) throws ServletException {
    
        }
    
        @Override
        public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
            HttpServletRequest request=(HttpServletRequest)servletRequest;
            String contentType = request.getContentType();
            String requestURI = request.getRequestURI();
            boolean verify = verify(requestURI);
            if(verify){
                filterChain.doFilter(servletRequest,servletResponse);
                return;
            }   
                //application/x-www-form-urlencoded
                Map<String, String[]> parameterMap = request.getParameterMap();
                for(Map.Entry<String,String[]> entry:parameterMap.entrySet()){
    //                String strings = entry.getKey();
                    //校验参数名是否合法
    //            boolean isTrue = verifySql(strings);
    //            if(!isTrue){
    //                return;
    //            }
                    //校验参数值是否合法
                    String[] value = entry.getValue();
                    for(String s:value){
                        //校验参数值是否合法
                        boolean b = verifySql(s);
                        if(!b){
                            return;
                        }
                    }
            }
            
                filterChain.doFilter(servletRequest,servletResponse);
            	return;
        }
    
        @Override
        public void destroy() {
    
        }
    
        /**
         * 校验参数非法字符
         */
        public boolean verifySql(String parameter){
            if(parameter.contains("'")){ //' 单引号
                return false;
            }else if(parameter.contains("\"")){ //" 双引号
                return false;
            }else if(parameter.contains("\\'")){//' 反斜杠单引号
                return false;
            }else if(parameter.contains("\\\"")){//" 反斜杠双引号
                return false;
            }else if(parameter.contains("(")||parameter.contains(")")||parameter.contains(";")){//括号和分号
                return false;
            }else if(parameter.contains("--")||parameter.contains("+")){//双减号 加号
                return false;
            }else if(parameter.toLowerCase().contains("select")||parameter.toLowerCase().contains("update")
            ||parameter.toLowerCase().contains("delete")||parameter.toLowerCase().contains("drop")
            ||parameter.toLowerCase().contains("updatexml")||parameter.toLowerCase().contains("concat")){
                return false;
            }
            return true;
    
        }
    }
    
    

    第一个版本的不足:

    它只能解析content-type为application/x-www-form-urlencoded的请求携带的参数

    由Map<String, String[]> parameterMap = request.getParameterMap()的方式进行获取

    但是它解析不了content-type类型为application/json格式的参数 ,上面那种方式已经获取不到了,所以要重新改版。

    我是如何跳坑的?

    刚开始我新加了一个方法,传入request对象,然后从request对象中拿到json字符串格式的参数,通过对字符串进行转换校验等处理,然后达到目的效果,但是我发现,处理之后,虽然过滤器放开了这个请求,当请求来到controller时,参数消失了?

    这是因为,request请求中的body参数只可以拿出来一次,拿出来就没有了!

    解决方案

    需要一个类继承HttpServletRequestWrapper,该类继承了ServletRequestWrapper并实现了HttpServletRequest,

    因此它可作为request在FilterChain中传递。

    该类需要重写getReader和getInputStream两个方法,并在返回时将读出的body数据重新写入。

    参考文章:https://my.oschina.net/u/4335633/blog/4252883

    新建BodyReaderRequestWrapper类
    public class BodyReaderRequestWrapper extends HttpServletRequestWrapper {
        private final String body;
    
        public String getBody() {
            return body;
        }
    
        /**
         * 取出请求体body中的参数(创建对象时执行)
         * @param request
         */
        public BodyReaderRequestWrapper(HttpServletRequest request) throws IOException {
            super(request);
            StringBuilder sb = new StringBuilder();
            InputStream ins = request.getInputStream();
            BufferedReader isr = null;
            try{
                if(ins != null){
                    isr = new BufferedReader(new InputStreamReader(ins));
                    char[] charBuffer = new char[128];
                    int readCount = 0;
                    while((readCount = isr.read(charBuffer)) != -1){
                        sb.append(charBuffer,0,readCount);
                    }
                }else{
                    sb.append("");
                }
            }catch (IOException e){
                throw e;
            }finally {
                if(isr != null) {
                    isr.close();
                }
            }
    
            sb.toString();
            body = sb.toString();
        }
    
        @Override
        public BufferedReader getReader() throws IOException {
            return new BufferedReader(new InputStreamReader(this.getInputStream()));
        }
    
        @Override
        public ServletInputStream getInputStream() throws IOException {
            final ByteArrayInputStream byteArrayIns = new ByteArrayInputStream(body.getBytes());
            ServletInputStream servletIns = 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 byteArrayIns.read();
                }
            };
            return  servletIns;
        }
    }
    
    filter过滤器更改

    在dofilter方法中创建BodyReaderRequestWrapper对象,并继续传递。

    		BodyReaderRequestWrapper wrapper=null;
            if("application/json".equals(contentType)){
                wrapper=new BodyReaderRequestWrapper(request);
                ......
                    
            if(wrapper==null){
                filterChain.doFilter(servletRequest,servletResponse);
            }else{
                filterChain.doFilter(wrapper,servletResponse);
            }
    

    既然可以获取到json对象的字符串信息了,那么开始写对json的校验过程

    对json格式参数递归解析

    讨论:json格式的参数种类很多,比如

    {
    "id":"test",
    "name":"test"
    }
    
    [
        {
            "id":"test",
            "name":"test"
    	}
        {
            "id":"test",
            "name":"test"
    	}
    ]
    
    {
    "id":"test",
    "name":[
                {
                    "id":"test",
                    "name":"test"
                }
                {
                    "id":"test",
                    "name":"test"
                }
    		]
    }
    

    以及更多,所以这里采用递归解析的方式

    过滤器的最终版本
    @Component
    @WebFilter(value = "/")
    public class SqlFilter implements Filter {
    
        //Sql注入配置文件白名单绝对路径
        @Value("${auth.authCodeUrl}")
        private String url;
    
    
        private boolean verify(String uri) throws IOException {
            Properties properties=new Properties();
            InputStream inputStream=new FileInputStream(new File(url));
            properties.load(inputStream);
            Map<String,String> codeMap=(Map)properties;
            String whiteDoc=codeMap.get("sqlverify");
            String[] strings = whiteDoc.split(",");
            boolean over=false;
            for(String s:strings){
                if(s.equals(uri)){
                    over=true;
                    break;
                }
            }
            return over;
        }
    
        @Override
        public void init(FilterConfig filterConfig) throws ServletException {
    
        }
    
        @Override
        public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
            HttpServletRequest request=(HttpServletRequest)servletRequest;
            String contentType = request.getContentType();
            String requestURI = request.getRequestURI();
            boolean verify = verify(requestURI);
            if(verify){
                filterChain.doFilter(servletRequest,servletResponse);
                return;
            }
            BodyReaderRequestWrapper wrapper=null;
            if("application/json".equals(contentType)){
                wrapper=new BodyReaderRequestWrapper(request);
                String requestPostStr = wrapper.getBody();
                if (requestPostStr.startsWith("{")) {
                    //解析json对象
                    boolean b = resolveJSONObjectObj(requestPostStr);
                    if(!b)return;
    
                }else if (requestPostStr.startsWith("[")) {
                    //把数据转换成json数组
                    JSONArray jsonArray = JSONArray.parseArray(requestPostStr);
                    jsonArray.forEach(json -> {
                        //解析json对象
                        boolean b = resolveJSONObjectObj(json.toString());
                        if(!b)return;
                    });
                }
    
            }else{
                //application/x-www-form-urlencoded
                Map<String, String[]> parameterMap = request.getParameterMap();
                for(Map.Entry<String,String[]> entry:parameterMap.entrySet()){
    //                String strings = entry.getKey();
                    //校验参数名是否合法
    //            boolean isTrue = verifySql(strings);
    //            if(!isTrue){
    //                return;
    //            }
                    //校验参数值是否合法
                    String[] value = entry.getValue();
                    for(String s:value){
                        //校验参数值是否合法
                        boolean b = verifySql(s);
                        if(!b){
                            return;
                        }
                    }
                }
            }
            if(wrapper==null){
                filterChain.doFilter(servletRequest,servletResponse);
            }else{
                filterChain.doFilter(wrapper,servletResponse);
    
            }
            return;
        }
    
        /**
         * 对JSONObject对象进行递归参数解析
         *
         * @param requestPostStr
         * @return
         */
        private boolean resolveJSONObjectObj(String requestPostStr) {
            boolean isover=true;
            // 创建需要处理的json对象
            JSONObject jsonObject = JSONObject.parseObject(requestPostStr);
            // 获取所有的参数key
            Set<String> keys = jsonObject.keySet();
            if (keys.size() > 0) {
                for (String key : keys) {
                    //获取参数名称
                    String value = null;
                    if (jsonObject.get(key) != null) {
                        value = String.valueOf(jsonObject.get(key));
                        //当value为数组时
                        if(value.startsWith("[")){
                            //把数据转换成json数组
                            JSONArray jsonArray = JSONArray.parseArray(value);
                            for(int i=0;i<jsonArray.size();i++){
                                //解析json对象
                                boolean b = resolveJSONObjectObj(jsonArray.get(i).toString());
                                if(!b){
                                    isover=false;
                                    break;
                                }
                            }
                        }else if(value.startsWith("{")){
                            boolean b = resolveJSONObjectObj(value);
                            if(!b){
                                isover=false;
                                break;
                            }
                        }else{
                            //校验参数值是否合法
                            boolean b = verifySql(value);
                            if(!b){
                                isover=false;
                                break;
                            }
                        }
                    }
                }
            }
            return isover;
        }
    
    
        @Override
        public void destroy() {
    
        }
    
        /**
         * 校验参数非法字符
         */
        public boolean verifySql(String parameter){
            if(parameter.contains("'")){ //' 单引号
                return false;
            }else if(parameter.contains("\"")){ //" 双引号
                return false;
            }else if(parameter.contains("\\'")){//' 反斜杠单引号
                return false;
            }else if(parameter.contains("\\\"")){//" 反斜杠双引号
                return false;
            }else if(parameter.contains("(")||parameter.contains(")")||parameter.contains(";")){//括号和分号
                return false;
            }else if(parameter.contains("--")||parameter.contains("+")){//双减号 加号
                return false;
            }else if(parameter.toLowerCase().contains("select")||parameter.toLowerCase().contains("update")
            ||parameter.toLowerCase().contains("delete")||parameter.toLowerCase().contains("drop")
            ||parameter.toLowerCase().contains("updatexml")||parameter.toLowerCase().contains("concat")){
                return false;
            }
            return true;
    
        }
    }
    

    这样,什么格式的json参数都会解析到!如果有任何问题可以联系本人,可以共同探讨!

    展开全文
  • 本文实例讲述了JS实现页面跳转参数不丢失的方法。分享给大家供大家参考,具体如下:需求...这里就会面临一个问题,url本身就是由多个参数组成的,这样纯粹的传递,就会出问题,参数丢失。所以要对url进行加密。esca...
  • 查询参数丢失场景业务描述: 业务系统需要更新用户系统中的A资源,由于只想更新A资源的一个字段信息为B,所以没有选择通过 entity 封装B,而是直接通过查询参数来传递B信息文字描述:使用FeignClient来进行远程调用...
  • 真有毅丝2020-07-07加粗标红插入代码插入链接插入图片上传视频请 登录 后发表内容关闭新增或编辑超链接链接地址关闭插入视频视频链接const app = getApp()let postData = {//这里填写请求参数,基础参数里的appKey等...
  • 解决URL参数+丢失问题1. 问题背景2. 问题展示【图片】2.1 url链接中2.2 开发者工具传参中2.3 后端接收的参数中3. 问题解决3.1 分析3.2 程序4. 解决后的效果【图片】 1. 问题背景 项目组需要开发一个第三方系统跳转本...
  • 服务端根据url中的参数获取对应的值。java编写的后台代码,可通过HttpServletRequest的方法getParameter("name")获取name的值:name=name1. 事实上HttpServletRequest获取参数是对字符串"?name=name1&id=id
  • 对于一些大的业务表,自增主键这里 ...对于大数值比如1218106361019314176,数据在服务端好好的,到了前端会发现变成1218106361019314200,造成精度丢失,这样显然是有问题的。解决办法:我们只需要配置一下json配...
  • $route.query 一个 key/value 对象,表示 URL 查询参数。 $route.path 字符串,对应当前路由的路径 $route.fullPath 完成解析后的 URL,包含查询参数和 hash 的完整路径。 分析 当浏览器刷新时,触发 导航守卫 ...
  • 1.基础概念 三次握手的丢包重传机制的次数限制和RTO的增长 第一次握手(syn包): tcp_syn_retires 的参数来限制第一次握手(syn包)的重传次数,默认为5次。 第二次握手(ack+ack包): ...2.第一次握手(syn包)丢失
  • 扩展一下,scope 有3个参数 spfile、memory 和 both。 memory 修改动态参数,设置后会立即生效,后面再重新启动数据库服务就失效了,一次性的。 both 修改动态参数,设置后会立即生效,重启数据库服务后一直有效。 ...
  • PID文件丢失处理的方法

    千次阅读 2021-01-19 00:13:49
    当MySQL实例启动时,会将自己的进程ID写入一个文件中-pid文件,该文件由参数pid_file控制,默认位于数据库目录下,文件名为主机名.pidmysql> show variables like 'pid_file';+---------------+-----------------...
  • qs.stringify参数是空数组的时候字段丢失 其中某个数组是空的时候,赋值Null,就不会出现字段丢失 for (let i in config.data) { if (Array.isArray(config.data[i])) { if (config.data[i].length === 0) { ...
  • vue前端处理后台返回的Long型数据精度丢失 问题描述 开发时后端返回的id为Long型,结果发现俩id怎么会一样呢?如下图是控制台Preview返回的数据 正以为是后端那边数据有误时,我点开Response发现这边的id是正常的…...
  • 路由传参的时候出现刷新参数丢失问题,具体解决如下: 在进行路由配置的时候使用如下设置进行的配置,用的params方法进行参数传递。 { path: 'data-detail-edit/:type', component: () => import('@/views/...
  • JavaScript 无法处理 Java 的长整型 Long 导致精度丢失,具体表现为主键最后两位永远为 0,解决思路: Long 转为 String 返回 FastJson 处理方式 @Override public void configureMessageConverters(List<...
  • 最近使用原生JS发起加密数据请求时,遇到请求...因此数据在不处理的情况下,会丢失符号数据。因此在我们需要处理可能含有“加号或连接符号”的数据时,一定要加转义处理:window.encodeURIComponent("a+b");为避免...
  • 通过测试,查看日志及返回值,发现参数缺失时,会抛出异常: org.springframework.web.bind.MethodArgumentNotValidException 所以,我们要对一些异常进行统一处理,首先在我们自定义的异常类加上@ControllerAdvice...
  • // 指定 ReturnCallback } /** * 交换机 */ @Bean public DirectExchange myDirectExchange() { // 参数意义: // name: 名称 // durable: true // autoDelete: 自动删除 return new DirectExchange(MqConstant....
  • Uri 获取参数参数值内存在#符号 丢失问题解决 例如如下链接 例如:url:xxxx//xl?type=2&id=50096160835145728&content=#内容# Uri uri = Uri.parse(url); String type = uri.getQueryParameter(...
  • 文章目录本篇要点经典问题:浮点数精度丢失十进制整数如何转化为二进制整数?十进制小数如何转化为二进制数?如何用BigDecimal解决double精度问题?new BigDecimal(double val)new BigDecimal(String val)BigDecimal...
  • 前端请求后端接口获取BigDecimal类型字段数值时丢失精度,例如:5999.00变成5999、5999.50变成5999.5。 2、解决方法: 在字段上添加 @JsonFormat(shape = JsonFormat.Shape.STRING)注解,在序列化数据时会以String...
  • 一、用系统光盘修复系统 1、设置光驱启动 Award BIOS 6.0设置 重启,按Del进入BIOS 6.0设置界面,找到Advanced Bios Features(高级BIOS参数设置)按回车进Advanced Bios Features界面,用键盘方向键盘选定First Boot ...
  • 最近在返回给前端数据的时候遇到了1 Long类型返回前端精度丢失 2LocalDateTime统一返回时间戳方便前端统一处理的问题,记录下解决方案。 代码如下 环境:springboot2.x ,JDK8 import ...
  • 解决表单提交的数据丢失问题:一、问题描述:当我们在给前台页面设置修改功能的时候,因为有些信息是不允许进行修改的,所以在修改表单中没有相应的修改输入框,但是在修改表单的数据提交的时候,那些不允许修改的...
  • 缘起 Http 请求时发现请求的url遇到特殊字符#被截断,导致部分字符丢失,最终造成请求返回的结果不对。 解决方案 使用System.Web.HttpUtility.HtmlEncode对字符串做处理
  • Dubbo在使用RpcContext.getContext()传递参数时,因为参数的生命周期。所以只能调用一次,如果在方法中出现了连续调用两次的情况,则会出现获取不到参数的情况。 实际场景在sass类项目里比较常见,经常需要传递区分...
  • 当打开多个标签页时,在一个页面输入框输入内容筛选搜索了数据,切换到其他页面再切换回搜索数据的页面,将会发现筛选查询输入框内容已丢失。 二、导致问题出现的原因: 路由配置name参数和对应访问vue文件内的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 321,707
精华内容 128,682
关键字:

参数丢失怎么处理