java复制代码@PreAuthorize("hasRole('ROLE_ADMIN')")
@RequestMapping("/role/admin1")
String admin() {
    return "role: ROLE_ADMIN";
}

java复制代码//过滤器链实际调用的方法。 简单地委托给invoke(FilterInvocation)方法。
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
    throws IOException, ServletException {
    invoke(new FilterInvocation(request, response, chain));
}

java复制代码public void invoke(FilterInvocation filterInvocation) throws IOException, ServletException {
    if (isApplied(filterInvocation) && this.observeOncePerRequest) {
		//过滤器已应用于此请求，用户希望我们观察每个请求处理一次，因此不要重新进行安全检查
        filterInvocation.getChain().doFilter(filterInvocation.getRequest(), filterInvocation.getResponse());
        return;
    }
    // 第一次调用这个请求，所以执行安全检查
    if (filterInvocation.getRequest() != null && this.observeOncePerRequest) {
        filterInvocation.getRequest().setAttribute(FILTER_APPLIED, Boolean.TRUE);
    }
    
    //调用 beforeInvocation(filterInvocation) 方法 跟着这个方法往下看
    InterceptorStatusToken token = super.beforeInvocation(filterInvocation) ;
    try {
        //每个过滤器都有这么一步 
        filterInvocation.getChain().doFilter(filterInvocation.getRequest(), filterInvocation.getResponse());
    }
    finally {
        //在安全对象调用完成后清理AbstractSecurityInterceptor的工作。
        //无论安全对象调用是否成功返回，都应该在安全对象调用之后和 afterInvocation 之前调用此方法（即它应该在 finally 块中完成）。
        super.finallyInvocation(token);
    }
    //当调用afterInvocation（InterceptorStatusToken，Object）时，AbstractSecurityInterceptor不会采取进一步的操作。
    super.afterInvocation(token, null);
}

java复制代码protected InterceptorStatusToken beforeInvocation(Object object) {
    	//检查操作
		Assert.notNull(object, "Object was null");
		if (!getSecureObjectClass().isAssignableFrom(object.getClass())) {
			//....
		}
    	//这里获取的信息看下图示1 ：
    	//object 就是调用处传过来的参数 FilterInvocation filterInvocation，它本身其实就是 HttpServletRequest 和 HttpServletResponse 的增强
    	//object :filter invocation [GET /role/admin1] "
   		//然后我们获取到的就是受保护调用的列表  
		Collection<ConfigAttribute> attributes = this.obtainSecurityMetadataSource().getAttributes(object);
		if (CollectionUtils.isEmpty(attributes)) {
            //...
			return null; // no further work post-invocation
		}
    	//在 SecurityContext 中未找到身份验证对象，会发事件抛异常
		if (SecurityContextHolder.getContext().getAuthentication() == null) {
			credentialsNotFound(this.messages.getMessage("AbstractSecurityInterceptor.authenticationNotFound",
					"An Authentication object was not found in the SecurityContext"), object, attributes);
		}
    
    	//在这里拿到了  Authentication 对象登录的信息 ,后文会简单说是如何拿到的
		Authentication authenticated = authenticateIfRequired();
		if (this.logger.isTraceEnabled()) {
			this.logger.trace(LogMessage.format("Authorizing %s with attributes %s", object, attributes));
		}
		// Attempt authorization ： 尝试授权 这步本文重点，用我的话来说，这就是鉴权的入口  重点关注，下文继续
		attemptAuthorization(object, attributes, authenticated);
		//...
		// Attempt to run as a different user
		Authentication runAs = this.runAsManager.buildRunAs(authenticated, object, attributes);
		if (runAs != null) {
			//...
		}
		// 无后续动作
		return new InterceptorStatusToken(SecurityContextHolder.getContext(), false, attributes, object);

	}

java复制代码//如果Authentication.isAuthenticated()返回 false 或属性alwaysReauthenticate已设置为 true，
//则检查当前的身份验证令牌并将其传递给 AuthenticationManager进行身份验证
private Authentication authenticateIfRequired() {
    Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
    if (authentication.isAuthenticated() && !this.alwaysReauthenticate) {
        return authentication;
    }
    authentication = this.authenticationManager.authenticate(authentication);
    SecurityContextHolder.getContext().setAuthentication(authentication);
    return authentication;
}

java复制代码private void attemptAuthorization(Object object, Collection<ConfigAttribute> attributes,
                                  Authentication authenticated) {
    try {
        //接着套娃 我们去看 AccessDecisionManager 下的 decide() 方法
        this.accessDecisionManager.decide(authenticated, object, attributes);
    }
    catch (AccessDeniedException ex) {
        if (this.logger.isTraceEnabled()) {
            this.logger.trace(LogMessage.format("Failed to authorize %s with attributes %s using %s", object,
                                                attributes, this.accessDecisionManager));
        }
        else if (this.logger.isDebugEnabled()) {
            this.logger.debug(LogMessage.format("Failed to authorize %s with attributes %s", object, attributes));
        }
        publishEvent(new AuthorizationFailureEvent(object, attributes, authenticated, ex));
        throw ex;
    }
}

java复制代码public interface AccessDecisionManager {

	/**
为传递的参数解析访问控制决策。
参数：
身份验证 - 调用方法的调用者（非空）
object – 被调用的安全对象
configAttributes – 与被调用的安全对象关联的配置属性
	 */
	void decide(Authentication authentication, Object object, Collection<ConfigAttribute> configAttributes)
			throws AccessDeniedException, InsufficientAuthenticationException;


    // 下面这两个方法主要起辅助作用的。大都执行检查操作
	boolean supports(ConfigAttribute attribute);

	boolean supports(Class<?> clazz);

}

java复制代码public class AffirmativeBased extends AbstractAccessDecisionManager {

	public AffirmativeBased(List<AccessDecisionVoter<?>> decisionVoters) {
		super(decisionVoters);
	}

	/**
	这个具体的实现只是轮询所有配置的AccessDecisionVoter并在任何AccessDecisionVoter投赞成票时授予访问权限。 仅当存在拒绝投票且没有赞成票时才拒绝访问。
如果每个AccessDecisionVoter放弃投票，则决策将基于isAllowIfAllAbstainDecisions()属性（默认为 false）。
	 */
	@Override
	@SuppressWarnings({ "rawtypes", "unchecked" })
	public void decide(Authentication authentication, Object object, Collection<ConfigAttribute> configAttributes)
			throws AccessDeniedException {
		int deny = 0;
		for (AccessDecisionVoter voter : getDecisionVoters()) {
			int result = voter.vote(authentication, object, configAttributes);
			switch (result) {
			case AccessDecisionVoter.ACCESS_GRANTED:
				return;
			case AccessDecisionVoter.ACCESS_DENIED:
				deny++;
				break;
			default:
				break;
			}
		}
		if (deny > 0) {
			throw new AccessDeniedException(
					this.messages.getMessage("AbstractAccessDecisionManager.accessDenied", "Access is denied"));
		}
		// To get this far, every AccessDecisionVoter abstained
		checkAllowIfAllAbstainDecisions();
	}
}

java复制代码//表示一个类负责对授权决定进行投票。
//投票的协调（即轮询AccessDecisionVoter ，统计他们的响应，并做出最终授权决定）由AccessDecisionManager执行。
public interface AccessDecisionVoter<S> {

    int ACCESS_GRANTED = 1;

    int ACCESS_ABSTAIN = 0;

    int ACCESS_DENIED = -1;

    //这两个用来执行check操作，判断参数是否合法等等
    boolean supports(ConfigAttribute attribute);
    boolean supports(Class<?> clazz);

    /**
指示是否授予访问权限。
决定必须是肯定的 ( ACCESS_GRANTED )、否定的 ( ACCESS_DENIED ) 或者 AccessDecisionVoter可以弃权 ( ACCESS_ABSTAIN ) 投票。 
在任何情况下，实现类都不应返回任何其他值。 如果需要对结果进行加权，则应改为在自定义AccessDecisionManager处理。
除非AccessDecisionVoter由于传递的方法调用或配置属性参数而专门用于对访问控制决策进行投票，否则它必须返回ACCESS_ABSTAIN 。 
这可以防止协调AccessDecisionManager计算来自那些AccessDecisionVoter的选票，而这些AccessDecisionVoter对访问控制决策没有合法利益。
虽然安全对象（例如MethodInvocation ）作为参数传递以最大限度地提高访问控制决策的灵活性，但实现类不应修改它或导致所表示的调用发生（例如，通过调用MethodInvocation.proceed() ） .
	 */
	int vote(Authentication authentication, S object, Collection<ConfigAttribute> attributes);
}

java复制代码public class WebExpressionVoter implements AccessDecisionVoter<FilterInvocation> {
	private SecurityExpressionHandler<FilterInvocation> expressionHandler = new DefaultWebSecurityExpressionHandler();

	@Override
	public int vote(Authentication authentication, FilterInvocation filterInvocation,
			Collection<ConfigAttribute> attributes) {
        //...执行的一些检查
        //
		WebExpressionConfigAttribute webExpressionConfigAttribute = findConfigAttribute(attributes);
		if (webExpressionConfigAttribute == null) {
			return ACCESS_ABSTAIN;
		}
        //允许对EvaluationContext进行后处理。 实现可能会返回一个新的EvaluationContext实例或修改传入的EvaluationContext 。
        EvaluationContext ctx = webExpressionConfigAttribute.postProcess(
            //调用内部模板方法来创建StandardEvaluationContext和SecurityExpressionRoot对象。
            this.expressionHandler.createEvaluationContext(authentication, filterInvocation), filterInvocation);
        //针对指定的根对象评估默认上下文中的表达式。 如果评估结果与预期结果类型不匹配（并且无法转换为），则将返回异常。
        boolean granted = ExpressionUtils.evaluateAsBoolean(webExpressionConfigAttribute.getAuthorizeExpression(), ctx);
		// 投赞同票，返回
        if (granted) {
			return ACCESS_GRANTED;
		}
		return ACCESS_DENIED;
	}

    //循环判断
	private WebExpressionConfigAttribute findConfigAttribute(Collection<ConfigAttribute> attributes) {
		for (ConfigAttribute attribute : attributes) {
			if (attribute instanceof WebExpressionConfigAttribute) {
				return (WebExpressionConfigAttribute) attribute;
			}
		}
		return null;
	}
    //...
}

java复制代码for (AccessDecisionVoter voter : getDecisionVoters()) {
    int result = voter.vote(authentication, object, configAttributes);
    switch (result) {
        case AccessDecisionVoter.ACCESS_GRANTED:
            return;
        case AccessDecisionVoter.ACCESS_DENIED:
            deny++;
            break;
        default:
            break;
    }
}

java复制代码private void attemptAuthorization(Object object, Collection<ConfigAttribute> attributes,
                                  Authentication authenticated) {
    try {
        this.accessDecisionManager.decide(authenticated, object, attributes);
    }
}

java复制代码protected InterceptorStatusToken beforeInvocation(Object object) {
    // 返回到这里，我们再顺着往下看，看如何执行	
    attemptAuthorization(object, attributes, authenticated);
    // Attempt to run as a different user ：尝试以其他用户身份运行
    Authentication runAs = this.runAsManager.buildRunAs(authenticated, object, attributes);
    if (runAs != null) {
        SecurityContext origCtx = SecurityContextHolder.getContext();
        SecurityContextHolder.setContext(SecurityContextHolder.createEmptyContext());
        SecurityContextHolder.getContext().setAuthentication(runAs);
        // 需要恢复到 token.Authenticated 调用后 true的意思是：如果能以其他用户运行 就执行刷新
        return new InterceptorStatusToken(origCtx, true, attributes, object);
    }
    return new InterceptorStatusToken(SecurityContextHolder.getContext(), false, attributes, object);
}

java复制代码	public void invoke(FilterInvocation filterInvocation) throws IOException, ServletException {
		if (isApplied(filterInvocation) && this.observeOncePerRequest) {
			// 过滤器已应用于此请求，用户希望我们观察每个请求处理一次，因此不要重新进行安全检查
			filterInvocation.getChain().doFilter(filterInvocation.getRequest(), filterInvocation.getResponse());
			return;
		}
		// 第一次调用这个请求，所以执行安全检查
		if (filterInvocation.getRequest() != null && this.observeOncePerRequest) {
			filterInvocation.getRequest().setAttribute(FILTER_APPLIED, Boolean.TRUE);
		}
		//返回至此处  
        //InterceptorStatusToken类上的doc注释说：
        //AbstractSecurityInterceptor子类接收的返回对象。
		//这个类反映了安全拦截的状态，以便最终调用AbstractSecurityInterceptor.afterInvocation(InterceptorStatusToken, Object)可以正确整理。
        InterceptorStatusToken token = super.beforeInvocation(filterInvocation);
		try {
            //每个过滤器的必备代码
			filterInvocation.getChain().doFilter(filterInvocation.getRequest(), filterInvocation.getResponse());
		}
		finally {
			super.finallyInvocation(token);
		}
		super.afterInvocation(token, null);
	}

java复制代码//提供对基于 AOP 联盟的方法调用的安全拦截。
//此安全拦截器所需的SecurityMetadataSource是MethodSecurityMetadataSource类型。 这与基于 AspectJ 的安全拦截器 ( AspectJSecurityInterceptor ) 共享，因为两者都与 Java Method 。
public class MethodSecurityInterceptor extends AbstractSecurityInterceptor implements MethodInterceptor {

	private MethodSecurityMetadataSource securityMetadataSource;

	//此方法应用于对MethodInvocation强制实施安全性。
	@Override
	public Object invoke(MethodInvocation mi) throws Throwable {
        //beforeInvocation 这个有没有似曾相识 ，莫错哈  就是我们之前在 FilterSecurityInterceptor 看到的那个 
        //需要注意到的是 之前我们传的参是一个  FilterInvocation ，这里则是一个  MethodInvocation 。
		InterceptorStatusToken token = super.beforeInvocation(mi);
		Object result;
		try {
			result = mi.proceed();
		}
		finally {
			super.finallyInvocation(token);
		}
		return super.afterInvocation(token, result);
	}
    //...
}

java复制代码protected void configure(HttpSecurity http) throws Exception {
    http.csrf().disable()
        .authorizeRequests()
        .antMatchers("/r/r1").hasAuthority("r1")
        .antMatchers("/r/r2").hasAuthority("r2")
        ....
}

java复制代码attemptAuthorization(object, attributes, authenticated);
this.accessDecisionManager.decide(authenticated, object, attributes);

java复制代码public class PreInvocationAuthorizationAdviceVoter implements AccessDecisionVoter<MethodInvocation> {

	private final PreInvocationAuthorizationAdvice preAdvice;

	public PreInvocationAuthorizationAdviceVoter(PreInvocationAuthorizationAdvice pre) {
		this.preAdvice = pre;
	}
    //...一些检查方法
	@Override
	public int vote(Authentication authentication, MethodInvocation method, Collection<ConfigAttribute> attributes) {
		// 查找 prefilter 和 preauth（或组合）属性，如果两者都为 null，则弃权使用它们调用建议
		PreInvocationAttribute preAttr = findPreInvocationAttribute(attributes);
		if (preAttr == null) {
			// 没有基于表达式的元数据，所以弃权
			return ACCESS_ABSTAIN;
		}
        //在这里又委托给 PreInvocationAuthorizationAdvice接口的before方法来做判断
		return this.preAdvice.before(authentication, method, preAttr) ? ACCESS_GRANTED : ACCESS_DENIED;
	}

	private PreInvocationAttribute findPreInvocationAttribute(Collection<ConfigAttribute> config) {
		for (ConfigAttribute attribute : config) {
			if (attribute instanceof PreInvocationAttribute) {
				return (PreInvocationAttribute) attribute;
			}
		}
		return null;
	}
}

bash复制代码$netstat -i

bash复制代码$netstat -uta

bash复制代码$netstat -ta

bash复制代码$netstat -ua

HTTP复制代码POST http://localhost:8532/MultiToken/Login
Content-Type: application/json

{
	"UserName":"catcherwong-1",
	"Password":"123"
}

JSON复制代码{"code":0,"msg":"ok","data":"catcherwong-1-token"}

HTTP复制代码GET http://localhost:8532//MultiToken/do?account=xxx
Content-Type: application/json
token: catcherwong-1-token

JSON复制代码{"code":0,"msg":"ok","data":"catcherwong-1-token"}

java复制代码String p1 = System.getProperty("user.dir");
String p2 = System.getProperty("file.separator");
String p3 = "user_token.csv";
String path = p1 + p2 + p3;

FileWriter fileWriter = new FileWriter(new File(path), true);
BufferedWriter writer = new BufferedWriter(fileWriter);
writer.append(vars.get("accout")+","+vars.get("access_token")+"\n");
writer.close();
fileWriter.close();

java复制代码String p1 = System.getProperty("user.dir");
String p2 = System.getProperty("file.separator");
String p3 = "user_token.csv";
String path = p1 + p2 + p3;

log.info("准备删除文件:" + path);

File file = new File(path);
if (!file.exists()) {
  log.info("删除文件失败:" + path + "不存在！");
} else {
  file.delete();
}

go复制代码// Package runner 管理进程的运行和生命周期。
package runner

import (
   "errors"
   "os"
   "os/signal"
   "time"
)

//Runner 在给定的超时时间内运行一组任务，并且可以在操作系统中断时关闭。
type Runner struct {
   // interrupt通道会传送操作系统发送来的信号 
   interrupt chan os.Signal

   // complete 通道会发来协程完成的信号
   complete chan error

   // timeout 会发来超时信号
   timeout <-chan time.Time

   // 任务包含一组按索引顺序同步执行的函数。
   tasks []func(int)
}

// 当在超时通道上接收到一个值时，返回 ErrTimeout。
var ErrTimeout = errors.New("received timeout")

// 当接收到来自操作系统的事件时，会返回 ErrInterrupt。
var ErrInterrupt = errors.New("received interrupt")

// New 返回一个新的准备被使用的Runner。
func New(d time.Duration) *Runner {
   return &Runner{
      interrupt: make(chan os.Signal, 1),
      complete:  make(chan error),
      timeout:   time.After(d),
   }
}

go复制代码// 添加任务到 Runner。 任务是一个接受 int整数型变量的函数。
func (r *Runner) Add(tasks ...func(int)) {
   r.tasks = append(r.tasks, tasks...)
}

// Start函数运行所有任务并监听通道事件。
func (r *Runner) Start() error {
   // 我们希望接收所有的中断信号。
   signal.Notify(r.interrupt, os.Interrupt)

   //在不同的协程上运行不同的任务。
   go func() {
      r.complete <- r.run()
   }()

   select {
   // 处理完成时发出信号。
   case err := <-r.complete:
      return err

   // 超时以后发出信号
   case <-r.timeout:
      return ErrTimeout
   }
}

// run函数执行每个注册的任务。
func (r *Runner) run() error {
   for id, task := range r.tasks {
      // 检查来自操作系统的中断信号。
      if r.gotInterrupt() {
         return ErrInterrupt
      }

      // 执行注册的任务。
      task(id)
   }

   return nil
}

// gotInterrupt函数验证是否已发出中断信号。
func (r *Runner) gotInterrupt() bool {
   select {
   // 中断事件被发送时发出信号。
   case <-r.interrupt:
      // 停止接收任何进一步的信号。
      signal.Stop(r.interrupt)
      return true

   // 像往常一样正常运行
   default:
      return false
   }
}

go复制代码package main
import (
   "log"
   "os"
   "time"

   "github.com/goinaction/code/chapter7/patterns/runner"
)

// timeout 规定了必须在多少秒内处理完成
const timeout = 3 * time.Second

// main 是程序的入口
func main() {
   log.Println("Starting work.")

   // 为本次执行分配超时时间
   r := runner.New(timeout)

   // 加入要执行的任务
   r.Add(createTask(), createTask(), createTask(), createTask(), createTask(),createTask())

   // 执行任务并处理结果
    if err := r.Start(); err != nil {
       log.Println(err.Error())
    }
   log.Println("Process ended.")
}

// createTask 返回一个根据 id
// 休眠指定秒数的示例任务
// 用来模拟正在进行工作
func createTask() func(int) {
   return func(id int) {
      log.Printf("Processor - Task #%d.", id)
      time.Sleep(time.Duration(id) * time.Second)
   }
}

yaml复制代码2021/10/18 01:09:39 Starting work.
2021/10/18 01:09:39 Processor - Task #0.
2021/10/18 01:09:39 Processor - Task #1.
2021/10/18 01:09:40 Processor - Task #2.
2021/10/18 01:09:42 received timeout
2021/10/18 01:09:42 Process ended.

java复制代码- new NacosServiceManager() 
- new NacosServiceDiscovery(discoveryProperties, nacosServiceManager) : 从缓存中获取列表
- new NacosDiscoveryClient(nacosServiceDiscovery)

java复制代码// C- NacosWatch
public void start() {
    
   if (this.running.compareAndSet(false, true)) {
       
       // Step 1 : 构建 EventListener 对象
      EventListener eventListener = listenerMap.computeIfAbsent(buildKey(),
            event -> new EventListener() {
               @Override
               public void onEvent(Event event) {
                  if (event instanceof NamingEvent) {
                  
                     List<Instance> instances = ((NamingEvent) event).getInstances();
                     
                     Optional<Instance> instanceOptional = selectCurrentInstance(instances);
                     
                     instanceOptional.ifPresent(currentInstance -> {
                        resetIfNeeded(currentInstance);
                     });
                  }
               }
            });

    
      // Step 2 : 通过 NacosProperties 准备 NamingService 对象 ->  2.1.2 Step 2
      NamingService namingService = nacosServiceManager
            .getNamingService(properties.getNacosProperties());
      try {
      
         namingService.subscribe(properties.getService(), properties.getGroup(),
               Arrays.asList(properties.getClusterName()), eventListener);
      }
      catch (Exception e) {
         log.error("namingService subscribe failed, properties:{}", properties, e);
      }

      this.watchFuture = this.taskScheduler.scheduleWithFixedDelay(
            this::nacosServicesWatch, this.properties.getWatchDelay());
   }
}

java复制代码// NamingService init 流程
private void init(Properties properties) throws NacosException {
    ValidatorUtils.checkInitParam(properties);
    this.namespace = InitUtils.initNamespaceForNaming(properties);
    InitUtils.initSerialization();
    initServerAddr(properties);
    // 初始化web容器
    InitUtils.initWebRootContext();
    // 初始化缓存目录
    initCacheDir();
    // 初始化 log 路径
    initLogName(properties);
    
    this.eventDispatcher = new EventDispatcher();
    // 代理对象用于调用远程 Server
    this.serverProxy = new NamingProxy(this.namespace, this.endpoint, this.serverList, properties);
    // 用于向Nacos服务端发送已注册服务的心跳
    this.beatReactor = new BeatReactor(this.serverProxy, initClientBeatThreadCount(properties));
    // HostReactor用于获取、保存、更新各Service实例信息
    this.hostReactor = new HostReactor(this.eventDispatcher, this.serverProxy, beatReactor, this.cacheDir,
            isLoadCacheAtStart(properties), initPollingThreadCount(properties));
}

java复制代码// 实际上是通过反射生产最终的实例对象
Class<?> driverImplClass = Class.forName("com.alibaba.nacos.client.naming.NacosNamingService");
Constructor constructor = driverImplClass.getConstructor(Properties.class);
NamingService vendorImpl = (NamingService) constructor.newInstance(properties);

// 工作空间
private String namespace;
//
private String endpoint;
// 服务列表对应的 Server地址 : localhost:8848
private String serverList;
// 本地缓存地址
private String cacheDir;
// log 名称 : 通常是 naming.log
private String logName;

private HostReactor hostReactor;
private BeatReactor beatReactor;

private EventDispatcher eventDispatcher;
private NamingProxy serverProxy;

java复制代码public void subscribe(String serviceName, String groupName, List<String> clusters, EventListener listener)
        throws NacosException {
        
    // 通过监听器来实现更新Service
    eventDispatcher.addListener(hostReactor
                    .getServiceInfo(NamingUtils.getGroupedName(serviceName, groupName), StringUtils.join(clusters, ",")),
            StringUtils.join(clusters, ","), listener);
}


public void addListener(ServiceInfo serviceInfo, String clusters, EventListener listener) {
    
    // 构建一个 EventListener 集合 
    List<EventListener> observers = Collections.synchronizedList(new ArrayList<EventListener>());
    observers.add(listener);
    
    // ConcurrentMap<String, List<EventListener>> observerMap
    // 其中有个 Notifier 的线程 , 通过 while 循环持续的处理实例
    // /nacos/v1/ns/instance
    observers = observerMap.putIfAbsent(ServiceInfo.getKey(serviceInfo.getName(), clusters), observers);
    if (observers != null) {
        observers.add(listener);
    }
    
    // change 时刷新 Service
    serviceChanged(serviceInfo);
}

java复制代码@Import(EnableDiscoveryClientImportSelector.class)
public @interface EnableDiscoveryClient {
   // 默认为 true , 开启后就会调用对应的 AutoServiceRegistration
   boolean autoRegister() default true;
}

java复制代码// C- NacosAutoServiceRegistration
public void start() {
   // 如果未开启 , 则直接return 
   
   
   // only initialize if nonSecurePort is greater than 0 and it isn't already running
   // because of containerPortInitializer below
   if (!this.running.get()) {
      this.context.publishEvent(new InstancePreRegisteredEvent(this, getRegistration()));
      
      // 调用 Registry 发起注册 : this.serviceRegistry.register(getRegistration());
      register();
      
      if (shouldRegisterManagement()) {
         registerManagement();
      }
      this.context.publishEvent(new InstanceRegisteredEvent<>(this, getConfiguration()));
      this.running.compareAndSet(false, true);
   }

}

java复制代码public void register(Registration registration) {

   if (StringUtils.isEmpty(registration.getServiceId())) {
      return;
   }

   // 构建当前的 ServiceId 和 Group  
   NamingService namingService = namingService();
   String serviceId = registration.getServiceId();
   String group = nacosDiscoveryProperties.getGroup();

   // 包括 IP , 端口 , 分配名 , 元数据  
   Instance instance = getNacosInstanceFromRegistration(registration);

   try {
      // 注册当前实例 , 同时会添加心跳
      // serverProxy.registerService(groupedServiceName, groupName, instance);
      namingService.registerInstance(serviceId, group, instance);
   }
   catch (Exception e) {
      log.error("nacos registry, {} register failed...{},", serviceId,
            registration.toString(), e);
      // rethrow a RuntimeException if the registration is failed.
      // issue : https://github.com/alibaba/spring-cloud-alibaba/issues/1132
      rethrowRuntimeException(e);
   }
}

java复制代码private List<NacosServer> getServers() {
      String group = discoveryProperties.getGroup();
      List<Instance> instances = discoveryProperties.namingServiceInstance()
            .selectInstances(serviceId, group, true);
      return instancesToServerList(instances);
}

java复制代码// C- NacosNamingService
public List<Instance> selectInstances(String serviceName, String groupName, List<String> clusters, boolean healthy,
        boolean subscribe) throws NacosException {
    ServiceInfo serviceInfo = hostReactor
                .getServiceInfoDirectlyFromServer(NamingUtils.getGroupedName(serviceName, groupName),
                        StringUtils.join(clusters, ","));
    return selectInstances(serviceInfo, healthy);
}

java复制代码public void updateServiceNow(String serviceName, String clusters) {
    ServiceInfo oldService = getServiceInfo0(serviceName, clusters);
    try {
        // 同样通过代理类发起调用
        String result = serverProxy.queryList(serviceName, clusters, pushReceiver.getUdpPort(), false);
        
        if (StringUtils.isNotEmpty(result)) {
            processServiceJson(result);
        }
    } catch (Exception e) {
        NAMING_LOGGER.error("[NA] failed to update serviceName: " + serviceName, e);
    } finally {
        if (oldService != null) {
            synchronized (oldService) {
                oldService.notifyAll();
            }
        }
    }
}


// 发起远程调用
public String queryList(String serviceName, String clusters, int udpPort, boolean healthyOnly)
        throws NacosException {
    
    final Map<String, String> params = new HashMap<String, String>(8);
    params.put(CommonParams.NAMESPACE_ID, namespaceId);
    params.put(CommonParams.SERVICE_NAME, serviceName);
    params.put("clusters", clusters);
    params.put("udpPort", String.valueOf(udpPort));
    params.put("clientIP", NetUtils.localIP());
    params.put("healthyOnly", String.valueOf(healthyOnly));
    
    // 这里可以看到具体的 API : 
    return reqApi(UtilAndComs.nacosUrlBase + "/instance/list", params, HttpMethod.GET);
}

复制代码一 JAVA内存模型的介绍
二 JVM 内部组成
三 JAVA对象内存布局介绍和创建过程
四 JVM 参数调优
五 垃圾回收机制详解
六 JVM性能分析命令

erlang复制代码 描述的是一组规范，定义了变量的访问方式.

bash复制代码引导类加载器：使用C/C++编写的，加载Java的核心类库，并不继承ClassLoader,没有父加载器
拓展类加载器：加载 jre/lib/ext  目录下的类库
应用程序加载器：加载用户自定义类的默认加载器
用户自定义类加载器：
    为何要自定义类加载器?
        隔离加载类,避免类冲突
        扩展加载源
        防止源码泄漏
    自定义步骤：
        继承ClassLoader
        也可以继承URLClassLoader

复制代码 通过一个类的全限定名来获取其定义的二进制字节流
 将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构

vbnet复制代码 验证：确保被加载类的正确性，但不是必须的，它对程序运行期没有影响
     分为如下几个阶段：
         文件格式验证：验证字节流是否符合Class文件格式的规范，例如：是否以0xCAFEBABE开头
         元数据验证：对字节码描述的信息进行语义分析，证其描述的信息符合Java语言规范的要求
         字节码验证：通过数据流和控制流分析，确定程序语义是合法的、符合逻辑的。
         符号引用验证：确保解析动作能正确执行。
 准备：为类变量分配内存并且设置该类变量的默认初始值,即零值
     注意：这时候进行内存分配的仅包括类变量（static），而不包括实例变量，实例变量会在对象实例化时随着对象一块分配在Java堆中
 解析：
     将常量池中的符号引用替换为直接引用（内存地址）的过程
     解析动作主要针对类或接口、字段、类方法、接口方法、方法类型、方法句柄和调用点限定符7类符号引用进行。

markdown复制代码只有对类的主动使用才会导致类的初始化，就是执行类构造器方法<clinit> 的过程
    类的主动使用包括以下六种：  
    – 创建类的实例，也就是new的方式

    – 访问某个类或接口的静态变量，或者对该静态变量赋值

    – 调用类的静态方法

    – 反射（如Class.forName(“com.shengsiyuan.Test”)）

    – 初始化某个类的子类，则其父类也会被初始化

    – Java虚拟机启动时被标明为启动类的类（Java Test），直接使用java.exe命令来运行某个主类

css复制代码生命周期：主管程序运行，在线程创建是创建,跟随线程的生命周期，线程结束栈内存释放。
不存在垃圾回收，并且线程私有。

运行原理：
     栈中的数据都是以栈帧（Stack Frame）的格式存在，栈帧是一个内存区块，是一个数据集，是一个有关方法和运行期数据的数据集。
     当一个方法A被调用时就产生了一个栈帧F1，并被压入到栈中，A方法又调用了B方法，于是产生栈帧F2也被压入栈，B方法又调用了C方法，于是产生栈帧F3也被压入栈…… 依次执行完毕后，先弹出后进......F3栈帧，再弹出F2栈帧，再弹出F1栈帧。

markdown复制代码    局部变量表
        保存方法的局部变量(8种基本数据类型/对象的引用地址)
动态链接
        指向运行时常量池的方法引用
操作数栈
        主要用于保存计算过程的中间结果,同时作为计算过程中变量临时的存储空间
        底层是数组实现
方法返回地址
一些附加信息

markdown复制代码新生代：占整个堆内存的1/3
        伊甸园区：占整个新生代8/10，当该区域满了的时候,会发生YGC/MinorGC
                
        幸存者区：该区域满时,不会发生GC,当伊甸园区满了才会在该区域发生GC
                幸存0区：占整个新生代1/10
                        
                幸存者1区：占整个新生代1/10
                

老年代：占整个堆内存的2/3
        当对象经历过15次GC后仍然可用,就会进入该区域
        主要存放长生命周期的对象
        发生在该区域的GC叫做MajorGC

markdown复制代码运行时常量池
方法信息
Class类信息
域信息(类属性)
注意
	使用本地内存
	虚拟机规范中没有明说是否要回收,也可能会存在类卸载
	线程共享

复制代码管理本地方法的调用

erlang复制代码每个线程都有一个程序计算器，就是一个指针，指向方法区中的方法字节码（下一个将要执行的指令代码），由执行引擎读取下一条指令.
不会GC,不会OOM
因为CPU需要不停的切换各个线程,切换回来后需要知道从哪开始执行

复制代码任务：将字节码指令解释/编译为对应平台上的本地机器指令

java复制代码native 修饰的方法,由C/C++ 实现

markdown复制代码一 对象头
    包含两部分：
        1 运行时数据
            Hash值
            GC分代年龄
            锁状态标志
            线程持有的锁
            偏向线程ID
        2 类型指针：指向类元数据
 
二 实例数据
        包括从父类继承下来的字段和自身的

markdown复制代码1 加载类元信息
        判断对应的类是否加载/链接/初始化
2 为对象分配内存
        若内存连续
                采用指针碰撞的方式分配
        若内存不连续
                使用空闲列表记录那些空闲的内存
3 处理并发问题
        采用CAS失败重试/区域加锁保证原子性
4 属性的默认初始化(零值初始化)
5 设置对象头信息
6 属性的显示初始化/代码块初始化/

ruby复制代码1 标配参数
比如：java    -version
2 XX参数
    boolean类型
        公式： -XX: + 或者 - 某个属性 。+表示开启，-表示关闭。
        比如：-XX:+PrintGCDetails
    KV类型
        公式：-XX:key=value
        比如：-XX:MetaspaceSize=21m

diff复制代码-Xms ：初始内存大小，默认物理内存的1/64
    等价于 -XX:InititalHeapSize

-Xmx : 最大分配内存，默认为物理内存1/4
    等价于 -XX:MaxHeapSize

-Xss : 设置单个线程栈的大小，默认值和平台有关，linux一般为1024k
    等价于 -XX:ThreadStackSize

-Xmn: 设置年轻代大小

-XX:MetaspaceSize ：
     设置元空间大小，元空间使用的本地内存。
     
-XX:+PrintGCDetails :打印垃圾回收信息：
     
-XX:SurvivorRatio :	设置新生代eden和s0/s1空间的比例，默认是8:1:1
    该值设置多少就是设置eden区的比例是多少，s0/s1相同。

-XX:NewRatio: 设置年轻代和老年代的比例。默认是2，即新生代：老年代=1:2
    
-XX:MaxTenuringThreshold :
     设置进入老年代最大年龄，默认为15，即对象需要经过15次GC才能进入老年代。

less复制代码引用计数算法:
    给对象中添加一个引用计数器，每当有一个地方引用它时，计数器值就加 1；当引用失效时，计数器值就减 1；
Java 语言中没有选用引用计数算法，原因是它很难解决对象之间的相互循环引用的问题。解释：当A、B两个对象没有其他对象引用时，但A、B相互引用着对方，计数器无法为0，于是无法回收A、B两个对象。

根搜索算法：
    通过一系列的名为“GC Roots”的对象作为起始点，从这些节点开始向下搜索，搜索所走过的路径称为引用链（Reference Chain），当一个对象到 GC Roots 没有任何引用链相连时，则证明此对象是不可用的。
    哪些可以作为GC Roots 对象？
        1、栈中引用的对象。
        2、方法区中类静态属性引用的对象。
        3、方法区中常量引用的对象。 比如，使用static final 修饰的对象。
        4、本地方法栈中引用的对象。
        5.同步锁sync持有的对象

markdown复制代码强引用：只要强引用关系还存在,永远不会被JVM回收

软引用：只有当内存不够的时候，JVM会对软引用的对象回收
        
弱引用：JVM只要有GC都会回收该引用对象
        
虚引用：PhantomReference  任何时候都可能会被GC回收。必须和引用队列联合使用，不能单独使用。
        该引用的对象在GC后会放入ReferenceQueue引用队列中。可以在该对象销毁后做些业务。
        唯一目的：就是在这个对象被收集器回收时收到一个系统通知

erlang复制代码1 复制算法：
    将内存空间分为两块,每次只使用其中一块，
    将正在使用的内存中的存活对象复制到未被使用的内存块中,
    之后清除正在使用的内存块中所有对象,交换两个内存的角色,最后完成垃圾回收.
    
    优点：
        运行高效
        可以保证空间的连续性,不会出现内存碎片
    缺点：需要2倍的内存空间
    场景：
        用在新生代。
        复制的存活对象越少,性能越高
        

2 标记/清除
    标记阶段：
        从引用根节点(GC  Roots)开始遍历,标记所有被引用的对象,一般在对象头中标记为可达对象.
    清除阶段：
        对堆中所有对象进行线性遍历,如果发现某个对象在其Header中没有标记为可达对象,则回收。
        
    缺点：
        容易导致内存碎片,需要维护一个空闲列表
        效率不高
        进行GC的时候,需要停止整个应用程序

3 标记/压缩
    标记阶段：
        从引用根节点(GC  Roots)开始遍历,标记所有被引用的对象,一般在对象头中标记为可达对象.
    压缩阶段：
        将所有存活对象压缩到内存的一端,按顺序排放,然后清理边界外的空间.
        
    总结：相当于在 标记/清除算法执行完成后,再进行一次的内存整理
    缺点
        效率上要低于复制算法
        移动过程中需要暂停用户线程,STW
    场景：老年代
4 分区算法
    把整个堆空间划分成连续不同的小区间,每个小区间独立使用,独立回收

ruby复制代码内存溢出：
    1、StackOverflowError:
    2、OutOfMemoryError:java heap space
    3、OutOfMemoryError:GC overhead limit exceeded
        服务器资源大量时间被用来GC，且GC效果很差。
    4、OutOfMemoryError:Direct buffer memory
        分配堆外内存不够用，即超过-XX:MaxDirectMemorySize的值。
        一般在NIO程序中会报这种异常。 
    5、OutOfMemoryError:unable to create new native thread
        原因是一个应用进程中创建了过多的线程。可以设置linux允许单个进程可以运行的最大线程数。
    6、OutOfMemoryError:Metaspace：
    
    解决办法：Java虚拟机的堆内存设置不够，可以通过参数-Xms、-Xmx来调整。
    
内存泄漏：对象不会再被程序使用,但是GC又不能回收。
    有可能在单例模式，数据库连接，网络连接中，对象没法被回收。

markdown复制代码Minor GC：又称新生代GC，指发生在新生代的垃圾收集动作；
    因为Java对象大多是朝生夕灭，所以Minor GC非常频繁，一般回收速度也比较快；

Full GC：又称Major GC或老年代GC，指发生在老年代的GC；
    Major GC速度一般比Minor GC慢10倍以上；

arduino复制代码1 Serial :串行垃圾回收器，只有一个线程进行垃圾回收，会暂停用户线程,直到完成。
    开启命令：-XX:+UseSerialGC
    应用场景：
        主要用于Client模式；
        而在Server模式有两大用途：
         1 在JDK1.5及之前，与Parallel Scavenge收集器搭配使用（JDK1.6有Parallel Old收集器可搭配）；
         2 作为CMS收集器的后备预案，在并发收集发生Concurrent Mode Failure时使用
    具体分类：
        Serial GC：发生在新生代，采用复制算法。
        Serial Old GC：用于老年代，采用标记/压缩算法

objectivec复制代码2 Parallel: 并行垃圾回收器，多个垃圾收集器线程并行工作，java8默认
    开启命令：-XX:+UseParrallelGC
    具体分类：
        1 ParNew：用于新生代,老年代可以使用CMS
            开启命令：
                    "-XX:+UseConcMarkSweepGC"：指定使用CMS后，会默认使用ParNew作为新生代收集器；
                    "-XX:+UseParNewGC"：强制指定使用ParNew；
            特点：除了多线程外，其余的行为、特点和Serial收集器一样；
        2 Parallel Scavenge：因为与吞吐量关系密切，也称为吞吐量收集器
            特点：有一些特点与ParNew收集器相似
                新生代收集器；
                采用复制算法；
                多线程收集；
            应用场景：
                高吞吐量为目标，即减少垃圾收集时间，让用户代码获得更长的运行时间；
                当应用程序运行在具有多个CPU上，对暂停时间没有特别高的要求时，
                即程序主要在后台进行计算，而不需要与用户进行太多交互；
                例如，那些执行批量处理、订单处理、工资支付、科学计算的应用程序；

objectivec复制代码3 CMS：并发垃圾回收器
    目的：减少STW的时间
    开启命令：-XX:+UseConMarkSweepGC 
    特点：
        针对老年代
        基于"标记-清除"算法(不进行压缩操作，产生内存碎片)；            
        以获取最短回收停顿时间为目标；
        并发收集、低停顿；
    应用场景：
          与用户交互较多的场景；        
          希望系统停顿时间最短，注重服务的响应速度；
          以给用户带来较好的体验；
    回收步骤：
        1 初始标记(CMS-initial-mark) 
            会导致STW； 初始标记阶段就是标记老年代中的GC ROOT对象和与GC ROOT对象关联的对象给标记出来。
        2 并发标记(CMS-concurrent-mark)
            从GC Roots的直接关联对象开始遍历,这个过程耗时较长,但是不需要暂停用户线程
        3 重新标记(CMS-remark) 
            为了修正并发标记期间,因为用户线程继续运作和导致标记产生变动的那一部分对象的标记记录,也会导致STW
        4 并发清除(CMS-concurrent-sweep)
            清理标记阶段被判断为垃圾的对象,可以与用户线程同时并发执行

objectivec复制代码    为何不使用标记压缩算法?
        因为当并发清除时,在整理内存过程中,用户线程还在运行,对象的内存地址不能修改。
        
    优点：并发收集
          低延迟
    缺点：
        1 会产生内存碎片
        2 无法处理浮动垃圾,可能出现"Concurrent Mode Failure"失败
            浮动垃圾（Floating Garbage）：在并发清除时，用户线程新产生的垃圾，称为浮动垃圾；
            这使得并发清除时需要预留一定的内存空间，不能像其他收集器在老年代几乎填满再进行收集；            
            如果CMS预留内存空间无法满足程序需要，就会出现一次"Concurrent Mode Failure"失败；     
        3 对CPU资源非常敏感，CMS的默认收集线程数量是=(CPU数量+3)/4；当cpu数量不足4个时，对系统影响较大。



4 G1：Garbage-First收集器：
    是JDK7-u4才推出商用的收集器；
    宏观上它不在区分年轻代和老年代，把内存划分为2048个独立的子区域。
        小范围内区分年轻代和老年代。最大的好处是避免了全内存扫描。
    设计目标取代CMS收集器。
    特点：
        1 并行与并发
             能充分利用多CPU、多核环境下的硬件优势；
             可以并行来缩短"Stop The World"停顿时间；
             也可以并发让垃圾收集与用户程序同时进行；

        2 分代收集，收集范围包括新生代和老年代    
              能独立管理整个GC堆（新生代和老年代），而不需要与其他收集器搭配；
              能够采用不同方式处理不同时期的对象；
        3 结合多种垃圾收集算法，空间整合，不产生碎片
            从整体看，是基于标记-整理算法；
            从局部（两个Region间）看，是基于复制算法；
        4 可预测的停顿：低停顿的同时实现高吞吐量
            G1除了追求低停顿处，还能建立可预测的停顿时间模型；
            可以明确指定M毫秒时间片内，垃圾收集消耗的时间不超过N毫秒；
    采用的算法：Region之间是复制算法	
    命令：
        -XX:+UseG1GC：开启
        "-XX:MaxGCPauseMillis"：为G1设置暂停时间目标，默认值为200毫秒；
    优点：
        用户可以指定停顿时间：
            使用-XX:MaxGCPauseMills  最大GC停顿时间。JVM尽可能做到。
        并行与并发兼具
        不会产生内存碎片
    使用场景：
        面向服务端应用，针对具有大内存、多处理器的机器；
        最主要的应用是为需要低GC延迟，并具有大堆的应用程序提供解决方案；
        大内存,多处理器的机器上
        在下面的情况时，使用G1可能比CMS好：
            超过50％的Java堆被活动数据占用；
            对象分配频率或年代提升频率变化很大；
            GC停顿时间过长（长于0.5至1秒）。
        是否一定采用G1呢？也未必：
            如果现在采用的收集器没有出现问题，不用急着去选择G1；
            如果应用程序追求低停顿，可以尝试选择G1；
            是否代替CMS需要实际场景测试才知道。

lua复制代码1 Jps: 列出系S统中所有java应用程序。
    Jps  -l :输出主函数的完整路径。
    
2 Jinfo：查看或修改虚拟机参数
    语法：jinfo  <option>  <pid>
    例如：jinfo  -flag PrintGCDetails  pid
            查看打印GC日志是否开启。
    也可以动态修改参数：
     Jinfo  -flag  +PrintGCDetails  pid
     
3 Jmap：内存映像工具
    它可以生成Java 程序的堆dump文件，还可以查看堆内对象实例的统计信息。
    
    生成当前java程序的堆快照：
    语法：
        Jmap  -dump:format=b,file=dump文件地址  <javaPid>
            生成dump文件后，可以使用jhat、Visual VM、MAT等工具分析。
        Jmap  -histo  pid  >  s.txt
            统计java程序的对象信息： 
            将pid的java程序的对象统计信息输出到s.txt中。
    
4 Jstat:用于观察Java应用程序运行时信息，查看堆的详细信息。
    例如：输出GC相关堆信息：jstat  -gc或 -gcutil  pid
5 Jstack :用于导出Java应用程序的线程堆栈。
    语法：Jstack  [-l]  <pid>
        可以帮助开发人员找到死锁问题。
        
6 Jvisualvm：Java Visual VM  可视化工具

7 Jconsole：监控堆信息、类加载情况，线程监控，还可以检测死锁。

8 Jcmd:	JDK1.7之后新增的命令行工具。它可以导出堆，查看java进程、导出线程信息、执行GC等。
    语法：
    Jcmd :查看java进程
    Jcmd  <pid>  Thread.print：打印线程栈信息
    Jcmd  <pid>  GC.heap_dump  dump文件地址:导出堆信息，供Mat等分析
    Jcmd  <pid>  help : 查看支持哪些命令

css复制代码cargo fmt to transform the terse code back into the recommended format.

sql复制代码rustup check

复制代码Rust Analyzer, CodeLLDB plugins

arduino复制代码error: no override and no default toolchain set

arduino复制代码rustup install stable
rustup default stable

arduino复制代码export RUSTUP_DIST_SERVER=https://mirrors.ustc.edu.cn/rust-static

export RUSTUP_UPDATE_ROOT=https://mirrors.ustc.edu.cn/rust-static/rustup

ini复制代码[source.crates-io]
registry = "https://github.com/rust-lang/crates.io-index"
# 指定镜像
replace-with = 'ustc' # 如：tuna、sjtu、ustc，或者 rustcc

# 注：以下源配置一个即可，无需全部

# 中国科学技术大学
[source.ustc]
registry = "https://mirrors.ustc.edu.cn/crates.io-index"
# >>> 或者 <<<
# registry = "git://mirrors.ustc.edu.cn/crates.io-index"

# 上海交通大学
[source.sjtu]
registry = "https://mirrors.sjtug.sjtu.edu.cn/git/crates.io-index/"

# 清华大学
[source.tuna]
registry = "https://mirrors.tuna.tsinghua.edu.cn/git/crates.io-index.git"

# rustcc社区
[source.rustcc]
registry = "https://code.aliyun.com/rustcc/crates.io-index.git"

ini复制代码@Override
public Map<String, String> mtOrderCallback(TreeMap<String, String> params) {
    String data = JSON.toJSONString(params);
    logger.info("美团回调参数：{}", data);
    MtOrderModel mtOrder = JSONObject.parseObject(data, MtOrderModel.class);
    String getSign = mtOrder.getSign();
    String sign = MtSignUtils.genSign(params, model.getMtCallbackSecret());
    Map<String, String> result = new HashMap<>(3);
    if (sign.equals(getSign)) {
        String userUuid = mtOrder.getSid();
        UserMember member = userMemberService.getOne(Wrappers.<UserMember>lambdaQuery().eq(UserMember::getUuid, userUuid));
        if (member != null) {
            String orderId = mtOrder.getOrderid();
            String status = mtOrder.getStatus();
            String type = mtOrder.getType();
            CpsOrder order = cpsOrderService.getOne(Wrappers.<CpsOrder>lambdaQuery()
                    .eq(CpsOrder::getOrderSn, orderId));
            if (order == null) {
                order = new CpsOrder();
                // TODO
                // 保存订单
                // ......
                cpsOrderService.save(order);
            } else {
                if (StringUtils.equals("8", status)) {
                    // 美团订单已完成
                    // ......
                } else if (StringUtils.equals("9", status)) {
                    // 美团订单已退款或风控
                    // ......
                }
                cpsOrderService.updateById(order);
            }
        }
        result.put("errcode", "0");
        result.put("errmsg", "ok");
    } else {
        result.put("errcode", "1");
        result.put("errmsg", "err");
    }
    logger.info("美团回调返回给美团的参数：{}", JSON.toJSONString(result));
    return result;
}

less复制代码@PostMapping("mtOrderCallback")
public Map<String, String> mtOrderCallback(@RequestBody TreeMap<String, String> params){
    return mtApiService.mtOrderCallback(params);
}

kotlin复制代码[
  {
    "$id": "1",
    "$type": "SourceTree.Api.Host.Identity.Model.IdentityAccount, SourceTree.Api.Host.Identity",
    "IsDefault": false,
    "Authenticate": true,
    "HostInstance": {
      "$id": "2",
      "$type": "SourceTree.Host.Atlassianaccount.AtlassianAccountInstance, SourceTree.Host.AtlassianAccount",
      "Host": {
        "$id": "3",
        "$type": "SourceTree.Host.Atlassianaccount.AtlassianAccountHost, SourceTree.Host.AtlassianAccount",
        "Id": "atlassian account"
      },
      "BaseUrl": "https://id.atlassian.com/"
    },
    "Credentials": {
      "$id": "4",
      "$type": "SourceTree.Api.Account.Basic.BasicAuthCredentials, SourceTree.Api.Account.Basic",
      "Username": "",
      "Email": null,
      "AvatarURL": null,
      "AuthenticationScheme": {
        "$type": "SourceTree.Api.Account.Basic.BasicAuthAuthenticationScheme, SourceTree.Api.Account.Basic",
        "Value": "用户名/密码",
        "Name": "Basic",
        "Description": "密码",
        "HeaderValuePrefix": "Basic",
        "UsernameIsRequired": true
      },
      "Id": "",
      "EmailHash": null,
      "DisplayName": null
    }
  },
  {
    "$ref": "1"
  }
]