spring aop

最新推荐文章于 2025-05-25 22:25:05 发布
最新推荐文章于 2025-05-25 22:25:05 发布
阅读量69 收藏
点赞数
分类专栏： 所谓技术 文章标签： AOP Spring Bean XML 编程
本文深入探讨了面向切面编程(AOP)的概念和技术实现，包括静态代理、动态代理、Advice类型及Pointcut的应用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

 一，从代理机制初探AOP
  1，使用静态代理

#代理对象和被代理对象必须实现共同的接口
package com.biaoflying;

public interface IHello {
    public void hello(String name);
}

 

#代理对象HelloProxy
package com.biaoflying;

import java.util.logging.*;

public class HelloProxy implements IHello {
    private IHello helloObject;
    private Logger logger=
        Logger.getLogger(this.getClass().getName());
    
    public HelloProxy(IHello helloObject){
        this.helloObject=helloObject;
    }
    public void hello(String name){
        log("hello method starts....");
        helloObject.hello(name);
        log("hello method ends....");
    }
    
    private void log(String msg){
        logger.log(Level.INFO,msg);
    }
}

 

#HelloSpeaker被代理对象
package com.biaoflying;

public class HelloSpeaker implements IHello {
    public void hello(String name){
        System.out.println("Hello "+name);
    }
}

 

#主程序
package com.biaoflying;

public class ProxyDemo {
    public static void main(String[] args){
        HelloProxy proxy=
            new HelloProxy(new HelloSpeaker());
        proxy.hello("biaoflying");
    }
}

 

#执行ProxyDemo的输出
信息: hello method starts....
Hello biaoflying
2008-3-21 9:05:40 com.biaoflying.HelloProxy log
信息: hello method ends....


  TIP:使用静态代理，代理对象和被代理对象必须实现共同的接口。本质上就是由代理对象呼叫被代理对象并执行相关的逻辑。同时可以看到，静态代理在程序规模稍大时就无法胜任了。

-----------------------------------------------------------------------------------

  2，动态代理

  去掉HelloProxy.java，编写以下的LogHandler.java文件。

package com.biaoflying;

import java.util.logging.*;
import java.lang.reflect.*;

public class LogHandler implements InvocationHandler{
    private Logger logger=
        Logger.getLogger(this.getClass().getName());
    
    private Object delegate;
    
    public Object bind(Object delegate){
        this.delegate=delegate;
        return Proxy.newProxyInstance(
                delegate.getClass().getClassLoader(),
                delegate.getClass().getInterfaces(),
                this);
    }
    public Object invoke(Object proxy,Method method,
            Object[] args)throws Throwable{
        Object result = null;
        try{
            log("method starts..."+method);
            result=method.invoke(delegate,args);
            logger.log(Level.INFO,"method ends..."+method);
        }catch(Exception e){
            log(e.toString());
        }
    return result;
    }
    private void log(String msg){
        logger.log(Level.INFO,msg);
}
}

 

#主程序
package com.biaoflying;

public class ProxyDemo2 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        LogHandler logHandler=new LogHandler();
        IHello helloProxy=
            (IHello)logHandler.bind(new HelloSpeaker());
        helloProxy.hello("biaoflying");
    }
}


  TIP：动态代理的执行流程是Proxy.newProxyInstance(..,..,this)方法返回一个代理对象，该代理对象每次执行相关的方法时都会委托给this.invoke方法。

-----------------------------------------------------------------------------------

  二，Advices

  由于织入Targets的时机不同，Advices被分为以下几种：Before advice,After advice,Around advice,Throw advice。

#MethodBeforeAdvice接口
package org.springframework.aop;
public interface MethodBeforeAdvice extends BeforeAdvice{
  void before(Method method,Object[] args,Object target)
  throws Throwable;
}

 
  具体的例子，IHello接口和HelloSpeaker.java如上

package com.biaoflying;

import java.lang.reflect.Method;
import java.util.logging.*;
import org.springframework.aop.MethodBeforeAdvice;

public class LogBeforeAdvice
        implements MethodBeforeAdvice{
    private Logger logger=
        Logger.getLogger(this.getClass().getName());
    
    public void before(Method method,Object[] args,
            Object target)throws Throwable{
        logger.log(Level.INFO,"Method starts..."+method);
    }
}

 

package com.biaoflying;

import org.springframework.context.*;
import org.springframework.context.support.*;

public class SpringAOPDemo {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ApplicationContext context=
            new FileSystemXmlApplicationContext(
                    "beans-config.xml");
        IHello helloProxy=(IHello)context.getBean(
                "helloProxy");
        helloProxy.hello("biaoflying");
    }

}

 

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING/DTD BEAN/EN"
 "http://www.springframework.org/dtd/spring-beans.dtd">
 
<beans>
    <bean id="logBeforeAdvice"
        class="com.biaoflying.LogBeforeAdvice"/>
    <bean id="helloSpeaker"
        class="com.biaoflying.HelloSpeaker"/>
        
    <bean id="helloProxy"
        class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="proxyInterfaces">
            <value>com.biaoflying.IHello</value>
        </property>
        <property name="target">
            <ref bean="helloSpeaker"/>
        </property>
        <property name="interceptorNames">
            <list>
                <value>logBeforeAdvice</value>
            </list>
        </property>
    </bean>
</beans>


  执行SpringAOPDemo.java会在hello方法执行之前输出log消息。
  另外对于After advice,Around advice是类似的。

-----------------------------------------------------------------------------------

  三，Throw Advice
 
  表示在目标对象调用方法发生异常时添加一个Aspect。

package com.biaoflying;

public interface IHello {
    public void hello(String name)throws Throwable;
}

 

package com.biaoflying;

public class HelloSpeaker implements IHello {
    public void hello(String name)throws Throwable{
        System.out.println("Hello "+name);
        throw new Exception("发生异常...");
    }
}

 

package com.biaoflying;

import java.lang.reflect.Method;
import java.util.logging.*;
import org.springframework.aop.ThrowsAdvice;

public class SomeThrowAdvice implements ThrowsAdvice{
    private Logger logger=
        Logger.getLogger(this.getClass().getName());
    public void afterThrowing(Method method,Object[] args,Object target,Throwable subclass){
        logger.log(Level.INFO,
                "Logging that a "+subclass+
                "Exception was thrown in "+method);
    }
}

 

package com.biaoflying;

import org.springframework.context.ApplicationContext;
import org.springframework.
    context.support.FileSystemXmlApplicationContext;

public class SpringAOPDemo {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ApplicationContext context=
            new FileSystemXmlApplicationContext(
                    "beans-config.xml");
        IHello helloProxy=
            (IHello)context.getBean("helloProxy");
        try{
            helloProxy.hello("biaoflying");
        }catch(Throwable throwable){
            System.err.println(throwable);
        }
    }
}

 

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING/DTD BEAN/EN"
 "http://www.springframework.org/dtd/spring-beans.dtd">
 
<beans>
    <bean id="someThrowAdvice"
        class="com.biaoflying.SomeThrowAdvice"/>
    
    <bean id="helloSpeaker" class="com.biaoflying.HelloSpeaker"/>
    <bean id="helloProxy"
        class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="proxyInterfaces">
            <value>com.biaoflying.IHello</value>
        </property>
        <property name="target">
            <ref bean="helloSpeaker"/>
        </property>
        <property name="interceptorNames">
            <list>
                <value>someThrowAdvice</value>
            </list>
        </property>
    </bean>
</beans>


  四，更为细化的AOP programming。

  通过定义Ponitcut来实现更为细化的AOP编程，如可以指定在Target的某个方法执行时加入advice。

package com.biaoflying;

public interface IHello {
    public void helloNewbie(String name);
    public void helloMaster(String name);
}

 

package com.biaoflying;

public class HelloSpeaker implements IHello {
    public void helloNewbie(String name){
        System.out.println("Hello "+name+" newbie");
    }
    public void helloMaster(String name){
        System.out.println("Hello "+name+" will be master");
    }
}

 

package com.biaoflying;

import java.lang.reflect.Method;
import java.util.logging.*;
import org.springframework.aop.MethodBeforeAdvice;

public class LogBeforeAdvice
        implements MethodBeforeAdvice{
    private Logger logger=
        Logger.getLogger(this.getClass().getName());
    
    public void before(Method method,Object[] args,
            Object target)throws Throwable{
        logger.log(Level.INFO,"Method starts..."+method);
    }
}

 

package com.biaoflying;

import org.springframework.context.ApplicationContext;
import org.springframework.
    context.support.FileSystemXmlApplicationContext;

public class SpringAOPDemo {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ApplicationContext context=
            new FileSystemXmlApplicationContext(
                    "beans-config1.xml");
        IHello helloProxy=
            (IHello)context.getBean("helloProxy");
        helloProxy.helloNewbie("abio");
        helloProxy.helloMaster("biaoflying");
    }
}

 

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING/DTD BEAN/EN"
 "http://www.springframework.org/dtd/spring-beans.dtd">
 
<beans>
    <bean id="logBeforeAdvice"
        class="com.biaoflying.LogBeforeAdvice"/>
    <bean id="helloAdvisor"
      class="org.springframework.aop.
       support.NameMatchMethodPointcutAdvisor">
        <property name="mappedName">
            <value>hello*</value>
        </property>
        <property name="advice">
            <ref bean="logBeforeAdvice"/>
        </property>
    </bean>
    
    <bean id="helloSpeaker"   class="com.
       biaoflying.HelloSpeaker"/>
    <bean id="helloProxy"
        class="org.springframework.
        aop.framework.ProxyFactoryBean">
        <property name="proxyInterfaces">
            <value>com.biaoflying.IHello</value>
        </property>
        <property name="target">
            <ref bean="helloSpeaker"/>
        </property>
        <property name="interceptorNames">
            <list>
                <value>helloAdvisor</value>
            </list>
        </property>
    </bean>
</beans>


  另外一个静态PointcutAdvisor为RegexpMethodPointcutAdvisor,更改以上的配置：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING/DTD BEAN/EN"
 "http://www.springframework.org/dtd/spring-beans.dtd">
 
<beans>
    <bean id="logBeforeAdvice"
        class="com.biaoflying.LogBeforeAdvice"/>
    <bean id="helloAdvisor"
        class="org.springframework.aop.
          support.RegexpMethodPointcutAdvisor">
        <property name="pattern">
          <value>.*hello.*</value>
        </property>
        <property name="advice">
            <ref bean="logBeforeAdvice"/>
        </property>
    </bean>
    
    <bean id="helloSpeaker"  class="com.biaoflying.
       HelloSpeaker"/>
    <bean id="helloProxy"
        class="org.springframework.
           aop.framework.ProxyFactoryBean">
        <property name="proxyInterfaces">
            <value>com.biaoflying.IHello</value>
        </property>
        <property name="target">
            <ref bean="helloSpeaker"/>
        </property>
        <property name="interceptorNames">
            <list>
                <value>helloAdvisor</value>
            </list>
        </property>
    </bean>
</beans>


  两者都可以得到一下的输出：

信息: Method starts...public abstract void com.biaoflying.IHello.helloNewbie(java.lang.String)
2008-3-22 18:38:22 com.biaoflying.LogBeforeAdvice before
信息: Method starts...public abstract void com.biaoflying.IHello.helloMaster(java.lang.String)
Hello abio newbie
Hello biaoflying will be master



Spring AOP 详解
2301_80035594的博客
10-19 6278
Spring AOP（Aspect-Oriented Programming，面向切面编程）是Spring框架提供的一种编程范式，它允许开发者将横切关注点（如日志、事务管理、权限检查等）与业务逻辑分离，从而提高代码的模块化和可维护性。Spring AOP 基于代理机制实现，它为Spring应用提供了声明式事务管理等功能。
SpringAOP(图文详解)
lhj520cb的博客
07-16 5万+
Spring实现的AOP是代理模式，给调用者使用的实际是已经过加工的对象，你编程时方法体里只写了A，但调用者拿到的对象的方法体却是xAy。x和y总还是需要你来写的，这就是增强。x和y具体在什么时候被调用总还是需要你来规定的，虽然是基于约定的声明这种简单的规定，这就是切点。
Spring AOP
2301_81096101的博客
03-22 1411
AOP（Aspect-Oriented Programming）即面向切面编程，是一种通过预编译或动态代理技术，将横切关注点（如日志、安全校验）与业务逻辑分离的编程范式。
Spring Aop
会写Bug的攻城狮
08-30 1839
Spring MVC：需要在XML配置中手动添加来启用AOP。：通过引入依赖，启用AOP功能，简化了配置过程。这种设计让Spring Boot提供了一种更为简便和现代的开发体验，减轻了开发者的负担。每种方案都有其适用的场景和优劣所在。大部分情况下，将方法拆分到不同的 Service 中是最佳实践，它能够保持代码的清晰性和可维护性。在复杂的应用中，可以根据具体的需求考虑其他方法，但在选择方案时要注意事务管理的影响。
spring AOP详解
是程序喵呀
11-07 3640
AOP（Aspect Orient Programming）是一种设计思想，是软件设计领域中的面向切面编程，它是面向对象编程(OOP)的一种补充和完善；
【JavaEE】Spring AOP的注解实现
yj20040627的博客
05-25 1万+
基于注解@annotation 和 execution 的方式实现SPring AOP
Spring AOP详解
2302_77758423的博客
07-21 1773
AOP英文全称：Aspect Oriented Programming（面向切面编程、面向方面编程），其实说白了，面向切面编程就是面向特定方法编程。使用场景（记录操作日志、权限控制、事务管理）。AOP的优势：减少重复代码、提高开发效率、维护方便、代码无侵入。案例某部分功能运行较慢，定位执行耗时较长的业务方法，此时需要统计每一个业务的执行耗时。我们可以在方法开始前，获取方法开始时间，方法结束后获取结束时间，由此计算执行耗时。这个思路是正确的，但是过于繁琐。动态代理是面向切面编程最主流的实现。
SpringAOP学习--SpringAOP简介及原理
热门推荐
u012098021的博客
05-15 6万+
前文对AOP做了介绍，实际项目中，一般不会直接上手手动实现aop，而是使用一些高级封装的aop实现，如SpringAOP。 Spring是一个广泛应用的框架，SpringAOP则是Spring提供的一个标准易用的aop框架，依托Spring的IOC容器，提供了极强的AOP扩展增强能力，对项目开发提供了极大地便利。 前文提到AOP的实现有AspectJ、JDK动态代理、CGLIB动态代理，SpringAOP不是一种新的AOP实现，其底层采用的是JDK/CGLIB动态代理。 JDK动态代理回顾 上一篇简单介绍了
Spring AOP术语
yuehua00的专栏
11-11 1723
Spring AOP 中的核心术语和概念包括切面、通知、切入点、连接点、引介、目标对象、代理对象、织入、通知方法、切点表达式、切面优先级、织入器、AOP 代理和 AOP 框架。理解这些术语有助于更好地掌握 Spring AOP 的使用和原理，从而在实际开发中有效地应用 AOP 技术。通过合理使用 AOP，可以提高代码的模块化程度和可维护性，减少重复代码，提高开发效率。
Spring AOP 使用详解
lzz的博客
11-14 1560
Spring AOP 使用详解。核心概念+实现示例+注意事项
Spring AOP 16道面试题及答案.docx
06-29
Spring AOP，全称为Aspect Oriented Programming，是面向切面编程的一种编程范式，它是对传统的面向对象编程（OOP）的一种补充。在OOP中，核心是对象，而在AOP中，核心则是切面。切面是关注点的模块化，即程序中的...
SpringAOP:Spring AOP示例
05-06
SpringAOP Spring AOP（面向方面​​的编程）用于模块化“横截面”服务。 用一种简单的方式，我们可以说它是一个旨在拦截某些进程的组件，例如，在执行某个方法时，Spring AOP可以审核该执行方法，并在该方法执行...
Spring源码最难问题：当Spring AOP遇上循环依赖.docx
06-15
Spring源码最难问题：当Spring AOP遇上循环依赖 Spring源码中最难的问题之一是循环依赖问题，当Spring AOP遇上循环依赖时，该如何解决？ Spring通过三级缓存机制解决循环依赖的问题。 在Spring中，bean的实例化...
前端表单验证最佳实践，提升用户体验.doc
08-21
前端表单验证最佳实践，提升用户体验.doc
该个体为基于MATLAB的答题卡识别。可以识别学号填读区域学科以及跟标准答案进行对比，带有人际交互界面。可在人际交互界面的基础之上进行相应的拓展。(11).zip
08-21
该个体为基于MATLAB的答题卡识别。可以识别学号填读区域学科以及跟标准答案进行对比，带有人际交互界面。可在人际交互界面的基础之上进行相应的拓展。(11).zip
qt5-qtwebengine-examples-5.15.8-5.el8.1.tar.gz
08-21
# 适用操作系统：Centos8 #Step1、解压 tar -zxvf xxx.el8.tar.gz #Step2、进入解压后的目录，执行安装 sudo rpm -ivh *.rpm
大学生选修选课-大学生选修选课系统-大学生选修选课系统源码-大学生选修选课系统代码-springboot大学生选修选课系统源码-基于springboot的大学生选修选课系统设计与实现-项目代码
最新发布
08-21
大学生选修选课-大学生选修选课系统-大学生选修选课系统源码-大学生选修选课系统代码-springboot大学生选修选课系统源码-基于springboot的大学生选修选课系统设计与实现-项目代码
该课题为基于Matlab的运动目标跟踪系统。可以实时框定运动目标。对运动目标的行为做识别。带有人机交互界面，需要在人机交互界面的基础上进行拓展(6).zip
08-21
该课题为基于Matlab的运动目标跟踪系统。可以实时框定运动目标。对运动目标的行为做识别。带有人机交互界面，需要在人机交互界面的基础上进行拓展(6).zip
Spring aop
06-28
###Spring AOP 的概念 AOP（Aspect-Oriented Programming）即面向切面编程，是一种编程范式，旨在通过分离横切关注点来提高模块化程度。在 Spring 框架中，AOP 被广泛用于实现诸如日志记录、事务管理、安全性等通用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值