spring_03AOP编程

AOP 编程

AOP( Aspect Oricented Programming ) 面向切面编程

是对所有对象或者是一类对象进行编程 

核心是（不  还）

    在不增加代码的基础上，还增加新的功能

spring AOP实现原理

• 动态代理&CGLib代理

    spring能够为容器中管理的对象生成动态代理对象
  
    以前我们要使用动态代理，我们需要自己调用下面这个方法：
  
        Proxy.newProxyInstance(xx,xx,xx)
  
    生成代理对象
  
  
    spring能帮我们生成代理对象

• 动态代理和CGLib代理的区别：

    动态代理：被代理的对象必须实现接口，才能产生代理对象，
  
        如果没有接口将不能使用动态代理技术
  
    cglib代理：第三方代理技术，cglib代理，可以对任何类生成代理，代理的原理是
  
        对目标对象进行继承代理。如果目标对象被final修饰，那么该类无法被
  
        cglib代理

• 具体的顺序：有接口的话，优先使用 动态代理，没有的话使用cglib代理

AOP的一些术语：

1. Joinpoint（连接点）：

    目标对象中，所有可以增强的方法

2. Pointcut（切入点）：

    目标对象，已经增强的方法

3. Afvice（通知/增强）：

    增强的代码

4. Target（目标对象）：

    被代理的对象

5. Weaving（织入）：

    动词，将通知织入连接点形成切入点

6. Proxy（代理）：

    将通知织入目标对象后，形成代理对象

7. aspect（切面）：

    切入点+通知

使用spring中的AOP：

1. 导包

    （4+2+2+2）4个核心+2个日志
   
    +（2）spring的aop包：
   
        spring-aop.jar 与 spring-aspects.jar
   
    +（2）spring需要第三方aop包：
   
        com.springsource.org.aopalliance-1.0.0.jar
   
        com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar

2. 准备目标对象

    package org.spring.service;
   
    public class UserService {
   
        public void save(){
            System.out.println("保存用户");
        }
        public void delete(){
            System.out.println("删除用户");
        }
        public void find(){
            System.out.println("查询用户");
        }
        public void update(){
            System.out.println("更新用户");
        }
    }

3. 定义通知：

    前置通知
   
        目标方法运行之前调用
   
    后置通知（如果出现异常不会调用）
   
        在目标方法运行之后调用
   
   
    环绕通知
   
        在目标方法之前和之后都调用
   
    异常拦截通知
   
        如果出现异常，就会调用
   
    后置通知（无论是否出现异常都会调用）
   
        在目标运行之后调用
   
   
   
    特殊：环绕通知需要手动调用目标方法
   
   
    package org.spring.advice;
   
    import org.aspectj.lang.ProceedingJoinPoint;
   
    public class MyAdvice {
        //前置通知
        public void before(){
            System.out.println("前置通知");
        }
        //后置通知
        public void afterRunning(){
            System.out.println("后置通知（如果出现异常不会调用）");
        }
        //环绕通知
        public Object around(ProceedingJoinPoint  pjp) throws Throwable{
            System.out.println("环绕通知-前");
            Object procced = pjp.proceed();
            System.out.println("环绕通知-后");
            return procced;
        }
        //异常通知
        public void afterException(){
            System.out.println("异常通知");
        }
        //后置通知
        public void after(){
            System.out.println("后置通知（出现异常也会调用）");
        }
    }

4. 配置进行织入，将通知织入目标对象中

    <!-- 准备工作：导入aop（约束）命名空间 -->
    <!-- 1.配置目标对象 -->
        <bean name="userService" class="org.spring.service.UserService"></bean>
    <!-- 2.配置通知对象 -->
        <bean name="myAdvice" class="org.spring.advice.MyAdvice"></bean>
    <!-- 3.配置将通知织入目标对象 -->
        <aop:config>
            <!-- 配置切入点
                public void org.spring.service.UserService.save()
                void org.spring.service.UserService.save()
                * org.spring.service.UserService.save()
                * org.spring.service.UserService.*()
                * org.spring.service.UserService.*(..)
                * org.spring.service.*Service.*(..)
                * org.spring.service..*Service.*(..)
             -->
            <aop:pointcut expression="execution(* org.spring.service.*Service.*(..))" id="pc"/>
            <!-- 通知对象 -->
            <aop:aspect ref="myAdvice">
                <!-- 指定通知类型与通知方法名以及切入点 -->
                <aop:before method="before" pointcut-ref="pc"/>
                <aop:after-returning method="afterRunning" pointcut-ref="pc"/>
                <aop:around method="around" pointcut-ref="pc"/>
                <aop:after-throwing method="afterException" pointcut-ref="pc"/>
                <aop:after method="after" pointcut-ref="pc"/>
            </aop:aspect>
        </aop:config>

springAOP的注解配置

1. applicationContext.xml中的配置

    <context:component-scan base-package="org.spring"></context:component-scan>
    <!--开启切面自动代理-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

2. 通知中的注解：

    package org.spring.advice;
   
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.After;
    import org.aspectj.lang.annotation.AfterReturning;
    import org.aspectj.lang.annotation.AfterThrowing;
    import org.aspectj.lang.annotation.Around;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Before;
    import org.aspectj.lang.annotation.Pointcut;
    import org.springframework.stereotype.Component;
    @Component("myAdvice")
    //表示该类是一个通知类
    @Aspect
    public class MyAdvice {
        //表示切入点的方法
        @Pointcut("execution(* org.spring.service.*Service.*(..))")
        public void pc(){}
   
        //前置通知
        @Before("MyAdvice.pc()")
        public void before(){
            System.out.println("前置通知");
        }
        //后置通知
        @AfterReturning("MyAdvice.pc()")
        public void afterRunning(){
            System.out.println("后置通知（如果出现异常不会调用）");
        }
        //环绕通知
        @Around("MyAdvice.pc()")
        public Object around(ProceedingJoinPoint  pjp) throws Throwable{
            System.out.println("环绕通知-前");
            Object procced = pjp.proceed();
            System.out.println("环绕通知-后");
            return procced;
        }
        //异常通知
        @AfterThrowing("MyAdvice.pc()")
        public void afterException(){
            System.out.println("异常通知");
        }
        //后置通知
        @After("MyAdvice.pc()")
        public void after(){
            System.out.println("后置通知（出现异常也会调用）");
        }
    }

转载于:https://www.cnblogs.com/nm666/p/8290097.html