java复制代码public class OAuthService extends BasePac4jService {

    private Logger logger = LoggerFactory.getLogger(this.getClass());

    private final static String CLIENT_ID = "b45e4-41c0-demo";
    private final static String CLIENT_SECRET = "0407581-ef15-f773-demo";
    private final static String CALLBACK_URL = "http://127.0.0.1:8088/oauth/callback";

    /**
     * 执行 Authorization 请求
     *
     * @return
     */
    public void doOAuthRequest(HttpServletRequest request, HttpServletResponse response) {

        // Step 1 :构建请求 Client
        OAuth20Configuration config = new OAuth20Configuration();
        config.setApi(new DefaultOAuthAPI());
        config.setProfileDefinition(new DefaultOAuthDefinition());
        config.setScope("user");
        config.setKey(CLIENT_ID);
        config.setSecret(CLIENT_SECRET);

        // Step 2 : 构建一个 Client
        OAuth20Client client = new OAuth20Client();

        // 补充完善属性
        client.setConfiguration(config);
        client.setCallbackUrl(CALLBACK_URL);

        // Step 3 : 构建请求 , 这里通过 302 重定向
        J2EContext context = new J2EContext(request, response);
        client.redirect(context);

        // Step 4 : 缓存数据
        request.getSession().setAttribute("client", client);

    }
}

java复制代码public class DefaultOAuthAPI extends DefaultApi20 {

    public String getRootEndpoint() {
        return "http://127.0.0.1/sso/oauth2.0/";
    }

    @Override
    public String getAccessTokenEndpoint() {
        return getRootEndpoint() + "accessToken";
    }

    @Override
    protected String getAuthorizationBaseUrl() {
        return getRootEndpoint() + "authorize";
    }
}

java复制代码
public class DefaultOAuthDefinition extends OAuth20ProfileDefinition<DefaultOAuhtProfile, OAuth20Configuration> {

    public static final String IS_FROM_NEW_LOGIN = "isFromNewLogin";
    public static final String AUTHENTICATION_DATE = "authenticationDate";
    public static final String AUTHENTICATION_METHOD = "authenticationMethod";
    public static final String SUCCESSFUL_AUTHENTICATION_HANDLERS = "successfulAuthenticationHandlers";
    public static final String LONG_TERM_AUTHENTICATION_REQUEST_TOKEN_USED = "longTermAuthenticationRequestTokenUsed";

    public DefaultOAuthDefinition() {
        super(x -> new DefaultOAuhtProfile());
        primary(IS_FROM_NEW_LOGIN, Converters.BOOLEAN);
        primary(AUTHENTICATION_DATE, new DefaultDateConverter());
        primary(AUTHENTICATION_METHOD, Converters.STRING);
        primary(SUCCESSFUL_AUTHENTICATION_HANDLERS, Converters.STRING);
        primary(LONG_TERM_AUTHENTICATION_REQUEST_TOKEN_USED, Converters.BOOLEAN);
    }

    @Override
    public String getProfileUrl(final OAuth2AccessToken accessToken, final OAuth20Configuration configuration) {
        return ((DefaultOAuthAPI) configuration.getApi()).getRootEndpoint() + "/profile";
    }

    @Override
    public DefaultOAuhtProfile extractUserProfile(final String body) {
        final DefaultOAuhtProfile profile = newProfile();
        
        // 参数从 attributes 中获取
        final String attributesNode = "attributes 中获取";
        JsonNode json = JsonHelper.getFirstNode(body);
        if (json != null) {
            profile.setId(ProfileHelper.sanitizeIdentifier(profile, JsonHelper.getElement(json, "id")));
            json = json.get(attributesNode);
            if (json != null) {
            
                // 这里以 CAS 的返回做了不同的处理
                if (json instanceof ArrayNode) {
                    final Iterator<JsonNode> nodes = json.iterator();
                    while (nodes.hasNext()) {
                        json = nodes.next();
                        final String attribute = json.fieldNames().next();
                        convertAndAdd(profile, PROFILE_ATTRIBUTE, attribute, JsonHelper.getElement(json, attribute));
                    }

                } else if (json instanceof ObjectNode) {
                    final Iterator<String> keys = json.fieldNames();
                    while (keys.hasNext()) {
                        final String key = keys.next();
                        convertAndAdd(profile, PROFILE_ATTRIBUTE, key, JsonHelper.getElement(json, key));
                    }
                }
            } else {
                raiseProfileExtractionJsonError(body, attributesNode);
            }
        } else {
            raiseProfileExtractionJsonError(body);
        }
        return profile;
    }
}

java复制代码
public class DefaultDateConverter extends DateConverter {

    public DefaultDateConverter() {
        super("yyyy-MM-dd'T'HH:mm:ss.SSSZ");
    }

    @Override
    public Date convert(final Object attribute) {
        Object a = attribute;
        if (a instanceof String) {
            String s = (String) a;
            int pos = s.lastIndexOf("[");
            if (pos > 0) {
                s = s.substring(0, pos);
                pos = s.lastIndexOf(":");
                if (pos > 0) {
                    s = s.substring(0, pos) + s.substring(pos + 1, s.length());
                }
                a = s;
            }
        }
        return super.convert(a);
    }
}

java复制代码public class DefaultOAuhtProfile extends OAuth20Profile {

    private static final long serialVersionUID = 1347249873352825528L;

    public Boolean isFromNewLogin() {
        return (Boolean) getAttribute(DefaultOAuthDefinition.IS_FROM_NEW_LOGIN);
    }

    public Date getAuthenticationDate() {
        return (Date) getAttribute(DefaultOAuthDefinition.AUTHENTICATION_DATE);
    }

    public String getAuthenticationMethod() {
        return (String) getAttribute(DefaultOAuthDefinition.AUTHENTICATION_METHOD);
    }

    public String getSuccessfulAuthenticationHandlers() {
        return (String) getAttribute(DefaultOAuthDefinition.SUCCESSFUL_AUTHENTICATION_HANDLERS);
    }

    public Boolean isLongTermAuthenticationRequestTokenUsed() {
        return (Boolean) getAttribute(DefaultOAuthDefinition.LONG_TERM_AUTHENTICATION_REQUEST_TOKEN_USED);
    }
}

java复制代码    @GetMapping("callback")
    public void callBack(final HttpServletRequest request, final HttpServletResponse response) throws IOException {

        logger.info("------> [SSO 回调 pac4j OAuth 逻辑] <-------");

        // 从 Session 中获取缓存的对象
        OAuth20Client client = (OAuth20Client) request.getSession().getAttribute("client");
        J2EContext context = new J2EContext(request, response);

        // 获取 AccessToken 对应的Credentials
        final Credentials credentials = client.getCredentials(context);

        // 通过 Profile 获取 Profile
        final CommonProfile profile = client.getUserProfile(credentials, context);

        // Web 返回数据信息
        logger.info("------> Pac4j Demo 获取用户信息 :[{}] <-------", profile.toString());
        response.getWriter().println(profile.toString());
    }

java复制代码C01- IndirectClient
    M101- redirect(WebContext context)
        ?- 之前可以看到 , 我们调用 redirect 发起了请求
    
    M102- getRedirectAction
        - 如果请求类型是 ajaxRequest , 则由 ajaxRequestResolver 进行额外处理
        - 
    
  
// M101 伪代码
public final HttpAction redirect(WebContext context) {
    RedirectAction action = this.getRedirectAction(context);
    return action.perform(context);
}
    
// M102 伪代码
public RedirectAction getRedirectAction(WebContext context) {
        this.init();
        if (this.ajaxRequestResolver.isAjax(context)) {
            RedirectAction action = this.redirectActionBuilder.redirect(context);
            this.cleanRequestedUrl(context);
            return this.ajaxRequestResolver.buildAjaxResponse(action.getLocation(), context);
        } else {
            String attemptedAuth = (String)context.getSessionStore().get(context, this.getName() + "$attemptedAuthentication");
            if (CommonHelper.isNotBlank(attemptedAuth)) {
                this.cleanAttemptedAuthentication(context);
                this.cleanRequestedUrl(context);
                throw HttpAction.unauthorized(context);
            } else {
                return this.redirectActionBuilder.redirect(context);
            }
        }
}    

C02- RedirectActionBuilder (OAuth20RedirectActionBuilder)
    M201- redirect
        - 生成 state 且放入 session
        2- this.configuration.buildService : 构建一个 OAuth20Service
        3- 通过 param 属性获取一个 authorizationUrl
        - RedirectAction.redirect(authorizationUrl) : 发起认证
        
        
// M201 伪代码
public RedirectAction redirect(WebContext context) {

    //伪代码 , 通过 generateState 生成 state ,且会放入 session
    String state=this.configuration.isWithState()?generateState : null;

    // M201-2 : OAuth20Service 是 OAuth 的业务类 
    OAuth20Service service = (OAuth20Service)this.configuration.buildService(context, this.client, state);
    // M201-3 : 设置了认证的地址
    String authorizationUrl = service.getAuthorizationUrl(this.configuration.getCustomParams());
    return RedirectAction.redirect(authorizationUrl);

} 


// 到这里还没有看到实际请求的情况 ,我们再往底层看看

我们回到 M101 方法的 perform 中
C- RedirectAction
    M- perform(WebContext context)
        -  this.type == RedirectAction.RedirectType.REDIRECT ? HttpAction.redirect(context, this.location) : HttpAction.ok(context, this.content);
        
// 再深入一层 , 真相大白了
public static HttpAction redirect(WebContext context, String url) {
    context.setResponseHeader("Location", url);
    context.setResponseStatus(302);
    return new HttpAction(302);
}

他使用的是302 重定向的状态码 , 由浏览器完成重定向 , 这里的充电关系地址是
http://127.0.0.1/sso/oauth2.0/authorize?response_type=code&client_id=b7a8cc2a-5dec-4a78&redirect_uri=http%3A%2F%2F127.0.0.1%3A9081%2Fmfa-client%2Foauth%2Fcallback%3Fclient_name%3DCasOAuthWrapperClient

java复制代码    public void oauthCallBack(final HttpServletRequest request, final HttpServletResponse response) throws IOException {

        // 这里可以和之前构建 Context 进行对比
        // 当时将多个属性放在了session 中 , 这里就形成了一个循环 , 将状态发了回来
        CasOAuthWrapperClient client = (CasOAuthWrapperClient) request.getSession().getAttribute("oauthClient");
        
        // 第二步 : 获取 AccessToken
        J2EContext context = new J2EContext(request, response);
        final OAuth20Credentials credentials = client.getCredentials(context);
        
        final CommonProfile profile = client.getUserProfile(credentials, context);

        response.getWriter().println(profile.toString());


    }

java复制代码C01- IndirectClient
    M103- getCredentials(WebContext context)
        - this.init() : OAuth 这一块主要是断言
            - CommonHelper.assertNotBlank("key", this.key);
            - CommonHelper.assertNotBlank("secret", this.secret);
            - CommonHelper.assertNotNull("api", this.api);
            - CommonHelper.assertNotNull("hasBeenCancelledFactory", this.hasBeenCancelledFactory);
            - CommonHelper.assertNotNull("profileDefinition", this.profileDefinition);
    
    


    public final C getCredentials(WebContext context) {
        this.init();
        C credentials = this.retrieveCredentials(context);
        if (credentials == null) {
            context.getSessionStore().set(context, this.getName() + "$attemptedAuthentication", "true");
        } else {
            this.cleanAttemptedAuthentication(context);
        }

        return credentials;
    }
    
// 继续索引 , 可以看到更复杂得
C03- BaseClient
    M301- retrieveCredentials
        -  this.credentialsExtractor.extract(context) : 获取一个 credentials 对象
            ?- 这个对象是之前 Authoriza 完成后返回的 Code 对象 :PS001
        - this.authenticator.validate(credentials, context) : 发起校验
            ?- 这里是 OAuth20Authenticator , 详见 
            
    
    
// 补充 PS001
#OAuth20Credentials# | code: OC-1-wVu2cc3p33ChsQshKd1rUabk6lggPB1QhWh | accessToken: null |
    
C04- OAuth20Authenticator
    M401- retrieveAccessToken
        - 从 OAuth20Credentials 获得 code
        - 通过 OAuth20Configuration 构建 OAuth20Service , 调用 getAccessToken

// M401 伪代码 : 这里就很清楚了
    protected void retrieveAccessToken(WebContext context, OAuthCredentials credentials) {
        OAuth20Credentials oAuth20Credentials = (OAuth20Credentials)credentials;
        String code = oAuth20Credentials.getCode();
        this.logger.debug("code: {}", code);

        OAuth2AccessToken accessToken;
        try {
            accessToken = ((OAuth20Service)((OAuth20Configuration)this.configuration).buildService(context, this.client, (String)null)).getAccessToken(code);
        } catch (InterruptedException | ExecutionException | IOException var7) {
            throw new HttpCommunicationException("Error getting token:" + var7.getMessage());
        }

        this.logger.debug("accessToken: {}", accessToken);
        oAuth20Credentials.setAccessToken(accessToken);
    }
    
    
C05- OAuth20Service
    M501- getAccessToken
        - OAuthRequest request = this.createAccessTokenRequest(code, pkceCodeVerifier);
        - this.sendAccessTokenRequestSync(request);
    M502- sendAccessTokenRequestSync
        - (OAuth2AccessToken)this.api.getAccessTokenExtractor().extract(this.execute(request));
               ?- 点进去可以发现 ,其底层实际上是一个 HttpClient 调用
               - httpClient.execute(userAgent, request.getHeaders(), request.getVerb(), request.getCompleteUrl(),request.getByteArrayPayload());
                   ?- PS002
                    
                

// PS002 补充 : 参数详见下图
http://127.0.0.1/sso/oauth2.0/accessToken?

java复制代码
// Step 1　：起点方法　
final CommonProfile profile = client.getUserProfile(credentials, context);

C03- BaseClient
    M302- getUserProfile
        -  U profile = retrieveUserProfile(credentials, context);
    M303- retrieveUserProfile
        - this.profileCreator.create(credentials, context);
            ?- 这里是 OAuth20ProfileCreator : M601
            
C06- OAuthProfileCreator
    M601- create
        - T token = this.getAccessToken(credentials) : 获取了 Token
        - return this.retrieveUserProfileFromToken(context, token);
    M602- retrieveUserProfileFromToken
        - final OAuthProfileDefinition<U, T, O> profileDefinition = configuration.getProfileDefinition();
            ?- OAuthProfileDefinition 用于构建请求 , 包括发送的类型等
        - final String profileUrl = profileDefinition.getProfileUrl(accessToken, configuration);
            ?- profile 地址
        - final S service = this.configuration.buildService(context, client, null);
            ?- 构建一个 Service
        - final String body = sendRequestForData(service, accessToken, profileUrl, profileDefinition.getProfileVerb());
            ?- 请求 Profile , 这里实际上就已经调用拿到数据了
       -  final U profile = (U) configuration.getProfileDefinition().extractUserProfile(body);
           ?- 解析成 Profile 对象
       -  addAccessTokenToProfile(profile, accessToken);
           ?- 构建最后的对象

java复制代码// Step 1 : 发起请求
- 构建一个 Configuration
- 构建一个 Client 
    - 因为 saml 的 API 都在 metadata 中 , 所以这里没有注入 API 的需求    
    
--> 发起调用
RedirectAction action = client.getRedirectAction(context);
action.perform(context);    

    -  return redirectActionBuilder.redirect(context);
        ?- 一样的套路 , 这里的 builder 是 SAML2RedirectActionBuilder

// 最后还是一样构建了一个 SAML 的 302 请求

java复制代码
final SAML2Client client = (SAML2Client) request.getSession().getAttribute("samlclient");

// 获取 J2EContext 对象
J2EContext context=new J2EContext(request,response);
final SAML2Credentials credentials = client.getCredentials(context);

// 获取 profile 数据
final CommonProfile profile = client.getUserProfile(credentials, context);
response.getWriter().println(profile.toString());

C- SAML2Authenticator
    M- validate
        - final SAML2Profile profile = getProfileDefinition().newProfile();
            ?- 获取返回的 Profile
        - profile.addAuthenticationAttribute(SESSION_INDEX, credentials.getSessionIndex());
        - profile.addAuthenticationAttribute(SAML_NAME_ID_FORMAT, nameId.getFormat());
        - profile.addAuthenticationAttribute(SAML_NAME_ID_NAME_QUALIFIER, nameId.getNameQualifier());
        - profile.addAuthenticationAttribute(SAML_NAME_ID_SP_NAME_QUALIFIER, nameId.getSpNameQualifier());
        - profile.addAuthenticationAttribute(SAML_NAME_ID_SP_PROVIDED_ID, nameId.getSpProviderId());
            ?- 配置相关属性
                
                
//  final CommonProfile profile = client.getUserProfile(credentials, context);

java复制代码package top.nikk.demo.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

    @GetMapping("")
    public String sayHello() {
        return "Hello Felix, This is docker image !";
    }
}

text复制代码# Docker image for springboot file run
# VERSION 1.0.0
# Author: Felix
# 基础镜像使用java
FROM java:8
# 作者
MAINTAINER Felix<Felix5200@163.com>
# VOLUME 指定了临时文件目录为/tmp。
# 其效果是在主机 /var/lib/docker 目录下创建了一个临时文件，并链接到容器的/tmp
VOLUME /tmp 
# 将jar包添加到容器中并更名为app.jar
ADD felix-admin.jar app.jar 
# 运行jar包
RUN bash -c 'touch /app.jar'
ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/app.jar"]

linux复制代码docker build -t top.nikk/docker-demo:1.0.0 .

diff复制代码-t ：指定要创建的目标镜像名

.  ：Dockerfile 文件所在目录，可以指定Dockerfile 的绝对路径

linux复制代码docker run -id -p 8080:8080 --name demo  top.nikk/docker-demo:1.0.0

javascript复制代码const { Wechaty } = require("wechaty");
const Qrterminal = require("qrcode-terminal");

const name = "wechat-puppet-wechat";
let bot = "";
bot = new Wechaty({
  name, // generate xxxx.memory-card.json and save login data for the next login
});

//  二维码生成
function onScan(qrcode, status) {
  Qrterminal.generate(qrcode); // 在console端显示二维码
  const qrcodeImageUrl = [
    "https://wechaty.js.org/qrcode/",
    encodeURIComponent(qrcode),
  ].join("");
  console.log(qrcodeImageUrl);
}

// 登录
async function onLogin(user) {
  console.log(`贴心小助理${user}登录了`);
  if (config.AUTOREPLY) {
    console.log(`已开启机器人自动聊天模式`);
  }
}

//登出
function onLogout(user) {
  console.log(`小助手${user} 已经登出`);
}

bot.on("scan", onScan);
bot.on("login", onLogin);
bot.on("logout", onLogout);
bot.on("message", function(message){
    console.log(message);
}) // 消息监听
bot
  .start()
  .then(() => console.log("开始登陆微信"))
  .catch((e) => console.error(e));

javascript复制代码const { Wechaty } = require('wechaty')

async function main () {
  conswt bot = new Wechaty()
  bot
    .on('scan', (qrcode, status) => console.log(`Scan QR Code to login: ${status}\nhttps://wechaty.js.org/qrcode/${encodeURIComponent(qrcode)}`))
    .on('login',            user => console.log(`User ${user} logged in`))
    .on('message',       message => console.log(`Message: ${message}`))
  await bot.start()
}

main()
  .catch(console.error)

javascript复制代码const { Wechaty } = require("wechaty");
const { PuppetPadlocal } = require("wechaty-puppet-padlocal");  // 引入协议包
const QrcodeTerminal = require("qrcode-terminal");  // 控制台二维码
const onMessage = require("./onMessage"); // 消息监听回调
const config = require("./config"); // 配置文件


// 实例化机器人
const bot = new Wechaty({
  puppet: new PuppetPadlocal({
    token: config.token,
  }),
});

// 添加监听事件
bot
  // 扫码登录
  .on("scan", (qrcode, status) => {
    console.log(
      `Scan QR Code to login: ${status}\nhttps://api.qrserver.com/v1/create-qr-code/?data=${encodeURIComponent(
        qrcode
      )}`
    );
    QrcodeTerminal.generate(qrcode);
  })
  // 登录监听
  .on("login", (user) => {
    console.log(user, "logined");
  })
  // 退出监听
  .on("logout", (user) => {
    console.log(user, "logout");
  })
  // 消息监听
  .on("message", onMessage(bot))
  .start();

ini复制代码 // 获取@你的群友
 let member = msg.talker();
 // 群聊@群友回复
 let response = ‘回复给群友的内容’;
 msg.room().say(response,member);

javascript复制代码const { UrlLink } = require("wechaty");
const request = require("request");
const urlencode = require("urlencode");
const config = require("./config");
const miniProrReply = require("../utils/miniProReply");  // 小程序参数
const translate = require("../utils/translate"); // 百度翻译
const { rainbowFart, circle ,drugInstruction} = require("../utils/txAPI");  // 天行api
const name = config.name;
const roomList = config.room.roomList;

// 消息监听回调
module.exports = (bot) => {
  return async function onMessage(msg) {
    // 判断消息来自自己，直接return
    if (msg.self()) return;
    // 消息类型判断
    switch (msg.type()) {
      case 7:
        var reg = /^[\u4e00-\u9fa5]+$/; // 文字正则
        console.log("获取到文本");
        // 回复信息是关键字 “加群”     测试成功
        if (await isAddRoom(msg)) return;
        // 回复信息是所管理的群聊名    测试成功
        if (await isRoomName(bot, msg)) return;
          // 开启机器人
          if (msg.payload.roomId) {
            // 添加判断 不是指定群聊的信息不触发  [不加判断机器人，机器人会回复任意所在群聊内容。。。]
            console.log("获取到群聊消息");
            if (msg.payload.roomId === "20856899751@chatroom") {
            // 判断群内回复内容不为文字
              if(!reg.test(msg.text())){
                translate(msg);
                return;
              } else{
                roomMessageReply(msg);
                return;
              }
            }
          }
        break;
      case 9:
        console.log("获取到小程序"); // 测试成功
        miniProrReply(msg);
        break;
      case 14:
        console.log("获取到卡片链接"); // 测试成功
        break;
      default:
        console.log("暂时不支持该类型的接收!");
        break;
    }
  };
};

/**
 * @description 回复群聊信息 处理函数
 * @param {Object} msg 消息对象
 * @return {Promise} true-是 false-不是
 */
async function roomMessageReply(msg) {
  const room = msg.room();
  const text = msg.text();
  if (await msg.mentionSelf()) {
    // 获取消息内容，拿到整个消息文本，去掉 @名字
    const sendText = msg.text().replace("@蔚蓝", "");
    // 请求机器人接口回复
    let res = await requestRobot(sendText);
    // 返回消息，并@来自人 只可以padplus调用
    // room.say(res, msg.fromId());
    // 此处替换为群内回话
    // padlocal使用 msg函数@指定人
    // 获取@你的群友 
    // let member = msg.talker();
    // 群聊@群友回复
    // msg.room().say(response,member);
    room.say(res);  
  } else {
    let content = await requestRobot(msg.text());
    room.say(content);
    return 
  }

  // 指定关键字触发
  if (/互动/.test(text)) {
    room.say("互动测试");
    return 
  } else if(/彩虹屁/.test(text)){
    let reply = await rainbowFart(params);
    room.say(reply);
    return 
  } else if(/文案/.test(text)){
    let reply = await circle(params);
    room.say(reply);
    return 
  }else if (/蔚蓝工作室/.test(text)) {
    room.say(new UrlLink(config.personal.introUrl));
    return 
  } else if(/药品/.test(text)){
    params.word = text.substring(2);
    console.log(params);
    let reply = await drugInstruction(params);
    room.say(reply);
    return 
  }
}

/**
 * @description 回复信息是关键字 “加群” 处理函数
 * @param {Object} msg 消息对象
 * @return {Promise} true-是 false-不是
 */
async function isAddRoom(msg) {
  // 关键字 加群 处理
  if (msg.text() == "加群") {
    let roomListName = Object.keys(roomList);
    let info = `${name}当前管理群聊有${roomListName.length}个，回复群聊名即可加入哦\n\n`;
    roomListName.map((v) => {
      info += "【" + v + "】" + "\n";
    });
    msg.say(info);
    return true;
  }
  return false;
}

/**
 * @description 回复信息是所管理的群聊名 处理函数
 * @param {Object} bot 实例对象
 * @param {Object} msg 消息对象
 * @return {Promise} true-是群聊 false-不是群聊
 */
async function isRoomName(bot, msg) {
  // 回复信息为管理的群聊名
  if (Object.keys(roomList).some((v) => v == msg.text())) {
    // 通过群聊id获取到该群聊实例
    const room = await bot.Room.find({ id: roomList[msg.text()] });
    // 获取当前room信息
    console.log(room);
    // 判断是否在房间中 在-提示并结束
    if (await room.has(msg.from())) {
      await msg.say("您已经在房间中了");
      return true;
    }

    // 发送群邀请
    await room.add(msg.from());
    await msg.say("已发送群邀请");
    return true;
  }
  return false;
}

/**
 * @description 机器人请求接口 处理函数
 * @param {String} info 发送文字
 * @return {Promise} 相应内容
 */
function requestRobot(info) {
  return new Promise((resolve, reject) => {
    let url = `https://open.drea.cc/bbsapi/chat/get?keyWord=${urlencode(info)}`;
    request(url, (error, response, body) => {
      if (!error && response.statusCode == 200) {
        let res = JSON.parse(body);
        if (res.isSuccess) {
          let send = res.data.reply;
          // 免费的接口，所以需要把机器人名字替换成为自己设置的机器人名字
          send = send.replace(/Smile/g, name);
          resolve(send);
        } else {
          if (res.code == 1010) {
            resolve("没事别老艾特我，我还以为爱情来了");
          } else {
            resolve("你在说什么，我听不懂");
          }
        }
      } else {
        resolve("你在说什么，我脑子有点短路诶！");
      }
    });
  });
}

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter</artifactId>
</dependency>

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-logging</artifactId>
</dependency>

<dependency>
  <groupId>ch.qos.logback</groupId>
  <artifactId>logback-classic</artifactId>
</dependency>
<dependency>
  <groupId>org.apache.logging.log4j</groupId>
  <artifactId>log4j-to-slf4j</artifactId>
</dependency>
<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>jul-to-slf4j</artifactId>
</dependency>

<property name="CONSOLE_LOG_PATTERN" value="%d{yyyy-MM-dd HH:mm:ss.SSS} %contextName [%thread] %-5level [%X{requestId}] %logger{36} - %msg%n"/>

public class BasicMDCAdapter implements MDCAdapter {

    private InheritableThreadLocal<Map<String, String>> inheritableThreadLocal = new InheritableThreadLocal<Map<String, String>>() {
        @Override
        protected Map<String, String> childValue(Map<String, String> parentValue) {
            if (parentValue == null) {
                return null;
            }
            return new HashMap<String, String>(parentValue);
        }
    };

    public void put(String key, String val) {
        if (key == null) {
            throw new IllegalArgumentException("key cannot be null");
        }
        Map<String, String> map = inheritableThreadLocal.get();
        if (map == null) {
            map = new HashMap<String, String>();
            inheritableThreadLocal.set(map);
        }
        map.put(key, val);
    }
    // ...
}

public class TraceIdUtils {

    /**
     * 生成traceId
     *
     * @return TraceId 基于UUID
     */
    public static String getTraceId() {
        return UUID.randomUUID().toString().replace("-", "");
    }
}

public class TraceIdContext {

    public static final String TRACE_ID_KEY = "requestId";

    public static void setTraceId(String traceId) {
        if (StringLocalUtil.isNotEmpty(traceId)) {
            MDC.put(TRACE_ID_KEY, traceId);
        }
    }

    public static String getTraceId() {
        String traceId = MDC.get(TRACE_ID_KEY);
        return traceId == null ? "" : traceId;
    }

    public static void removeTraceId() {
        MDC.remove(TRACE_ID_KEY);
    }

    public static void clearTraceId() {
        MDC.clear();
    }

}

public class TraceIdRequestLoggingFilter extends AbstractRequestLoggingFilter {

    @Override
    protected void beforeRequest(HttpServletRequest request, String message) {
        String requestId = request.getHeader(TraceIdContext.TRACE_ID_KEY);
        if (StringLocalUtil.isNotEmpty(requestId)) {
            TraceIdContext.setTraceId(requestId);
        } else {
            TraceIdContext.setTraceId(TraceIdUtils.getTraceId());
        }
    }

    @Override
    protected void afterRequest(HttpServletRequest request, String message) {
        TraceIdContext.removeTraceId();
    }
}

@Configuration
public class TraceIdConfig {

    @Bean
    public TraceIdRequestLoggingFilter traceIdRequestLoggingFilter() {
        return new TraceIdRequestLoggingFilter();
    }
}

@Configuration
public class FeignConfig implements RequestInterceptor {

    @Override
    public void apply(RequestTemplate requestTemplate) {
        requestTemplate.header(TraceIdContext.TRACE_ID_KEY, TraceIdContext.getTraceId());
    }

}

2021-04-13 10:58:31.092 cloud-sevice-consumer-demo [http-nio-7199-exec-1] INFO  [ef76526ca96242bc8e646cdef3ab31e6] c.b.demo.controller.CityController - getCity
2021-04-13 10:58:31.185 cloud-sevice-consumer-demo [http-nio-7199-exec-1] WARN  [ef76526ca96242bc8e646cdef3ab31e6] o.s.c.o.l.FeignBlockingLoadBalancerClient -

groovy复制代码dependencies {
    // Kotlin
    implementation "org.jetbrains.kotlin:kotlin-stdlib:1.4.32"

    // 协程核心库
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.4.3"
    // 协程Android支持库
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.4.3"
    // 协程Java8支持库
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-jdk8:1.4.3"
  
    // lifecycle对于协程的扩展封装
    implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:2.2.0"
    implementation "androidx.lifecycle:lifecycle-runtime-ktx:2.2.0"
    implementation "androidx.lifecycle:lifecycle-livedata-ktx:2.2.0"
}

kotlin复制代码import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import kotlinx.coroutines.*

class MainActivity : AppCompatActivity() {

    /**
     * 使用官方库的 MainScope()获取一个协程作用域用于创建协程
     */
    private val mScope = MainScope()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // 创建一个默认参数的协程，其默认的调度模式为Main 也就是说该协程的线程环境是Main线程
        val job1 = mScope.launch {
            // 这里就是协程体

            // 延迟1000毫秒  delay是一个挂起函数
            // 在这1000毫秒内该协程所处的线程不会阻塞
            // 协程将线程的执行权交出去，该线程该干嘛干嘛，到时间后会恢复至此继续向下执行
            delay(1000)
        }

        // 创建一个指定了调度模式的协程，该协程的运行线程为IO线程
        val job2 = mScope.launch(Dispatchers.IO) {

            // 此处是IO线程模式

            // 切线程 将协程所处的线程环境切至指定的调度模式Main
            withContext(Dispatchers.Main) {
                // 现在这里就是Main线程了  可以在此进行UI操作了
            }
        }

        // 下面直接看一个例子： 从网络中获取数据  并更新UI
        // 该例子不会阻塞主线程
        mScope.launch(Dispatchers.IO) {
            // 执行getUserInfo方法时会将线程切至IO去执行
            val userInfo = getUserInfo()
            // 获取完数据后 切至Main线程进行更新UI
            withContext(Dispatchers.Main) {
                // 更新UI
            }
        }
    }

    /**
     * 获取用户信息 该函数模拟IO获取数据
     * @return String
     */
    private suspend fun getUserInfo(): String {
        return withContext(Dispatchers.IO) {
            delay(2000)
            "Kotlin"
        }
    }

    override fun onDestroy() {
        super.onDestroy()
        // 取消协程 防止协程泄漏  如果使用lifecycleScope则不需要手动取消
        mScope.cancel()
    }
}

kotlin复制代码fun asyncTest() {
    mScope.launch {
        // 开启一个IO模式的线程 并返回一个Deferred，Deferred可以用来获取返回值
        // 代码执行到此处时会新开一个协程 然后去执行协程体  父协程的代码会接着往下走
        val deferred = async(Dispatchers.IO) {
            // 模拟耗时
            delay(2000)
            // 返回一个值
            "Quyunshuo"
        }
        // 等待async执行完成获取返回值 此处并不会阻塞线程  而是挂起 将线程的执行权交出去
        // 等到async的协程体执行完毕后  会恢复协程继续往下执行
        val date = deferred.await()
    }
}

kotlin复制代码fun asyncTest2() {
    mScope.launch {
        // 此处有一个需求  同时请求5个接口  并且将返回值拼接起来

        val job1 = async {
            // 请求1 
            delay(5000)
            "1"
        }
        val job2 = async {
            // 请求2 
            delay(5000)
            "2"
        }
        val job3 = async {
            // 请求3 
            delay(5000)
            "3"
        }
        val job4 = async {
            // 请求4 
            delay(5000)
            "4"
        }
        val job5 = async {
            // 请求5
            delay(5000)
            "5"
        }

        // 代码执行到此处时  5个请求已经同时在执行了
        // 等待各job执行完 将结果合并
        Log.d(
            "TAG",
            "asyncTest2: ${job1.await()} ${job2.await()} ${job3.await()} ${job4.await()} ${job5.await()}"
        )

        // 因为我们设置的模拟时间都是5000毫秒  所以当job1执行完时  其他job也均执行完成
    }
}

kotlin复制代码public fun CoroutineScope.launch(
    context: CoroutineContext = EmptyCoroutineContext,	// 协程上下文
    start: CoroutineStart = CoroutineStart.DEFAULT,			// 协程启动模式
    block: suspend CoroutineScope.() -> Unit						// 运行在协程的逻辑
): Job {
    val newContext = newCoroutineContext(context)
    val coroutine = if (start.isLazy)
        LazyStandaloneCoroutine(newContext, block) else
        StandaloneCoroutine(newContext, active = true)
    coroutine.start(start, coroutine, block)
    return coroutine
}

kotlin复制代码fun main() {
    val coroutineContext = Job() + Dispatchers.Default + CoroutineName("myContext")
    println("$coroutineContext,${coroutineContext[CoroutineName]}")
    val newCoroutineContext = coroutineContext.minusKey(CoroutineName)
    println("$newCoroutineContext")
}

scss复制代码[JobImpl{Active}@7eda2dbb, CoroutineName(myContext), Dispatchers.Default],CoroutineName(myContext)
[JobImpl{Active}@7eda2dbb, Dispatchers.Default]

kotlin复制代码public interface CoroutineContext {
    
    public operator fun <E : Element> get(key: Key<E>): E?

    public fun <R> fold(initial: R, operation: (R, Element) -> R): R

    public operator fun plus(context: CoroutineContext): CoroutineContext{...}

    public fun minusKey(key: Key<*>): CoroutineContext

    public interface Key<E : Element>

    public interface Element : CoroutineContext {...}
}

sql复制代码                                      wait children
+-----+ start  +--------+ complete   +-------------+  finish  +-----------+
| New | -----> | Active | ---------> | Completing  | -------> | Completed |
+-----+        +--------+            +-------------+          +-----------+
                 |  cancel / fail       |
                 |     +----------------+
                 |     |
                 V     V
             +------------+                           finish  +-----------+
             | Cancelling | --------------------------------> | Cancelled |
             +------------+                                   +-----------+

kotlin复制代码public interface Deferred<out T> : Job {

    public val onAwait: SelectClause1<T>

    public suspend fun await(): T

    @ExperimentalCoroutinesApi
    public fun getCompleted(): T

    @ExperimentalCoroutinesApi
    public fun getCompletionExceptionOrNull(): Throwable?
}

kotlin复制代码/**
 * Creates a _supervisor_ job object in an active state.
 * Children of a supervisor job can fail independently of each other.
 * 
 * A failure or cancellation of a child does not cause the supervisor job to fail and does not affect its other children,
 * so a supervisor can implement a custom policy for handling failures of its children:
 *
 * * A failure of a child job that was created using [launch][CoroutineScope.launch] can be handled via [CoroutineExceptionHandler] in the context.
 * * A failure of a child job that was created using [async][CoroutineScope.async] can be handled via [Deferred.await] on the resulting deferred value.
 *
 * If [parent] job is specified, then this supervisor job becomes a child job of its parent and is cancelled when its
 * parent fails or is cancelled. All this supervisor's children are cancelled in this case, too. The invocation of
 * [cancel][Job.cancel] with exception (other than [CancellationException]) on this supervisor job also cancels parent.
 *
 * @param parent an optional parent job.
 */
@Suppress("FunctionName")
public fun SupervisorJob(parent: Job? = null) : CompletableJob = SupervisorJobImpl(parent)

kotlin复制代码/**
 * Creates the main [CoroutineScope] for UI components.
 *
 * Example of use:
 *

kotlin复制代码public interface CoroutineScope {
    public val coroutineContext: CoroutineContext
}

kotlin复制代码public object GlobalScope : CoroutineScope {
    /**
     * Returns [EmptyCoroutineContext].
     */
    override val coroutineContext: CoroutineContext
        get() = EmptyCoroutineContext
}

kotlin复制代码/**
 * Runs a new coroutine and **blocks** the current thread _interruptibly_ until its completion.
 * This function should not be used from a coroutine. It is designed to bridge regular blocking code
 * to libraries that are written in suspending style, to be used in `main` functions and in tests.
 *
 * The default [CoroutineDispatcher] for this builder is an internal implementation of event loop that processes continuations
 * in this blocked thread until the completion of this coroutine.
 * See [CoroutineDispatcher] for the other implementations that are provided by `kotlinx.coroutines`.
 *
 * When [CoroutineDispatcher] is explicitly specified in the [context], then the new coroutine runs in the context of
 * the specified dispatcher while the current thread is blocked. If the specified dispatcher is an event loop of another `runBlocking`,
 * then this invocation uses the outer event loop.
 *
 * If this blocked thread is interrupted (see [Thread.interrupt]), then the coroutine job is cancelled and
 * this `runBlocking` invocation throws [InterruptedException].
 *
 * See [newCoroutineContext][CoroutineScope.newCoroutineContext] for a description of debugging facilities that are available
 * for a newly created coroutine.
 *
 * @param context the context of the coroutine. The default value is an event loop on the current thread.
 * @param block the coroutine code.
 */
@Throws(InterruptedException::class)
public fun <T> runBlocking(context: CoroutineContext = EmptyCoroutineContext, block: suspend CoroutineScope.() -> T): T {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    val currentThread = Thread.currentThread()
    val contextInterceptor = context[ContinuationInterceptor]
    val eventLoop: EventLoop?
    val newContext: CoroutineContext
    if (contextInterceptor == null) {
        // create or use private event loop if no dispatcher is specified
        eventLoop = ThreadLocalEventLoop.eventLoop
        newContext = GlobalScope.newCoroutineContext(context + eventLoop)
    } else {
        // See if context's interceptor is an event loop that we shall use (to support TestContext)
        // or take an existing thread-local event loop if present to avoid blocking it (but don't create one)
        eventLoop = (contextInterceptor as? EventLoop)?.takeIf { it.shouldBeProcessedFromContext() }
            ?: ThreadLocalEventLoop.currentOrNull()
        newContext = GlobalScope.newCoroutineContext(context)
    }
    val coroutine = BlockingCoroutine<T>(newContext, currentThread, eventLoop)
    coroutine.start(CoroutineStart.DEFAULT, coroutine, block)
    return coroutine.joinBlocking()
}

kotlin复制代码/**
 * Creates the main [CoroutineScope] for UI components.
 *
 * Example of use:
 *

kotlin复制代码/**
 * [CoroutineScope] tied to this [LifecycleOwner]'s [Lifecycle].
 *
 * This scope will be cancelled when the [Lifecycle] is destroyed.
 *
 * This scope is bound to
 * [Dispatchers.Main.immediate][kotlinx.coroutines.MainCoroutineDispatcher.immediate].
 */
val LifecycleOwner.lifecycleScope: LifecycleCoroutineScope
    get() = lifecycle.coroutineScope

kotlin复制代码/**
 * [CoroutineScope] tied to this [ViewModel].
 * This scope will be canceled when ViewModel will be cleared, i.e [ViewModel.onCleared] is called
 *
 * This scope is bound to
 * [Dispatchers.Main.immediate][kotlinx.coroutines.MainCoroutineDispatcher.immediate]
 */
val ViewModel.viewModelScope: CoroutineScope
        get() {
            val scope: CoroutineScope? = this.getTag(JOB_KEY)
            if (scope != null) {
                return scope
            }
            return setTagIfAbsent(JOB_KEY,
                CloseableCoroutineScope(SupervisorJob() + Dispatchers.Main.immediate))
        }

kotlin复制代码/**
 * Creates a [CoroutineScope] with [SupervisorJob] and calls the specified suspend block with this scope.
 * The provided scope inherits its [coroutineContext][CoroutineScope.coroutineContext] from the outer scope, but overrides
 * context's [Job] with [SupervisorJob].
 *
 * A failure of a child does not cause this scope to fail and does not affect its other children,
 * so a custom policy for handling failures of its children can be implemented. See [SupervisorJob] for details.
 * A failure of the scope itself (exception thrown in the [block] or cancellation) fails the scope with all its children,
 * but does not cancel parent job.
 */
public suspend fun <R> supervisorScope(block: suspend CoroutineScope.() -> R): R {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    return suspendCoroutineUninterceptedOrReturn { uCont ->
        val coroutine = SupervisorCoroutine(uCont.context, uCont)
        coroutine.startUndispatchedOrReturn(coroutine, block)
    }
}



/**
 * Creates a [CoroutineScope] and calls the specified suspend block with this scope.
 * The provided scope inherits its [coroutineContext][CoroutineScope.coroutineContext] from the outer scope, but overrides
 * the context's [Job].
 *
 * This function is designed for _parallel decomposition_ of work. When any child coroutine in this scope fails,
 * this scope fails and all the rest of the children are cancelled (for a different behavior see [supervisorScope]).
 * This function returns as soon as the given block and all its children coroutines are completed.
 * A usage example of a scope looks like this:
 *
 *

kotlin复制代码import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.util.Log
import kotlinx.coroutines.*

class MainActivity : AppCompatActivity() {

    /**
     * 使用官方库的 MainScope()获取一个协程作用域用于创建协程
     */
    private val mScope = MainScope()

    companion object {
        const val TAG = "Kotlin Coroutine"
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        mScope.launch(Dispatchers.Default) {
            delay(500)
            Log.e(TAG, "Child 1")
        }

        mScope.launch(Dispatchers.Default) {
            delay(1000)
            Log.e(TAG, "Child 2")
            throw RuntimeException("--> RuntimeException <--")
        }

        mScope.launch(Dispatchers.Default) {
            delay(1500)
            Log.e(TAG, "Child 3")
        }
    }
}


打印结果：
E/Kotlin Coroutine: Child 1
E/Kotlin Coroutine: Child 2
E/AndroidRuntime: FATAL EXCEPTION: DefaultDispatcher-worker-3
    Process: com.quyunshuo.kotlincoroutine, PID: 24240
    java.lang.RuntimeException: --> RuntimeException <--
        at com.quyunshuo.kotlincoroutine.MainActivity$onCreate$2.invokeSuspend(MainActivity.kt:31)
        at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith(ContinuationImpl.kt:33)
        at kotlinx.coroutines.DispatchedTask.run(DispatchedTask.kt:106)
        at kotlinx.coroutines.scheduling.CoroutineScheduler.runSafely(CoroutineScheduler.kt:571)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.executeTask(CoroutineScheduler.kt:750)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.runWorker(CoroutineScheduler.kt:678)
        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.run(CoroutineScheduler.kt:665)
E/Kotlin Coroutine: Child 3

kotlin复制代码override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)

    mScope.launch(Dispatchers.Default) {
        delay(500)
        Log.e(TAG, "Child 1")
    }

  	// 在Child 2的上下文添加了异常处理
    mScope.launch(Dispatchers.Default + CoroutineExceptionHandler { coroutineContext, throwable ->
        Log.e(TAG, "CoroutineExceptionHandler: $throwable")
    }) {
        delay(1000)
        Log.e(TAG, "Child 2")
        throw RuntimeException("--> RuntimeException <--")
    }

    mScope.launch(Dispatchers.Default) {
        delay(1500)
        Log.e(TAG, "Child 3")
    }
}


输出结果：
E/Kotlin Coroutine: Child 1
E/Kotlin Coroutine: Child 2
E/Kotlin Coroutine: CoroutineExceptionHandler: java.lang.RuntimeException: --> RuntimeException <--
E/Kotlin Coroutine: Child 3

kotlin复制代码import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.util.Log
import kotlinx.coroutines.*

class MainActivity : AppCompatActivity() {

    companion object {
        const val TAG = "Kotlin Coroutine"
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        val scope = CoroutineScope(Job() + Dispatchers.Default)

        scope.launch(CoroutineExceptionHandler { coroutineContext, throwable ->
            Log.e(TAG, "CoroutineExceptionHandler: $throwable")
        }) {
            supervisorScope {
                launch {
                    delay(500)
                    Log.e(TAG, "Child 1 ")
                }
                launch {
                    delay(1000)
                    Log.e(TAG, "Child 2 ")
                    throw  RuntimeException("--> RuntimeException <--")
                }
                launch {
                    delay(1500)
                    Log.e(TAG, "Child 3 ")
                }
            }
        }
    }
}

输出结果：
E/Kotlin Coroutine: Child 1 
E/Kotlin Coroutine: Child 2 
E/Kotlin Coroutine: CoroutineExceptionHandler: java.lang.RuntimeException: --> RuntimeException <--
E/Kotlin Coroutine: Child 3

markdown复制代码[main]: aaa

[pool-1-thread-1]: aaa
[pool-1-thread-1]: bbb

[pool-1-thread-2]: aaa
[pool-1-thread-1]: bbb
[pool-1-thread-4]: aaa
[pool-1-thread-1]: bbb
[pool-1-thread-2]: aaa
[pool-1-thread-3]: aaa
[pool-1-thread-2]: aaa
[pool-1-thread-1]: bbb
[pool-1-thread-4]: aaa
[pool-1-thread-3]: aaa

[main]: aaa

markdown复制代码[main]: aaa

[pool-1-thread-1]:aaa
[pool-1-thread-1]:bbb

[pool-1-thread-2]:aaa
[pool-1-thread-1]:aaa
[pool-1-thread-3]:aaa
[pool-1-thread-4]:aaa
[pool-1-thread-3]:aaa
[pool-1-thread-1]:aaa
[pool-1-thread-3]:aaa
[pool-1-thread-2]:aaa
[pool-1-thread-1]:aaa
[pool-1-thread-4]:aaa

[main]: aaa

bash复制代码监控和日志也要做好啊喂(#`O′)

复制代码是不是想到了tcpdump，所以对于比较复杂的流量，更推荐使用tcpcopy来进行流量复制

bash复制代码# 1. 简单的 HTTP 流量复制：
gor –input-raw :80 –output-http “http://example.com”

# 2.HTTP 流量复制频率控制：
gor –input-tcp :28020 –output-http “http://example.com|10″

# 3.HTTP 流量复制缩小：
gor –input-raw :80 –output-tcp “replay.local:28020|10%”

# 4.HTTP 流量记录到本地文件：
gor –input-raw :80 –output-file requests.gor

# 5.HTTP 流量回放和压测：
gor –input-file “requests.gor|200%” –output-http “example.com”

# 6.HTTP 流量过滤复制：
gor –input-raw :8080 –output-http example.com –output-http-url-regexp ^www.

# 7.HTTP指定接口流量复制：
gor --input-raw :80 --http-allow-url '/api/v1' --output-stdout   # --output-stdout表示直接在控制台输出

bash复制代码./gor --input-raw :7018 \ # 设置监听端口
    --input-raw-track-response \ # 同时保存response
    --output-file logs/requests-%Y%m%d.gor \ # 按天输出文件
    --output-file-append # 默认会分割文件，我们需要合并在一个文件中

go复制代码// 通过回调函数，在外面解析具体的请求
func load(filename string, iter func(i int, req *http.Request, resp *http.Response) error) error {
	file, err := os.Open(filename)
	if err != nil {
		log.Printf("Cannot open text file: %s, err: [%v]", filename, err)
		return err
	}
	defer file.Close()
        
        // 设置一个读取的buffer，这里自定义了一个bufio.SplitFunc
	buf := make([]byte, 0, 1024*1024)
	scanner := bufio.NewScanner(file)
	scanner.Buffer(buf, 10*1024*1024)
        
        // 你没有看错，是通过emoji分割的
	scanner.Split(splitByWords([]byte("🐵🙈🙉")))
	var req *http.Request
	var resp *http.Response
	var i = 1
	for scanner.Scan() {
		text := scanner.Bytes()
		n := bytes.IndexByte(text, '\n')
                
                // 根据第一个字符判断是request还是response
                // 这里直接使用了原生方法读取了request
		if text[0] == '1' {
			req, _ = http.ReadRequest(bufio.NewReader(bytes.NewReader(text[n+1:])))
		} else if text[0] == '2' {
			resp, _ = http.ReadResponse(bufio.NewReader(bytes.NewReader(text[n+1:])), req)
		}
		if i%2 == 0 {
			if iter(i/2, req, resp) != nil {
				return err
			}
		}
		i += 1
	}

	if err := scanner.Err(); err != nil {
		log.Printf("Cannot scanner text file: %s, err: [%v]", filename, err)
		return err
	}

	return nil
}

go复制代码// copy from bufio.ScanWords
func isSpace(r rune) bool {
	if r <= '\u00FF' {
		// Obvious ASCII ones: \t through \r plus space. Plus two Latin-1 oddballs.
		switch r {
		case ' ', '\t', '\n', '\v', '\f', '\r':
			return true
		case '\u0085', '\u00A0':
			return true
		}
		return false
	}
	// High-valued ones.
	if '\u2000' <= r && r <= '\u200a' {
		return true
	}
	switch r {
	case '\u1680', '\u2028', '\u2029', '\u202f', '\u205f', '\u3000':
		return true
	}
	return false
}

func splitByWords(words []byte) bufio.SplitFunc {
	return func(data []byte, atEOF bool) (advance int, token []byte, err error) {
		start := 0
		for width := 0; start < len(data); start += width {
			var r rune
			r, width = utf8.DecodeRune(data[start:])
			if !isSpace(r) {
				break
			}
		}
		for width, i := 0, start; i < len(data); i += width {
			_, width = utf8.DecodeRune(data[i:])
			if bytes.HasSuffix(data[start:i], words) {
				return i + width, data[start : i-len(words)], nil
			}
		}
		// If we're at EOF, we have a final, non-empty, non-terminated word. Return it.
		if atEOF && len(data) > start {
			return len(data), data[start:], nil
		}
		return start, nil, nil
	}
}