Tomcat 高级配置技巧

Advanced Configuration Techniques

概述

Tomcat高级配置技巧包括自定义组件开发、性能调优策略、企业级部署模式和运维自动化。本文详细介绍这些高级技术，帮助你在复杂环境中优化Tomcat的性能和可靠性。

1. 自定义Valve开发

1.1 请求拦截Valve

// RequestInterceptorValve.java
package com.example.valve;

import org.apache.catalina.valves.ValveBase;
import org.apache.catalina.connector.Request;
import org.apache.catalina.connector.Response;

import javax.servlet.ServletException;
import java.io.IOException;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicLong;

public class RequestInterceptorValve extends ValveBase {

    private final ConcurrentHashMap<String, AtomicLong> requestCounts = new ConcurrentHashMap<>();
    private long maxRequestsPerMinute = 100;

    @Override
    public void invoke(Request request, Response response) 
            throws IOException, ServletException {

        String clientIP = getClientIP(request);

        // 限流检查
        if (!checkRateLimit(clientIP)) {
            response.sendError(429, "Too Many Requests");
            return;
        }

        // 请求预处理
        request.setAttribute("requestId", generateRequestId());
        request.setAttribute("startTime", System.currentTimeMillis());

        // 执行后续处理
        getNext().invoke(request, response);

        // 记录指标
        recordMetrics(request, response);
    }

    private String getClientIP(Request request) {
        String xForwardedFor = request.getHeader("X-Forwarded-For");
        if (xForwardedFor != null && !xForwardedFor.isEmpty()) {
            return xForwardedFor.split(",")[0].trim();
        }
        return request.getRemoteAddr();
    }

    private boolean checkRateLimit(String clientIP) {
        AtomicLong count = requestCounts.computeIfAbsent(clientIP, k -> new AtomicLong(0));
        long currentCount = count.incrementAndGet();

        // 简化的滑动窗口实现
        if (currentCount > maxRequestsPerMinute) {
            return false;
        }

        // 定期重置计数器
        if (currentCount % 50 == 0) {
            requestCounts.remove(clientIP);
        }

        return true;
    }

    private String generateRequestId() {
        return java.util.UUID.randomUUID().toString().replace("-", "");
    }

    private void recordMetrics(Request request, Response response) {
        Long startTime = (Long) request.getAttribute("startTime");
        if (startTime != null) {
            long duration = System.currentTimeMillis() - startTime;
            if (duration > 5000) {
                getLogger().warn("Slow request: " + request.getRequestURI() + " (" + duration + "ms)");
            }
        }
    }
}

1.2 配置自定义Valve

<!-- server.xml - 自定义Valve配置 -->
<Host name="localhost" appBase="webapps">

  <Valve className="com.example.valve.RequestInterceptorValve"
         maxRequestsPerMinute="100" />

  <Valve className="org.apache.catalina.valves.AccessLogValve" 
         directory="logs"
         prefix="access_log" 
         suffix=".txt"
         pattern='%h %l %u %t "%r" %s %b %D %{requestId}r' />
</Host>

2. 自定义Realm认证

2.1 多因素认证Realm

// MultiFactorRealm.java
package com.example.realm;

import org.apache.catalina.realm.RealmBase;
import java.security.Principal;
import javax.sql.DataSource;

public class MultiFactorRealm extends RealmBase {

    private String dataSourceName = "jdbc/AuthDB";
    private boolean enableTOTP = true;

    @Override
    protected String getName() {
        return "MultiFactorRealm";
    }

    @Override
    protected String getPassword(String username) {
        return loadPasswordFromDatabase(username);
    }

    @Override
    protected Principal getPrincipal(String username) {
        UserInfo user = loadUserFromDatabase(username);
        if (user != null) {
            return new GenericPrincipal(username, user.getPassword(), user.getRoles());
        }
        return null;
    }

    @Override
    public Principal authenticate(String username, String password) {
        // 第一步：密码验证
        if (!verifyPassword(username, password)) {
            return null;
        }

        // 第二步：TOTP验证（如果启用）
        if (enableTOTP) {
            String totpCode = extractTOTPFromPassword(password);
            if (!verifyTOTP(username, totpCode)) {
                return null;
            }
        }

        return getPrincipal(username);
    }

    private String loadPasswordFromDatabase(String username) {
        // 数据库查询实现
        return null;
    }

    private boolean verifyPassword(String username, String password) {
        String storedPassword = getPassword(username);
        String cleanPassword = removeTOTPFromPassword(password);
        return digest(cleanPassword).equals(storedPassword);
    }

    private boolean verifyTOTP(String username, String totpCode) {
        // TOTP验证实现
        return true;
    }

    private String extractTOTPFromPassword(String password) {
        if (password.contains("|")) {
            String[] parts = password.split("\\|");
            return parts.length > 1 ? parts[1] : null;
        }
        return null;
    }

    private String removeTOTPFromPassword(String password) {
        return password.contains("|") ? password.split("\\|")[0] : password;
    }
}

3. 高级性能调优

3.1 自适应线程池

// AdaptiveThreadPool.java
package com.example.executor;

import org.apache.tomcat.util.threads.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.LinkedBlockingQueue;

public class AdaptiveThreadPool extends ThreadPoolExecutor {

    private volatile double targetUtilization = 0.7;
    private volatile long lastAdjustTime = System.currentTimeMillis();
    private final long adjustInterval = 30000; // 30秒

    public AdaptiveThreadPool(int corePoolSize, int maximumPoolSize) {
        super(corePoolSize, maximumPoolSize, 60L, TimeUnit.SECONDS, 
              new LinkedBlockingQueue<>());
    }

    @Override
    protected void afterExecute(Runnable r, Throwable t) {
        super.afterExecute(r, t);

        long now = System.currentTimeMillis();
        if (now - lastAdjustTime > adjustInterval) {
            adjustPoolSize();
            lastAdjustTime = now;
        }
    }

    private void adjustPoolSize() {
        int activeCount = getActiveCount();
        int poolSize = getPoolSize();
        double utilization = (double) activeCount / poolSize;

        if (utilization > targetUtilization && poolSize < getMaximumPoolSize()) {
            // 增加线程
            int newSize = Math.min(poolSize + 5, getMaximumPoolSize());
            setMaximumPoolSize(newSize);
            System.out.println("Increased pool size to: " + newSize);

        } else if (utilization < (targetUtilization - 0.2) && poolSize > getCorePoolSize()) {
            // 减少线程
            int newSize = Math.max(poolSize - 5, getCorePoolSize());
            setMaximumPoolSize(newSize);
            System.out.println("Decreased pool size to: " + newSize);
        }
    }
}

3.2 连接器优化配置

<!-- server.xml - 智能连接器配置 -->
<Service name="Catalina">

  <Executor name="adaptiveThreadPool" 
            className="com.example.executor.AdaptiveThreadPool"
            namePrefix="catalina-exec-" 
            maxThreads="200" 
            minSpareThreads="25" />

  <Connector port="8080" 
             protocol="org.apache.coyote.http11.Http11NioProtocol"
             executor="adaptiveThreadPool"
             connectionTimeout="20000"
             keepAliveTimeout="60000"
             maxKeepAliveRequests="100"
             compression="on"
             compressionMinSize="1024" />
</Service>

4. 企业级部署模式

4.1 蓝绿部署脚本

#!/bin/bash
# blue-green-deploy.sh

BLUE_PORT=8080
GREEN_PORT=8081
HEALTH_URL="/health"

current_environment() {
    if curl -s "http://localhost:$BLUE_PORT$HEALTH_URL" > /dev/null; then
        echo "blue"
    elif curl -s "http://localhost:$GREEN_PORT$HEALTH_URL" > /dev/null; then
        echo "green"
    else
        echo "none"
    fi
}

deploy_to_environment() {
    local env=$1
    local port=$2
    local version=$3

    echo "Deploying version $version to $env environment..."

    # 停止目标环境
    docker-compose -f docker-compose-$env.yml down

    # 更新镜像版本
    sed -i "s/image: myapp:.*/image: myapp:$version/" docker-compose-$env.yml

    # 启动新版本
    docker-compose -f docker-compose-$env.yml up -d

    # 健康检查
    for i in {1..30}; do
        if curl -s "http://localhost:$port$HEALTH_URL" > /dev/null; then
            echo "$env environment is healthy"
            return 0
        fi
        sleep 10
    done

    echo "Failed to start $env environment"
    return 1
}

switch_traffic() {
    local target_port=$1

    # 更新负载均衡器配置
    sed -i "s/server 127.0.0.1:[0-9]*/server 127.0.0.1:$target_port/" /etc/nginx/conf.d/app.conf
    nginx -s reload

    echo "Traffic switched to port $target_port"
}

main() {
    local action=$1
    local version=$2

    case $action in
        "deploy")
            current=$(current_environment)

            if [ "$current" = "blue" ]; then
                target="green"
                target_port=$GREEN_PORT
            else
                target="blue"
                target_port=$BLUE_PORT
            fi

            if deploy_to_environment $target $target_port $version; then
                switch_traffic $target_port
                echo "Deployment successful!"
            else
                echo "Deployment failed!"
                exit 1
            fi
            ;;
        "status")
            echo "Current environment: $(current_environment)"
            ;;
        *)
            echo "Usage: $0 {deploy|status} [version]"
            ;;
    esac
}

main "$@"

5. 自动化运维

5.1 智能监控脚本

#!/bin/bash
# intelligent-monitor.sh

TOMCAT_PID=$(jps -l | grep Bootstrap | awk '{print $1}')
ALERT_THRESHOLD_CPU=80
ALERT_THRESHOLD_MEMORY=85

check_system_resources() {
    # CPU使用率
    cpu_usage=$(top -p $TOMCAT_PID -n 1 -b | grep java | awk '{print $9}' | cut -d'%' -f1)

    # 内存使用率
    memory_usage=$(jstat -gc $TOMCAT_PID | tail -1 | awk '{
        used=$3+$4+$6+$8; 
        total=$1+$2+$5+$7; 
        printf "%.1f", used*100/total
    }')

    echo "System Resources:"
    echo "  CPU Usage: ${cpu_usage}%"
    echo "  Memory Usage: ${memory_usage}%"

    # 告警检查
    if (( $(echo "$cpu_usage > $ALERT_THRESHOLD_CPU" | bc -l) )); then
        send_alert "High CPU usage: ${cpu_usage}%"
    fi

    if (( $(echo "$memory_usage > $ALERT_THRESHOLD_MEMORY" | bc -l) )); then
        send_alert "High memory usage: ${memory_usage}%"
    fi
}

check_application_health() {
    response_time=$(curl -w "%{time_total}" -s -o /dev/null http://localhost:8080/health)
    http_status=$(curl -w "%{http_code}" -s -o /dev/null http://localhost:8080/health)

    echo "Application Health:"
    echo "  HTTP Status: $http_status"
    echo "  Response Time: ${response_time}s"

    if [ "$http_status" != "200" ]; then
        send_alert "Health check failed: HTTP $http_status"
    fi
}

auto_recovery() {
    echo "Attempting auto-recovery..."

    # 强制垃圾回收
    jcmd $TOMCAT_PID GC.run

    # 清理临时文件
    find /opt/tomcat/temp -type f -mtime +1 -delete
    find /opt/tomcat/work -type f -mtime +1 -delete

    echo "Auto-recovery completed"
}

send_alert() {
    local message="$1"
    echo "ALERT: $message" | mail -s "Tomcat Alert" admin@example.com
}

main() {
    echo "=== Tomcat Intelligent Monitor $(date) ==="

    if [ -z "$TOMCAT_PID" ]; then
        send_alert "Tomcat process not found"
        exit 1
    fi

    check_system_resources
    echo

    check_application_health
    echo

    # 如果检测到问题，尝试自动恢复
    if [ "$?" -ne 0 ]; then
        auto_recovery
    fi

    echo "Monitor check completed"
}

main

5.2 配置管理脚本

#!/bin/bash
# config-manager.sh

TOMCAT_HOME="/opt/tomcat9"
CONFIG_BACKUP_DIR="/opt/backups/tomcat-config"
CONFIG_TEMPLATES_DIR="/opt/templates/tomcat"

backup_config() {
    local backup_name="config_$(date +%Y%m%d_%H%M%S)"
    local backup_path="$CONFIG_BACKUP_DIR/$backup_name"

    mkdir -p "$backup_path"

    # 备份配置文件
    cp -r "$TOMCAT_HOME/conf" "$backup_path/"

    # 备份web应用配置
    find "$TOMCAT_HOME/webapps" -name "*.xml" -exec cp {} "$backup_path/" \;

    echo "Configuration backed up to: $backup_path"
}

apply_template() {
    local template_name=$1
    local template_path="$CONFIG_TEMPLATES_DIR/$template_name"

    if [ ! -d "$template_path" ]; then
        echo "Template not found: $template_name"
        return 1
    fi

    # 备份当前配置
    backup_config

    # 应用模板
    cp -r "$template_path"/* "$TOMCAT_HOME/conf/"

    echo "Template $template_name applied successfully"
}

validate_config() {
    echo "Validating Tomcat configuration..."

    # 检查XML语法
    for xml_file in "$TOMCAT_HOME/conf"/*.xml; do
        if ! xmllint --noout "$xml_file" 2>/dev/null; then
            echo "Invalid XML: $xml_file"
            return 1
        fi
    done

    # 检查端口冲突
    ports=$(grep -h "port=" "$TOMCAT_HOME/conf/server.xml" | grep -o 'port="[0-9]*"' | cut -d'"' -f2)
    if [ $(echo "$ports" | sort | uniq -d | wc -l) -gt 0 ]; then
        echo "Port conflicts detected"
        return 1
    fi

    echo "Configuration validation passed"
    return 0
}

optimize_config() {
    echo "Optimizing Tomcat configuration..."

    # 自动调整JVM参数
    total_memory=$(free -m | awk 'NR==2{print $2}')
    heap_size=$((total_memory * 70 / 100))

    # 更新setenv.sh
    cat > "$TOMCAT_HOME/bin/setenv.sh" << EOF
export JAVA_OPTS="-Xms${heap_size}m -Xmx${heap_size}m -XX:+UseG1GC"
export CATALINA_OPTS="-Dfile.encoding=UTF-8 -Djava.security.egd=file:/dev/./urandom"
EOF

    chmod +x "$TOMCAT_HOME/bin/setenv.sh"

    echo "Configuration optimized for ${total_memory}MB system memory"
}

case "$1" in
    "backup") backup_config ;;
    "apply") apply_template "$2" ;;
    "validate") validate_config ;;
    "optimize") optimize_config ;;
    *)
        echo "Usage: $0 {backup|apply|validate|optimize} [template_name]"
        echo "  backup           - 备份当前配置"
        echo "  apply <template> - 应用配置模板"
        echo "  validate         - 验证配置文件"
        echo "  optimize         - 优化配置参数"
        ;;
esac

小结

通过本文学习，你应该掌握：

1. 自定义Valve和Realm组件开发
2. 自适应线程池和性能优化技术
3. 企业级蓝绿部署和金丝雀部署
4. 智能监控和自动恢复机制
5. 配置管理和模板化部署
6. 高级安全配置和隔离技术

下一篇文章将介绍Tomcat故障排除与调优技术。