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 ">

 

  <bean name="userService" class="com.xcy.service.UserServiceImpl"></bean>

  <bean name="myAdvice" class="com.xcy.advice.MyAdvice"></bean>

 

  <!-- weaving -->

  <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>

</beans>

第五步：测试  如果使用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 ">

 

  <bean name="userService" class="com.xcy.service.UserServiceImpl"></bean>

  <bean name="myAdvice" class="com.xcy.advice.MyAdvice02"></bean>

 

  <!-- 开启使用注解织入 -->

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

</beans>

 

 

错误总结：

不要忘记写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;

        }

   

}