SSM框架之AOP、动态代理、事务处理相关随笔 AOP

SSM框架之AOP、动态代理、事务处理相关随笔
AOP：

原理：底层利用动态代理(两种动态代理技术都使用了)

两种实现方案：

第一种：JDK动态代理技术

    实现的InvocationHandler接口，要想实现某个类的动态代理对象，必须有接口有实现类。

第二种：cglib动态代理技术（需要导入spring包–4个核心包）

    实现了MethodInterceptor接口，原理是继承要代理的类。

第一步：导入包 4+2+2+2

第二步：准备肉鸡

编写一个接口UserService 和 UserServiceImpl，具体详见代码

第三步：编写通知类

public class MyAdvice {

//Spring中的代码增强，方式非常多

// 前置通知

   //--目标对象方法（切入点）执行之前调用

// 后置通知（如果出现异常不会执行）

    //--目标对象方法（切入点）执行之后调用

// 环绕通知

    //--目标对象方法（切入点）执行之前和之后调用

// 异常拦截通知

    //--切入点执行异常才会调用

// 后置通知（不论是否出现异常都会执行）

    //--目标对象方法（切入点）执行之后调用



    // 前置通知

    public void before(){

        System.out.println("这是前置通知代码");

    }



    // 后置通知

    public void after01(){

        System.out.println("这是后置通知代码（出现异常不调用）");

    }

   

    // 后置通知

    public void after02(){

                System.out.println("这是后置通知代码（都调用）");

    }

   

    //异常通知

    public void afterException(){

        System.out.println("妈呀，出异常了，怎么办？");

    }

   

    //环绕通知

    public Object  around(ProceedingJoinPoint pip) throws Throwable{

        System.out.println("这是环绕通知前");

        Object obj=pip.proceed();

        System.out.println("这是环绕通知后");

        return obj;

    }

}

第四步：书写配置文件

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

<beans xmlns:xsi=“http://www.w3.org/2001/XMLSchema-instance”

xmlns="http://www.springframework.org/schema/beans" 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-4.2.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd ">

aop:config

  <!--

    public void  com.xcy.service.UserServiceImpl.save()

    void  com.xcy.service.UserServiceImpl.save()

    *  com.xcy.service.UserServiceImpl.*()

    *  com.xcy.service.*ServiceImpl.*(..)

    *  com.xcy.service..*ServiceImpl.*(..)

 

   -->

   <!-- 切入點： 想要增強的方法 -->

  <aop:pointcut expression="execution(* com.xcy.service..*ServiceImpl.*(..))" id="pc"/>

  <!-- 切面：增強、通知  +  切入點   -->

  <aop:aspect ref="myAdvice">

      <!-- 前置增強 -->

      <aop:before method="before" pointcut-ref="pc"/>

      <aop:after-returning method="after01" pointcut-ref="pc"/>

      <aop:after method="after02" pointcut-ref="pc"/>

      <aop:after-throwing method="afterException" pointcut-ref="pc"/>

      <aop:around method="around"  pointcut-ref="pc"/>

  </aop:aspect>

</aop:config>

第五步：测试 如果使用junit和spring整合的方式测试，需要导入包（3个）

package com.xcy.test;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.test.context.ContextConfiguration;

import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.xcy.service.UserService;

//帮我们创建容器

@RunWith(SpringJUnit4ClassRunner.class)

//创建容器时，需要指定配置文件

@ContextConfiguration(“classpath:applicationContext02.xml”)

public class SpringJUnit {

//代理對象

@Autowired

private UserService userService;



@Test

public void  testAop(){

   

    userService.save();

}

}

注解方式：以上是通过xml配置方式书写，以下是通过注解方法书写。

package com.xcy.advice;

。。。相关包

@Aspect//表示该类为通知类、增强类

publicclass MyAdvice02 {

//Spring中的代码增强，方式非常多

// 前置通知

   //--目标对象方法（切入点）执行之前调用

// 后置通知（如果出现异常不会执行）

    //--目标对象方法（切入点）执行之后调用

// 环绕通知

    //--目标对象方法（切入点）执行之前和之后调用

// 异常拦截通知

    //--切入点执行异常才会调用

// 后置通知（不论是否出现异常都会执行）

    //--目标对象方法（切入点）执行之后调用

    // 前置通知

    @Before("execution(* com.xcy.service..*ServiceImpl.*(..))")

    publicvoid before(){

        System.out.println("这是前置通知代码");

    }



    // 后置通知

    @AfterReturning("execution(* com.xcy.service..*ServiceImpl.*(..))")

    publicvoid after01(){

        System.out.println("这是后置通知代码（出现异常不调用）");

    }

   

    // 后置通知

    @After("execution(* com.xcy.service..*ServiceImpl.*(..))")

    publicvoid after02(){

                System.out.println("这是后置通知代码（都调用）");

    }

   

    //异常通知

    @AfterThrowing("execution(* com.xcy.service..*ServiceImpl.*(..))")

    publicvoid afterException(){

        System.out.println("妈呀，出异常了，怎么办？");

    }

   

    //环绕通知

    @Around("execution(* com.xcy.service..*ServiceImpl.*(..))")

    public Object  around(ProceedingJoinPoint pip) throws Throwable{

        System.out.println("这是环绕通知前");

        Object obj=pip.proceed();

        System.out.println("这是环绕通知后");

        return obj;

    }

}

配置文件：

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

<beans xmlns:xsi=“http://www.w3.org/2001/XMLSchema-instance”

xmlns="http://www.springframework.org/schema/beans" 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-4.2.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd ">

aop:aspectj-autoproxy</aop:aspectj-autoproxy>

错误总结：

不要忘记写execution单词

package com.xcy.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;

@Aspect//表示该类为通知类、增强类

publicclass MyAdvice02 {

//Spring中的代码增强，方式非常多

// 前置通知

   //--目标对象方法（切入点）执行之前调用

// 后置通知（如果出现异常不会执行）

    //--目标对象方法（切入点）执行之后调用

// 环绕通知

    //--目标对象方法（切入点）执行之前和之后调用

// 异常拦截通知

    //--切入点执行异常才会调用

// 后置通知（不论是否出现异常都会执行）

    //--目标对象方法（切入点）执行之后调用



    // 前置通知

    @Before("execution(* com.xcy.service..*ServiceImpl.*(..))")

    publicvoid before(){

        System.out.println("这是前置通知代码");

    }



    // 后置通知

    @AfterReturning("execution(* com.xcy.service..*ServiceImpl.*(..))")

    publicvoid after01(){

        System.out.println("这是后置通知代码（出现异常不调用）");

    }

   

    // 后置通知

    @After("execution(* com.xcy.service..*ServiceImpl.*(..))")

    publicvoid after02(){

                System.out.println("这是后置通知代码（都调用）");

    }

   

    //异常通知

    @AfterThrowing("execution(* com.xcy.service..*ServiceImpl.*(..))")

    publicvoid afterException(){

        System.out.println("妈呀，出异常了，怎么办？");

    }

   

    //环绕通知

    @Around("execution(* com.xcy.service..*ServiceImpl.*(..))")

    public Object  around(ProceedingJoinPoint pip) throws Throwable{

        System.out.println("这是环绕通知前");

        Object obj=pip.proceed();

        System.out.println("这是环绕通知后");

        return obj;

    }

}