spring aop怎么切

fiy 1年前其他 19

共3条回复我来回复

fiy
Worktile&PingCode市场小伙伴
评论
Spring AOP可以通过配置或者注解的方式进行切面编程。下面分别介绍两种常见的切面编程的方式：

1、配置方式：
首先，在Spring配置文件中声明一个切面，使用<aop:config>来进行配置。在<aop:config>标签下，可以使用<aop:aspect>来定义一个切面。在<aop:aspect>标签中使用<aop:pointcut>来定义切点，即要在哪些连接点上切入。在<aop:aspect>标签中可以使用<aop:before>、<aop:after>、<aop:around>等标签来定义切面的通知类型，即在连接点之前、之后或者环绕连接点执行的代码。

2、注解方式：
使用注解的方式，首先在需要使用切面的类上添加@Aspect注解，将其标注为切面类。然后使用@Pointcut注解来定义切点。切点的定义可以参考Spring AOP中的表达式语言，例如使用execution()来定义方法的切点。接下来，可以在需要切入的方法上使用@Before、@After、@Around等注解来定义切面的通知类型。

无论是配置方式还是注解方式，在编写切点表达式时需要注意以下几点：
- 使用execution()来定义方法的切点，可以使用通配符来匹配方法名、参数类型等，例如execution(* com.example.service.*.*(..))表示匹配com.example.service包下所有类的所有方法。
- 使用within()来定义类的切点，例如within(com.example.service.*)表示匹配com.example.service包下所有类的所有方法。
- 使用@annotation()来定义带有特定注解的方法的切点，例如@annotation(org.springframework.transaction.annotation.Transactional)表示匹配使用了@Transactional注解的方法。
- 使用args()来定义特定参数类型的切点，例如args(String)表示匹配有一个String类型参数的方法。
总之，Spring AOP提供了多种方式来定义切点，可以根据具体的需求来选择使用配置方式还是注解方式。以上只是一些基本的用法，更复杂的切面编程可以结合使用切点表达式、切面通知类型等来实现。
1年前 0条评论
不及物动词
这个人很懒，什么都没有留下～
评论
Spring AOP（Aspect-Oriented Programming）是Spring框架提供的一种轻量级的AOP框架，用于在运行时动态地将横切关注点（Cross-cutting Concerns）插入到应用程序的特定位置。

在Spring AOP中，可以通过注解或配置文件的方式来定义切面（Aspect），切面定义了横切关注点以及其在目标方法执行前、执行后或执行过程中的执行顺序。切面定义了在何时以及如何切入到目标方法中执行某些逻辑。

那么，Spring AOP如何切入应用程序中的目标对象呢？下面是几种常见的切入方式：
1. 基于注解的切入：
  在Spring AOP中，可以通过在切面类和目标类的方法上添加注解来实现切入逻辑。具体步骤如下：
  （1）在xml配置文件中开启注解扫描：<context:component-scan base-package="com.example" />；
  （2）在切面类中添加@Aspect注解，表示该类是一个切面；
  （3）在切面类的方法上添加@Before、@After、@Around等注解，表示在目标方法的前后执行某些逻辑；
  （4）在目标类的方法上添加@注解，表示对该方法进行切入。
2. 基于XML配置的切入：
  除了注解方式外，还可以使用XML文件来配置切面。具体步骤如下：
  （1）在xml配置文件中定义切面：<aop:aspect id="myAspect" ref="aspectBean">
  <aop:before method="before" pointcut="execution(* com.example.*.*(..))"/>
；
（2）在XML文件中定义目标对象：；
（3）在XML文件中配置切面和目标对象：aop:config
<aop:aspect ref="myAspect">
<aop:pointcut id="myPointcut" expression="execution(* com.example.*.*(..))" />
<aop:before method="before" pointcut-ref="myPointcut"/>

；
1. 基于@EnableAspectJAutoProxy的切入：
  Spring提供了@EnableAspectJAutoProxy注解，用于启用AspectJ自动代理。具体步骤如下：
  （1）在配置类上添加@EnableAspectJAutoProxy注解；
  （2）在切面类上添加@Aspect注解；
  （3）在目标类上添加@注解。
2. 基于动态代理的切入：
  Spring AOP实现切入的方式之一就是使用动态代理。在Spring中，可以使用JDK动态代理或CGLIB动态代理来实现代理对象。具体步骤如下：
  （1）定义切面类，实现Advice接口，并重写相应的方法；
  （2）使用ProxyFactory或ProxyFactoryBean创建代理对象；
  （3）配置目标对象，并将代理对象与目标对象绑定。
3. 基于自定义切面的切入：
  除了使用注解或配置文件进行切入外，还可以使用自定义切面进行切入。具体步骤如下：
  （1）自定义切面类，实现org.springframework.aop.aspectj.AspectJExpressionPointcutAdvisor接口；
  （2）在切面类中定义切入点表达式以及切入的逻辑；
  （3）在xml配置文件中配置自定义切面。
总结来说，Spring AOP提供了多种切入方式，包括基于注解的切入、基于XML配置的切入、基于@EnableAspectJAutoProxy的切入、基于动态代理的切入以及基于自定义切面的切入。开发者可以根据具体需求选择适合的方式来切入到应用程序中的目标对象中执行横切关注点的逻辑。
1年前 0条评论
worktile
Worktile官方账号
评论
在Spring框架中，AOP（面向切面编程）允许我们通过切面将横切关注点模块化。切面可以定义要应用在目标对象的哪些方法上，以及何时将这些方法应用到目标对象。

Spring AOP提供了多种方式来进行切面编程，下面将介绍常见的几种切面的切入点表达式。
1. 匹配切入点表达式的语法
  切入点表达式是一种语言，用于定义我们希望AOP在代码中应用的位置。
- execution：用于匹配方法执行的连接点，是AOP中最常见的切入点表达式。
- within：用于匹配指定类型内的方法执行连接点。
- this：用于匹配指定AOP代理对象的类型。
- target：用于匹配指定目标对象的类型。
- args：用于匹配参数有指定注解的方法。
- @annotation：用于匹配方法有指定注解的方法。
- bean：用于匹配指定的Spring bean的名称。
- @within：用于匹配类有指定注解的方法。
- @target：用于匹配当前目标对象有指定注解的类。
- @args：用于匹配当前方法的执行参数有指定注解的类。
- @annotation：用于匹配当前目标对象的类有指定注解的方法。
1. 切入点表达式示例
  下面是一些常见的切入点表达式示例。
- 匹配任意的公共方法：
  execution(public * *(..))
- 匹配Person类中的任意方法：
  execution(* com.example.Person.*(..))
- 匹配com.example包及其子包下的任意方法：
  execution(* com.example...(..))
- 匹配任意以“Service”结尾的bean中的任意方法：
  execution(* Service.(..))
- 匹配任意实现了Person接口的代理对象的方法：
  this(com.example.Person)
- 匹配任意目标对象的方法，其中目标对象实现了Person接口：
  target(com.example.Person)
- 匹配参数中含有@MyAnnotation注解的方法：
  args(@com.example.MyAnnotation *)
1. 声明切面
  在Spring中，我们可以通过XML配置文件或注解的方式来声明切面。
- XML配置文件方式：
```

<bean id="myAspect" class="com.example.MyAspect"></bean>


<aop:config>
    
    <aop:pointcut expression="execution(public * com.example.Person.*(..))" id="pointcut"/>
    <aop:aspect ref="myAspect">
        <aop:before pointcut-ref="pointcut" method="beforeAdvice"/>
        <aop:after-returning pointcut-ref="pointcut" method="afterReturningAdvice"/>
    </aop:aspect>
</aop:config>
```
- 注解方式（使用Java配置）：
```
@Configuration
@EnableAspectJAutoProxy
public class AppConfig {
  
    @Bean
    public MyAspect myAspect(){
        return new MyAspect();
    }
  
    @Before("execution(public * com.example.Person.*(..))")
    public void beforeAdvice(){
        // 前置通知逻辑
    }
  
    @AfterReturning("execution(public * com.example.Person.*(..))")
    public void afterReturningAdvice(){
        // 后置返回通知逻辑
    }
}
```
1. 编写切面逻辑
  切面类是一个普通的Java类，其中包含的方法称为通知（Advice），通知定义了在目标方法执行之前、之后或抛出异常时执行的逻辑。
下面是一个切面类的示例：
```
@Aspect
public class MyAspect {

    @Before("execution(public * com.example.Person.*(..))")
    public void beforeAdvice(){
        System.out.println("Before advice executed.");
    }

    @AfterReturning("execution(public * com.example.Person.*(..))")
    public void afterReturningAdvice(){
        System.out.println("After returning advice executed.");
    }

}
```
在上述示例中，@Before和@AfterReturning注解用于指定切入点表达式，并定义了相应的通知方法。
1. 使用切面
  要使用切面，我们需要创建一个被代理的目标对象，并使用Spring容器来获取该对象的代理对象。
```
@Configuration
@ComponentScan("com.example")
@EnableAspectJAutoProxy
public class AppConfig {

    @Bean
    public Person person(){
        return new Person();
    }

    @Bean
    public MyAspect myAspect(){
        return new MyAspect();
    }

}

public class Main {

    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        Person person = context.getBean(Person.class);
        person.getName(); // 调用目标对象的方法
    }

}
```
在上述示例中，我们使用了@ComponentScan注解来扫描com.example包下的所有组件，并使用@EnableAspectJAutoProxy注解来启用Spring的AOP功能。然后，我们在AppConfig中声明了Person类和MyAspect切面，并通过ApplicationContext获取了Person对象的代理对象。接下来，我们可以通过代理对象来调用目标对象的方法，并触发切面的执行。

总结：
Spring AOP提供了多种方式来进行切面编程，常见的切入点表达式包括execution、within、this、target、args、@annotation等。我们可以通过XML配置文件或注解的方式来声明切面，并在切面类中定义通知方法。最后，我们可以通过Spring容器获取目标对象的代理对象，并使用代理对象来调用目标方法，从而触发切面的执行。
1年前 0条评论