import io.netty.handler.traffic.TrafficCounter; //导入依赖的package包/类
@GET
@Path("/stats")
@Produces(ContentType.APPLICATION_JSON)
public Response stats(Request httpRequest) {

    if (trafficShapingHandler != null) {
        TrafficCounter trafficCounter = trafficShapingHandler.trafficCounter();

        return Response.ok().content(gson.toJson(new ApexStatsResponse(ApexResponse.Status.OK,
                "OK",
                Apex.getChannelGroup().size(),
                connectionsPerSecondTask.getPerSecond(),
                Apex.getBalancingStrategy().getBackend().size(),
                trafficCounter.currentReadBytes(),
                trafficCounter.currentWrittenBytes(),
                trafficCounter.lastReadThroughput(),
                trafficCounter.lastWriteThroughput(),
                trafficCounter.cumulativeReadBytes(),
                trafficCounter.cumulativeWrittenBytes()))).build();
    } else {
        return STATS_DISABLED;
    }
}
 

import io.netty.handler.traffic.TrafficCounter; //导入依赖的package包/类
@Override
public boolean execute(String[] args) {

    logger.info("Connections: {}", Apex.getChannelGroup().size());
    if (Apex.getInstance().getConnectionsPerSecondTask() != null) {
        logger.info("Connections per second: {}", Apex.getInstance().getConnectionsPerSecondTask().getPerSecond());
    }
    logger.info("Online backend servers: {}", Apex.getBalancingStrategy().size());

    GlobalTrafficShapingHandler trafficShapingHandler = Apex.getInstance().getTrafficShapingHandler();
    if (trafficShapingHandler != null) {
        TrafficCounter trafficCounter = trafficShapingHandler.trafficCounter();

        logger.info("Current bytes read: {}", trafficCounter.currentReadBytes());
        logger.info("Current bytes written: {}", trafficCounter.currentWrittenBytes());
        logger.info("Last read throughput: {}", trafficCounter.lastReadThroughput());
        logger.info("Last write throughput: {}", trafficCounter.lastWrittenBytes());
        logger.info("Total bytes read: {}", trafficCounter.cumulativeReadBytes());
        logger.info("Total bytes written: {}", trafficCounter.cumulativeWrittenBytes());
    }

    return true;
}
 

import io.netty.handler.traffic.TrafficCounter; //导入依赖的package包/类
public String[] getTraffic(String uri, Map<String, String> params) {
    TrafficCounter counter = Status.TRAFFIC_HANDLER.trafficCounter();
    return new String[]{"text", "{\"readSum\":" + counter.cumulativeReadBytes() +
            ",\"read\":" + counter.currentReadBytes() +
            ",\"writeSum\":" + counter.cumulativeWrittenBytes() +
            ",\"write\":" + counter.currentWrittenBytes() + "}"};
}
 

import io.netty.handler.traffic.TrafficCounter; //导入依赖的package包/类
@Override
protected void doAccounting(TrafficCounter counter) {
    long currentTime = System.currentTimeMillis();
    long interval = currentTime - lastChacked.getAndSet(currentTime);
    if (interval == 0) {
        return;
    }
    this.lastReads = currentReads.getAndSet(0L);
    this.lastWrites = currentWrites.getAndSet(0L);

    long readsPerSec = (lastReads / interval) * 1000;
    long writesPerSec = (lastWrites / interval) * 1000;
    metrics.setLastReads(readsPerSec);
    metrics.setLastWrites(writesPerSec);

    TrafficCounter traffic = trafficCounter();
    long readThroughput = traffic.lastReadThroughput();
    long writeThroughput = traffic.lastWriteThroughput();
    metrics.setReadThroughput(readThroughput);
    metrics.setWriteThroughput(writeThroughput);

    if (logger.isInfoEnabled()) {
        if (lastReads > 0 || lastWrites > 0) {
            logger.info(toString());
        }
    }
}
 

import io.netty.handler.traffic.TrafficCounter; //导入依赖的package包/类
@Override
public String toString() {
    TrafficCounter traffic = trafficCounter();
    final StringBuilder buf = new StringBuilder(512);
    long readThroughput = traffic.lastReadThroughput();
    buf.append("Read Throughput: ").append(readThroughput / 1024L).append(" KB/sec, ");
    buf.append(lastReads).append(" msg/sec\n");
    long writeThroughput = traffic.lastWriteThroughput();
    buf.append("Write Throughput: ").append(writeThroughput / 1024).append(" KB/sec, ");
    buf.append(lastWrites).append(" msg/sec");
    return buf.toString();
}
 

import io.netty.handler.traffic.TrafficCounter; //导入依赖的package包/类
@Override
protected void doAccounting(TrafficCounter counter) {
    long read = counter.lastReadBytes();
    long write = counter.lastWrittenBytes();
    for(BandwidthHandler handler : bandwidthHandlers.values()) {
        handler.update(read, write);
    }
}
 

import io.netty.handler.traffic.TrafficCounter; //导入依赖的package包/类
private void init(Channel channel, HandshakeRequest request, HandlerRegistration handlerReg) {
    NettyServerHandlerConfig<Object> cfg = handlerReg.config();

    if (cfg.getLoggerCategory() != null) {
        log = LoggerFactory.getLogger(cfg.getLoggerCategory());

        debug = log.isDebugEnabled();
        trace = log.isTraceEnabled();
    }

    if (debug) {
        log.debug("Initialized connection [from={}, protocol={}]", address(), cfg.getProtocol());
    }

    this.eventLoop = channel.eventLoop();
    this.serverHandler = cfg.getHandler();
    this.handlerReg = handlerReg;
    this.metrics = handlerReg.metrics();
    this.codec = request.codec();

    // Register this client.
    handlerReg.add(this);

    if (metrics != null) {
        channel.pipeline().addFirst(new ChannelTrafficShapingHandler(0, 0, NettyClient.TRAFFIC_SHAPING_INTERVAL) {
            @Override
            protected void doAccounting(TrafficCounter counter) {
                metrics.onBytesReceived(counter.lastReadBytes());
                metrics.onBytesSent(counter.lastWrittenBytes());
            }
        });

        metrics.onConnect();
    }

    // Accept handshake.
    HandshakeAccept accepted = new HandshakeAccept(hbInterval, hbLossThreshold, hbDisabled);

    channel.writeAndFlush(accepted).addListener(future -> {
            if (channel.isOpen()) {
                connectNotified = true;

                // Notify on connect.
                serverHandler.onConnect(request.payload(), this);
            }
        }
    );
}
 

import io.netty.handler.traffic.TrafficCounter; //导入依赖的package包/类
public TrafficCounter getTrafficCounter() {
	return trafficHandler.trafficCounter();
}