# 5.4.3. 声明切入点

切入点确定连接点，从而使我们能够控制通知何时运行。Spring AOP 仅支持 Spring bean 的方法执行连接点，因此您可以将切入点视为匹配 Spring bean 上的方法执行。切入点声明有两部分：一个包含名称和任何参数的签名和一个切入点表达式，它准确地确定我们感兴趣的方法执行。在 AOP 的 @AspectJ 注解样式中，切入点签名由常规方法定义提供, 切入点表达式使用`@Pointcut`注解表示（作为切入点签名的方法必须有`void`返回类型）。

一个示例可能有助于明确切入点签名和切入点表达式之间的区别。以下示例定义了一个名为的切入点`anyOldTransfer`，它与任何名为`transfer` 的方法的执行相匹配：

```java
@Pointcut("execution(* transfer(..))") // the pointcut expression
private void anyOldTransfer() {} // the pointcut signature
```

形成`@Pointcut`注解值的切入点表达式是常规的 AspectJ 切入点表达式。有关 AspectJ 切入点语言的完整讨论，请参阅[AspectJ Programming Guide](https://www.eclipse.org/aspectj/doc/released/progguide/index.html)（以及扩展的 [AspectJ 5 Developer's Notebook](https://www.eclipse.org/aspectj/doc/released/adk15notebook/index.html)）或有关 AspectJ 的书籍之一（例如Colyer 等人的*Eclipse AspectJ或\*\*AspectJ in Action*，拉姆尼瓦斯·拉达德）。

**支持的切入点指示符**

Spring AOP 支持在切入点表达式中使用以下 AspectJ 切入点指示符 (PCD)：

* `execution`：用于匹配方法执行连接点。这是使用 Spring AOP 时使用的主要切入点指示符。
* `within`: 限制匹配到特定类型内的连接点（使用 Spring AOP 时执行匹配类型内声明的方法）。
* `this`：限制匹配到连接点（使用 Spring AOP 时方法的执行），其中 bean 引用（Spring AOP 代理）是给定类型的实例。
* `target`：将匹配限制在目标对象（被代理的应用程序对象）是给定类型的实例的连接点（使用 Spring AOP 时方法的执行）。
* `args`: 限制匹配到参数是给定类型的实例的连接点（使用 Spring AOP 时方法的执行）。
* `@target`：限制匹配到连接点（使用 Spring AOP 时方法的执行），其中执行对象的类具有给定类型的注解。
* `@args`：将匹配限制为连接点（使用 Spring AOP 时方法的执行），其中传递的实际参数的运行时类型具有给定类型的注解。
* `@within`：将匹配限制为具有给定注解的类型内的连接点（使用 Spring AOP 时执行在具有给定注解的类型中声明的方法）。
* `@annotation`：限制匹配到连接点的主题（在 Spring AOP 中运行的方法）具有给定注解的连接点。

其他切入点类型

完整的 AspectJ 切入点语言支持 Spring 中不支持的其他切入点指示符：`call`、`get`、`set`、`preinitialization`、 `staticinitialization`、`initialization`、`handler`、`adviceexecution`、`withincode`、`cflow`、 `cflowbelow`、`if`、`@this`和`@withincode`。在 Spring AOP 解释的切入点表达式中使用这些切入点指示符会导致抛出`IllegalArgumentException`异常。

Spring AOP 支持的切入点指示符集可能会在未来的版本中扩展，以支持更多的 AspectJ 切入点指示符。

由于 Spring AOP 将匹配限制为仅方法执行连接点，因此前面对切入点指示符的讨论给出了比您在 AspectJ 编程指南中找到的更窄的定义。此外，AspectJ 本身具有基于类型的语义，并且在执行连接点处，`this`和`target`两者都引用同一个对象：执行方法的对象。Spring AOP 是一个基于代理的系统，它区分代理对象本身（绑定到`this`）和代理背后的目标对象（绑定到`target`）。

由于 Spring 的 AOP 框架基于代理的特性，根据定义，目标对象内的调用不会被拦截。对于 JDK 代理，只能拦截代理上的公共接口方法调用。使用 CGLIB，代理上的公共和受保护的方法调用被拦截（如果需要，甚至包可见的方法）。但是，通过代理的常见交互应始终通过公共签名进行设计。请注意，切入点定义通常与任何拦截的方法匹配。如果切入点严格来说是只公开的，即使在 CGLIB 代理场景中，通过代理进行潜在的非公开交互，也需要相应地定义它。如果您的拦截需求包括目标类中的方法调用甚至构造函数，请考虑使用 Spring 驱动的[原生 AspectJ 编织](https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#aop-aj-ltw)，而不是 Spring 的基于代理的 AOP 框架。这就构成了具有不同特点的不同AOP使用模式，所以在做决定之前一定要让自己熟悉编织。

Spring AOP 还支持一个名为`bean`的PCD. 此 PCD 允许您将连接点的匹配限制为特定命名的 Spring bean 或一组命名的 Spring bean（使用通配符时）。`bean` PCD具有以下形式：

```java
bean(idOrNameOfBean)
```

`idOrNameOfBean`令牌可以是任何 Spring bean 的名称。提供了使用`*`字符的有限通配符支持，因此，如果您为 Spring bean 建立了一些命名约定，则可以编写一个`bean`PCD 表达式来选择它们。与其他切入点指示符的情况一样，`bean`PCD 也可以与`&&`(and)、`||`(or) 和`!`(negation) 运算符一起使用。

`bean`PCD 仅在 Spring AOP 中受支持，在本机 AspectJ 编织中不支持。它是 AspectJ 定义的标准 PCD 的特定于 Spring 的扩展，因此不适用于`@Aspect`模型中声明的切面。PCD在`bean`实例级别（基于 Spring bean 名称概念）而不是仅在类型级别（基于编织的 AOP 受限）运行。基于实例的切入点指示符是 Spring 基于代理的 AOP 框架的一种特殊功能，它与 Spring bean 工厂的紧密集成，通过名称来识别特定的 bean 是自然而直接的。

**组合切入点表达式**

您可以使用`&&`，`||` 和`!`组合切入点表达式。您还可以按名称引用切入点表达式。以下示例显示了三个切入点表达式：

```java
@Pointcut("execution(public * *(..))")
private void anyPublicOperation() {} 

@Pointcut("within(com.xyz.myapp.trading..*)")
private void inTrading() {} 

@Pointcut("anyPublicOperation() && inTrading()")
private void tradingOperation() {} 
```

如前所述，使用较小的命名组件构建更复杂的切入点表达式是最佳实践。当按名称引用切入点时，应用正常的 Java 可见性规则（您可以看到相同类型的私有切入点、层次结构中的受保护切入点、任何地方的公共切入点，等等）。可见性不影响切入点匹配。

**共享通用切入点定义**

在使用企业应用程序时，开发人员通常希望从多个切面引用应用程序的模块和特定的操作集。我们通知为此目的定义一个捕获通用切入点表达式的`CommonPointcuts`切面。这样的切面通常类似于以下示例：

```java
package com.xyz.myapp;

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

@Aspect
public class CommonPointcuts {

    /**
     * A join point is in the web layer if the method is defined
     * in a type in the com.xyz.myapp.web package or any sub-package
     * under that.
     */
    @Pointcut("within(com.xyz.myapp.web..*)")
    public void inWebLayer() {}

    /**
     * A join point is in the service layer if the method is defined
     * in a type in the com.xyz.myapp.service package or any sub-package
     * under that.
     */
    @Pointcut("within(com.xyz.myapp.service..*)")
    public void inServiceLayer() {}

    /**
     * A join point is in the data access layer if the method is defined
     * in a type in the com.xyz.myapp.dao package or any sub-package
     * under that.
     */
    @Pointcut("within(com.xyz.myapp.dao..*)")
    public void inDataAccessLayer() {}

    /**
     * A business service is the execution of any method defined on a service
     * interface. This definition assumes that interfaces are placed in the
     * "service" package, and that implementation types are in sub-packages.
     *
     * If you group service interfaces by functional area (for example,
     * in packages com.xyz.myapp.abc.service and com.xyz.myapp.def.service) then
     * the pointcut expression "execution(* com.xyz.myapp..service.*.*(..))"
     * could be used instead.
     *
     * Alternatively, you can write the expression using the 'bean'
     * PCD, like so "bean(*Service)". (This assumes that you have
     * named your Spring service beans in a consistent fashion.)
     */
    @Pointcut("execution(* com.xyz.myapp..service.*.*(..))")
    public void businessService() {}

    /**
     * A data access operation is the execution of any method defined on a
     * dao interface. This definition assumes that interfaces are placed in the
     * "dao" package, and that implementation types are in sub-packages.
     */
    @Pointcut("execution(* com.xyz.myapp.dao.*.*(..))")
    public void dataAccessOperation() {}

}
```

您可以在需要切入点表达式的任何地方引用在此类切面中定义的切入点。例如，要使服务层具有事务性，您可以编写以下代码：

```xml
<aop:config>
    <aop:advisor
        pointcut="com.xyz.myapp.CommonPointcuts.businessService()"
        advice-ref="tx-advice"/>
</aop:config>

<tx:advice id="tx-advice">
    <tx:attributes>
        <tx:method name="*" propagation="REQUIRED"/>
    </tx:attributes>
</tx:advice>
```

`<aop:config>`和`<aop:advisor>`元素在基于[模式的 AOP 支持](https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#aop-schema)中讨论。事务元素在[事务管理](https://docs.spring.io/spring-framework/docs/current/reference/html/data-access.html#transaction)中讨论。

**例子**

Spring AOP 用户可能`execution`最常使用切入点指示符。执行表达式的格式如下：

```
execution(modifiers-pattern?
			ret-type-pattern
			declaring-type-pattern?name-pattern(param-pattern)
			throws-pattern?)
```

除了返回类型模式（在`ret-type-pattern`前面的代码片段中）、名称模式和参数模式之外的所有部分都是可选的。返回类型模式确定方法的返回类型必须是什么才能匹配连接点。 `*`最常用作返回类型模式。它匹配任何返回类型。仅当方法返回给定类型时，完全限定的类型名称才匹配。名称模式与方法名称匹配。您可以将`*`通配符用作名称模式的全部或一部分。如果您指定声明类型模式，请包含一个尾随`.`以将其连接到名称模式组件。参数模式稍微复杂一些：`()`匹配不带参数的方法，而`(..)`匹配任意数量（零个或多个）的参数。该`(*)`模式匹配采用任何类型的一个参数的方法。 `(*,String)`匹配带有两个参数的方法。第一个可以是任何类型，而第二个必须是`String`. 有关更多信息，请参阅 AspectJ 编程指南的 [语言语义](https://www.eclipse.org/aspectj/doc/released/progguide/semantics-pointcuts.html)部分。

以下示例显示了一些常见的切入点表达式：

* 任何公共方法的执行：

  ```
  execution(public * *(..))
  ```
* 名称以 开头的任何方法的执行`set`：

  ```
  execution(public * *(..))
  ```
* `AccountService`接口定义的任何方法的执行：

  ```
  execution(* com.xyz.service.AccountService.*(..))
  ```
* 包中定义的任何方法的执行`service`：

  ```
  execution(* com.xyz.service.*.*(..))
  ```
* 服务包或其子包之一中定义的任何方法的执行：

  ```
  execution(* com.xyz.service..*.*(..))
  ```
* 服务包中的任何连接点（仅在 Spring AOP 中执行方法）：

  ```
  within(com.xyz.service.*)
  ```
* 服务包或其子包之一中的任何连接点（仅在 Spring AOP 中执行方法）：

  ```
  within(com.xyz.service..*)
  ```
* `AccountService`代理实现接口的任何连接点（仅在 Spring AOP 中执行方法） ：

  ```
  this(com.xyz.service.AccountService)
  ```

  `this`更常用于绑定形式。 有关如何使代理对象在通知正文中可用的信息， 请参阅[声明通知部分。](https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#aop-advice)
* `AccountService`目标对象实现接口的任何连接点（仅在 Spring AOP 中执行方法） ：

  ```
  target(com.xyz.service.AccountService)
  ```

  `target`更常用于绑定形式。有关如何使目标对象在通知正文中可用的信息， 请参阅[声明通知部分。](https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#aop-advice)
* 任何接受单个参数且在运行时传递的参数为`Serializable`的连接点（仅在 Spring AOP 中执行方法）：

  ```
  args(java.io.Serializable)
  ```

  `args`更常用于绑定形式。请参阅[声明通知](https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#aop-advice)部分，了解如何使方法参数在通知正文中可用。

  请注意，此示例中给出的切入点与`execution(* *(java.io.Serializable))`. 如果在运行时传递的参数是 `Serializable`则args 版本匹配，如果方法签名声明了一个`Serializable`类型的参数，则执行版本匹配。
* 目标对象具有 `@Transactional`注解的任何连接点（仅在 Spring AOP 中执行方法）：

  ```
  @target(org.springframework.transaction.annotation.Transactional)
  ```

  您也可以`@target`在绑定表单中使用。有关如何使注解对象在通知正文中可用的信息， 请参阅[声明通知部分。](https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#aop-advice)
* 目标对象的声明类型具有`@Transactional`注解的任何连接点（仅在 Spring AOP 中执行方法）：

  ```
  @within(org.springframework.transaction.annotation.Transactional)
  ```

  您也可以在绑定表单中使用`@within`。有关如何使注解对象在通知正文中可用的信息， 请参阅[声明通知部分。](https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#aop-advice)
* 执行方法具有 `@Transactional`注解的任何连接点（仅在 Spring AOP 中执行方法）：

  ```
  @annotation(org.springframework.transaction.annotation.Transactional)
  ```

  您也可以在绑定表单中使用`@annotation`。有关如何使注解对象在通知正文中可用的信息， 请参阅[声明通知部分。](https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#aop-advice)
* 任何接受单个参数的连接点（仅在 Spring AOP 中执行方法），并且传递的参数的运行时类型具有`@Classified`注解：

  ```
  @args(com.xyz.security.Classified)
  ```

  您也可以在绑定表单中使用`@args`。请参阅[声明通知](https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#aop-advice)部分如何使注解对象在通知正文中可用。
* Spring bean 上的任何连接点（方法仅在 Spring AOP 中执行）名为 `tradeService`：

  ```
  bean(tradeService)
  ```
* 名称与`*Service`通配符表达式匹配的 Spring bean 上的任何连接点（仅在 Spring AOP 中执行方法）：

  ```
  bean(*Service)
  ```

**编写好的切入点**

在编译期间，AspectJ 处理切入点以优化匹配性能。检查代码并确定每个连接点是否（静态或动态）匹配给定的切入点是一个代价高昂的过程。（动态匹配意味着无法从静态分析中完全确定匹配，并且在代码中放置测试以确定代码运行时是否存在实际匹配）。在第一次遇到切入点声明时，AspectJ 将其重写为匹配过程的最佳形式。这是什么意思？基本上，切入点在 DNF（析取范式）中被重写，切入点的组件被排序，以便首先检查那些评估成本较低的组件。

然而，AspectJ 只能使用它被告知的内容。为了获得最佳匹配性能，您应该考虑他们试图实现的目标，并在定义中尽可能缩小匹配的搜索空间。现有的指示符自然属于以下三组之一：kinded、scoping 和 contextual：

* 种类指示符选择一种特定类型的连接点： `execution`、`get`、`set`、`call`和`handler`。
* 范围指示符选择一组连接兴趣点（可能有多种）：`within`和`withincode`
* 上下文指示符根据上下文匹配（并且可以选择绑定）： `this`、、`target`和`@annotation`

一个写得很好的切入点应该至少包括前两种类型（种类和范围）。您可以包含上下文指示符以根据连接点上下文进行匹配，或绑定该上下文以在通知中使用。由于额外的处理和分析，只提供一个 kinded 指示符或只提供一个上下文指示符是可行的，但可能会影响编织性能（使用的时间和内存）。范围指示符的匹配速度非常快，使用它们意味着 AspectJ 可以非常快速地消除不应进一步处理的连接点组。如果可能，一个好的切入点应始终包含一个切入点。