看这个报错信息是因为 test1 这个接口没有实现 error 这个接口

增加一下实现代码就行了

func (t *test1) Error() string{
    // 自定义错误信息
    return fmt.Sprintf("code %d: %s", t.Code, t.Message)
}

在写一个Golang项目，一个方法中有一个返回值，如下：

func jwtErrorHandler(err error) error {
    return &echo.HTTPError{
        Code:     http.StatusUnauthorized,
        Message:  "invalid or expired jwt1",
        Internal: err,
    }
}

其中 &echo.HTTPError 点进去之后，是echo中的一个结构体：

// HTTPError represents an error that occurred while handling a request.
    HTTPError struct {
        Code     int
        Message  interface{}
        Internal error // Stores the error returned by an external dependency
    }

我现在不想使用echo中的结构体，想用我自己的结构体，但是替换之后却报错，我自己的结构体如下：

type test1 struct {
    Code     int
    Message  interface{}
    Internal error // Stores the error returned by an external dependency
}

替换后如下：

func jwtErrorHandler(err error) error {
    return &test1{
        Code:     http.StatusUnauthorized,
        Message:  "invalid or expired jwt1",
        Internal: err,
    }
}

出现如下报错：

cannot use &test1 literal (type *test1) as type error in return argument:
    *test1 does not implement error (missing Error method)

希望大佬帮忙解答，小弟不胜感激！

感谢@管大侠的回答，我自己的结构体确实没实现Error()方法，但是实现之后目前又出现了一个问题，如下：

在我使用echo.HTTPError这个结构体的时候，是可以正常返回的

func jwtErrorHandler(err error) error {
    return &echo.HTTPError{
        Code:     http.StatusUnauthorized,
        Message:  "invalid or expired jwt1",
        Internal: err,
    }
}

echo日志输出如下：

但是使用自己的结构体之后，无法正常返回了，如下图所示：

func jwtErrorHandler(err error) error {
    return &test1{
        Code:     http.StatusUnauthorized,
        Message:  "invalid or expired jwt2",
        Internal: err,
    }
}

PostMan输出如下

echo日志输出如下：

可以看到日志中的错误信息确实为结构体中定义的invalid or expired jwt2,但是直接在内部被拦截了，并没有正确返回给客户端，本人初学Echo，不太清楚这个是自己结构体写法问题，还是Echo内部的机制，这个可能是有哪些问题导致的呢？

\#\#\# 问题描述

一个方法的回调中，有一个stream流，我想把这个流赋值到全局对象，但是赋值后无法使用了，只能在当前作用域里使用

\#\#\# 相关代码

initSSH() {
      const { Client } = window.require("ssh2");
      const conn = new Client();
      conn.on("ready", () => {
          console.log("Client :: ready");
          conn.shell((err, stream) => {
            if (err){
              this.term.write(err)
              conn.end()
            }
            console.log("stream",stream)
            // 这里把stream赋值给this.sshClientStream后 无法使用
            this.sshClientStream = stream;
            stream
              .on("close", () => {
                console.log("Stream :: close");
                conn.end();
              })
              .on("data", (data) => {
                // console.log("OUTPUT: " + data);
                this.term.write(data);
                this.term.scrollToBottom();
              });
            this.bindTermOnKey()
          });
        })
        
      conn.connect({
          host: "127.0.0.1",
          port: 12,
          username: "root",
          password: "root",
      });
    },

    bindTermOnKey(){
      console.log("sshClientStream",this.sshClientStream)
      this.term.onKey((e) => {
        console.log(e);
        console.log(e.key);
        this.sshClientStream.cork();
        this.sshClientStream.write(e.key);
        this.sshClientStream.uncork();
      });
    },

\#\#\# 你期待的结果是什么？实际看到的错误信息又是什么？
在其他方法中使用this.sshClientStream.write(xxx)直接报错

打印了赋值前后对stream进行对比，发现赋值前是Channel，赋之后this.sshClientStream变成了Proxy

调用write错误信息如下

internal/crypto/cipher.js:157 Uncaught TypeError: Illegal invocation
    at Proxy.update (internal/crypto/cipher.js:157)
    at send_ (/Users/shishuaibiao/Documents/文稿 - 时帅彪的MacBook Pro/ElectronProjects/okshell/okshell/node_modules/_ssh2-streams@0.4.10@ssh2-streams/lib/ssh.js:5047)
    at send (/Users/shishuaibiao/Documents/文稿 - 时帅彪的MacBook Pro/ElectronProjects/okshell/okshell/node_modules/_ssh2-streams@0.4.10@ssh2-streams/lib/ssh.js:4961)
    at Proxy.SSH2Stream.channelData (/Users/shishuaibiao/Documents/文稿 - 时帅彪的MacBook Pro/ElectronProjects/okshell/okshell/node_modules/_ssh2-streams@0.4.10@ssh2-streams/lib/ssh.js:969)
    at Proxy.Channel._write (/Users/shishuaibiao/Documents/文稿 - 时帅彪的MacBook Pro/ElectronProjects/okshell/okshell/node_modules/_ssh2@0.8.9@ssh2/lib/Channel.js:347)
    at doWrite (_stream_writable.js:435)
    at clearBuffer (_stream_writable.js:574)
    at Proxy.Writable.uncork (_stream_writable.js:329)
    at eval (HelloWorld.vue?fdab:108)
    at e.fire (xterm.js?7243:1)

TCP建立连接需要经历三次握手，断开连接需要四次挥手，为什么我抓包，断开连接时只挥了三次手呢？

点击建立连接之后，经历了三次握手，这个没问题

现在点击断开连接，如下图，只发了三个包，正常情况下不应该是4个包吗？

logs/error.log:1070958:2020/05/07 09:31:17 [warn] 29552#0: conflicting server name "suichen.xiaomy.net" on 0.0.0.0:443, ignored

但是我查了所有配置文件,确实没有重复的

跪求大佬解决

大佬们好，想写个sh脚本，对Centos10000:50000之间的端口限速128kb/s，但是查了一翻资料上手捯饬了半天还是不行，求助大佬们帮忙！

用Qt写了一个Tunnel类，每次new这个类，构造函数都会socket连接到服务器，并与服务器保持通讯。

但是现在有个问题：每次new这个类，之前new的类里面的socket就会断开，我new了第一个，是正常的，new第二个，第一个类里面的socket就会断开，以此类推，ne十个，只有最后一个连接会是正常的，求大神帮忙看下，代码如下：

我是这样new的：

for(int i=0;i<=10;i++){
    Tunnel *t=new Tunnel();
    t->init(ExternData::userid,itemData.tunnelid,ExternData::token,itemData.server_ip,itemData.local_port,itemData.client_local);
    t->startTunnel();
}

tunnel.h

#ifndef TUNNEL_H
#define TUNNEL_H

#include <QByteArray>
#include <QTcpSocket>
#include <QJsonDocument>
#include <QJsonParseError>
#include <QFile>
#include <QJsonObject>
#include <QDebug>
#include <QJsonArray>
#include <QDebug>
#include <baseutility.h>
#include <packet.h>
#include <readwritetunnel.h>
#include <QMouseEvent>
#include <QObject>

class Tunnel : public QObject
{
    Q_OBJECT
public:
    Tunnel();
    void init(int userid1,int id1,QString token1,QString server_ip1,int local_port1,QString local_ip1);

    QByteArray qba;

    bool startTunnel();


private slots:

    void ClientRecvData();

private:
    QTcpSocket* socket;//创建socket对象

};





#endif // TUNNEL_H

tunnel.cpp

#include "tunnel.h"



int userid;
int id;
QString token;
QString server_ip;
int local_port;
QString local_ip;

Packet *p2;



Tunnel::Tunnel(){

}

void::Tunnel::init(int userid1,int id1,QString token1,QString server_ip1,int local_port1,QString local_ip1)
{
    userid=userid1;
    id=id1;
    token=token1;
    server_ip=server_ip1;
    local_port=local_port1;
    local_ip=local_ip1;

    p2=new Packet();
    socket=new QTcpSocket(this);
}


bool Tunnel::startTunnel()
{
    socket=new QTcpSocket();
    //QString ip="127.0.0.1";
    int port=8888;

    socket->connectToHost(server_ip,port);

    if(!socket->waitForConnected(3000)){
        //QMessageBox::information(this,"QT网络通信","连接服务器失败");
        return false;
    }
    //QMessageBox::information(this, "QT网络通信", "连接成功");

    QJsonObject json;
    json.insert("userid", userid);
    json.insert("token",token);
    json.insert("id", id);
    json.insert("type", "LOGIN");


    connect(socket,SIGNAL(readyRead()),this,SLOT(ClientRecvData()));


    Packet *p1=new Packet(json,QString("login").toLatin1());
    p1->Send1(socket);

    return true;
}


void Tunnel::ClientRecvData(){

    //这个是我自己写的packet类，用来解析服务器传过来的数据的
    QByteArray data =p2->unPacket(socket,server_ip,local_port,local_ip);

    if(data.isNull()){
        return;
    }

}

主要是隔离读和写，让读不影响写，这样尽最大努力防止在线业务受影响。另一方面，面对读多写少的场景，水平扩展读性能。