import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import redis.clients.jedis.Jedis;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.time.LocalDate;

@Component
public class UVInterceptor implements HandlerInterceptor {

    private Jedis jedis;

    public UVInterceptor() {
        this.jedis = new Jedis("localhost", 6379); // 初始化Redis連接
    }

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        String uniqueId = getUniqueIdFromRequest(request);
        String key = "UV:" + LocalDate.now(); // 按日期存儲UV

        jedis.sadd(key, uniqueId); // 使用Set進(jìn)行去重
        jedis.expire(key, 86400); // 設(shè)置過期時間為一天

        return true;
    }

    private String getUniqueIdFromRequest(HttpServletRequest request) {
        // 示例中使用IP地址，可以替換為cookie或用戶ID
        return request.getRemoteAddr();
    }
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Autowired
    private UVInterceptor uvInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(uvInterceptor).addPathPatterns("/**");
    }
}

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;
import redis.clients.jedis.Jedis;

@Aspect
@Component
public class PageViewAspect {

    private Jedis jedis;

    public PageViewAspect() {
        this.jedis = new Jedis("localhost", 6379); // 初始化Redis連接
    }

    @After("execution(* com.example.controller..*(..))")
    public void logPageView(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        String key = "PV:" + methodName + ":" + LocalDate.now();

        jedis.incr(key); // 增加PV計數(shù)
        jedis.expire(key, 86400); // 設(shè)置過期時間為一天
    }
}

<!-- Spring Boot中的pom.xml通常已包含AOP依賴 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class QPSCounter {

    private AtomicInteger requestCount = new AtomicInteger(0);
    private ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);

    public QPSCounter() {
        // 每秒打印一次QPS
        scheduler.scheduleAtFixedRate(() -> {
            int qps = requestCount.getAndSet(0);
            System.out.println("Current QPS: " + qps);

            // 這里可以添加報警邏輯
            if (qps > 1000) {
                System.out.println("QPS exceeds threshold!");
            }
        }, 0, 1, TimeUnit.SECONDS);
    }

    public void recordRequest() {
        requestCount.incrementAndGet();
    }

    public static void main(String[] args) {
        QPSCounter qpsCounter = new QPSCounter();

        // 模擬請求
        for (int i = 0; i < 5000; i++) {
            qpsCounter.recordRequest();
            try {
                Thread.sleep(1); // 模擬請求間隔
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.PostConstruct;
import java.util.concurrent.Executor;

@Service
public class TPSCounter {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    private Executor executor;

    @PostConstruct
    public void init() {
        ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
        taskExecutor.setCorePoolSize(10);
        taskExecutor.setMaxPoolSize(50);
        taskExecutor.setQueueCapacity(100);
        taskExecutor.initialize();
        this.executor = taskExecutor;
    }

    @Async
    @Transactional
    public void processTransaction(String transactionData) {
        // 模擬事務(wù)處理
        jdbcTemplate.update("INSERT INTO transactions (data) VALUES (?)", transactionData);

        // 其他業(yè)務(wù)邏輯
    }

    public void simulateTransactions(int numberOfTransactions) {
        for (int i = 0; i < numberOfTransactions; i++) {
            processTransaction("Transaction " + i);
        }
    }

    public static void main(String[] args) {
        TPSCounter tpsCounter = new TPSCounter();
        tpsCounter.simulateTransactions(1000);
    }
}

public class ResponseTimeMeasure {

    public static long measureResponseTime() {
        long startTime = System.currentTimeMillis();
        // 模擬請求處理
        try {
            Thread.sleep(100); // 假設(shè)處理請求需要100毫秒
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        long endTime = System.currentTimeMillis();
        return endTime - startTime;
    }

    public static void main(String[] args) {
        long responseTime = measureResponseTime();
        System.out.println("Response Time: " + responseTime + " ms");
    }
}

public class ThroughputMeasure {

    public static void measureThroughput() {
        long requestCount = 0;
        long startTime = System.currentTimeMillis();
        // 模擬請求處理
        try {
            for (int i = 0; i < 1000; i++) {
                // 模擬處理請求
                Thread.sleep(1); // 假設(shè)每個請求處理需要1毫秒
                requestCount++;
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        long endTime = System.currentTimeMillis();
        long elapsedTime = endTime - startTime;
        System.out.println("Throughput: " + (requestCount / (elapsedTime / 1000.0)) + " requests/second");
    }

    public static void main(String[] args) {
        measureThroughput();
    }
}

public class ErrorRateMeasure {

    public static double measureErrorRate(int totalRequests, int failedRequests) {
        return (double) failedRequests / totalRequests;
    }

    public static void main(String[] args) {
        int totalRequests = 1000;
        int failedRequests = 10;
        double errorRate = measureErrorRate(totalRequests, failedRequests);
        System.out.println("Error Rate: " + errorRate);
    }
}

import java.util.concurrent.atomic.AtomicInteger;

public class ConcurrentUsersMeasure {

    private static final AtomicInteger concurrentUsers = new AtomicInteger(0);

    public static void addUser() {
        concurrentUsers.incrementAndGet();
        System.out.println("Current Concurrent Users: " + concurrentUsers.get());
    }

    public static void removeUser() {
        concurrentUsers.decrementAndGet();
        System.out.println("Current Concurrent Users: " + concurrentUsers.get());
    }

    public static void main(String[] args) {
        // 模擬用戶登錄和登出
        addUser();
        addUser();
        removeUser();
    }
}

CREATE TABLE transactions (
    id INT AUTO_INCREMENT PRIMARY KEY,
    transaction_data VARCHAR(255),
    timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
    status VARCHAR(50)
);