Java Interceptor拦截器如何实现日志记录

在Java中，拦截器（Interceptor）通常用于在方法调用前后执行一些操作，例如日志记录、权限检查等。要实现一个拦截器来记录日志，你可以使用Java的动态代理或者第三方库（如Spring AOP）。下面是两种实现方法的示例：

方法一：使用Java动态代理

1. 创建一个接口：

public interface MyInterface {
    void doSomething();
}

2. 实现接口：

public class MyInterfaceImpl implements MyInterface {
    @Override
    public void doSomething() {
        System.out.println("MyInterfaceImpl: doSomething");
    }
}

3. 创建一个代理类：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class LoggingInterceptor implements InvocationHandler {
    private Object target;

    public LoggingInterceptor(Object target) {
        this.target = target;
    }

    public static Object newProxyInstance(Object target) {
        return Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new LoggingInterceptor(target));
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before method: " + method.getName());
        Object result = method.invoke(target, args);
        System.out.println("After method: " + method.getName());
        return result;
    }
}

4. 使用代理类：

public class Main {
    public static void main(String[] args) {
        MyInterface myInterface = new MyInterfaceImpl();
        MyInterface proxy = (MyInterface) LoggingInterceptor.newProxyInstance(myInterface);
        proxy.doSomething();
    }
}

方法二：使用Spring AOP

1. 添加Spring AOP依赖（Maven）：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

2. 创建一个切面类：

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class LoggingAspect {
    @Before("execution(* com.example.MyInterface.*(..))")
    public void before(JoinPoint joinPoint) {
        System.out.println("Before method: " + joinPoint.getSignature().getName());
    }

    @After("execution(* com.example.MyInterface.*(..))")
    public void after(JoinPoint joinPoint) {
        System.out.println("After method: " + joinPoint.getSignature().getName());
    }
}

3. 创建一个接口和实现类：

package com.example;

public interface MyInterface {
    void doSomething();
}

package com.example;

import org.springframework.stereotype.Service;

@Service
public class MyInterfaceImpl implements MyInterface {
    @Override
    public void doSomething() {
        System.out.println("MyInterfaceImpl: doSomething");
    }
}

4. 在Spring Boot应用中使用：

import com.example.MyInterface;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application implements CommandLineRunner {
    @Autowired
    private MyInterface myInterface;

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }

    @Override
    public void run(String... args) {
        myInterface.doSomething();
    }
}

这样，在调用doSomething方法前后，日志记录功能就会被执行。