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;
    }
}

在这个代码实例中，我们定义了一个简单的配置类WhiteListConfig，它使用@ConfigurationProperties注解来声明这个类的属性与配置文件中以white-list为前缀的属性相绑定。例如，如果你的application.properties或application.yml文件中包含以下配置：

white-list.ips=192.168.1.1,192.168.1.2,192.168.1.3

或者使用YAML格式：

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

Spring Boot会自动将这些配置属性绑定到WhiteListConfig类的ips属性上，你可以在其他组件中通过@Autowired注入WhiteListConfig来使用这些配置值。

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")
}

这段代码演示了如何在Gin框架中编写JWT认证中间件和处理跨域请求的中间件。在这个例子中，我们假设JWT认证成功通过检查请求头中的Authorization字段，并返回一个简单的JSON响应。跨域中间件允许跨源请求，并设置了一些标准的CORS头部。在实际应用中，JWT认证逻辑和CORS策略会根据具体需求进行更复杂的配置。

package main
 
import (
    "fmt"
    "github.com/gin-gonic/gin"
    "net/http"
)
 
// 自定义中间件
func MyMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        fmt.Println("中间件开始执行")
        // 在这里可以进行一些预处理操作
        // 调用下一个中间件或控制器
        c.Next()
        // 在这里可以进行一些后处理操作
        fmt.Println("中间件执行结束")
    }
}
 
// 自定义控制器
func CustomController(c *gin.Context) {
    name := c.Query("name")
    c.String(http.StatusOK, "Hello %s", name)
}
 
func main() {
    router := gin.Default() // 创建一个带有默认中间件的路由引擎
 
    // 使用自定义中间件
    router.Use(MyMiddleware())
 
    // 创建一个基本路由
    router.GET("/hello", CustomController)
 
    // 启动服务器
    router.Run(":8080")
}

这段代码定义了一个自定义的中间件MyMiddleware和一个自定义的控制器CustomController。在main函数中，我们创建了一个带有默认中间件的Gin路由引擎，并使用Use方法加入了自定义的中间件。然后，我们定义了一个基本的GET路由，并将自定义控制器绑定到该路由上。最后，我们启动服务器，监听8080端口的请求。

const log4js = require('log4js');
 
// 配置log4js
log4js.configure({
  appenders: {
    console: { type: 'console' },
    access: { type: 'dateFile', filename: 'logs/access.log', pattern: 'yyyy-MM-dd', alwaysIncludePattern: true },
    app: { type: 'dateFile', filename: 'logs/app.log', pattern: 'yyyy-MM-dd', alwaysIncludePattern: true }
  },
  categories: {
    default: { appenders: ['console', 'app'], level: 'info' },
    http: { appenders: ['console', 'access'], level: 'info' }
  }
});
 
const logger = log4js.getLogger('http');
 
// Koa2日志记录中间件
const logMiddleware = () => {
  return async (ctx, next) => {
    const start = Date.now();
    await next();
    // 路径、状态码、响应时间
    logger.info(`${ctx.method} ${ctx.url} ${ctx.status} - ${Date.now() - start}ms`);
  };
};
 
module.exports = logMiddleware;

这段代码定义了一个Koa2中间件，用于记录每个HTTP请求的方法、URL、状态码和响应时间。它使用了log4js库来进行日志记录，并且将日志输出到控制台和文件中。这个例子展示了如何在实际应用中使用log4js进行日志管理。

DELIMITER $$
 
CREATE TRIGGER `trigger_after_data_fowarding` AFTER INSERT ON `source_table`
FOR EACH ROW
BEGIN
    DECLARE v_source_id INT;
    DECLARE v_destination_id INT;
    -- 假设source_table有id字段，destination_table有source_id字段
    -- 获取新插入数据的id
    SELECT NEW.id INTO v_source_id;
    -- 假设data_forwarding_function是一个返回目的地表id的函数
    SET v_destination_id = data_forwarding_function(v_source_id);
    -- 假设destination_table有source_id和destination_id字段
    -- 插入数据到目的地表
    INSERT INTO destination_table (source_id, destination_id) VALUES (v_source_id, v_destination_id);
END$$
 
DELIMITER ;

这个示例代码创建了一个名为trigger_after_data_fowarding的触发器，它会在source_table上的每次插入操作之后执行。触发器会获取新插入行的id，然后调用一个假设的data_forwarding_function函数来获取目标表的destination_id，最后将源表的source_id和目标表的destination_id插入到目标表中。这个过程可以作为数据投递中间件的一个简单示例。

在Node.js中，Express是一个非常流行的web开发框架，它提供了一种简单的方法来创建web服务器，并处理HTTP请求。

在第七章中，我们主要讨论了Express的路由和中间件。

路由：

路由是指确定应用程序如何响应客户端请求的过程。在Express中，我们可以使用app.get(), app.post(), app.use()等方法来定义路由。

const express = require('express');
const app = express();
 
app.get('/', (req, res) => {
  res.send('Hello World!');
});
 
app.listen(3000, () => {
  console.log('Server is running on port 3000');
});

在上述代码中，我们定义了一个路由处理器，当客户端向根URL（'/'）发送GET请求时，服务器将响应'Hello World!'。

中间件：

中间件是一个函数，它可以访问请求对象（req）、响应对象（res）和next函数。在中间件函数内部，可以执行任何代码，并在必要时继续执行下一个中间件或路由处理器。

const express = require('express');
const app = express();
 
app.use((req, res, next) => {
  console.log('Incoming request');
  next();
});
 
app.get('/', (req, res) => {
  res.send('Hello World!');
});
 
app.listen(3000, () => {
  console.log('Server is running on port 3000');
});

在上述代码中，我们定义了一个中间件，它会在控制台输出'Incoming request'，然后继续执行下一个中间件或路由处理器。

错误处理中间件：

错误处理中间件是一种特殊的中间件，它用于处理在应用程序中发生的错误。

const express = require('express');
const app = express();
 
app.get('/', (req, res) => {
  // 制造一个错误
  throw new Error('Something went wrong');
});
 
app.use((err, req, res, next) => {
  console.error(err.message);
  res.status(500).send('Internal Server Error');
});
 
app.listen(3000, () => {
  console.log('Server is running on port 3000');
});

在上述代码中，我们定义了一个错误处理中间件，它会捕获应用程序中发生的任何错误，并将错误的消息打印到控制台，同时向客户端返回500响应码和'Internal Server Error'。

以上就是Node.js中Express框架的路由和中间件的基本使用方法。

package main
 
import (
    "github.com/gin-gonic/gin"
    "net/http"
)
 
// 局部中间件，仅应用于特定路由
func localMiddleware(c *gin.Context) {
    // 在调用下游处理器之前执行的逻辑
    c.Writer.Header().Set("X-Local-Middleware", "true")
    c.Next() // 调用下一个中间件或路由处理器
    // 在调用下游处理器之后执行的逻辑
}
 
// 全局中间件，应用于所有路由
func globalMiddleware(c *gin.Context) {
    // 在调用下游处理器之前执行的逻辑
    c.Writer.Header().Set("X-Global-Middleware", "true")
    c.Next() // 调用下一个中间件或路由处理器
    // 在调用下游处理器之后执行的逻辑
}
 
func main() {
    router := gin.Default() // 创建一个带有默认中间件的路由器
 
    // 全局注册中间件
    router.Use(globalMiddleware)
 
    // 创建一个分支路由，并注册局部中间件
    api := router.Group("/api")
    api.Use(localMiddleware)
    {
        api.GET("/hello", func(c *gin.Context) {
            c.String(http.StatusOK, "Hello from API")
        })
    }
 
    // 启动服务器
    router.Run(":8080")
}

这段代码演示了如何在Gin框架中定义和使用局部和全局中间件。首先定义了两个中间件函数localMiddleware和globalMiddleware。然后在路由器中全局注册了globalMiddleware，并在特定分支路由上注册了localMiddleware。最后，在:8080端口启动了服务器。

在Node.js中，中间件是一种用于处理HTTP请求和响应的函数，它可以访问请求对象（request）、响应对象（response）以及应用程序的请求-响应循环内的next函数。中间件的一个常见用途是日志记录、身份验证、会话处理、错误处理等。

以下是一个简单的中间件示例，它记录每个请求的路径，并调用next()函数以继续执行下一个中间件或路由处理程序：

function logRequestPath(req, res, next) {
    console.log('Requested path:', req.path);
    next(); // 调用下一个中间件或路由处理程序
}
 
// 使用中间件的示例
const express = require('express');
const app = express();
 
app.use(logRequestPath); // 注册中间件
 
app.get('/', (req, res) => {
    res.send('Hello World!');
});
 
app.listen(3000, () => {
    console.log('Server is running on port 3000');
});

在这个例子中，当你访问 http://localhost:3000/ 时，你会在控制台看到输出 "Requested path: /"，然后你会看到 "Hello World!" 响应。这是因为注册的中间件在请求到达路由处理程序之前执行，并且通过调用next()函数，请求-响应循环继续进行。

通关步骤：

1. 使用Burp Suite抓包修改请求，发送到weblogic模块。
2. 使用Burp Suite的Repeater模块重发请求，注意修改Content-Length。

具体操作：

1. 打开Burp Suite并开始抓取流量。
2. 使用浏览器访问http://your-ip:8080/iwebsec\_weblogic\_war\_exploded/，进入Web应用。
3. 在Burp Suite中找到到达Tomcat服务器的流量，并将其发送到Repeater。
4. 在Repeater中修改请求，例如修改Content-Length，确保请求长度与修改后的内容长度一致。
5. 发送修改后的请求到Tomcat服务器，并查看响应。

注意：

• 请确保在修改请求时保留原始请求的必要头信息，如Host、User-Agent等。
• 修改Content-Length以匹配修改后的请求体长度。
• 如果遇到问题，可以尝试不同的修改，并观察响应来确定是否成功。

Redis的过期策略主要是通过定时任务和惰性删除相结合的方式来管理键的生命周期。

1. 定时任务：Redis 会定期遍历一部分键，检查其是否过期，并删除过期键。
2. 惰性删除：当一个键被访问(GET/SET)时，Redis 会检查它是否过期，如果过期就删除它。

// 伪代码示例：Redis 过期策略的核心函数
 
// 定时任务处理函数
void activeExpireCycle(void) {
    // 遍历数据库中的键，检查是否过期
    for (int i = 0; i < db->dict->size; i++) {
        dictEntry *de = dictGetRandomKey(db->dict);
        if (de) {
            dictEntry *expired = dbExpireIfNeeded(de);
            if (expired) {
                // 删除过期键
                deleteExpired(expired);
            }
        }
    }
}
 
// 检查键是否过期，如果过期返回1，否则返回0
int checkIfExpired(dictEntry *de) {
    // 检查键的过期时间
    if (de->expire) {
        if (mstime() > de->expire) {
            return 1;
        }
    }
    return 0;
}
 
// 惰性删除
void lazyExpire(dictEntry *de) {
    if (checkIfExpired(de)) {
        // 键过期，从数据库中删除
        deleteKey(db, de);
    }
}

注意：以上代码仅为示例，实际的 Redis 代码实现会更加复杂，包括对时间和资源的精细管理。