过滤器(Filter)，拦截器(Interceptor)，AOP之间的差异

过滤器（Filter）

过滤器是在Java EE中用于处理HTTP请求和响应的组件之一。它主要用于在请求到达目标资源之前或响应离开目标资源之后执行一些任务。过滤器通常用于实现与请求和响应处理相关的功能，如身份验证、日志记录、字符编码转换等。

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import java.io.IOException;

public class MyFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        // 初始化操作
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        // 执行过滤操作，例如日志记录或身份验证

        // 继续请求链
        chain.doFilter(request, response);

        // 执行过滤操作，例如修改响应内容
    }

    @Override
    public void destroy() {
        // 销毁操作
    }
}

拦截器（Interceptor）

拦截器是Spring框架中的概念，用于在请求进入处理器（controller）之前和离开处理器之后执行一些任务。拦截器通常用于实现横切关注点，如日志、事务管理等。

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class MyInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws Exception {
        // 执行在处理器之前的操作，例如身份验证
        return true; // 如果返回false，请求将被中止
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
                           ModelAndView modelAndView) throws Exception {
        // 执行在处理器之后、视图渲染之前的操作
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler,
                                Exception ex) throws Exception {
        // 执行在视图渲染之后的操作
    }
}

AOP（面向切面编程）

AOP是一种编程范式，允许将横切关注点从业务逻辑中分离出来。在Java中，AOP通常通过使用AspectJ等框架来实现。它可以在方法执行前、后或抛出异常时执行一些横切逻辑。

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

@Aspect
public class MyAspect {
    @Before("execution(* com.example.service.*.*(..))")
    public void beforeServiceMethodExecution() {
        // 在service层方法执行前执行的逻辑，例如加锁
    }
}

加锁的Java代码例子

public class Example {
    private static final Object lock = new Object();

    public void performOperation() {
        // 其他代码...

        synchronized (lock) {
            // 需要加锁的操作
            // 例如，对共享资源的修改
        }

        // 其他代码...
    }
}

在这个例子中，通过synchronized关键字，我们创建了一个临界区，确保在任何时候只有一个线程能够执行加锁的操作。这有助于防止并发问题，确保对共享资源的安全访问。请注意，过多的锁可能导致性能问题，因此在使用锁时需要谨慎。