RestTemplate使用不当引发的504及连接池耗尽问题分析

news2024/10/5 18:29:41

背景

  • 系统: SpringBoot开发的Web应用;
  • ORM: JPA(Hibernate)
  • 接口功能简述: 根据实体类ID到数据库中查询实体信息,然后使用RestTemplate调用外部系统接口获取数据。

问题现象

  1. 浏览器页面有时报504 GateWay Timeout错误,刷新多次后,则总是timeout
  2. 数据库连接池报连接耗尽异常
  3. 调用外部系统时有时报502 Bad GateWay错误

分析过程

为便于描述将本系统称为A,外部系统称为B。

这三个问题环环相扣,导火索是第3个问题,然后导致第2个问题,最后导致出现第3个问题;
原因简述: 第3个问题是由于Nginx负载下没有挂系统B,导致本系统在请求外部系统时报502错误,而A没有正确处理异常,导致http请求无法正常关闭,而springboot默认打开openSessionInView, 只有调用A的请求关闭时才会关闭数据库连接,而此时调用A的请求没有关闭,导致数据库连接没有关闭。

这里主要分析第1个问题:为什么请求A的连接出现504 Timeout.

AbstractConnPool

通过日志看到A在调用B时出现阻塞,直到timeout,打印出线程堆栈查看:

线程阻塞在AbstractConnPool类getPoolEntryBlocking方法中

    private E getPoolEntryBlocking(
            final T route, final Object state,
            final long timeout, final TimeUnit timeUnit,
            final Future<E> future) throws IOException, InterruptedException, TimeoutException {

        Date deadline = null;
        if (timeout > 0) {
            deadline = new Date (System.currentTimeMillis() + timeUnit.toMillis(timeout));
        }
        this.lock.lock();
        try {
           //根据route获取route对应的连接池
            final RouteSpecificPool<T, C, E> pool = getPool(route);
            E entry;
            for (;;) {
                Asserts.check(!this.isShutDown, "Connection pool shut down");
                for (;;) {
                   //获取可用的连接
                    entry = pool.getFree(state);
                    if (entry == null) {
                        break;
                    }
                    // 判断连接是否过期,如过期则关闭并从可用连接集合中删除
                    if (entry.isExpired(System.currentTimeMillis())) {
                        entry.close();
                    }
                    if (entry.isClosed()) {
                        this.available.remove(entry);
                        pool.free(entry, false);
                    } else {
                        break;
                    }
                }
               // 如果从连接池中获取到可用连接,更新可用连接和待释放连接集合
                if (entry != null) {
                    this.available.remove(entry);
                    this.leased.add(entry);
                    onReuse(entry);
                    return entry;
                }

                // 如果没有可用连接,则创建新连接
                final int maxPerRoute = getMax(route);
                // 创建新连接之前,检查是否超过每个route连接池大小,如果超过,则删除可用连接集合相应数量的连接(从总的可用连接集合和每个route的可用连接集合中删除)
                final int excess = Math.max(0, pool.getAllocatedCount() + 1 - maxPerRoute);
                if (excess > 0) {
                    for (int i = 0; i < excess; i++) {
                        final E lastUsed = pool.getLastUsed();
                        if (lastUsed == null) {
                            break;
                        }
                        lastUsed.close();
                        this.available.remove(lastUsed);
                        pool.remove(lastUsed);
                    }
                }

                if (pool.getAllocatedCount() < maxPerRoute) {
                   //比较总的可用连接数量与总的可用连接集合大小,释放多余的连接资源
                    final int totalUsed = this.leased.size();
                    final int freeCapacity = Math.max(this.maxTotal - totalUsed, 0);
                    if (freeCapacity > 0) {
                        final int totalAvailable = this.available.size();
                        if (totalAvailable > freeCapacity - 1) {
                            if (!this.available.isEmpty()) {
                                final E lastUsed = this.available.removeLast();
                                lastUsed.close();
                                final RouteSpecificPool<T, C, E> otherpool = getPool(lastUsed.getRoute());
                                otherpool.remove(lastUsed);
                            }
                        }
                       // 真正创建连接的地方
                        final C conn = this.connFactory.create(route);
                        entry = pool.add(conn);
                        this.leased.add(entry);
                        return entry;
                    }
                }

               //如果已经超过了每个route的连接池大小,则加入队列等待有可用连接时被唤醒或直到某个终止时间
                boolean success = false;
                try {
                    if (future.isCancelled()) {
                        throw new InterruptedException("Operation interrupted");
                    }
                    pool.queue(future);
                    this.pending.add(future);
                    if (deadline != null) {
                        success = this.condition.awaitUntil(deadline);
                    } else {
                        this.condition.await();
                        success = true;
                    }
                    if (future.isCancelled()) {
                        throw new InterruptedException("Operation interrupted");
                    }
                } finally {
                    //如果到了终止时间或有被唤醒时,则出队,加入下次循环
                    pool.unqueue(future);
                    this.pending.remove(future);
                }
                // 处理异常唤醒和超时情况
                if (!success && (deadline != null && deadline.getTime() <= System.currentTimeMillis())) {
                    break;
                }
            }
            throw new TimeoutException("Timeout waiting for connection");
        } finally {
            this.lock.unlock();
        }
    }

getPoolEntryBlocking方法用于获取连接,主要有三步:(1).检查可用连接集合中是否有可重复使用的连接,如果有则获取连接,返回. (2)创建新连接,注意同时需要检查可用连接集合(分为每个route的和全局的)是否有多余的连接资源,如果有,则需要释放。(3)加入队列等待;

从线程堆栈可以看出,第1个问题是由于走到了第3步。开始时是有时会报504异常,刷新多次后会一直报504异常,经过跟踪调试发现前几次会成功获取到连接,而连接池满后,后面的请求会阻塞。正常情况下当前面的连接释放到连接池后,后面的请求会得到连接资源继续执行,可现实是后面的连接一直处于等待状态,猜想可能是由于连接一直未释放导致。

我们来看一下连接在什么时候会释放。

RestTemplate

由于在调外部系统B时,使用的是RestTemplate的getForObject方法,从此入手跟踪调试看一看。

	@Override
	public <T> T getForObject(String url, Class<T> responseType, Object... uriVariables) throws RestClientException {
		RequestCallback requestCallback = acceptHeaderRequestCallback(responseType);
		HttpMessageConverterExtractor<T> responseExtractor =
				new HttpMessageConverterExtractor<T>(responseType, getMessageConverters(), logger);
		return execute(url, HttpMethod.GET, requestCallback, responseExtractor, uriVariables);
	}

	@Override
	public <T> T getForObject(String url, Class<T> responseType, Map<String, ?> uriVariables) throws RestClientException {
		RequestCallback requestCallback = acceptHeaderRequestCallback(responseType);
		HttpMessageConverterExtractor<T> responseExtractor =
				new HttpMessageConverterExtractor<T>(responseType, getMessageConverters(), logger);
		return execute(url, HttpMethod.GET, requestCallback, responseExtractor, uriVariables);
	}

	@Override
	public <T> T getForObject(URI url, Class<T> responseType) throws RestClientException {
		RequestCallback requestCallback = acceptHeaderRequestCallback(responseType);
		HttpMessageConverterExtractor<T> responseExtractor =
				new HttpMessageConverterExtractor<T>(responseType, getMessageConverters(), logger);
		return execute(url, HttpMethod.GET, requestCallback, responseExtractor);
	}

getForObject都调用了execute方法(其实RestTemplate的其它http请求方法调用的也是execute方法)

	@Override
	public <T> T execute(String url, HttpMethod method, RequestCallback requestCallback,
			ResponseExtractor<T> responseExtractor, Object... uriVariables) throws RestClientException {

		URI expanded = getUriTemplateHandler().expand(url, uriVariables);
		return doExecute(expanded, method, requestCallback, responseExtractor);
	}

	@Override
	public <T> T execute(String url, HttpMethod method, RequestCallback requestCallback,
			ResponseExtractor<T> responseExtractor, Map<String, ?> uriVariables) throws RestClientException {

		URI expanded = getUriTemplateHandler().expand(url, uriVariables);
		return doExecute(expanded, method, requestCallback, responseExtractor);
	}

	@Override
	public <T> T execute(URI url, HttpMethod method, RequestCallback requestCallback,
			ResponseExtractor<T> responseExtractor) throws RestClientException {

		return doExecute(url, method, requestCallback, responseExtractor);
	}

所有execute方法都调用了同一个doExecute方法

	protected <T> T doExecute(URI url, HttpMethod method, RequestCallback requestCallback,
			ResponseExtractor<T> responseExtractor) throws RestClientException {

		Assert.notNull(url, "'url' must not be null");
		Assert.notNull(method, "'method' must not be null");
		ClientHttpResponse response = null;
		try {
			ClientHttpRequest request = createRequest(url, method);
			if (requestCallback != null) {
				requestCallback.doWithRequest(request);
			}
			response = request.execute();
			handleResponse(url, method, response);
			if (responseExtractor != null) {
				return responseExtractor.extractData(response);
			}
			else {
				return null;
			}
		}
		catch (IOException ex) {
			String resource = url.toString();
			String query = url.getRawQuery();
			resource = (query != null ? resource.substring(0, resource.indexOf('?')) : resource);
			throw new ResourceAccessException("I/O error on " + method.name() +
					" request for \"" + resource + "\": " + ex.getMessage(), ex);
		}
		finally {
			if (response != null) {
				response.close();
			}
		}
	}

doExecute方法创建了请求,然后执行,处理异常,最后关闭。可以看到关闭操作放在finally中,任何情况都会执行到,除非返回的response为null。

InterceptingClientHttpRequest

进入到request.execute()方法中,对应抽象类org.springframework.http.client.AbstractClientHttpRequest的execute方法

	@Override
	public final ClientHttpResponse execute() throws IOException {
		assertNotExecuted();
		ClientHttpResponse result = executeInternal(this.headers);
		this.executed = true;
		return result;
	}

调用内部方法executeInternal,executeInternal方法是一个抽象方法,由子类实现(restTemplate内部的http调用实现方式有多种)。进入executeInternal方法,到达抽象类
org.springframework.http.client.AbstractBufferingClientHttpRequest

	protected ClientHttpResponse executeInternal(HttpHeaders headers) throws IOException {
		byte[] bytes = this.bufferedOutput.toByteArray();
		if (headers.getContentLength() < 0) {
			headers.setContentLength(bytes.length);
		}
		ClientHttpResponse result = executeInternal(headers, bytes);
		this.bufferedOutput = null;
		return result;
	}

缓充请求body数据,调用内部方法executeInternal

ClientHttpResponse result = executeInternal(headers, bytes);

executeInternal方法中调用另一个executeInternal方法,它也是一个抽象方法

进入executeInternal方法,此方法由org.springframework.http.client.AbstractBufferingClientHttpRequest的子类org.springframework.http.client.InterceptingClientHttpRequest实现

	protected final ClientHttpResponse executeInternal(HttpHeaders headers, byte[] bufferedOutput) throws IOException {
		InterceptingRequestExecution requestExecution = new InterceptingRequestExecution();
		return requestExecution.execute(this, bufferedOutput);
	}

实例化了一个带拦截器的请求执行对象InterceptingRequestExecution

		public ClientHttpResponse execute(HttpRequest request, final byte[] body) throws IOException {
              // 如果有拦截器,则执行拦截器并返回结果
			if (this.iterator.hasNext()) {
				ClientHttpRequestInterceptor nextInterceptor = this.iterator.next();
				return nextInterceptor.intercept(request, body, this);
			}
			else {
               // 如果没有拦截器,则通过requestFactory创建request对象并执行
				ClientHttpRequest delegate = requestFactory.createRequest(request.getURI(), request.getMethod());
				for (Map.Entry<String, List<String>> entry : request.getHeaders().entrySet()) {
					List<String> values = entry.getValue();
					for (String value : values) {
						delegate.getHeaders().add(entry.getKey(), value);
					}
				}
				if (body.length > 0) {
					if (delegate instanceof StreamingHttpOutputMessage) {
						StreamingHttpOutputMessage streamingOutputMessage = (StreamingHttpOutputMessage) delegate;
						streamingOutputMessage.setBody(new StreamingHttpOutputMessage.Body() {
							@Override
							public void writeTo(final OutputStream outputStream) throws IOException {
								StreamUtils.copy(body, outputStream);
							}
						});
					 }
					else {
						StreamUtils.copy(body, delegate.getBody());
					}
				}
				return delegate.execute();
			}
		}

InterceptingClientHttpRequest的execute方法,先执行拦截器,最后执行真正的请求对象(什么是真正的请求对象?见后面拦截器的设计部分)。

看一下RestTemplate的配置:

        RestTemplateBuilder builder = new RestTemplateBuilder();
        return builder
                .setConnectTimeout(customConfig.getRest().getConnectTimeOut())
                .setReadTimeout(customConfig.getRest().getReadTimeout())
                .interceptors(restTemplateLogInterceptor)
                .errorHandler(new ThrowErrorHandler())
                .build();
    }

可以看到配置了连接超时,读超时,拦截器,和错误处理器。
看一下拦截器的实现:

    public ClientHttpResponse intercept(HttpRequest httpRequest, byte[] bytes, ClientHttpRequestExecution clientHttpRequestExecution) throws IOException {
        // 打印访问前日志
        ClientHttpResponse execute = clientHttpRequestExecution.execute(httpRequest, bytes);
        if (如果返回码不是200) {
            // 抛出自定义运行时异常
        }
        // 打印访问后日志
        return execute;
    }

可以看到当返回码不是200时,抛出异常。还记得RestTemplate中的doExecute方法吧,此处如果抛出异常,虽然会执行doExecute方法中的finally代码,但由于返回的response为null(其实是有response的),没有关闭response,所以这里不能抛出异常,如果确实想抛出异常,可以在错误处理器errorHandler中抛出,这样确保response能正常返回和关闭。

RestTemplate源码部分解析

如何决定使用哪一个底层http框架

知道了原因,我们再来看一下RestTemplate在什么时候决定使用什么http框架。其实在通过RestTemplateBuilder实例化RestTemplate对象时就决定了。
看一下RestTemplateBuilder的build方法

	public RestTemplate build() {
		return build(RestTemplate.class);
	}
	public <T extends RestTemplate> T build(Class<T> restTemplateClass) {
		return configure(BeanUtils.instantiate(restTemplateClass));
	}

可以看到在实例化RestTemplate对象之后,进行配置。可以指定requestFactory,也可以自动探测

	public <T extends RestTemplate> T configure(T restTemplate) {
               // 配置requestFactory
		configureRequestFactory(restTemplate);
        .....省略其它无关代码
	}


	private void configureRequestFactory(RestTemplate restTemplate) {
		ClientHttpRequestFactory requestFactory = null;
		if (this.requestFactory != null) {
			requestFactory = this.requestFactory;
		}
		else if (this.detectRequestFactory) {
			requestFactory = detectRequestFactory();
		}
		if (requestFactory != null) {
			ClientHttpRequestFactory unwrappedRequestFactory = unwrapRequestFactoryIfNecessary(
					requestFactory);
			for (RequestFactoryCustomizer customizer : this.requestFactoryCustomizers) {
				customizer.customize(unwrappedRequestFactory);
			}
			restTemplate.setRequestFactory(requestFactory);
		}
	}

看一下detectRequestFactory方法

	private ClientHttpRequestFactory detectRequestFactory() {
		for (Map.Entry<String, String> candidate : REQUEST_FACTORY_CANDIDATES
				.entrySet()) {
			ClassLoader classLoader = getClass().getClassLoader();
			if (ClassUtils.isPresent(candidate.getKey(), classLoader)) {
				Class<?> factoryClass = ClassUtils.resolveClassName(candidate.getValue(),
						classLoader);
				ClientHttpRequestFactory requestFactory = (ClientHttpRequestFactory) BeanUtils
						.instantiate(factoryClass);
				initializeIfNecessary(requestFactory);
				return requestFactory;
			}
		}
		return new SimpleClientHttpRequestFactory();
	}

循环REQUEST_FACTORY_CANDIDATES集合,检查classpath类路径中是否存在相应的jar包,如果存在,则创建相应框架的封装类对象。如果都不存在,则返回使用JDK方式实现的RequestFactory对象。

看一下REQUEST_FACTORY_CANDIDATES集合

	private static final Map<String, String> REQUEST_FACTORY_CANDIDATES;

	static {
		Map<String, String> candidates = new LinkedHashMap<String, String>();
		candidates.put("org.apache.http.client.HttpClient",
				"org.springframework.http.client.HttpComponentsClientHttpRequestFactory");
		candidates.put("okhttp3.OkHttpClient",
				"org.springframework.http.client.OkHttp3ClientHttpRequestFactory");
		candidates.put("com.squareup.okhttp.OkHttpClient",
				"org.springframework.http.client.OkHttpClientHttpRequestFactory");
		candidates.put("io.netty.channel.EventLoopGroup",
				"org.springframework.http.client.Netty4ClientHttpRequestFactory");
		REQUEST_FACTORY_CANDIDATES = Collections.unmodifiableMap(candidates);
	}

可以看到共有四种Http调用实现方式,在配置RestTemplate时可指定,并在类路径中提供相应的实现jar包。

Request拦截器的设计

再看一下InterceptingRequestExecution类的execute方法。

  public ClientHttpResponse execute(HttpRequest request, final byte[] body) throws IOException {
        // 如果有拦截器,则执行拦截器并返回结果
	  if (this.iterator.hasNext()) {
			ClientHttpRequestInterceptor nextInterceptor = this.iterator.next();
			return nextInterceptor.intercept(request, body, this);
		}
		else {
         // 如果没有拦截器,则通过requestFactory创建request对象并执行
		    ClientHttpRequest delegate = requestFactory.createRequest(request.getURI(), request.getMethod());
			for (Map.Entry<String, List<String>> entry : request.getHeaders().entrySet()) {
			    List<String> values = entry.getValue();
				for (String value : values) {
					delegate.getHeaders().add(entry.getKey(), value);
				}
			}
			if (body.length > 0) {
				if (delegate instanceof StreamingHttpOutputMessage) {
					StreamingHttpOutputMessage streamingOutputMessage = (StreamingHttpOutputMessage) delegate;
					streamingOutputMessage.setBody(new StreamingHttpOutputMessage.Body() {
						@Override
						public void writeTo(final OutputStream outputStream) throws IOException {
							StreamUtils.copy(body, outputStream);
						}
					});
			   }
			   else {
				StreamUtils.copy(body, delegate.getBody());
			   }
			}
			return delegate.execute();
		}
   }

大家可能会有疑问,传入的对象已经是request对象了,为什么在没有拦截器时还要再创建一遍request对象呢?
其实传入的request对象在有拦截器的时候是InterceptingClientHttpRequest对象,没有拦截器时,则直接是包装了各个http调用实现框的Request。如HttpComponentsClientHttpRequestOkHttp3ClientHttpRequest等。当有拦截器时,会执行拦截器,拦截器可以有多个,而这里 this.iterator.hasNext() 不是一个循环,为什么呢?秘密在于拦截器的intercept方法。

ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution)
      throws IOException;

此方法包含request,body,execution。exection类型为ClientHttpRequestExecution接口,上面的InterceptingRequestExecution便实现了此接口,这样在调用拦截器时,传入exection对象本身,然后再调一次execute方法,再判断是否仍有拦截器,如果有,再执行下一个拦截器,将所有拦截器执行完后,再生成真正的request对象,执行http调用。

那如果没有拦截器呢?
上面已经知道RestTemplate在实例化时会实例化RequestFactory,当发起http请求时,会执行restTemplate的doExecute方法,此方法中会创建Request,而createRequest方法中,首先会获取RequestFactory

// org.springframework.http.client.support.HttpAccessor
protected ClientHttpRequest createRequest(URI url, HttpMethod method) throws IOException {
   ClientHttpRequest request = getRequestFactory().createRequest(url, method);
   if (logger.isDebugEnabled()) {
      logger.debug("Created " + method.name() + " request for \"" + url + "\"");
   }
   return request;
}


// org.springframework.http.client.support.InterceptingHttpAccessor
public ClientHttpRequestFactory getRequestFactory() {
   ClientHttpRequestFactory delegate = super.getRequestFactory();
   if (!CollectionUtils.isEmpty(getInterceptors())) {
      return new InterceptingClientHttpRequestFactory(delegate, getInterceptors());
   }
   else {
      return delegate;
   }
}

看一下RestTemplate与这两个类的关系就知道调用关系了。

而在获取到RequestFactory之后,判断有没有拦截器,如果有,则创建InterceptingClientHttpRequestFactory对象,而此RequestFactory在createRequest时,会创建InterceptingClientHttpRequest对象,这样就可以先执行拦截器,最后执行创建真正的Request对象执行http调用。

连接获取逻辑流程图

以HttpComponents为底层Http调用实现的逻辑流程图。

流程图说明:

  1. RestTemplate可以根据配置来实例化对应的RequestFactory,包括apache httpComponents、OkHttp3、Netty等实现。
  2. RestTemplate与HttpComponents衔接的类是HttpClient,此类是apache httpComponents提供给用户使用,执行http调用。HttpClient是创建RequestFactory对象时通过HttpClientBuilder实例化的,在实例化HttpClient对象时,实例化了HttpClientConnectionManager和多个ClientExecChainHttpRequestExecutorHttpProcessor以及一些策略。
  3. 当发起请求时,由requestFactory实例化httpRequest,然后依次执行ClientexecChain,常用的有四种:
    • RedirectExec: 请求跳转;根据上次响应结果和跳转策略决定下次跳转的地址,默认最大执行50次跳转;
    • RetryExec:决定出现I/O错误的请求是否再次执行
    • ProtocolExec: 填充必要的http请求header,处理http响应header,更新会话状态
    • MainClientExec:请求执行链中最后一个节点;从连接池CPool中获取连接,执行请求调用,并返回请求结果;
  4. PoolingHttpClientConnectionManager用于管理连接池,包括连接池初始化,获取连接,获取连接,打开连接,释放连接,关闭连接池等操作。
  5. CPool代表连接池,但连接并不保存在CPool中;CPool中维护着三个连接状态集合:leased(租用的,即待释放的)/available(可用的)/pending(等待的),用于记录所有连接的状态;并且维护着每个Route对应的连接池RouteSpecificPool;
  6. RouteSpecificPool是连接真正存放的地方,内部同样也维护着三个连接状态集合,但只记录属于本route的连接。
    HttpComponents将连接按照route划分连接池,有利于资源隔离,使每个route请求相互不影响;

结束语

  • 在使用框架时,特别是在增强其功能,自定义行为时,要考虑到自定义行为对框架原有流程逻辑的影响,并且最好要熟悉框架相应功能的设计意图。
  • 在与外部事物交互,包括网络,磁盘,数据库等,做到异常情况的处理,保证程序健壮性。

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/467214.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

C语言函数大全-- r 开头的函数

C语言函数大全 本篇介绍C语言函数大全-- r 开头的函数 1. raise 1.1 函数说明 函数声明函数功能int raise(int sig);用于向当前进程发送指定的信号。 参数&#xff1a; sig &#xff1a; 指定要发送的信号编号 返回值&#xff1a; 如果调用成功&#xff0c;raise() 函数将返…

霍兰德人格分析雷达图

雷达图 Radar Chart 雷达图是多特性直观展示的重要方式 问题分析 霍兰德认为&#xff1a;人格兴趣与职业之间应有一种内在的对应关系 人格分类&#xff1a;研究型、艺术型、社会型、企业型、传统型、现实性 职业&#xff1a;工程师、实验员、艺术家、推销员、记事员、社会工…

【AUTOSAR】【信息安全】SecOC

目录 一、概述 二、约束和假设 三、依赖模块 四、功能描述 4.1 安全解决方案的规范 4.1.1 安全解决方案的基本实体 4.1.2 安全的I-PDU构建 4.1.3 安全的I-PDU验证 4.2 与PduR的关系 4.3 初始化 4.4 传出PDU的身份验证 4.5 传入pdu的验证 4.6 网关功能 4.7 多核分…

【java】Java中的锁

文章目录 前言一、悲观锁二、乐观锁三、自旋锁原理自旋锁优缺点优点缺点 自旋锁时间阈值(1.6 引入了适应性自旋锁)自旋锁的开启 四、可重入锁(递归锁)五、读写锁六、公平锁七、非公平锁八、共享锁九、独占锁十、轻量级锁十一、重量级锁十二、偏向锁十三、分段锁十四、互斥锁十五…

Docker实战笔记5-利用 commit 理解镜像构成

转载请标明出处&#xff1a;http://blog.csdn.net/zhaoyanjun6/article/details/130338433 本文出自【赵彦军的博客】 文章目录 慎用 docker commit 注意&#xff1a; docker commit 命令除了学习之外&#xff0c;还有一些特殊的应用场合&#xff0c;比如被入侵后保存现场等。但…

【软件测试】测试用例的设计

文章目录 一. 针对没有需求的案例来设计测试用例二. 针对有需求的案例来设计测试用例1. 穷举法2. 等价类3. 边界值4. 判定表法5. 场景设计法5.1 简介5.2 基本设计步骤5.3 基本流和备选流5.4 使用场景5.5 优缺点5.6 实例 6. 错误猜测法 一. 针对没有需求的案例来设计测试用例 针…

网络安全入行?来了解下网络安全从业人员类别及其工作任务

又到了每年重保期间&#xff0c;红蓝双方都开始进行准备蓄势待发&#xff0c;网络安全从业人员每年供不应求&#xff0c;尤其是重保期间&#xff0c;双方都在疯狂的招揽准备网络安全人员。那网络安全从业人员分类到底有哪些&#xff0c;都负责哪些具体的工作任务呢&#xff1f;…

基于云计算技术的B/S架构云HIS 云HIS 云HIS系统

传统的HIS经历了20多年的建设&#xff0c;已经从单机版发展到局域网的版本&#xff0c;更被深入应用到医院的各项业务活动&#xff0c;成为医院必不可缺的基础设施平台&#xff0c;724小时不间断地支撑医院运行。因此医院都十分重视信息化建设。随着医改的不断推进和医疗行业的…

前端路由hash模式以及history模式详解

文章目录 前言一、hash 模式1、hash 定义2、location 对象3、window.onhashchange 事件 二、history 模式1、history 定义2、history API3、window.onpopstate 事件4、解决history模式下页面刷新404问题 前言 在前后端分离的项目中&#xff0c;前端一般使用 SPA 单页面应用模式…

屌的一批,阿里P8推荐的Spring Cloud实战笔记

Spring Cloud 前世今生 Spring Cloud体系由Spring 在2015年年初推出&#xff0c;至今已经五年多&#xff0c;其子项目在不断增加与完善&#xff0c;其所包含的功能点已经基本满足整个微服务体系的需求。加上Spring本身强大的技术后盾和活跃的技术社区氛围&#xff0c;Spring C…

车载毫米波雷达中国市场有望在2025年实现30亿美元的市场规模

近日&#xff0c;专注于前沿科技领域的国际咨询机构ICV发布了全球车载毫米波雷达的市场研究报告&#xff0c;汽车毫米波&#xff08;mmWave&#xff09;雷达基于频率为77 GHz的电磁波&#xff0c;具有高精度和准确性&#xff0c;可用于目标检测。这种技术有着广泛的应用&#x…

解决方案丨票据集中在集团总部处理,如何解决实物票据管理难?

目前越来越多的企业都成立了财务共享中心&#xff0c;通过统一财务中心可以进行集中式、标准化、统一化管理&#xff0c;提升财务运营水平与效率、降低企业的整体运作成本、集团战略发展支撑。 如何确保财务共享中心稳健和高效运营&#xff0c;是很多企业建立共享中心后面的难…

【Leetcode每日一刷】动态规划:931. 下降路径最小和

博主简介&#xff1a;努力学习的22级计科生博主主页&#xff1a; 是瑶瑶子啦所属专栏: LeetCode每日一题–进击大厂 目录 一、动态规划套路二、分析1、dp数组含义2、确定递推公式&#xff08;递推函数的实现&#xff09;3、dp数组初始化&#xff08;base case)4、遍历顺序 解题…

React面向组件编程

React面向组件编程 基本理解和使用组件三大核心属性1: state效果理解强烈注意 组件三大核心属性2: props效果理解作用编码操作 组件三大核心属性3: refs与事件处理效果理解编码2.4.4. 事件处理 收集表单数据效果理解 组件的生命周期(重要&#xff09;效果理解生命周期流程图(旧…

《庖丁解牛Linux内核分析》课后实验:实验一:反汇编分析

实验内容 参照第 1.3 节&#xff0c;将如下 C 语言代码汇编成“.s”文件&#xff0c;并分析“.s”文件中的汇编代码 的执行过程&#xff0c;其中重点关注 EBP/ESP 寄存器、EAX 寄存器、EIP 寄存器和函数调用堆栈空 间在汇编代码的执行过程是如何变化的。 int g(int x) { return…

省钱!NewBing硬核新玩法;手把手教你训练AI模特;用AI替代同事的指南;B站最易上手AI绘画教程 | ShowMeAI日报

&#x1f440;日报&周刊合集 | &#x1f3a1;生产力工具与行业应用大全 | &#x1f9e1; 点赞关注评论拜托啦&#xff01; &#x1f916; 『NewBing 的2种硬核新用法』阅读文档并回答问题 & AI绘图 社区同学分享了两种NewBing的新用法&#xff0c;不仅准确高效&#x…

2023年湖北省武汉安全员ABC报名时间考试通过率如何?启程别

2023年湖北省武汉安全员ABC报名时间考试通过率如何&#xff1f;启程别 都2023年了&#xff0c;建筑企业想要报考三类人员&#xff0c;不知道在哪里报名&#xff0c;具备什么样的条件才可以报考建筑安全员abc,什么时间报名考试等等一系列问题&#xff0c;启程别来给你们细细说明…

即时通讯源码自己开发好还是对接云服务好

随着科技的飞速发展&#xff0c;通信技术也日新月异。与此同时&#xff0c;即时通讯应用也越来越受欢迎。许多企业在构建应用程序时会遇到一个问题&#xff1a;使用即时通讯源码自己开发好还是对接云服务好&#xff1f;本文将探讨这两种方法的优缺点&#xff0c;并为您提供一些…

环境配置 | Win10 VSCode连接远程服务器里的docker容器

环境&#xff1a;win10, VS code, 远程服务器Ubuntu16.04&#xff08;远程服务器上已经安装好了dockers&#xff09;, 1.VScode下载 网址&#xff1a;Download Visual Studio Code - Mac, Linux, Windows 下载后双击运行 2.VSCode上配置 STEP 1.点击vscode右边工具栏点击拓展…

《嵌入式系统的WEB开发》

硬件平台&#xff1a;RK1109/T31/RK3308 软件系统&#xff1a;Linux&#xff0c;Lighttpd/ Nginx, FCGI, HTML/JS 选择使用FCGI&#xff0c;除了使用C 开发调用系统资源方便外. FCGI 可以解决CGI 多入口的问题&#xff0c;统一的入口&#xff0c;对数据同步&#xff0c;都是比…