首页 > 其他分享 >SpringMVC-处理异常

SpringMVC-处理异常

时间:2022-11-19 14:01:32浏览次数:43  
标签:return SpringMVC request 处理 handler ex null 异常 response

DispatcherServlet.doDispatch

protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
	HttpServletRequest processedRequest = request;
	HandlerExecutionChain mappedHandler = null;
	boolean multipartRequestParsed = false;

	WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);

	try {
		ModelAndView mv = null;
		Exception dispatchException = null;

		try {
			processedRequest = checkMultipart(request);
			multipartRequestParsed = (processedRequest != request);

			// Determine handler for the current request.
			mappedHandler = getHandler(processedRequest);
			if (mappedHandler == null) {
				noHandlerFound(processedRequest, response);
				return;
			}

			// Determine handler adapter for the current request.
			HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

			// Process last-modified header, if supported by the handler.
			String method = request.getMethod();
			boolean isGet = "GET".equals(method);
			if (isGet || "HEAD".equals(method)) {
				long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
				if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
					return;
				}
			}

			if (!mappedHandler.applyPreHandle(processedRequest, response)) {
				return;
			}

			// Actually invoke the handler.
			mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

			if (asyncManager.isConcurrentHandlingStarted()) {
				return;
			}

			applyDefaultViewName(processedRequest, mv);
			mappedHandler.applyPostHandle(processedRequest, response, mv);
		}
		catch (Exception ex) {
			dispatchException = ex;
		}
		catch (Throwable err) {
			// As of 4.3, we're processing Errors thrown from handler methods as well,
			// making them available for @ExceptionHandler methods and other scenarios.
			dispatchException = new NestedServletException("Handler dispatch failed", err);
		}
		processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
	}
	catch (Exception ex) {
		triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
	}
	catch (Throwable err) {
		triggerAfterCompletion(processedRequest, response, mappedHandler,
				new NestedServletException("Handler processing failed", err));
	}
	finally {
		if (asyncManager.isConcurrentHandlingStarted()) {
			// Instead of postHandle and afterCompletion
			if (mappedHandler != null) {
				mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
			}
		}
		else {
			// Clean up any resources used by a multipart request.
			if (multipartRequestParsed) {
				cleanupMultipart(processedRequest);
			}
		}
	}
}

ha.handle处理request,如果出现异常下面会捕捉到Exception并将Exception赋值给dispatchException。processDispatchResult处理异常。

DispatcherServlet.processDispatchResult(HttpServletRequest request, HttpServletResponse response,
@Nullable HandlerExecutionChain mappedHandler, @Nullable ModelAndView mv,
@Nullable Exception exception)

private void processDispatchResult(HttpServletRequest request, HttpServletResponse response,
		@Nullable HandlerExecutionChain mappedHandler, @Nullable ModelAndView mv,
		@Nullable Exception exception) throws Exception {

	boolean errorView = false;

	if (exception != null) {
		if (exception instanceof ModelAndViewDefiningException) {
			logger.debug("ModelAndViewDefiningException encountered", exception);
			mv = ((ModelAndViewDefiningException) exception).getModelAndView();
		}
		else {
			Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null);
			mv = processHandlerException(request, response, handler, exception);
			errorView = (mv != null);
		}
	}

	// Did the handler return a view to render?
	if (mv != null && !mv.wasCleared()) {
		render(mv, request, response);
		if (errorView) {
			WebUtils.clearErrorRequestAttributes(request);
		}
	}
	else {
		if (logger.isTraceEnabled()) {
			logger.trace("No view rendering, null ModelAndView returned.");
		}
	}

	if (WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
		// Concurrent handling started during a forward
		return;
	}

	if (mappedHandler != null) {
		// Exception (if any) is already handled..
		mappedHandler.triggerAfterCompletion(request, response, null);
	}
}

如果exception不为null处理异常:如果异常类型是ModelAndViewDefiningException则获取ModelAndView。否则processHandlerException处理异常。

DispatcherServlet.processHandlerException(HttpServletRequest request, HttpServletResponse response,
@Nullable Object handler, Exception ex)

protected ModelAndView processHandlerException(HttpServletRequest request, HttpServletResponse response,
		@Nullable Object handler, Exception ex) throws Exception {

	// Success and error responses may use different content types
	request.removeAttribute(HandlerMapping.PRODUCIBLE_MEDIA_TYPES_ATTRIBUTE);

	// Check registered HandlerExceptionResolvers...
	ModelAndView exMv = null;
	if (this.handlerExceptionResolvers != null) {
		for (HandlerExceptionResolver resolver : this.handlerExceptionResolvers) {
			exMv = resolver.resolveException(request, response, handler, ex);
			if (exMv != null) {
				break;
			}
		}
	}
	if (exMv != null) {
		if (exMv.isEmpty()) {
			request.setAttribute(EXCEPTION_ATTRIBUTE, ex);
			return null;
		}
		// We might still need view name translation for a plain error model...
		if (!exMv.hasView()) {
			String defaultViewName = getDefaultViewName(request);
			if (defaultViewName != null) {
				exMv.setViewName(defaultViewName);
			}
		}
		if (logger.isTraceEnabled()) {
			logger.trace("Using resolved error view: " + exMv, ex);
		}
		else if (logger.isDebugEnabled()) {
			logger.debug("Using resolved error view: " + exMv);
		}
		WebUtils.exposeErrorRequestAttributes(request, ex, getServletName());
		return exMv;
	}

	throw ex;
}

1、如果handlerExceptionResolvers不为空,handlerExceptionResolvers处理异常并返回ModelAndView
2、如果ModelAndView不为空,处理视图名

handlerExceptionResolvers有三类:

  • ExceptionHandlerExceptionResolver:解析@ExceptionHandler标注的方法处理的异常
  • ResponseStatusExceptionResolver:处理@ResponseStatus
  • DefaultHandlerExceptionResolver:解决标准的SpringMVC异常并将其转换为相应的HTTP状态代码。

异常的处理顺序是ExceptionHandlerExceptionResolver首先处理,如果能处理,即resolveException方法返回值不为空,则不再处理异常。否则由ResponseStatusExceptionResolver处理异常。不能处理异常则由DefaultHandlerExceptionResolver处理异常。

AbstractHandlerExceptionResolver.resolveException

AbstractHandlerExceptionResolver.resolveException(
		HttpServletRequest request, HttpServletResponse response, @Nullable Object handler, Exception ex) 

public ModelAndView resolveException(
		HttpServletRequest request, HttpServletResponse response, @Nullable Object handler, Exception ex) {

	if (shouldApplyTo(request, handler)) {
		prepareResponse(ex, response);
		ModelAndView result = doResolveException(request, response, handler, ex);
		if (result != null) {
			// Print debug message when warn logger is not enabled.
			if (logger.isDebugEnabled() && (this.warnLogger == null || !this.warnLogger.isWarnEnabled())) {
				logger.debug("Resolved [" + ex + "]" + (result.isEmpty() ? "" : " to " + result));
			}
			// Explicitly configured warn logger in logException method.
			logException(ex, request);
		}
		return result;
	}
	else {
		return null;
	}
}

1、shouldApplyTo判断handler是否是HandlerMethod类型,ExceptionHandlerExceptionResolver处理@Controller抛出的异常
2、prepareResponse处理Cache-Control响应头,如果preventResponseCaching为true,将Cache-Control响应头设置为no-store。
3、doResolveException解析异常

一、ExceptionHandlerExceptionResolver

AbstractHandlerMethodExceptionResolver.doResolveException(
HttpServletRequest request, HttpServletResponse response, @Nullable Object handler, Exception ex)

protected final ModelAndView doResolveException(
		HttpServletRequest request, HttpServletResponse response, @Nullable Object handler, Exception ex) {

	HandlerMethod handlerMethod = (handler instanceof HandlerMethod ? (HandlerMethod) handler : null);
	return doResolveHandlerMethodException(request, response, handlerMethod, ex);
}

HandlerMethod是抛出异常的方法。

ExceptionHandlerExceptionResolver.doResolveHandlerMethodException(HttpServletRequest request,
HttpServletResponse response, @Nullable HandlerMethod handlerMethod, Exception exception)

protected ModelAndView doResolveHandlerMethodException(HttpServletRequest request,
		HttpServletResponse response, @Nullable HandlerMethod handlerMethod, Exception exception) {

	ServletInvocableHandlerMethod exceptionHandlerMethod = getExceptionHandlerMethod(handlerMethod, exception);
	if (exceptionHandlerMethod == null) {
		return null;
	}

	if (this.argumentResolvers != null) {
		exceptionHandlerMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);
	}
	if (this.returnValueHandlers != null) {
		exceptionHandlerMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers);
	}

	ServletWebRequest webRequest = new ServletWebRequest(request, response);
	ModelAndViewContainer mavContainer = new ModelAndViewContainer();

	ArrayList<Throwable> exceptions = new ArrayList<>();
	try {
		if (logger.isDebugEnabled()) {
			logger.debug("Using @ExceptionHandler " + exceptionHandlerMethod);
		}
		// Expose causes as provided arguments as well
		Throwable exToExpose = exception;
		while (exToExpose != null) {
			exceptions.add(exToExpose);
			Throwable cause = exToExpose.getCause();
			exToExpose = (cause != exToExpose ? cause : null);
		}
		Object[] arguments = new Object[exceptions.size() + 1];
		exceptions.toArray(arguments);  // efficient arraycopy call in ArrayList
		arguments[arguments.length - 1] = handlerMethod;
		exceptionHandlerMethod.invokeAndHandle(webRequest, mavContainer, arguments);
	}
	catch (Throwable invocationEx) {
		// Any other than the original exception (or a cause) is unintended here,
		// probably an accident (e.g. failed assertion or the like).
		if (!exceptions.contains(invocationEx) && logger.isWarnEnabled()) {
			logger.warn("Failure in @ExceptionHandler " + exceptionHandlerMethod, invocationEx);
		}
		// Continue with default processing of the original exception...
		return null;
	}

	if (mavContainer.isRequestHandled()) {
		return new ModelAndView();
	}
	else {
		ModelMap model = mavContainer.getModel();
		HttpStatus status = mavContainer.getStatus();
		ModelAndView mav = new ModelAndView(mavContainer.getViewName(), model, status);
		mav.setViewName(mavContainer.getViewName());
		if (!mavContainer.isViewReference()) {
			mav.setView((View) mavContainer.getView());
		}
		if (model instanceof RedirectAttributes) {
			Map<String, ?> flashAttributes = ((RedirectAttributes) model).getFlashAttributes();
			RequestContextUtils.getOutputFlashMap(request).putAll(flashAttributes);
		}
		return mav;
	}
}

1、getExceptionHandlerMethod获取@ExceptionHandler标注的异常处理方法
2、exceptionHandlerMethod异常处理方法设置argumentResolvers和returnValueHandlers
3、执行exceptionHandlerMethod.invokeAndHandle处理异常

ExceptionHandlerExceptionResolver.getExceptionHandlerMethod(
@Nullable HandlerMethod handlerMethod, Exception exception)

protected ServletInvocableHandlerMethod getExceptionHandlerMethod(
		@Nullable HandlerMethod handlerMethod, Exception exception) {

	Class<?> handlerType = null;

	if (handlerMethod != null) {
		// Local exception handler methods on the controller class itself.
		// To be invoked through the proxy, even in case of an interface-based proxy.
		handlerType = handlerMethod.getBeanType();
		ExceptionHandlerMethodResolver resolver = this.exceptionHandlerCache.get(handlerType);
		if (resolver == null) {
			resolver = new ExceptionHandlerMethodResolver(handlerType);
			this.exceptionHandlerCache.put(handlerType, resolver);
		}
		Method method = resolver.resolveMethod(exception);
		if (method != null) {
			return new ServletInvocableHandlerMethod(handlerMethod.getBean(), method);
		}
		// For advice applicability check below (involving base packages, assignable types
		// and annotation presence), use target class instead of interface-based proxy.
		if (Proxy.isProxyClass(handlerType)) {
			handlerType = AopUtils.getTargetClass(handlerMethod.getBean());
		}
	}

	for (Map.Entry<ControllerAdviceBean, ExceptionHandlerMethodResolver> entry : this.exceptionHandlerAdviceCache.entrySet()) {
		ControllerAdviceBean advice = entry.getKey();
		if (advice.isApplicableToBeanType(handlerType)) {
			ExceptionHandlerMethodResolver resolver = entry.getValue();
			Method method = resolver.resolveMethod(exception);
			if (method != null) {
				return new ServletInvocableHandlerMethod(advice.resolveBean(), method);
			}
		}
	}

	return null;
}

1、从@Controller类中找出@ExceptionHandler处理指定类型的方法。如果handlerMethod不为空,获取bean类型,通过bean类型从exceptionHandlerCache中获取ExceptionHandlerMethodResolver。如果获取不到,创建ExceptionHandlerMethodResolver,并将bean类型,ExceptionHandlerMethodResolver加入exceptionHandlerCache。resolveMethod通过异常类型从mappedMethods获取异常处理方法。如果找到返回ServletInvocableHandlerMethod。
2、如果在@Controller类中未找到处理异常的方法。从@ControllerAdvice的class中找出@ExceptionHandler处理指定异常的方法。即从exceptionHandlerAdviceCache找出处理异常的方法。

设置exceptionHandlerAdviceCache:

ExceptionHandlerExceptionResolver实现了InitializingBean接口,在实例化bean之后调用InitializingBean接口的afterPropertiesSet方法。

ExceptionHandlerExceptionResolver.afterPropertiesSet()

	public void afterPropertiesSet() {
	// Do this first, it may add ResponseBodyAdvice beans
	initExceptionHandlerAdviceCache();

	if (this.argumentResolvers == null) {
		List<HandlerMethodArgumentResolver> resolvers = getDefaultArgumentResolvers();
		this.argumentResolvers = new HandlerMethodArgumentResolverComposite().addResolvers(resolvers);
	}
	if (this.returnValueHandlers == null) {
		List<HandlerMethodReturnValueHandler> handlers = getDefaultReturnValueHandlers();
		this.returnValueHandlers = new HandlerMethodReturnValueHandlerComposite().addHandlers(handlers);
	}
}

1、initExceptionHandlerAdviceCache初始化exceptionHandlerAdviceCache
2、设置argumentResolvers和returnValueHandlers

ExceptionHandlerExceptionResolver.initExceptionHandlerAdviceCache()

private void initExceptionHandlerAdviceCache() {
	if (getApplicationContext() == null) {
		return;
	}

	List<ControllerAdviceBean> adviceBeans = ControllerAdviceBean.findAnnotatedBeans(getApplicationContext());
	for (ControllerAdviceBean adviceBean : adviceBeans) {
		Class<?> beanType = adviceBean.getBeanType();
		if (beanType == null) {
			throw new IllegalStateException("Unresolvable type for ControllerAdviceBean: " + adviceBean);
		}
		ExceptionHandlerMethodResolver resolver = new ExceptionHandlerMethodResolver(beanType);
		if (resolver.hasExceptionMappings()) {
			this.exceptionHandlerAdviceCache.put(adviceBean, resolver);
		}
		if (ResponseBodyAdvice.class.isAssignableFrom(beanType)) {
			this.responseBodyAdvice.add(adviceBean);
		}
	}

	if (logger.isDebugEnabled()) {
		int handlerSize = this.exceptionHandlerAdviceCache.size();
		int adviceSize = this.responseBodyAdvice.size();
		if (handlerSize == 0 && adviceSize == 0) {
			logger.debug("ControllerAdvice beans: none");
		}
		else {
			logger.debug("ControllerAdvice beans: " +
					handlerSize + " @ExceptionHandler, " + adviceSize + " ResponseBodyAdvice");
		}
	}
}

从beanFactory中找出@ControllerAdvice的所有bean,bean封装成ControllerAdviceBean,异常封装成ExceptionHandlerMethodResolver加入exceptionHandlerAdviceCache。

ExceptionHandlerMethodResolver

public ExceptionHandlerMethodResolver(Class<?> handlerType) {
	for (Method method : MethodIntrospector.selectMethods(handlerType, EXCEPTION_HANDLER_METHODS)) {
		for (Class<? extends Throwable> exceptionType : detectExceptionMappings(method)) {
			addExceptionMapping(exceptionType, method);
		}
	}
}

public static final MethodFilter EXCEPTION_HANDLER_METHODS = method ->
		AnnotatedElementUtils.hasAnnotation(method, ExceptionHandler.class);

从handlerType找出@ExceptionHandler的方法。将处理的exceptionType异常类型为key,@ExceptionHandler标注方法为value加入mappedMethods。

二、ResponseStatusExceptionResolver

ResponseStatusExceptionResolver.doResolveException(
HttpServletRequest request, HttpServletResponse response, @Nullable Object handler, Exception ex)

protected ModelAndView doResolveException(
		HttpServletRequest request, HttpServletResponse response, @Nullable Object handler, Exception ex) {

	try {
		if (ex instanceof ResponseStatusException) {
			return resolveResponseStatusException((ResponseStatusException) ex, request, response, handler);
		}

		ResponseStatus status = AnnotatedElementUtils.findMergedAnnotation(ex.getClass(), ResponseStatus.class);
		if (status != null) {
			return resolveResponseStatus(status, request, response, handler, ex);
		}

		if (ex.getCause() instanceof Exception) {
			return doResolveException(request, response, handler, (Exception) ex.getCause());
		}
	}
	catch (Exception resolveEx) {
		if (logger.isWarnEnabled()) {
			logger.warn("Failure while trying to resolve exception [" + ex.getClass().getName() + "]", resolveEx);
		}
	}
	return null;
}

1、如果异常类型是ResponseStatusException,调用resolveResponseStatusException
2、查找@ResponseStatus标注的方法,如果存在调用resolveResponseStatus
3、如果ex.getCause()是Exception调用doResolveException。

ResponseStatusExceptionResolver.resolveResponseStatusException(ResponseStatusException ex,
HttpServletRequest request, HttpServletResponse response, @Nullable Object handler)

protected ModelAndView resolveResponseStatusException(ResponseStatusException ex,
		HttpServletRequest request, HttpServletResponse response, @Nullable Object handler) throws Exception {

	ex.getResponseHeaders().forEach((name, values) ->
			values.forEach(value -> response.addHeader(name, value)));

	return applyStatusAndReason(ex.getRawStatusCode(), ex.getReason(), response);
}

1、设置响应头
2、applyStatusAndReason

ResponseStatusExceptionResolver.applyStatusAndReason(int statusCode, @Nullable String reason, HttpServletResponse response)

protected ModelAndView applyStatusAndReason(int statusCode, @Nullable String reason, HttpServletResponse response)
		throws IOException {

	if (!StringUtils.hasLength(reason)) {
		response.sendError(statusCode);
	}
	else {
		String resolvedReason = (this.messageSource != null ?
				this.messageSource.getMessage(reason, null, reason, LocaleContextHolder.getLocale()) :
				reason);
		response.sendError(statusCode, resolvedReason);
	}
	return new ModelAndView();
}

设置reason

ResponseStatusExceptionResolver.resolveResponseStatus(ResponseStatus responseStatus, HttpServletRequest request,
HttpServletResponse response, @Nullable Object handler, Exception ex)

protected ModelAndView resolveResponseStatus(ResponseStatus responseStatus, HttpServletRequest request,
		HttpServletResponse response, @Nullable Object handler, Exception ex) throws Exception {

	int statusCode = responseStatus.code().value();
	String reason = responseStatus.reason();
	return applyStatusAndReason(statusCode, reason, response);
}

获取statusCode和reason设置到response。

三、DefaultHandlerExceptionResolver

DefaultHandlerExceptionResolver.doResolveException(
HttpServletRequest request, HttpServletResponse response, @Nullable Object handler, Exception ex)

protected ModelAndView doResolveException(
		HttpServletRequest request, HttpServletResponse response, @Nullable Object handler, Exception ex) {

	try {
		if (ex instanceof HttpRequestMethodNotSupportedException) {
			return handleHttpRequestMethodNotSupported(
					(HttpRequestMethodNotSupportedException) ex, request, response, handler);
		}
		else if (ex instanceof HttpMediaTypeNotSupportedException) {
			return handleHttpMediaTypeNotSupported(
					(HttpMediaTypeNotSupportedException) ex, request, response, handler);
		}
		else if (ex instanceof HttpMediaTypeNotAcceptableException) {
			return handleHttpMediaTypeNotAcceptable(
					(HttpMediaTypeNotAcceptableException) ex, request, response, handler);
		}
		else if (ex instanceof MissingPathVariableException) {
			return handleMissingPathVariable(
					(MissingPathVariableException) ex, request, response, handler);
		}
		else if (ex instanceof MissingServletRequestParameterException) {
			return handleMissingServletRequestParameter(
					(MissingServletRequestParameterException) ex, request, response, handler);
		}
		else if (ex instanceof ServletRequestBindingException) {
			return handleServletRequestBindingException(
					(ServletRequestBindingException) ex, request, response, handler);
		}
		else if (ex instanceof ConversionNotSupportedException) {
			return handleConversionNotSupported(
					(ConversionNotSupportedException) ex, request, response, handler);
		}
		else if (ex instanceof TypeMismatchException) {
			return handleTypeMismatch(
					(TypeMismatchException) ex, request, response, handler);
		}
		else if (ex instanceof HttpMessageNotReadableException) {
			return handleHttpMessageNotReadable(
					(HttpMessageNotReadableException) ex, request, response, handler);
		}
		else if (ex instanceof HttpMessageNotWritableException) {
			return handleHttpMessageNotWritable(
					(HttpMessageNotWritableException) ex, request, response, handler);
		}
		else if (ex instanceof MethodArgumentNotValidException) {
			return handleMethodArgumentNotValidException(
					(MethodArgumentNotValidException) ex, request, response, handler);
		}
		else if (ex instanceof MissingServletRequestPartException) {
			return handleMissingServletRequestPartException(
					(MissingServletRequestPartException) ex, request, response, handler);
		}
		else if (ex instanceof BindException) {
			return handleBindException((BindException) ex, request, response, handler);
		}
		else if (ex instanceof NoHandlerFoundException) {
			return handleNoHandlerFoundException(
					(NoHandlerFoundException) ex, request, response, handler);
		}
		else if (ex instanceof AsyncRequestTimeoutException) {
			return handleAsyncRequestTimeoutException(
					(AsyncRequestTimeoutException) ex, request, response, handler);
		}
	}
	catch (Exception handlerEx) {
		if (logger.isWarnEnabled()) {
			logger.warn("Failure while trying to resolve exception [" + ex.getClass().getName() + "]", handlerEx);
		}
	}
	return null;
}

解决标准的SpringMVC异常并将其转换为相应的HTTP状态代码。如果异常类型没有@ExceptionHandler和@ResponseStatus异常处理方法。则由DefaultHandlerExceptionResolver处理异常。

标签:return,SpringMVC,request,处理,handler,ex,null,异常,response
From: https://www.cnblogs.com/shigongp/p/16905886.html

相关文章

  • php处理csv文件
    php读取上传的csv文件$filePath=$_FILES['file']['tmp_name'];$data=[];if(file_exists($filePath)){$handle=fopen($filePath,'r');while($tmp=......
  • SpringMVC-处理404
    一、解析mvc:default-servlet-handler/mvc.xml中<mvc:default-servlet-handler/>由DefaultServletHandlerBeanDefinitionParser负责解析。DefaultServletHandlerBeanDefi......
  • 返回有限状态(包含错误码、布尔值)的方法不应该抛出异常
    什么时候抛出异常?在一个方法无法完成它声明的行动时主动抛出。程序出bug时被动抛出。 C#中返回有限状态(包含错误码、布尔值)的方法不应该抛出异常。这种方法声明了什么?......
  • vba错误处理语句
    vba错误处理语句: a、OnErrorResumeNext//OnError表示过程出现错误怎么办?ResumeNext//表示跳过错误执行语句,执行错误语句的后面语句 //总体......
  • 系统闪退,调试提示异常Exception_WasThrown记录
    WPF应用中,点击某个按钮时提示系统卡住,随后崩溃经过调试,系统提示Exception_WasThrown原因:某个属性get然后了它本身代码privateDateTimeendTime=DateTime.Today;......
  • 针对zabbix二次开发的监控脚本执行timeout时,zabbix-server性能消耗增大问题,开发处理ti
    脚本内容:#!/bin/sh####################################################Scripttohandleexecutiontimeoutstates#scriptbyshell#writedbyDeliver#huchangx......
  • 单周期riscv处理器的实现
    目录单周期riscv处理器的实现指令分析实现指令处理器总体思路分块拆解处理器完整实现各分模块实现指令存储器数据存储器控制模块立即数生成模块单周期riscv处理器的实现......
  • spring-boot-route(四)全局异常处理
    在开发中,我们经常会使用try/catch块来捕获异常进行处理,如果有些代码中忘记捕获异常或者不可见的一些异常出现,就会响应给前端一些不友好的提示,这时候我们可以使用全局异常处......
  • springMVC
    SpringMVCssm:mybatis+Spring+SpringMVCSpringMVC:SpringMVC的执行流程SpringMVC:SSM框架整合MVC是模型(Model)、视图(View)、控制器(Controller)的简写,是一种软件设计规......
  • RTSP协议的处理--RECORD
        一、ABLMediaServer的过程1.没做过多的处理,只是对协议进行回复。2.Session是在ANNOUNCE命令中得到。二、ZLMediaKit的过程1.Session也是在ANNOUNCE命令中得......