# -a 表示输出命令行选项
# p表PID
# s表示指定进程的父进程
$ pstree -aps 3084
systemd,1
  └─dockerd,15006 -H fd://
      └─docker-containe,15024 --config /var/run/docker/containerd/containerd.toml
          └─docker-containe,3991 -namespace moby -workdir...
              └─app,4009
                  └─(app,3084)

spring.data.mongodb.uri=mongodb://127.0.0.1:27017/faceguard?retryWrites=true

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;

/**
 * @Author: liuhaoeric
 * Create time: 2020/04/18
 * Description:
 */
@Data
@ConfigurationProperties(prefix = "mongo.client.option")
public class MongoClientOptionProperties {
    private int connectionsPerHost = 20;
    private int minConnectionsPerHost = 20;
    private int connectTimeout = 6000;
    private int maxWaitTime = 6000;
    private int socketTimeout = 0;
    private int heartbeatFrequency = 0;
}

package com.ericliu.mongodb.plus.config;

import com.mongodb.MongoClient;
import com.mongodb.MongoClientOptions;
import com.mongodb.MongoCredential;
import com.mongodb.ServerAddress;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.gridfs.GridFSBucket;
import com.mongodb.client.gridfs.GridFSBuckets;
import org.apache.logging.log4j.util.Strings;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.convert.CustomConversions;
import org.springframework.data.mongodb.MongoDbFactory;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.SimpleMongoDbFactory;
import org.springframework.data.mongodb.core.convert.DbRefResolver;
import org.springframework.data.mongodb.core.convert.DefaultDbRefResolver;
import org.springframework.data.mongodb.core.convert.DefaultMongoTypeMapper;
import org.springframework.data.mongodb.core.convert.MappingMongoConverter;
import org.springframework.data.mongodb.core.mapping.MongoMappingContext;

import java.util.ArrayList;
import java.util.List;

/**
 * @author pengkai
 * @date 2019-02-21
 */
@Configuration
@EnableConfigurationProperties(MongoClientOptionProperties.class)//建议这样引入MongoClientOptionProperties
public class MongoConfig {
    private static final Logger LOG = LoggerFactory.getLogger(MongoConfig.class);

    @Value("${mongo.database}")
    private String database;
    @Value("${mongo.host}")
    private String host;
    @Value("${mongo.port}")
    private int port;
    @Value("${mongo.username:}")
    private String userName;
    @Value("${mongo.password:}")
    private String password;

    @Bean
    public GridFSBucket getGridFSBuckets(MongoDbFactory mongoDbFactory) {
        MongoDatabase db = mongoDbFactory.getDb();
        return GridFSBuckets.create(db);
    }

    @Bean
    public MappingMongoConverter mappingMongoConverter(MongoDbFactory factory, MongoMappingContext context, BeanFactory beanFactory) {
        DbRefResolver dbRefResolver = new DefaultDbRefResolver(factory);

        MappingMongoConverter mappingConverter = new MappingMongoConverter(dbRefResolver, context);
        try {
            mappingConverter.setCustomConversions(beanFactory.getBean(CustomConversions.class));
        } catch (NoSuchBeanDefinitionException ignore) {
        }

        // Don't save _class to mongo
        mappingConverter.setTypeMapper(new DefaultMongoTypeMapper(null));
        return mappingConverter;
    }


    // 覆盖默认的MongoDbFactory
    @Bean
    MongoDbFactory mongoDbFactory(MongoClientOptionProperties mongoClientOptionProperties) {
        MongoClientOptions.Builder builder = new MongoClientOptions.Builder();
        builder.connectionsPerHost(mongoClientOptionProperties.getConnectionsPerHost());
        builder.minConnectionsPerHost(mongoClientOptionProperties.getMinConnectionsPerHost());
        builder.connectTimeout(mongoClientOptionProperties.getConnectTimeout());
        builder.maxWaitTime(mongoClientOptionProperties.getMaxWaitTime());
        builder.socketTimeout(mongoClientOptionProperties.getSocketTimeout());
        if (mongoClientOptionProperties.getHeartbeatFrequency() > 0) {
            builder.heartbeatFrequency(mongoClientOptionProperties.getHeartbeatFrequency());
        }
        MongoClientOptions mongoClientOptions = builder.build();

        // MongoDB地址列表
        List<ServerAddress> serverAddresses = new ArrayList<>();
        ServerAddress serverAddress = new ServerAddress(host, port);
        serverAddresses.add(serverAddress);

        // 连接认证
        MongoClient mongoClient = null;
        if (!Strings.isEmpty(userName)) {
            mongoClient = new MongoClient(serverAddresses, MongoCredential.createCredential(
                    userName,
                    database,
                    password.toCharArray()), mongoClientOptions);
        } else {
            mongoClient = new MongoClient(serverAddresses, mongoClientOptions);
        }

        //创建客户端和Factory
        return new SimpleMongoDbFactory(mongoClient, database);
    }

    @Bean
    MongoTemplate mongoTemplate(MongoDbFactory mongoDbFactory) {
        return new MongoTemplate(mongoDbFactory);
    }
}

protected final void processRequest(HttpServletRequest request, HttpServletResponse response)
		throws ServletException, IOException {

	long startTime = System.currentTimeMillis();
	Throwable failureCause = null;

	//从ThreadLocal中获取上一个请求的LocaleContext
	LocaleContext previousLocaleContext = LocaleContextHolder.getLocaleContext();//
	//new当前请求的LocaleContext
	LocaleContext localeContext = buildLocaleContext(request);//SimpleLocaleContext

	//从ThreadLocal中获取上一个请求的RequestAttributes(ServletRequestAttributes)
	RequestAttributes previousAttributes = RequestContextHolder.getRequestAttributes();
	//new当前请求的ServletRequestAttributes
	ServletRequestAttributes requestAttributes = buildRequestAttributes(request, response, previousAttributes);

	WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
	asyncManager.registerCallableInterceptor(FrameworkServlet.class.getName(), new RequestBindingInterceptor());

	//保存进ThreadLocal中
	initContextHolders(request, localeContext, requestAttributes);

	try {
		//抽象方法具体实现在DeipatchServlet,重点方法
		doService(request, response);
	}
	catch (ServletException | IOException ex) {
		failureCause = ex;
		throw ex;
	}
	catch (Throwable ex) {
		failureCause = ex;
		throw new NestedServletException("Request processing failed", ex);
	}

	finally {
		//恢复previousLocaleContext，previousAttributes
		//这里是我没太看明白的地方，说下我的猜测：
		// 1、previousLocaleContext,previousAttributes大概率为空这里就重置了ThreadLocal
		// 2、previousLocaleContext,previousAttributes不为空，说明当前线程处理别的请求，所以
		// 		在doservice时候context用的是current的值，请求处理完了将值还原称之前的值。
		resetContextHolders(request, previousLocaleContext, previousAttributes);
		if (requestAttributes != null) {
			requestAttributes.requestCompleted();
		}
		logResult(request, response, failureCause, asyncManager);
		publishRequestHandledEvent(request, response, startTime, failureCause);
	}
}

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 {
			//判断reqeust的ContentType包含multipart/ 如果是multipart则返回StandardMultipartHttpServletRequest
			processedRequest = checkMultipart(request);
			multipartRequestParsed = (processedRequest != request);

			// Determine handler for the current request.
			//根据请求获取HandlerExecutionChain，包含对应的handlerMethod和interceptor【MappedInterceptor 和 HandlerIntercpetor等等】
			//具体介绍见下方
			mappedHandler = getHandler(processedRequest);
			if (mappedHandler == null) {
				noHandlerFound(processedRequest, response);
				return;
			}

			// Determine handler adapter for the current request.
			// 根据handler找到HandlerAdapter
			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;
				}
			}

			//关键代码，执行拦截器的preHandle
			if (!mappedHandler.applyPreHandle(processedRequest, response)) {
				return;
			}

			// Actually invoke the handler.
			//关键代码，执行handlerMethod，ha的类型是RequestMappingHandlerAdapter，
			// 调用路径是AbstractHandlerMethodAdapter.handle()-->AbstractHandlerMethodAdapter.handleInternal()-->ha的类型是RequestMappingHandlerAdapter.handleInternal
			mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

			/**
			 * todo 待看的组件
			 * WebDataBinderFactory
			 * ModelFactory
			 *
			 * ServletInvocableHandlerMethod
			 *
			 * HandlerMethodArgumentResolverComposite
			 * HandlerMethodReturnValueHandlerComposite
			 *
			 * ModelAndViewContainer
			 * modelAndView
			 */

			//todo asyncManager 待看
			if (asyncManager.isConcurrentHandlingStarted()) {
				return;
			}

			//todo
			applyDefaultViewName(processedRequest, mv);
			//关键代码，执行拦截器的postHandle
			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);
		}
		//todo 书签 渲染modelAndView，同时触发mappedHandler.triggerAfterCompletion
		processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
	} catch (Exception ex) {
		//触发mappedHandler.triggerAfterCompletion
		triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
	} catch (Throwable err) {
		//触发mappedHandler.triggerAfterCompletion
		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.
			//这里要注意，Multipar在这里被清理掉所以如果Multipart有异步场景，需要将copy到别的对象中。
			if (multipartRequestParsed) {
				cleanupMultipart(processedRequest);
			}
		}
	}
}