精华内容
下载资源
问答
  • SpringBoot1.5.8 简单解决Spring框架RFD(反射型文件下载)漏洞
    2020-09-24 15:41:42

    标题SpringBoot1.5.8 简单解决Spring框架RFD(反射型文件下载)漏洞

    我的程序采用的是springboot+gradle模式,
    修复此漏洞的版本为Spring Framework:
    5.2.9
    5.1.18
    5.0.19
    4.3.29
    而我的springboot版本为1.5.8只能将spring Framework版本由默认的4.3.12升级为4.3.29。需要修改build.gradle配置文件,增加Spring Framework的版本要求:
    ext {
    springVersion = ‘4.3.29.RELEASE’
    }
    allprojects {
    dependencies {
    dependency(“org.springframework:spring-aop: s p r i n g V e r s i o n " ) d e p e n d e n c y ( " o r g . s p r i n g f r a m e w o r k : s p r i n g − b e a n s : {springVersion}") dependency("org.springframework:spring-beans: springVersion")dependency("org.springframework:springbeans:{springVersion}”)
    dependency(“org.springframework:spring-context: s p r i n g V e r s i o n " ) d e p e n d e n c y ( " o r g . s p r i n g f r a m e w o r k : s p r i n g − c o n t e x t − s u p p o r t : {springVersion}") dependency("org.springframework:spring-context-support: springVersion")dependency("org.springframework:springcontextsupport:{springVersion}”)
    dependency(“org.springframework:spring-core: s p r i n g V e r s i o n " ) d e p e n d e n c y ( " o r g . s p r i n g f r a m e w o r k : s p r i n g − e x p r e s s i o n : {springVersion}") dependency("org.springframework:spring-expression: springVersion")dependency("org.springframework:springexpression:{springVersion}”)
    dependency(“org.springframework:spring-jdbc: s p r i n g V e r s i o n " ) d e p e n d e n c y ( " o r g . s p r i n g f r a m e w o r k : s p r i n g − o r m : {springVersion}") dependency("org.springframework:spring-orm: springVersion")dependency("org.springframework:springorm:{springVersion}”)
    dependency(“org.springframework:spring-oxm: s p r i n g V e r s i o n " ) d e p e n d e n c y ( " o r g . s p r i n g f r a m e w o r k : s p r i n g − t e s t : {springVersion}") dependency("org.springframework:spring-test: springVersion")dependency("org.springframework:springtest:{springVersion}”)
    dependency(“org.springframework:spring-tx: s p r i n g V e r s i o n " ) d e p e n d e n c y ( " o r g . s p r i n g f r a m e w o r k : s p r i n g − w e b : {springVersion}") dependency("org.springframework:spring-web: springVersion")dependency("org.springframework:springweb:{springVersion}”)
    dependency(“org.springframework:spring-webmvc:${springVersion}”)
    }
    }

    第二种方法就是springboot升级到2.3.4,、2.2.10,、2.1.17三个版本,默认对应的spring Framework版5.2.9、5.1.18、5.0.19也可以修复此问题。
    我也试过springboot升级到2.1.17版本,经过一番修改程序没有问题,却在打包后部署到weblogic12C版本时提示 tomcat-embled-el-9.0.38.jar!/META-INF/web-fragment.xml problem:cvc-enumeration-valid:string value ‘4.0’ is not a valid enumeration value for web-app-versionType is namespace。目前还在研究中,估计是因为版本冲突的原因。

    更多相关内容
  • VMware Tanzu发布安全公告,在Spring Framework版本5.2.0-5.2.8、 5.1.0-5.1.17、 5.0.0-5.0.18、 4.3.0-4.3.28和较旧的不受支持的版本中,公布了一个存在于Spring Framework中的反射型文件下载(Reflected File ...

    VMware Tanzu发布安全公告,在Spring Framework版本 5.2.0-5.2.8、 5.1.0-5.1.17、 5.0.0-5.0.18、 4.3.0-4.3.28 和较旧的不受支持的版本中,公布了一个存在于Spring Framework中的反射型文件下载(Reflected File Download,RFD)漏洞CVE-2020-5421。
    CVE-2020-5421 可通过jsessionid路径参数,绕过防御RFD攻击的保护。先前针对RFD的防护是为应对 CVE-2015-5211 添加的。
    攻击者通过向用户发送带有批处理脚本扩展名的URL,使用户下载并执行文件,从而危害用户系统。VMware Tanzu官方已发布修复漏洞的新版本。
    Spring Framework是 Java 平台的一个开源全栈应用程序框架和控制反转容器实现,一般被直接称为 Spring。

    参考资料 https://tanzu.vmware.com/security/cve-2020-5421

    Affected VMware Products and Versions   受影响的版本

    Severity is high unless otherwise noted.

    • Spring Framework
      • 5.2.0 to 5.2.8
      • 5.1.0 to 5.1.17
      • 5.0.0 to 5.0.18
      • 4.3.0 to 4.3.28
      • Older, unsupported versions

    Mitigation  安全版本

    Users of affected versions should apply the following mitigation or upgrade. Releases that have fixed this issue include:

    • Spring Framework
      • 5.2.9
      • 5.1.18
      • 5.0.19
      • 4.3.29

    看公告,我们需要将我们spring的核心版本升级到指定的安全版本

    我们项目是springboot的,仓库用的maven

    先看一下我们的仓库,果然是存在漏洞的版本

     

     然后修改pom

     我们这里的版本需要去maven仓库远程地址去看一下有哪些版本  https://repo.maven.apache.org/maven2/org/springframework/boot/spring-boot-starter-parent/

     截止目前文章发布日期来看,正式版是2.3.9

     

    这里比较恶心的是,我们看的这个版本并不知道maven导入的spring核心版本是多少,所以只能试(我没找到对应版本的关系图)

    这里我找到的安全版本 5.2.9  对应parent是  2.3.4.RELEASE

     

    maven重新clean并install

    刷新maven发现spring核心组件的版本都是5.2.9了

     

    关于原来是1.几低版本的问题

    应用启动类报错

    import org.springframework.boot.web.support.SpringBootServletInitializer;

    改成

    import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;

    综合来讲下次搭架子的时候直接用安全版本就行,省的换了麻烦

     

    展开全文
  • 这几天有个对SpringCloud-Gateway网关请求参数做安全校验的需求,网上多数教程不适用于SpringBoot2.1+版本。我在SpringCloud gateway Github中的Issues找到了答案,放上连接:作者采纳的答案。 具体代码如下: @...

    SpringCloudGateway,获取body的参数,网上的解决方案能试的都试了,踩了很多坑,要么代码是很复杂,要么是参数只能获取一次,要么是get类型的请求有问题了,要么是压根获取不到参数,还有一种问题是post请求下,无参数的接口访问会出问题,会返回空串

    以上问题都在这里解决:

    Talk is cheap. Show me the code. --Linus Torvalds

    参数模型:

    /**
     * 网关上下文
     */
    @Data
    public class GatewayContext {
    
        public static final String CACHE_GATEWAY_CONTEXT = "cacheGatewayContext";
    
        /**
         * cache headers
         */
        private HttpHeaders headers;
    
        /**
         * baseHeader
         */
        private BaseHeader baseHeader;
    
        /**
         * cache json body
         */
        private String cacheBody;
        /**
         * cache formdata
         */
        private MultiValueMap<String, String> formData = new LinkedMultiValueMap<>();
    
        /**
         * ipAddress
         */
        private String  ipAddress;
    
        /**
         * path
         */
        private String path;
    
    }
    

    参数可以根据自己业务需求进行定制

    请求参数过滤器:

    import io.netty.buffer.ByteBufAllocator;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.cloud.gateway.filter.GatewayFilterChain;
    import org.springframework.cloud.gateway.filter.GlobalFilter;
    import org.springframework.core.Ordered;
    import org.springframework.core.io.ByteArrayResource;
    import org.springframework.core.io.buffer.DataBuffer;
    import org.springframework.core.io.buffer.DataBufferUtils;
    import org.springframework.core.io.buffer.NettyDataBufferFactory;
    import org.springframework.http.HttpHeaders;
    import org.springframework.http.MediaType;
    import org.springframework.http.codec.HttpMessageReader;
    import org.springframework.http.server.reactive.ServerHttpRequest;
    import org.springframework.http.server.reactive.ServerHttpRequestDecorator;
    import org.springframework.http.server.reactive.ServerHttpResponse;
    import org.springframework.stereotype.Component;
    import org.springframework.util.MultiValueMap;
    import org.springframework.web.reactive.function.server.HandlerStrategies;
    import org.springframework.web.reactive.function.server.ServerRequest;
    import org.springframework.web.server.ServerWebExchange;
    import reactor.core.publisher.Flux;
    import reactor.core.publisher.Mono;
    
    
    import java.io.UnsupportedEncodingException;
    import java.net.URLEncoder;
    import java.nio.charset.Charset;
    import java.nio.charset.StandardCharsets;
    import java.util.List;
    import java.util.Map;
    
    /**
     * 请求内容存储 处理请求内容 内容放在gatewayContext中
     */
    /**
     * @author kam
     *
     *         <p>
     *         请求内容存储 处理请求内容 内容放在gatewayContext中
     *         </p>
     */
    @Component
    @Slf4j
    public class RequestCoverFilter implements GlobalFilter, Ordered {
    
        /**
         * default HttpMessageReader
         */
        private static final List<HttpMessageReader<?>> messageReaders = HandlerStrategies.withDefaults().messageReaders();
    
        /**
         * ReadFormData
         *
         * @param exchange
         * @param chain
         * @return
         */
        private Mono<Void> readFormData(ServerWebExchange exchange, GatewayFilterChain chain,
            GatewayContext gatewayContext) {
            final ServerHttpRequest request = exchange.getRequest();
            HttpHeaders headers = request.getHeaders();
    
            return exchange.getFormData().doOnNext(multiValueMap -> {
                gatewayContext.setFormData(multiValueMap);
                log.debug("[GatewayContext]Read FormData:{}", multiValueMap);
            }).then(Mono.defer(() -> {
                Charset charset = headers.getContentType().getCharset();
                charset = charset == null ? StandardCharsets.UTF_8 : charset;
                String charsetName = charset.name();
                MultiValueMap<String, String> formData = gatewayContext.getFormData();
                /**
                 * formData is empty just return
                 */
                if (null == formData || formData.isEmpty()) {
                    return chain.filter(exchange);
                }
                StringBuilder formDataBodyBuilder = new StringBuilder();
                String entryKey;
                List<String> entryValue;
                try {
                    /**
                     * repackage form data
                     */
                    for (Map.Entry<String, List<String>> entry : formData.entrySet()) {
                        entryKey = entry.getKey();
                        entryValue = entry.getValue();
                        if (entryValue.size() > 1) {
                            for (String value : entryValue) {
                                formDataBodyBuilder.append(entryKey).append("=")
                                    .append(URLEncoder.encode(value, charsetName)).append("&");
                            }
                        } else {
                            formDataBodyBuilder.append(entryKey).append("=")
                                .append(URLEncoder.encode(entryValue.get(0), charsetName)).append("&");
                        }
                    }
                } catch (UnsupportedEncodingException e) {
                    // ignore URLEncode Exception
                }
                /**
                 * substring with the last char '&'
                 */
                String formDataBodyString = "";
                if (formDataBodyBuilder.length() > 0) {
                    formDataBodyString = formDataBodyBuilder.substring(0, formDataBodyBuilder.length() - 1);
                }
                /**
                 * get data bytes
                 */
                byte[] bodyBytes = formDataBodyString.getBytes(charset);
                int contentLength = bodyBytes.length;
                ServerHttpRequestDecorator decorator = new ServerHttpRequestDecorator(request) {
                    /**
                     * change content-length
                     *
                     * @return
                     */
                    @Override
                    public HttpHeaders getHeaders() {
                        HttpHeaders httpHeaders = new HttpHeaders();
                        httpHeaders.putAll(super.getHeaders());
                        if (contentLength > 0) {
                            httpHeaders.setContentLength(contentLength);
                        } else {
                            httpHeaders.set(HttpHeaders.TRANSFER_ENCODING, "chunked");
                        }
                        return httpHeaders;
                    }
    
                    /**
                     * read bytes to Flux<Databuffer>
                     *
                     * @return
                     */
                    @Override
                    public Flux<DataBuffer> getBody() {
                        return DataBufferUtils.read(new ByteArrayResource(bodyBytes),
                            new NettyDataBufferFactory(ByteBufAllocator.DEFAULT), contentLength);
                    }
                };
                ServerWebExchange mutateExchange = exchange.mutate().request(decorator).build();
                log.info("[GatewayContext]Rewrite Form Data :{}", formDataBodyString);
    
                return chain.filter(mutateExchange);
            }));
        }
    
        /**
         * ReadJsonBody
         *
         * @param exchange
         * @param chain
         * @return
         */
        private Mono<Void> readBody(ServerWebExchange exchange, GatewayFilterChain chain, GatewayContext gatewayContext) {
            /**
             * join the body
             */
            return DataBufferUtils.join(exchange.getRequest().getBody()).flatMap(dataBuffer -> {
                /*
                 * read the body Flux<DataBuffer>, and release the buffer
                 * //TODO when SpringCloudGateway Version Release To G.SR2,this can be update with the new version's feature
                 * see PR https://github.com/spring-cloud/spring-cloud-gateway/pull/1095
                 */
                byte[] bytes = new byte[dataBuffer.readableByteCount()];
                dataBuffer.read(bytes);
                DataBufferUtils.release(dataBuffer);
                Flux<DataBuffer> cachedFlux = Flux.defer(() -> {
                    DataBuffer buffer = exchange.getResponse().bufferFactory().wrap(bytes);
                    DataBufferUtils.retain(buffer);
                    return Mono.just(buffer);
                });
                /**
                 * repackage ServerHttpRequest
                 */
                ServerHttpRequest mutatedRequest = new ServerHttpRequestDecorator(exchange.getRequest()) {
                    @Override
                    public Flux<DataBuffer> getBody() {
                        return cachedFlux;
                    }
                };
                /**
                 * mutate exchage with new ServerHttpRequest
                 */
                ServerWebExchange mutatedExchange = exchange.mutate().request(mutatedRequest).build();
                /**
                 * read body string with default messageReaders
                 */
                return ServerRequest.create(mutatedExchange, messageReaders).bodyToMono(String.class)
                    .doOnNext(objectValue -> {
                        gatewayContext.setCacheBody(objectValue);
                        log.debug("[GatewayContext]Read JsonBody:{}", objectValue);
                    }).then(chain.filter(mutatedExchange));
            });
        }
    
        @Override
        public int getOrder() {
            return HIGHEST_PRECEDENCE;
        }
    
        @Override
        public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
            /**
             * save request path and serviceId into gateway context
             */
            ServerHttpRequest request = exchange.getRequest();
            ServerHttpResponse response = exchange.getResponse();
    
            GatewayContext gatewayContext = new GatewayContext();
            String path = request.getPath().pathWithinApplication().value();
            gatewayContext.setPath(path);
            gatewayContext.getFormData().addAll(request.getQueryParams());
            gatewayContext.setIpAddress(String.valueOf(request.getRemoteAddress()));
            HttpHeaders headers = request.getHeaders();
            gatewayContext.setHeaders(headers);
            log.debug("HttpMethod:{},Url:{}", request.getMethod(), request.getURI().getRawPath());
    
            /// 注意,因为webflux的响应式编程 不能再采取原先的编码方式 即应该先将gatewayContext放入exchange中,否则其他地方可能取不到
            /**
             * save gateway context into exchange
             */
            exchange.getAttributes().put(GatewayContext.CACHE_GATEWAY_CONTEXT, gatewayContext);
    
            // 处理参数
            MediaType contentType = headers.getContentType();
            long contentLength = headers.getContentLength();
            if (contentLength > 0) {
                if (MediaType.APPLICATION_JSON.equals(contentType) || MediaType.APPLICATION_JSON_UTF8.equals(contentType)) {
                    return readBody(exchange, chain, gatewayContext);
                }
                if (MediaType.APPLICATION_FORM_URLENCODED.equals(contentType)) {
                    return readFormData(exchange, chain, gatewayContext);
                }
            }
            // TODO 多版本划区域控制后期实现
    
            log.debug("[GatewayContext]ContentType:{},Gateway context is set with {}", contentType, gatewayContext);
            return chain.filter(exchange);
        }
    
    }
    

    使用的地方:

      // 获取request body
    GatewayContext gatewayContext = exchange.getAttribute(GatewayContext.CACHE_GATEWAY_CONTEXT);
    
    

    总结:

    内容参考:
    SpringCloud Gateway 记录缓存请求Body和Form表单

    展开全文
  • 1.spring boot 不支持jsp打jar包,jsp只能打war包. 方法: <packaging>war <groupId>org.springframework.boot <artifactId>spring-boot-maven-plugin 2.tomcat版本不能太新,太新容易不...
  • 在学习spring boot时,遇到了一些问题,当我需要向前端发送一个视图的时候,return + 视图名无法返回视图,也就是前端无法打印出这个视图,只能以字符串形式将视图名打印到浏览器端,如图所示 package ...

    在学习spring boot时,遇到了一些问题,当我需要向前端发送一个视图的时候,return + 视图名无法返回视图,也就是前端无法打印出这个视图,只能以字符串形式将视图名打印到浏览器端,如图所示

    首先,添加依赖,必须要添加一个模板才可以,要不然浏览器无法解析(本文添加的是thymeleaf模板引擎)

        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-thymeleaf</artifactId>
            </dependency>
    
    package com.wcc.spring_boot_testthymeleaf.Controller;
    
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    import org.springframework.web.servlet.ModelAndView;
    
    
    @RestController
    public class HelloController {
    
        @RequestMapping("/success1")
        public String success1(){
            return "success";
        }
    
        @RequestMapping("/success")
        public ModelAndView success(){
            return new ModelAndView("success");
        }
    
    }
    
    
    <!DOCTYPE html>
    <html lang="en" xmlns:th="http://www.thymeleaf.org">
    <head>
        <meta charset="UTF-8">
        <title>Title</title>
    </head>
    <body>
    <h1>成功!!!</h1>
    <!--    &lt;!&ndash;th:text将div中的文本内容设置为${}&ndash;&gt;
        <div th:text="${hello}">123</div>-->
    </body>
    </html>
    

    访问http://localhost:8080/success1时的运行结果
    在这里插入图片描述
    访问http://localhost:8080/success时的运行结果
    在这里插入图片描述
    上面两张截图是在@RestController注解下的两种不同返回类型所返回的界面,上面的那张截图的方法返回的是String类型,下面的那张截图的方法返回的是ModelAndView 类型,造成了两种不同的结果

    当将@RestController注解换成@Controller注解时,代码和截图如下:

    package com.wcc.spring_boot_testthymeleaf.Controller;
    
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.servlet.ModelAndView;
    
    
    @Controller
    public class HelloController {
    
        @RequestMapping("/success1")
        public String success1(){
            return "success";
        }
    
        @RequestMapping("/success")
        public ModelAndView success(){
            return new ModelAndView("success");
        }
    
    }
    

    访问http://localhost:8080/success1时的运行结果
    在这里插入图片描述
    访问http://localhost:8080/success时的运行结果
    在这里插入图片描述
    发现两种访问都会定位到success.html页面,不会出现打印html文件名称的字符的情况。n

    那么,造成这种情况的根本原因是什么呢?

    据官方文档显示:A convenience annotation that is itself annotated with @Controller and @ResponseBody.

    1)如果使用@RestController注解,则Controller中的方法无法返回jsp页面,配置的视图解析器InternalResourceViewResolver则不起作用,返回的内容就是Return 里的内容(String/JSON),也就是只有返回类型是ModelAndView类型才能返回视图到前端,若返回其他类型都会以字符串的形式在前端显示

    2)如果使用@Controller注解,如果需要返回JSON,XML或自定义mediaType内容到页面,则需要在对应的方法上加上@ResponseBody注解。

    展开全文
  • 无论在Spring5的webflux编程或者普通web编程中,只能从request中获取body一次,后面无法再获取,这个问题怎么解决呢? 网上博客有多种处理办法,对不同的spring cloud gateway版本不一定有用。本文着重说明下版本...
  • 跨域资源共享CORS(Cross-origin Resource Sharing),是W3C的一个标准,允许浏览器向跨源的服务器发起XMLHttpRequest请求,克服ajax请求只能同源使用的限制。关于CORS的详细解读,可参考阮一峰大神的博客:跨域资源...
  • 一个能够为基于Spring的企业应用系统提供声明式的安全訪问控制解决方式的安全框架(简单说是对访问权限进行控制嘛),应用的安全性包括用户认证(Authentication)和用户授权(Authorization)两个部分。用户认证指...
  • Spring 是如何解决循环依赖问题的

    千次阅读 2021-04-24 16:20:05
    首先我们要知道什么是Spring的循环依赖问题。假如我们有两个bean,A 和 B。他们的代码简单如下: @Bean public class A { @Autowire private B b; } @Bean public class B { @Autowire private A a; } 也...
  • java spring mvc网站报XMLHttpRequest cannot load,只能get访问不能post访问 的解决办法.zip
  • spring boot 解决 @RequestBody只能读取一次的问题 新建 BodyReaderFilter.class @WebFilter(filterName="bodyReaderFilter",urlPatterns="/*") public class BodyReaderFilter implements Filter { @...
  • Spring 如何使用级缓存解决循环依赖。通过对依赖注入、spring创建bean的过程、级缓存的详细分析,说明了spring是如何利用Bean的生命周期来灵活解决循环依赖问题,以及使用级缓存的必要性!
  • spring解决循环依赖

    千次阅读 2019-06-17 16:50:07
    1、想看Spring源码,但是不知道应当如何入手去看,对整个Bean的流程没有概念,碰到相关问题也没有头绪如何下手 2、看过几遍源码,没办法彻底理解,没什么感觉,没过一阵子又忘了 本文将结合实际问题,由问题引出...
  • 无论在Spring5的webflux编程或者普通web编程中,只能从request中获取body一次,后面再获取就会报错,但我们有时候会需要获取body中的数据进行加签、验签,这个问题怎么解决呢。   ServerHttpRequestDecorator与...
  • // 此处读取了request中的inputStream,因为只能被读取一次,后面spring框架无法读取了,所以需要添加wrapper和filter解决只能读取一次的问题 BufferedReader reader = request.getReader(); if (reader == ...
  • Spring解决了什么问题

    千次阅读 2019-04-08 15:53:08
    不像struts只能负责控制层的,而hibernate只能负责数据层,spring全都可以就行负责。   spring主要的运行场景:   总结: spring中避免了关键字new造成耦合的问题; spring本身就是一个工厂...
  • 单例:一个类只能产生一个对象(对应到spring中,注入的对象永远是同一个) 多例:一个类能产生多个对象(对应到spring中,注入的对象永远是新的) @Scope("prototype") @Scope("singleton") 可以使用@Scope注解,...
  • 循环依赖的产生1 构造器方式产生的循环依赖(spring本身无法解决,抛出异常)2 setter方法产生的循环依赖3 setter方式原型,prototypespring级缓存解决循环依赖问题:总结 什么是循环依赖? 循环依赖就是循环...
  • 需要把app部署在多台服务器上,但只能让其中一台服务器的job执行,一台服务器挂了,另一台还能继续执行job,通过网上查找资料,都是java工程的方式,不好部署并测试,经过天辛苦整合,终于整理成一个单spring web...
  • 以上种方法都可以解决问题,最常用的应该是第一种、第种,控制在自家几个域名范围下足以,一般没必要搞得太细。 这种配置方式都用了的话,谁生效呢,类似css中样式,就近原则,懂了吧。 【推荐阅读】 Docker...
  • Spring Cloud Gateway解决跨域问题

    千次阅读 2022-01-04 16:55:07
    Spring Cloud Gateway解决跨域问题1、什么是跨域2、为什么会有跨域问题3、Spring Cloud Gateway解决跨域问题3.1 搭建server-gateway模块3.2 引入相关依赖3.3 resources下添加配置文件3.4 启动类3.5 解决跨域问题3.6 ...
  • Springboot+Redis实现Session共享,一个用户只能登录一次,再次登录会把上次登录给挤掉。
  • Spring如何解决循环依赖的问题

    千次阅读 2021-03-11 10:27:15
    前言在面试的时候这两年有一个非常高频的关于spring的问题,那就是spring是如何解决循环依赖的。这个问题听着就是轻描淡写的一句话,其实考察的内容还是非常多的,主要还是考察的应聘者有没有研究过spring的源码。...
  • spring如何解决循环依赖问题?

    千次阅读 多人点赞 2021-03-01 15:49:35
    // 级缓存 对于setter注入造成的依赖是通过Spring容器提前暴露刚完成实例化但未完成初始化的bean来完成的,而且只能解决单例作用域的bean循环依赖。通过提前暴露一个单例工厂方法,从而使其他bean能引用到该bean...
  • Spring循环依赖的种方式以及解决办法 【转】https://www.cnblogs.com/liuqing576598117/p/11227007.html 示例 ...
  • 近段时间一直在研究源码层面的东西,在调试Spring源代码的时候,发现idea无法下载Spring的源代码,只能看到idea反编译过来的代码,有点头痛,又懒得去Spring官网下载,害! 下载源代码报错提示如下 Sources not ...
  • 详细整理Spring事务失效的具体场景及解决方案

    万次阅读 多人点赞 2020-08-04 22:25:14
    好多小伙伴可能只是简单了解一下,遇到事务失效的情况,便会无从下手,溪源此篇文章给大家整理了一下常见Spring事务失效的场景,希望开发过程尽量避免踩坑,造成时间精力的浪费。 溪源按照最基本的使用方式以及常见...
  • 1.2 两种Spring容器循环依赖:1.3 在Spring中循环依赖处理分为3种情况1.3.1 构造器循环依赖(无法解决)1.3.2 setter循环依赖(可以解决)1.3.3 范围的依赖处理1.4 针对上述的作用域(scope)分析1.5 spring容器...
  • 解决办法 解决脏读 @Transactional(isolation = Isolation.READ_COMMITTED)//读已提交 脏读 要求Transaction01只能读取Transaction02已提交的修改。 解决不可重复读 @Transactional(isolation = Isolation....
  • SpringCloud 学习微服务架构必须有年以上的开发的经验: 微服务概念 把一个大型的单体应用拆分为数个支持微服务,他可扩展单个组件而不是整个的应用程序堆栈,从而满足服务等级协议 定义:围绕业务领域组件进行...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 149,087
精华内容 59,634
关键字:

64位下载spring只能下载32位的怎么解决

spring 订阅
友情链接: avisd.rar