`
lin213_213
  • 浏览: 78697 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

SpringAop

阅读更多

Spring Aop

AOPAspect Oriented Programming的缩写,意思是面向方面编程,一种新兴的编程技术。
一、原理:通过 Proxy方式完成切面编程.

作用:就是为了更清晰的逻辑,可以让你的业务逻辑去关注自己本身的业务,而不去想一些其他的事情,这些其他的事情包括:安全,事物,日志等。

实现方式:

1.      声明代理类:

2.  public class LogInterceptor  implements InvocationHandler{//要实现InvocationHandler接口重写Invoke()方法

3.  //目标对象

4.  public Object target;

5.  //在代理实例上处理方法调用并返回结果

6.  public Object invoke(Object proxy, Method method, Object[] args)

7.          throws Throwable {

8.      beforeMethod(method);

9.      //对带有指定参数的指定对象调用由此 Method 对象表示的底层方法

10.    method.invoke(target, args);

11.    return null;

12. }  

13. public void beforeMethod(Method m){

14.    System.out.println(new SimpleDateFormat("yyyy-MM-dd hh:mm:ss ").format(new Date())+m.getName()+"  AOP");

15. }

16. public Object getTarget() {

17.    return target;

18. }

19. public void setTarget(Object target) {

20.    this.target = target;

21. }  

22.}

2.测试

public static void main(String[] args) {

       UserDao u = new UserDaoImpl();

       LogInterceptor li =new LogInterceptor();

       li.setTarget(u);

       //返回一个指定接口的代理类实例(通过实现接口来得到代理对像)

    UserDao userDaoProxy=(UserDao)  Proxy.newProxyInstance(u.getClass().getClassLoader(), new Class[]{UserDao.class}, li);

    userDaoProxy.add("AOP Proxy"); 

    }

二、概念

1Advice(通知):定义在连接点做什么,为切面增强提供织入接口。(先定义要增强的功能)

         Before adviceAfterreturningAdviceThrowAdviceAroundAdvice(MethodInteceptor)

2.JoinPoint(连接点)就是方法的前、后或者是抛出异常时。

3.切入点(Pointcut

    上面说的连接点的基础上,来定义切入点,你的一个类里,有15个方法,那就有几十个连接点了对把,但是你并不想在所有方法附近都使用通知(使用叫织入,以后再说),你只想让其中的几个,在调用这几个方法之前,之后或者抛出异常时干点什么,那么就用切点来定义这几个方法,让切点来筛选连接点,选中那几个你想要的方法。

   4.切面(Aspect

    切面是通知和切入点的结合。现在发现了吧,没连接点什么事情,连接点就是为了让你好理解切点,搞出来的,明白这个概念就行了。通知说明了干什么和什么时候干(什么时候通过方法名中的before,afteraround等就能知道),而切入点说明了在哪干(指定到底是哪个方法),这就是一个完整的切面定义。

   5.引入(introduction

    允许我们向现有的类添加新方法属性。这不就是把切面(也就是新方法属性:通知定义的)用到目标类中吗

   6.目标(target

    引入中所提到的目标类,也就是要被通知的对象,也就是真正的业务逻辑,他可以在毫不知情的情况下,被咱们织入切面。而自己专注于业务本身的逻辑。

    7.代理(proxy)

    怎么实现整套aop机制的,都是通过代理,这个一会给细说。

    8.织入(weaving)

把切面应用到目标对象来创建新的代理对象的过程。有3种方式,spring采用的是运行时,为什么是运行时,后面解释。

三、Aop实现:

1annotation注解的方式

1》配置

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

     xmlns:context="http://www.springframework.org/schema/context"

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

     xsi:schemaLocation="http://www.springframework.org/schema/beans

         http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

         http://www.springframework.org/schema/context

         http://www.springframework.org/schema/context/spring-context-3.0.xsd

         http://www.springframework.org/schema/aop

         http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">

    <!-- 用于注解 -->

   <context:annotation-config/>

   <!-- 根据指定的文件容器扫描注解 -->

    <context:component-scan base-package="com"/>

    <!-- 注解自动产生代理 -->

    <aop:aspectj-autoproxy/>

</beans>

 

2》实现

 

@Aspect

@Component

public class AopInterceptor {  

    /** 

     * 定义切入点 

     * 第一个*表示方法的返回值,这里使用通配符,只有返回值符合条件的才拦截,(!void表示有返回值) 

     * 第一个..表示com.javaeye.aop包及其子包 

     * 倒数第二个*表示包下的所有Java类都被拦截 

     * 最后一个*表示类的所有方法都被拦截 

     * (..)表示方法的参数可以任意多个如[(java.lang.String,java.lang.Integer)表示第一个参数是String,第二个参数是int的方法才会被拦截] 

     */ 

    @Pointcut("execution(* com.javaeye.aop..*.*(..))") //定义一个切入点,名称为pointCutMethod(),拦截类的所有方法  

    private void pointCutMethod() {   

    }         

    @Before("pointCutMethod()") //定义前置通知  

    public void doBefore() {  

        System.out.println("前置通知");  

    }         

    @AfterReturning("pointCutMethod()") //定义后置通知  

    public void doAfterReturning() {  

        System.out.println("后置通知");  

    }        

    @AfterThrowing("pointCutMethod()") //定义例外通知  

    public void doAfterException() {  

        System.out.println("异常通知");  

    }        

    @After("pointCutMethod()") //定义最终通知  

    public void doAfter() {  

        System.out.println("最终通知");  

    }        

    @Around("pointCutMethod()") //定义环绕通知  

    public Object doAround(ProceedingJoinPoint pjp) throws Throwable {  

        System.out.println("进入方法");  

        Object object = pjp.proceed(); //必须执行pjp.proceed()方法,如果不执行此方法,业务bean的方法以及后续通知都不执行  

        System.out.println("退出方法");  

        return object;  

    }  

} 

 

2xml的方式:

参考以下配置

  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  4.        xmlns:context="http://www.springframework.org/schema/context"    
  5.        xmlns:aop="http://www.springframework.org/schema/aop"         
  6.        xsi:schemaLocation="http://www.springframework.org/schema/beans   
  7.            http://www.springframework.org/schema/beans/spring-beans-2.5.xsd   
  8.            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd   
  9.            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">  
  10.         <aop:aspectj-autoproxy/>    
  11.         <bean id="aspjectbean" class="com.royzhou.aop.MyInterceptor" />  
  12.         <bean id="UserBean" class="com.royzhou.aop.UserBean"></bean>  
  13.         <aop:config>  
  14.             <aop:aspect id="asp" ref="aspjectbean">  
  15.                 <aop:pointcut id="mycut" expression="execution(* com.royzhou.aop..*.*(..))"/>  
  16.                 <aop:before pointcut="execution(* com.royzhou.aop..*.*(..)) and args(userName)" method="doBefore" />  
  17.                 <aop:after-returning pointcut-ref="mycut" method="doAfterReturning" returning="result" />  
  18.                 <aop:after-throwing pointcut-ref="mycut" method="doAfterReturning" throwing="e" />  
  19.                 <aop:after pointcut-ref="mycut" method="doAfter"/>  
  20.                 <aop:around pointcut-ref="mycut" method="doArround"/>  
  21.             </aop:aspect>  
  22.         </aop:config>  
  23. </beans> 

 

分享到:
评论

相关推荐

    spring aop jar 包

    Spring AOP(Aspect Oriented Programming,面向切面编程)是Spring框架的重要组成部分,它提供了一种在不修改源代码的情况下,对程序进行功能增强的技术。这个"spring aop jar 包"包含了实现这一功能所需的类和接口,...

    Spring AOP 16道面试题及答案.docx

    Spring AOP,全称为Aspect Oriented Programming,是面向切面编程的一种编程范式,它是对传统的面向对象编程(OOP)的一种补充。在OOP中,核心是对象,而在AOP中,核心则是切面。切面是关注点的模块化,即程序中的...

    简单spring aop 例子

    Spring AOP(面向切面编程)是Spring框架的重要组成部分,它提供了一种模块化和声明式的方式来处理系统中的交叉关注点问题,如日志、事务管理、安全性等。本示例将简要介绍如何在Spring应用中实现AOP,通过实际的...

    Spring AOP完整例子

    Spring AOP(面向切面编程)是Spring框架的核心特性之一,它允许开发者在不修改源代码的情况下,通过插入切面来增强或改变程序的行为。在本教程中,我们将深入探讨Spring AOP的不同使用方法,包括定义切点、通知类型...

    spring aop依赖jar包

    现在,我们回到主题——"springaop依赖的jar包"。在Spring 2.5.6版本中,使用Spring AOP通常需要以下核心jar包: - `spring-aop.jar`:这是Spring AOP的核心库,包含了AOP相关的类和接口。 - `spring-beans.jar`:...

    spring aop 自定义注解保存操作日志到mysql数据库 源码

    3、对spring aop认识模糊的,不清楚如何实现Java 自定义注解的 4、想看spring aop 注解实现记录系统日志并入库等 二、能学到什么 1、收获可用源码 2、能够清楚的知道如何用spring aop实现自定义注解以及注解的逻辑...

    Spring Aop四个依赖的Jar包

    Spring AOP,全称Aspect-Oriented Programming(面向切面编程),是Spring框架的一个重要模块,它通过提供声明式的方式来实现面向切面编程,从而简化了应用程序的开发和维护。在Spring AOP中,我们无需深入到每个...

    死磕Spring之AOP篇 - Spring AOP两种代理对象的拦截处理(csdn)————程序.pdf

    Spring AOP 是一种面向切面编程的技术,它允许我们在不修改源代码的情况下,对应用程序的特定部分(如方法调用)进行增强。在 Spring 中,AOP 的实现主要依赖于代理模式,有两种代理方式:JDK 动态代理和 CGLIB 动态...

    Spring AOP实现机制

    **Spring AOP 实现机制详解** Spring AOP(面向切面编程)是Spring框架的核心特性之一,它允许程序员在不修改源代码的情况下,通过“切面”来插入额外的业务逻辑,如日志、事务管理等。AOP的引入极大地提高了代码的...

    springAOP配置动态代理实现

    Spring AOP(面向切面编程)是Spring框架的重要组成部分,它允许程序员在不修改源代码的情况下,通过在运行时插入额外的行为(如日志记录、性能监控等)来增强对象的功能。动态代理则是Spring AOP实现的核心技术之一...

    反射实现 AOP 动态代理模式(Spring AOP 的实现原理)

    面向切面编程(AOP)是一种编程范式,旨在将横切关注点(如日志、安全等)与业务逻辑分离,从而提高模块化。...利用Java反射机制和Spring AOP框架,开发者可以方便地实现AOP,从而提升代码的模块化和可维护性。

    Spring AOP面向方面编程原理:AOP概念

    ### Spring AOP面向方面编程原理:AOP概念详解 #### 一、引言 随着软件系统的日益复杂,传统的面向对象编程(OOP)逐渐暴露出难以应对某些横切关注点(cross-cutting concerns)的问题。为了解决这一挑战,面向方面编程...

    小马哥讲 Spring AOP 编程思想 - API 线索图.pdf

    在讨论Spring AOP(面向切面编程)时,首先需要理解几个核心概念。Spring AOP 是Spring框架提供的一个功能模块,它允许开发者将横切关注点(cross-cutting concerns)从业务逻辑中解耦出来,通过在方法调用前后进行...

    spring aop 五个依赖jar

    Spring AOP(面向切面编程)是Spring框架的重要组成部分,它提供了一种模块化和声明式的方式来处理系统中的交叉关注点,如日志、事务管理等。在Java应用中,AOP通过代理模式实现了切面编程,使得我们可以将业务逻辑...

    spring AOP 引入jar包,spring IOC 引入Jar包

    Spring AOP 和 Spring IOC 是 Spring 框架的两个核心组件,它们对于任何基于 Java 的企业级应用开发都至关重要。Spring AOP(面向切面编程)允许开发者在不修改源代码的情况下,通过“切面”来插入新的行为或增强已...

    spring aop切面拦截指定类和方法实现流程日志跟踪

    ### Spring AOP 实现流程日志跟踪 #### 一、背景与目的 在现代软件开发过程中,为了确保系统的稳定性和可维护性,通常会引入非功能性的需求来增强应用程序的功能,比如日志记录、安全控制等。这些需求往往不是业务...

    Spring AOP 入门作者:廖雪峰

    ### Spring AOP 入门详解 #### 一、Spring AOP 概述 Spring AOP(Aspect Oriented Programming,面向切面编程)是Spring框架的一个关键特性,它为开发者提供了在运行时动态添加代码(即横切关注点或切面)到已有...

    spring AOP依赖三个jar包

    Spring AOP,即Spring的面向切面编程模块,是Spring框架的重要组成部分,它允许开发者在不修改源代码的情况下,对程序进行横切关注点的处理,如日志、事务管理等。实现这一功能,主要依赖于三个核心的jar包:aop...

    spring aop的demo

    在`springAop1`这个压缩包中,可能包含了一个简单的应用示例,展示了如何定义一个切面类,以及如何在该类中定义通知方法。例如,我们可能会看到一个名为`LoggingAspect`的类,其中包含了`@Before`注解的方法,用于在...

    springaop多数据库读写分离

    Spring AOP(面向切面编程)与MyBatis框架的结合应用,可以帮助我们实现这一目标。以下将详细讲解如何利用Spring AOP来实现多数据库的读写分离。 首先,了解读写分离的基本概念。读写分离是指在一个数据库系统中,...

Global site tag (gtag.js) - Google Analytics