🍊
翻译橙
🍊返回主站🤖参与贡献
  • hello,这里是翻译橙
  • spring boot参考文档
    • 1. 法律
    • 2. 寻求帮助
    • 3. 文档概述
    • 4. 入门
    • 5. 升级Spring Boot
    • 6. 使用 Spring Boot 进行开发
      • 6.1. 构建系统
      • 6.2. 构建你的代码
      • 6.3. 配置类
      • 6.4. 自动配置
      • 6.5. Spring Bean 和依赖注入
      • 6.6. 使用@SpringBootApplication注解
      • 6.7. 运行您的应用程序
      • 6.8. 开发者工具
      • 6.9. 打包您的生产应用程序
      • 6.10. 接下来读什么
    • 7.核心特性
      • 7.1. SpringApplication
      • 7.2. 外部化配置
      • 7.3.Profile配置
      • 7.4.日志记录
      • 7.5.国际化
      • 7.6 面向切面的编程
      • 7.7. JSON
      • 7.8. 任务执行与调度
      • 7.9. 单元测试
        • 7.9.1. 测试范围依赖
        • 7.9.2. 测试 Spring 应用程序
        • 7.9.3. 测试 Spring Boot 应用程序
        • 7.9.4. 测试容器
        • 7.9.5. 测试工具
      • 7.10. Docker Compose 支持
      • 7.11. 测试容器支持
      • 7.12. 创建您自己的自动配置
      • 7.13. Kotlin 支持
      • 7.14 SSL
      • 7.15.接下来要读什么
    • 8. 网络
      • 8.1. Servlet Web 应用程序
        • 8.1.1. “Spring Web MVC 框架”
        • 8.1.2. JAX-RS 和Jersey
        • 8.1.3. 嵌入式 Servlet 容器支持
      • 8.2 反应式网络应用程序
        • 8.2.1. “Spring WebFlux 框架”
        • 8.2.2. 嵌入式反应式服务器支持
        • 8.2.3. 反应式服务器资源配置
      • 8.3. 优雅关机
      • 8.4. spring安全
        • 8.4.1. MVC安全
        • 8.4.2. WebFlux 安全
        • 8.4.3. OAuth2
        • 8.4.4. SAML 2.0
      • 8.5. spring 会话
      • 8.6.GraphQL
      • 8.7. Spring HATEOAS
      • 8.8.接下来读什么
    • 9. 数据
      • 9.1. SQL数据库
      • 9.2. 使用 NoSQL 技术
      • 9.3. 接下来读什么
    • 10. 消息
      • 10.1. JMS
      • 10.2. AMQP
      • 10.3. Apache Kafka 支持
      • 10.4. Apache Pulsar 支持
      • 10.5. RSocket
      • 10.6. Spring Integration
      • 10.7. WebSockets
      • 10.8. What to Read Next
    • 11. IO
      • 11.1. 缓存
      • 11.2. Hazelcast
      • 11.3. Quartz 调度程序
      • 11.4. 发送电子邮件
      • 11.5. 验证
      • 11.6. 调用 REST 服务
      • 11.7. web services
      • 11.8. 使用 JTA 进行分布式事务
      • 11.9. 接下来读什么
    • 12. 容器镜像
  • Spring核心功能
    • 1.IOC容器和Bean简介
      • 1.2. 容器概述
      • 1.3. Bean概述
      • 1.4. 依赖项
        • 1.4.1. 依赖注入
        • 1.4.2. 详细的依赖关系和配置
        • 1.4.3. 使用depends-on
        • 1.4.4. 延迟初始化的 Bean
        • 1.4.5. 自动装配协作者
        • 1.4.6. 方法注入
    • 2. Resources
      • 2.1. 介绍
      • 2.2. Resource接口
      • 2.3. 内置Resource实现
      • 2.4. ResourceLoader接口
      • 2.5. ResourcePatternResolver接口
      • 2.6. ResourceLoaderAware接口
      • 2.7. 资源作为依赖
      • 2.8. 应用程序上下文和资源路径
    • 3. 验证、数据绑定和类型转换
      • 3.1. 使用 Spring 的 Validator 接口进行验证
      • 3.2. 将代码解析为错误消息
      • 3.3. Bean 操作和BeanWrapper
      • 3.4. spring类型转换
      • 3.5. spring字段格式
      • 3.6. 配置全局日期和时间格式
      • 3.7. Java Bean 验证
    • 4. SpEL表达式
    • 5. Spring 面向切面编程
      • 5.1. AOP 概念
      • 5.2. Spring AOP 的能力和目标
      • 5.3. AOP 代理
      • 5.4. @AspectJ 支持
        • 5.4.1. 启用@AspectJ 支持
        • 5.4.2. 声明一个切面
        • 5.4.3. 声明切入点
        • 5.4.4. 声明切点
        • 5.4.5. 切面说明
        • 5.4.6. 切面实例化模型
        • 5.4.7. AOP 示例
      • 5.5. 基于模式的 AOP 支持
      • 5.6. 选择要使用的 AOP 声明样式
      • 5.7. 混合切面类型
      • 5.8. 代理机制
      • 5.9. @AspectJ 代理的程序化创建
      • 5.10. 在 Spring 应用程序中使用 AspectJ
      • 5.11.更多资源
    • 6. Spring AOP API
      • 6.1. Spring中的切入点API
      • 6.2. Spring 中的 Advice API
      • 6.3. Spring 中的 Advisor API
      • 6.4. 使用ProxyFactoryBean创建 AOP 代理
      • 6.5. 简洁的代理定义
      • 6.6. 以编程方式创建 AOP 代理ProxyFactory
      • 6.7. 操作切面对象
      • 6.8. 使用“自动代理”工具
      • 6.9. 使用TargetSource实现
      • 6.10. 定义新的切面类型
    • 7. 空指针安全
    • 8. 数据缓冲器和编解码器
    • 9. 日志
    • 10. 附录
      • 10.1. XML 模式
      • 10.2. 自定义XML Schema
        • 10.2.1. 创作 Schema
        • 10.2.2. 编码一个NamespaceHandler
        • 10.2.3. 使用BeanDefinitionParser
        • 10.2.4. 注册处理程序和模式
        • 10.2.5. 在 Spring XML 配置中使用自定义扩展
        • 10.2.6. 更详细的例子
      • 10.3. 应用程序启动步骤
  • 使用redis实现分布式锁
  • Java 安全标准算法名称
  • JDK 9 JEP
  • JDK 10 JEP
  • 人件
    • 《人件》
    • 第一部分 管理人力资源
      • 01 此时此刻,一个项目正在走向失败
      • 02 干酪汉堡,做一个,卖一个
      • 03 维也纳在等你
      • 04 质量——如果时间允许
      • 05 再谈帕金森定律
      • 06 苦杏素
    • 第二部分 办公环境
      • 07 家具警察
      • 08 “朝九晚五在这里啥也完成不了。”
      • 09 在空间上省钱
      • 间奏曲:生产效率度量和不明飞行物
      • 10 大脑时问与身体时间
      • 11 电话
      • 12 门的回归
      • 13 采取保护步骤
    • 第三部分 正确的人
      • 14 霍恩布洛尔因素
      • 15 谈谈领导力
      • 16 雇一名杂耍演员
      • 17 与他人良好合作
      • 18 童年的终结
      • 19 在这儿很开心
      • 20 人力资本
    • 第四部分 高效团队养成
      • 21 整体大于部分之和
      • 22 黑衣团队
      • 23 团队自毁
      • 24 再谈团队自毁
      • 25 竞争
      • 26 一顿意面晚餐
      • 27 敞开和服
      • 28 团队形成的化学反应
    • 第五部分 沃土
      • 29 自我愈复系统
      • 30 与风险共舞
      • 3l 会议、独白和交流
      • 32 终极管理罪恶得主是……
      • 33 “邪恶”电邮
      • 34 让改变成为可能
      • 35 组织型学习
      • 36 构建社区
    • 第六部分 快乐地工作
      • 37 混乱与秩序
      • 38 自由电子
      • 39 霍尔加·丹斯克
由 GitBook 提供支持
在本页

这有帮助吗?

在GitHub上编辑
  1. Spring核心功能
  2. 6. Spring AOP API

6.4. 使用ProxyFactoryBean创建 AOP 代理

上一页6.3. Spring 中的 Advisor API下一页6.5. 简洁的代理定义

最后更新于1年前

这有帮助吗?

如果您将 Spring IoC 容器(ApplicationContext或BeanFactory)用于您的业务对象(您应该这样做!),您希望使用 Spring 的 AOP FactoryBean实现之一。(请记住,工厂 bean 引入了一个间接层,让它创建不同类型的对象。)

Spring AOP 支持也在幕后使用了工厂 bean。 |

在 Spring 中创建 AOP 代理的基本方法是使用 org.springframework.aop.framework.ProxyFactoryBean. 这可以完全控制切入点、任何适用的切面及其顺序。但是,如果您不需要此类控制,则可以使用更简单的选项。

6.4.1. 基本

与其他 SpringFactoryBean实现一样,ProxyFactoryBean引入了间接级别。如果定义名为 foo 的 ProxyFactoryBean,则引用 foo 的对象不会看到 ProxyFactoryBean 实例本身,而是看到由 ProxyFactoryBean 中的getObject()方法的实现创建的对象。此方法创建一个包装目标对象的 AOP 代理。

使用一个ProxyFactoryBean或另一个 IoC 感知类来创建 AOP 代理的最重要的好处之一是切面和切入点也可以由 IoC 管理。这是一个强大的特性,可以实现其他 AOP 框架难以实现的某些方法。例如,一个通知本身可能引用应用程序对象(除了目标,它应该在任何 AOP 框架中都可用),受益于依赖注入提供的所有可插入性。

6.4.2. JavaBean 属性

与 Spring 提供的大多数FactoryBean实现一样, ProxyFactoryBean该类本身就是一个 JavaBean。它的属性用于:

  • 指定要代理的目标。

  • 指定是否使用 CGLIB(稍后描述,另请参见)。

一些关键属性继承自org.springframework.aop.framework.ProxyConfig (Spring 中所有 AOP 代理工厂的超类)。这些关键属性包括:

  • proxyTargetClass:true:如果要代理目标类,而不是目标类的接口。如果此属性值设置为true,则创建 CGLIB 代理(另请参阅)。

  • optimize:控制是否对通过 CGLIB 创建的代理应用积极优化。除非您完全了解相关的 AOP 代理如何处理优化,否则您不应轻率地使用此设置。这目前仅用于 CGLIB 代理。它对 JDK 动态代理没有影响。

  • frozen:如果代理配置是frozen,则不再允许更改配置。这对于轻微的优化和在创建代理后不希望调用者能够操纵代理(通过Advised 接口)的情况都很有用。此属性的默认值为 false,因此允许更改(例如添加额外的切面)。

  • exposeProxy:确定当前代理是否应该在ThreadLocal中公开, 以便目标可以访问它。如果目标需要获取代理并且exposeProxy属性设置为true,目标可以使用该 AopContext.currentProxy()方法。

ProxyFactoryBean其他属性具体包括以下内容:

  • proxyInterfaces:String类型的接口名称数组。如果未提供,则使用目标类的 CGLIB 代理(但另请参阅)。

  • interceptorNames:要应用的 、拦截器或其他切面名称的String数组。Advisor订购很重要,先到先得。也就是说列表中的第一个拦截器是第一个能够拦截调用的。

    这些名称是当前工厂中的 bean 名称,包括来自祖先工厂的 bean 名称。您不能在此处提及 bean 引用,因为这样做会导致 ProxyFactoryBean忽略通知的单例设置。

    您可以附加一个带有星号 ( *) 的拦截器名称。这样做会导致应用名称以要应用的星号之前的部分开头的所有Advisor bean。中找到使用此功能的示例。

  • 单例:工厂是否应该返回单个对象,无论getObject()方法被调用的频率如何。几个FactoryBean实现提供了这样的方法。默认值为true。如果你想使用有状态的切面——例如,对于有状态的 mixins——使用原型切面和 false.

6.4.3. 基于 JDK 和 CGLIB 的代理

本节是关于如何ProxyFactoryBean 选择为特定目标对象(将被代理)创建基于 JDK 的代理或基于 CGLIB 的代理的权威文档。

在 Spring 的 1.2.x 和 2.0 版本之间,创建基于 JDK 或 CGLIB 的代理 ProxyFactoryBean的行为发生了变化。现在ProxyFactoryBean在自动检测接口方面表现出与TransactionProxyFactoryBean类相似的语义 。

如果要代理的目标对象的类(以下简称目标类)没有实现任何接口,则创建基于CGLIB的代理。这是最简单的场景,因为 JDK 代理是基于接口的,没有接口意味着 JDK 代理甚至是不可能的。您可以插入目标 bean 并通过设置interceptorNames属性来指定拦截器列表。请注意,即使 ProxyFactoryBean的proxyTargetClass属性已设置为false,也会创建基于 CGLIB 的代理。(这样做毫无意义,最好从 bean 定义中删除,因为它充其量是多余的,最坏的情况是令人困惑。)

如果目标类实现一个(或多个)接口,则创建的代理类型取决于ProxyFactoryBean.

如果 ProxyFactoryBean的proxyTargetClass属性已设置为true,则创建基于 CGLIB 的代理。这是有道理的,并且符合最小意外原则。即使ProxyFactoryBean 的proxyInterfaces属性 已设置为一个或多个完全限定的接口名称,该proxyTargetClass属性设置为true这一事实也会导致基于 CGLIB 的代理生效。

如果 ProxyFactoryBean的proxyInterfaces属性已设置为一个或多个完全限定的接口名称,则会创建一个基于 JDK 的代理。proxyInterfaces 创建的代理实现了属性中指定的所有接口。如果目标类碰巧实现了比proxyInterfaces属性中指定的接口多得多的接口,那很好,但是返回的代理不会实现这些额外的接口。

如果 ProxyFactoryBean 的 proxyInterfaces 属性尚未设置,但目标类确实实现了一个(或多个)接口,则 ProxyFactoryBean 会自动检测目标类确实至少实现了一个接口,并且基于 JDK 的代理被建造。实际被代理的接口是目标类实现的所有接口。实际上,这与向 proxyInterfaces 属性提供目标类实现的每个接口的列表相同。然而,它的工作量明显减少,并且不太容易出现印刷错误。

6.4.4. 代理接口

考虑一个简单的例子ProxyFactoryBean。此示例涉及:

  • 被代理的目标 bean。这是personTarget示例中的 bean 定义。

  • Advisor和 Interceptor用于提供切面。

  • 一个 AOP 代理 bean 定义,用于指定目标对象(personTargetbean)、要代理的接口以及要应用的切面。

以下清单显示了该示例:

<bean id="personTarget" class="com.mycompany.PersonImpl">
    <property name="name" value="Tony"/>
    <property name="age" value="51"/>
</bean>

<bean id="myAdvisor" class="com.mycompany.MyAdvisor">
    <property name="someProperty" value="Custom string property value"/>
</bean>

<bean id="debugInterceptor" class="org.springframework.aop.interceptor.DebugInterceptor">
</bean>

<bean id="person"
    class="org.springframework.aop.framework.ProxyFactoryBean">
    <property name="proxyInterfaces" value="com.mycompany.Person"/>

    <property name="target" ref="personTarget"/>
    <property name="interceptorNames">
        <list>
            <value>myAdvisor</value>
            <value>debugInterceptor</value>
        </list>
    </property>
</bean>

请注意,该interceptorNames属性需要一个 String列表,其中包含当前工厂中拦截器或Advisor的 bean 名称。您可以在返回之前、之后使用Advisor、拦截器和抛出切面对象。Advisor的顺序很重要。

您可能想知道为什么该列表不包含 bean 引用。这样做的原因是,如果ProxyFactoryBean 的单例属性设置为false,它必须能够返回独立的代理实例。如果任何Advisor本身是原型,则需要返回一个独立的实例,因此必须能够从工厂获取原型的实例。持有参考资料是不够的。

前面显示的personbean 定义可以用来代替Person实现,如下所示:

Person person = (Person) factory.getBean("person");

同一个 IoC 上下文中的其他 bean 可以表达对它的强类型依赖,就像普通的 Java 对象一样。以下示例显示了如何执行此操作:

<bean id="personUser" class="com.mycompany.PersonUser">
    <property name="person"><ref bean="person"/></property>
</bean>

此示例中的PersonUser类公开了一个类型为Person 的属性。就它而言,可以透明地使用 AOP 代理来代替“真实”的人员实现。但是,它的类将是一个动态代理类。可以将其转换为Advised接口(稍后讨论)。

您可以使用匿名内部 bean 隐藏目标和代理之间的区别。只是ProxyFactoryBean定义不同。该切面仅出于完整性考虑。以下示例显示了如何使用匿名内部 bean:

<bean id="myAdvisor" class="com.mycompany.MyAdvisor">
    <property name="someProperty" value="Custom string property value"/>
</bean>

<bean id="debugInterceptor" class="org.springframework.aop.interceptor.DebugInterceptor"/>

<bean id="person" class="org.springframework.aop.framework.ProxyFactoryBean">
    <property name="proxyInterfaces" value="com.mycompany.Person"/>
    <!-- Use inner bean, not local reference to target -->
    <property name="target">
        <bean class="com.mycompany.PersonImpl">
            <property name="name" value="Tony"/>
            <property name="age" value="51"/>
        </bean>
    </property>
    <property name="interceptorNames">
        <list>
            <value>myAdvisor</value>
            <value>debugInterceptor</value>
        </list>
    </property>
</bean>

使用匿名内部 bean 的优点是只有一个类型的对象Person。如果我们想要阻止应用程序上下文的用户获取对不切面的对象的引用,或者需要避免 Spring IoC 自动装配的任何歧义,这很有用。可以说,还有一个优点是ProxyFactoryBean定义是独立的。但是,有时能够从工厂获得不切面的目标实际上可能是一种优势(例如,在某些测试场景中)。

6.4.5. 代理类

如果您需要代理一个类而不是一个或多个接口怎么办?

想象一下,在我们前面的示例中,没有 Person 接口。我们需要建议一个名为Person的类,它没有实现任何业务接口。在这种情况下,您可以将 Spring 配置为使用 CGLIB 代理而不是动态代理。为此,请将前面显示的 ProxyFactoryBean 上的 proxyTargetClass 属性设置为 true。虽然最好对接口而不是类进行编程,但在处理遗留代码时,建议未实现接口的类的能力可能会很有用。 (一般来说,Spring 不是规定性的。虽然它使应用良好实践变得容易,但它避免了强制采用特定的方法。)

如果你愿意,你可以在任何情况下强制使用 CGLIB,即使你有接口。

CGLIB 代理通过在运行时生成目标类的子类来工作。Spring 将这个生成的子类配置为将方法调用委托给原始目标。子类用于实现装饰器模式,编织在通知中。

CGLIB 代理通常应该对用户透明。但是,有一些问题需要考虑:

  • Final类不能被代理,因为他们无法拓展

  • final方法不能被切面,因为他们无法被覆写

  • private方法不能被切面,因为他们无法被覆写

无需将 CGLIB 添加到您的类路径中。从 Spring 3.2 开始,CGLIB 被重新打包并包含在 spring-core JAR 中。换句话说,基于 CGLIB 的 AOP 像 JDK 动态代理一样“开箱即用”。

CGLIB 代理和动态代理之间几乎没有性能差异。在这种情况下,性能不应成为决定性的考虑因素。

6.4.6. 使用“全局”Advisor

通过将星号附加到拦截器名称,所有具有与星号之前的部分匹配的 bean 名称的Advisor都将添加到Advisor链中。如果您需要添加一组标准的“全局”Advisor,这会派上用场。以下示例定义了两个全局Advisor:

<bean id="proxy" class="org.springframework.aop.framework.ProxyFactoryBean">
    <property name="target" ref="service"/>
    <property name="interceptorNames">
        <list>
            <value>global*</value>
        </list>
    </property>
</bean>

<bean id="global_debug" class="org.springframework.aop.interceptor.DebugInterceptor"/>
<bean id="global_performance" class="org.springframework.aop.interceptor.PerformanceMonitorInterceptor"/>
基于 JDK 和 CGLIB 的代理
基于 JDK 和 CGLIB 的代理
基于 JDK 和 CGLIB 的代理
您可以在使用“全局”Advisor