spring aop如何拦截器 • Worktile社区

worktile

Worktile官方账号

Spring AOP通过拦截器拦截方法的执行。拦截器（Interceptor）是Spring AOP中的一种特殊类型的通知（Advice），用于在方法执行前、后或者抛出异常时执行一些额外的操作。

要实现拦截器，需要以下几个步骤：

创建一个类实现org.aopalliance.intercept.MethodInterceptor接口。这个接口定义了invoke方法，用于拦截方法的执行。在invoke方法中，你可以在方法执行前后加入额外的逻辑。

public class MyInterceptor implements MethodInterceptor {
    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        // 在方法执行前加入额外的逻辑
        System.out.println("Before method execution");

        // 调用方法
        Object result = invocation.proceed();

        // 在方法执行后加入额外的逻辑
        System.out.println("After method execution");

        return result;
    }
}

配置拦截器。

可以使用xml配置或Java配置来配置拦截器。以下是两种配置方式的示例：

xml配置方式：

<beans ...
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="...
           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
    <aop:config>
        <aop:advisor advice-ref="myInterceptor" pointcut="execution(* com.example.service.*.*(..))"/>
    </aop:config>

    <bean id="myInterceptor" class="com.example.MyInterceptor"/>
</beans>

Java配置方式：

@Configuration
@EnableAspectJAutoProxy
public class AppConfig {
    @Bean
    public MyInterceptor myInterceptor() {
        return new MyInterceptor();
    }

    @Bean
    public Advisor myAdvisor(MyInterceptor myInterceptor) {
        AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();
        pointcut.setExpression("execution(* com.example.service.*.*(..))");
        return new DefaultPointcutAdvisor(pointcut, myInterceptor);
    }
}

在配置中，需要指定要拦截的方法所在的类和类的方法签名。

在上述配置中，使用了Advice的子类Advisor来配置拦截器。Advisor将拦截器和切入点（Pointcut）组合在一起。

测试拦截器。

使用拦截器拦截的方法，在其执行前后会执行额外的逻辑。

@Service
public class MyService {
    public void doSomething() {
        System.out.println("Doing something...");
    }
}

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = AppConfig.class)
public class MyServiceTest {
    @Autowired
    private MyService myService;

    @Test
    public void testDoSomething() {
        myService.doSomething();
    }
}

输出结果：

Before method execution
Doing something...
After method execution

通过以上步骤，你就可以使用Spring AOP实现方法的拦截器了。你可以在拦截器中加入任意的逻辑处理，例如日志记录、事务管理等。

1年前 0条评论

不及物动词

这个人很懒，什么都没有留下～

Spring AOP（Aspect Oriented Programming）是Spring框架提供的一种面向切面编程的技术。通过AOP，可以将程序的横切逻辑（cross-cutting concerns）与核心业务逻辑进行分离，提高代码的可维护性和可重用性。在Spring AOP中，拦截器（Interceptor）用于在目标对象的方法调用前后进行切面逻辑的执行。下面是关于Spring AOP拦截器的一些重点信息：

拦截器接口
在Spring AOP中，拦截器通过实现AopMethodInterceptor接口来定义。该接口定义了一个唯一的方法invoke，该方法接收一个MethodInvocation对象作为参数，并返回一个Object类型的返回值。
拦截器的执行顺序
多个拦截器可以通过配置进行串联，形成一个拦截器链。在拦截器链中，拦截器的执行顺序与其在配置中的声明顺序相关。通常情况下，拦截器链的第一个拦截器执行前置通知（Before Advice），最后一个拦截器执行后置通知（After Advice），如果目标方法抛出异常，则会执行异常通知（Throws Advice）。
拦截器的应用场景
拦截器可以用于实现日志记录、性能监控、事务等横切逻辑。通过将这些横切逻辑独立于核心业务逻辑，可以提高代码的可维护性和扩展性。
拦截器的配置
在Spring AOP中，拦截器的配置可以通过注解或XML进行。使用注解方式配置拦截器时，可以通过@Aspect注解将拦截器标识为一个切面，并使用@Before、@After等注解定义不同类型的通知。使用XML方式配置拦截器时，可以使用aop:config元素来定义切面和通知的配置。
拦截器的参数传递
拦截器可以获取目标方法的参数，并在切面逻辑中进行处理。在Spring AOP中，可以通过使用ProceedingJoinPoint对象来获取目标方法的参数，并在方法调用前后进行处理。

总结：
Spring AOP中的拦截器是用于实现面向切面编程的重要组件。它可以在目标方法的执行之前和之后插入横切逻辑，实现日志记录、性能监控、事务等功能。拦截器可以通过实现AopMethodInterceptor接口来定义，并可以通过注解或XML方式进行配置。拦截器链的执行顺序与其在配置中的声明顺序相关，可以通过传递ProceedingJoinPoint对象来获取目标方法的参数。通过合理使用拦截器，可以提高代码的可维护性和可重用性。

1年前 0条评论

fiy

Worktile&PingCode市场小伙伴

Spring AOP提供了一种方便的方式来使用拦截器（Interceptor）对方法进行拦截。在Spring AOP中，我们可以使用AspectJ注解或XML配置的方式来定义拦截器。

使用AspectJ注解方式配置拦截器：
通过使用AspectJ注解，我们可以在方法上直接标注拦截器，并指定拦截器的类型。

首先，我们需要在Spring配置文件中启用AspectJ自动代理：

<bean class="org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator" />

然后，我们可以创建一个拦截器类，并使用@Aspect注解标注该类。在拦截器类中，我们可以使用@Around注解标注具体的拦截方法，并在方法中编写拦截逻辑。

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Around;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class MyInterceptor {
    @Around("execution(* com.example.service.*.*(..))")
    public Object intercept(ProceedingJoinPoint joinPoint) throws Throwable {
        // 在方法执行前进行拦截逻辑
        // ...

        // 调用原始方法
        Object result = joinPoint.proceed();

        // 在方法执行后进行拦截逻辑
        // ...

        return result;
    }
}

在上面的例子中，我们使用@Around注解标注了一个拦截方法，拦截的范围是com.example.service包及其子包下的所有方法。我们可以在拦截方法中编写我们希望执行的拦截逻辑。

使用XML配置方式配置拦截器：
在Spring AOP中，我们也可以使用XML配置来定义拦截器。

首先，我们需要在Spring配置文件中配置AOP的命名空间：

xmlns:aop="http://www.springframework.org/schema/aop"
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd

然后，在配置文件中定义拦截器：

<aop:config>
    <aop:aspect id="myInterceptor" ref="myInterceptor">
        <aop:around pointcut="execution(* com.example.service.*.*(..))" method="intercept" />
    </aop:aspect>
</aop:config>

<bean id="myInterceptor" class="com.example.MyInterceptor" />

在上面的例子中，我们使用aop:config标签来定义AOP配置，aop:aspect标签中定义了拦截器的和。

通过使用AspectJ注解或XML配置，我们可以很方便地在Spring AOP中定义拦截器，实现对方法的拦截操作。拦截器可以在方法执行前后进行一些通用的操作，例如日志记录、性能监控等。在拦截器中，我们还可以通过ProceedingJoinPoint对象来调用原始方法，并获取方法的参数和返回值。

1年前 0条评论