import io.prometheus.client.Counter;
import io.prometheus.client.Gauge;
import io.prometheus.client.exporter.HTTPServer;

public class MonitoringService {

    // 定义计数器，用于监控请求总数
    private static final Counter requestTotal = Counter.build()
            .name("service_requests_total")
            .labelNames("method")
            .help("Total requests served.")
            .register();

    // 定义计数器，用于监控错误数
    private static final Counter errorTotal = Counter.build()
            .name("service_errors_total")
            .labelNames("cause")
            .help("Total errors.")
            .register();

    // 定义度量，用于监控当前活跃的连接数
    private static final Gauge activeConnections = Gauge.build()
            .name("service_active_connections")
            .help("Active connections.")
            .register();

    public static void main(String[] args) {
        HTTPServer server = new HTTPServer(8080); // 开启一个HTTP服务器监听8080端口

        // 示例代码：模拟业务逻辑
        while (true) {
            // 处理请求
            processRequest();
            // 模拟错误发生
            simulateError();
            // 模拟连接变化
            simulateConnectionChange();

            // 为了简洁，这里不包含具体的业务逻辑实现
            // ...
        }
    }

    private static void processRequest() {
        // 请求方法随机，这里仅为示例
        String method = "GET"; // 实际应用中应该是动态的
        requestTotal.labels(method).inc(); // 增加请求计数
    }

    private static void simulateError() {
        // 错误原因随机，这里仅为示例
        String cause = "timeout"; // 实际应用中应该是动态的
        errorTotal.labels(cause).inc(); // 增加错误计数
    }

    private static void simulateConnectionChange() {
        // 模拟连接数增加或减少
        activeConnections.inc(); // 假设有新的连接
        // ...
        // 实际应用中应该跟踪连接的开启和关闭
    }
}

package main

import (
    "fmt"
    "github.com/gin-gonic/gin"
)

func main() {
    r := gin.Default()

    r.Use(func(c *gin.Context) {
        fmt.Println("开始中间件1")
        c.Next() // 调用下一个中间件或路由处理函数
        fmt.Println("结束中间件1")
    })

    r.Use(func(c *gin.Context) {
        fmt.Println("开始中间件2")
        c.Abort() // 终止后续中间件和路由处理函数
        fmt.Println("终止中间件2")
    })

    r.GET("/", func(c *gin.Context) {
        fmt.Println("路由处理函数")
    })

    r.Run()
}

import org.apache.shardingsphere.infra.config.properties.ConfigurationProperties;
import org.apache.shardingsphere.infra.context.metadata.MetaDataContexts;
import org.apache.shardingsphere.infra.context.runtime.RuntimeContext;
import org.apache.shardingsphere.infra.database.DefaultSchema;
import org.apache.shardingsphere.infra.executor.kernel.ExecutorEngine;
import org.apache.shardingsphere.infra.metadata.ShardingSphereMetaData;
import org.apache.shardingsphere.infra.optimize.context.OptimizerContext;
import org.apache.shardingsphere.infra.rule.ShardingSphereRule;
import org.apache.shardingsphere.mode.manager.ContextManager;
import org.apache.shardingsphere.mode.metadata.MetaDataContextsBuilder;
import org.apache.shardingsphere.transaction.context.TransactionContexts;
import org.junit.Test;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

public class ShardingSphereReadWriteSplittingTest {

    @Test
    public void assertReadWriteSplitting() throws SQLException {
        // 创建ShardingSphereRule列表，这里可以添加读写分离规则等
        ShardingSphereRule rule = mock(ShardingSphereRule.class);
        // 创建ShardingSphereMetaData
        ShardingSphereMetaData metaData = mock(ShardingSphereMetaData.class);
        // 创建事务上下文
        TransactionContexts transactionContexts = mock(TransactionContexts.class);
        // 创建执行引擎
        ExecutorEngine executorEngine = mock(ExecutorEngine.class);
        // 创建配置属性
        ConfigurationProperties properties = new ConfigurationProperties(new HashMap<>());
        // 构建MetaDataContexts
        MetaDataContexts metaDataContexts = new MetaDataContextsBuilder(
                Collections.singletonMap("ds_0", mock(DataSource.class)),
                Collections.singletonMap("ds_0", metaData),
                new ShardingSphereRuleMetaData(Collections.singleton(rule)),
                properties).build();
        // 创建上下文管理器
        ContextManager contextManager = new ContextManager(
                null,
                false,
                new MemorySchemaMetaDataLoader(metaDataContexts),
                metaDataContexts,
                transactionContexts,
                executorEngine,

import redis

# 连接到Redis服务器
redis_host = 'localhost'
redis_port = 6379
r = redis.StrictRedis(host=redis_host, port=redis_port, decode_responses=True)

# 获取INFO命令的输出
info = r.info()

# 打印部分关键指标
print(f"Connected Clients: {info['connected_clients']}")
print(f"Uptime (seconds): {info['uptime']}")
print(f"Used Memory (bytes): {info['used_memory_human']}")
print(f"Memory Fragmentation Ratio: {info['mem_fragmentation_ratio']}")
print(f"Blocked Clients: {info['blocked_clients']}")
print(f"Expired Keys: {info['expired_keys']}")
print(f"Evicted Keys: {info['evicted_keys']}")

// action-types.js
export const INCREMENT = 'INCREMENT';

// action-creators.js
export const increment = () => ({ type: INCREMENT });

// thunk.js
export const incrementAfterDelay = (delay = 1000) => (dispatch) => {
  setTimeout(() => {
    dispatch(increment());
  }, delay);
};

// reducer.js
const initialState = 0;
export default (state = initialState, action) => {
  switch (action.type) {
    case INCREMENT:
      return state + 1;
    default:
      return state;
  }
};

// store.js
import { createStore, applyMiddleware } from 'redux';
import thunk from 'redux-thunk';
import reducer from './reducer';

const store = createStore(reducer, applyMiddleware(thunk));

// 使用thunk
store.dispatch(incrementAfterDelay(2000)); // 2秒后state增加1

const express = require('express');
const { createProxyMiddleware } = require('http-proxy-middleware');

const app = express();

// 创建代理服务器配置
const proxy = createProxyMiddleware('/api', {
    target: 'http://backend:3000', // 目标服务器地址
    changeOrigin: true, // 改变源地址，使目标服务器看到请求来自于代理服务器而不是直接来自客户端
    pathRewrite: {
        '^/api': '', // 重写请求路径
    },
    // 可以添加更多配置选项，如 onProxyReq, onProxyRes, secure, cookieDomainRewrite 等
});

// 使用代理服务器中间件
app.use(proxy);

// 其他中间件或路由配置...

app.listen(3000, () => {
    console.log('Proxy server is running on port 3000');
});

const Koa = require('koa');
const compress = require('koa-compress');
const serve = require('koa-static');
const path = require('path');

const app = new Koa();

// 使用 `koa-compress` 中间件来压缩响应体
app.use(compress({
    filter: function(content_type) {
        return /text/i.test(content_type); // 压缩 text 类型的响应
    },
    threshold: 2048, // 响应体大于 2kb 时压缩
    flush: require('zlib').Z_SYNC_FLUSH
}));

// 使用 `koa-static` 中间件来提供静态文件服务
app.use(serve(path.join(__dirname, 'public')));

app.listen(3000);
console.log('Server listening on port 3000');

import scrapy
from scrapy.http import HtmlResponse
from selenium import webdriver
from selenium.webdriver.chrome.options import Options
from scrapy_selenium import SeleniumMiddleware

class MySpider(scrapy.Spider):
    name = 'myspider'
    start_urls = ['http://example.com']

    def start_requests(self):
        # 使用selenium来生成起始请求
        for url in self.start_urls:
            yield SeleniumRequest(url=url, callback=self.parse)

    def parse(self, response):
        # 解析响应内容
        pass

class SeleniumMiddlewareCustom(SeleniumMiddleware):
    def __init__(self, driver_name='chrome', driver_executable_path=None, port=0,
                 chrome_options=None, service_args=None, proxy=None,
                 download_timeout=None, wait_until=None,
                 browser_profile=None):
        super().__init__(driver_name, driver_executable_path, port,
                 chrome_options, service_args, proxy,
                 download_timeout, wait_until,
                 browser_profile)
        self.driver = webdriver.Chrome(options=chrome_options, service_args=service_args)

    @classmethod
    def from_crawler(cls, crawler):
        # 从爬虫设置中获取选项和服务参数
        settings = crawler.settings
        chrome_options = Options()
        service_args = ['--verbose', '--log-path=/tmp/geckodriver.log']
        # 其他设置...
        return cls(chrome_options=chrome_options, service_args=service_args)

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;
import java.util.List;

@Configuration
@ConfigurationProperties(prefix = "white-list")
public class WhiteListConfig {

    private List<String> ips;

    public List<String> getIps() {
        return ips;
    }

    public void setIps(List<String> ips) {
        this.ips = ips;
    }
}

white-list.ips=192.168.1.1,192.168.1.2,192.168.1.3

white-list:
  ips:
    - 192.168.1.1
    - 192.168.1.2
    - 192.168.1.3

package main

import (
    "fmt"
    "github.com/gin-gonic/gin"
    "net/http"
)

// JWT认证中间件
func JWTAuthMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        // 实现JWT认证逻辑
        // 例如，检查请求头中的Authorization字段
        // 如果认证失败，返回错误信息
        // 如果认证成功，调用c.Next()继续后续处理
        authorization := c.Request.Header.Get("Authorization")
        if authorization == "" {
            c.JSON(http.StatusUnauthorized, gin.H{"code": 401, "msg": "未认证"})
            c.Abort()
            return
        }
        // 假设jwtToken是从authorization字段中提取的token
        jwtToken := "从authorization字段提取的token"
        // 验证JWT token
        if jwtToken != "valid_token" {
            c.JSON(http.StatusUnauthorized, gin.H{"code": 401, "msg": "无效的token"})
            c.Abort()
            return
        }
        c.Next()
    }
}

// 跨域请求中间件
func CORSMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        c.Writer.Header().Set("Access-Control-Allow-Origin", "*")
        c.Writer.Header().Set("Access-Control-Max-Age", "86400")
        c.Writer.Header().Set("Access-Control-Allow-Methods", "POST, GET, OPTIONS, PUT, DELETE, UPDATE")
        c.Writer.Header().Set("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept, Authorization")
        c.Writer.Header().Set("Access-Control-Expose-Headers", "Content-Length, Access-Control-Allow-Origin, Access-Control-Allow-Headers, Cache-Control, Content-Language, Content-Type")
        c.Writer.Header().Set("Access-Control-Allow-Credentials", "true")

        if c.Request.Method == "OPTIONS" {
            fmt.Println("Preflight request received!")
            c.AbortWithStatus(http.StatusNoContent)
        } else {
            c.Next()
        }
    }
}

func main() {
    r := gin.Default()

    // 使用JWT认证中间件
    r.Use(JWTAuthMiddleware())
    // 使用跨域请求中间件
    r.Use(CORSMiddleware())

    // 示例路由
    r.GET("/hello", func(c *gin.Context) {
        c.JSON(http.StatusOK, gin.H{"message": "Hello, World!"})
    })

    // 启动服务器
    r.Run(":8080")
}