Spring学习四

1先导入 Asject的jar包

2配置文件加入标签 ，并加入

<aop:aspectj-autoproxy proxy-target-class="true">（如果是实现接口模式的代理就不用后面的true）

</aop:aspectj-autoproxy>

3代理class加@Componet 和@Aspect，方法前面加@Before 当然不止Before 后面介绍

代码如下

package AOP;//接口类

public interface CalculatorMethod {

   int add(int x,int y);

   int sub(int x,int y);

   int mul(int x,int y);

   int div(int x,int y);

}

package AOP;

import org.springframework.stereotype.Component;

@Component

public class Calculator implements CalculatorMethod {

    public int add(int x,int y) {

        return (x+y);

    }

    public int sub(int x,int y) {

        return (x-y);

    }

    public int mul(int x,int y) {

        return (x*y);

    }

    public int div(int x,int y) {

        return (x/y);

    }

}

package AOP;//关键代理文件

import org.aspectj.lang.annotation.Aspect;

import org.aspectj.lang.annotation.Before;

import org.springframework.stereotype.Component;

@Aspect

@Component

public class Logging {

    @Before("execution(int AOP.Calculator.add(int, int))")

    /*

     *   可以缩略成execution(int AOP.Calculator.*(int, int))，代表这个包下所有方法都行。

     *

     * */

    public void log(){

        System.out.println("I am out");

    }

}

package AOP;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {

    public static void main(String[] args) {

         ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");//在工程目录下读取bean的配置。

        // CalculatorMethod cal = (CalculatorMethod) context.getBean("calculator");//这是基于接口形式 如果要基于cglib这种，则要修改xml配置文件加入proxy-target-class="true"

         Calculator cal = (Calculator) context.getBean("calculator");

         System.out.println(cal.add(8, 8));

         System.out.println(cal.sub(8, 8));

    }

}

/*

输出

I am out

16

0

*/

Bean文件添加

<!-- 如果要指定某些anntion 则可以使用 标签<context:include-filter>当然  use-defalut-filters要设置为false  -->

<context:component-scan base-package="AOP" >

<context:include-filter type="annotation" expression="org.springframework.stereotype.Service"/>

</context:component-scan>

<aop:aspectj-autoproxy proxy-target-class="true">

</aop:aspectj-autoproxy>

五种注解，@Before 前置，@After后置， @AfterReturning 返回，@AfterThrowing 异常， @Around环绕，具体关系看代码。

package AOP;

import java.util.Arrays;

import java.util.List;

import org.aspectj.lang.JoinPoint;

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.springframework.stereotype.Component;

@Aspect

@Component

public class Logging {

    @Before("execution(int AOP.Calculator.add(int, int))")

    /*

     *   可以缩略成execution(int AOP.Calculator.*(int, int))，代表这个包下所有方法都行。

     *

     * */

    public void log(){

        System.out.println("I am out");

    }

    @After("execution(int AOP.Calculator.*(int, int))")//这里不能用返回值，因为返回值得再返回函数。

    public void log2(JoinPoint jp){

        String methodName = jp.getSignature().getName();

        List<Object> l = Arrays.asList(jp.getArgs());

        System.out.println("Method name: "+methodName+"  with "+l);

    }

    //@AfterReturning("execution(int AOP.Calculator.*(int, int))",returning="result")

     @AfterReturning(returning="result"

     , pointcut="execution(int AOP.Calculator.*(int, int))")

    public void log3(JoinPoint jp,Object result){

        String methodName = jp.getSignature().getName();

        List<Object> l = Arrays.asList(jp.getArgs());

        System.out.println("Method name: "+methodName+" end with "+result);

    }

     @AfterThrowing(throwing="e", pointcut="execution(int AOP.Calculator.*(int, int))")

     public void log4(JoinPoint jp,Exception e){//注意这里填写什么异常就捕获什么异常，比如NullPointExcepiton只捕获空指针异常。

         String methodName = jp.getSignature().getName();

            List<Object> l = Arrays.asList(jp.getArgs());

            System.out.println("Method name: "+methodName+"  with "+l+"  error:"+e);

     }

     @Around("execution(int AOP.Calculator.*(int, int))")//相当于一次代理，用这个可以理解上面的过程

     public Object log5(ProceedingJoinPoint pjp){

         Object result =null;

             try {

             System.out.println("Around 前置");     //前置

                result = pjp.proceed();

                System.out.println("Around 后置");//后置

            } catch (Throwable e) {//异常

                // TODO Auto-generated catch block

                System.out.println("Around 异常");

                e.printStackTrace();

            }

             System.out.println("Around 返回");//返回

         return result;

     }

}

切面的优先级 @Order 数值越小优先级越高，切入表达式 @Pointcut  声明表达式，不用加入其它方法，只是用于声明切入点，用的在其他方法里面加入该方法名字即可。其他class加class名字

代码简单如下

@Order(1)

@Aspect

@Component

public class Logging2 {

    @Pointcut("execution(int AOP.Calculator.add(int, int))")

    public void logPoint(){}

    @After("logPoint()")

    public void log1(){

        System.out.println("afetr log 2");

    }

}

package AOP;

import java.util.Arrays;

import java.util.List;

import org.aspectj.lang.JoinPoint;

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.springframework.core.annotation.Order;

import org.springframework.stereotype.Component;

@Order(2)

@Aspect

@Component

public class Logging {

    @Before("Logging2.logPoint()")

    /*

     *   可以缩略成execution(int AOP.Calculator.*(int, int))，代表这个包下所有方法都行。

     *

     * */

    public void log(){

        System.out.println("I am out");

    }

    @After("Logging2.logPoint()")//这里不能用返回值，因为返回值得再返回函数。

    public void log2(JoinPoint jp){

        String methodName = jp.getSignature().getName();

        List<Object> l = Arrays.asList(jp.getArgs());

        System.out.println("Method name: "+methodName+"  with "+l);

    }

    //@AfterReturning("execution(int AOP.Calculator.*(int, int))",returning="result")

     @AfterReturning(returning="result"

     , pointcut="Logging2.logPoint()")

    public void log3(JoinPoint jp,Object result){

        String methodName = jp.getSignature().getName();

        List<Object> l = Arrays.asList(jp.getArgs());

        System.out.println("Method name: "+methodName+" end with "+result);

    }

     @AfterThrowing(throwing="e", pointcut="Logging2.logPoint()")

     public void log4(JoinPoint jp,Exception e){//注意这里填写什么异常就捕获什么异常，比如NullPointExcepiton只捕获空指针异常。

         String methodName = jp.getSignature().getName();

            List<Object> l = Arrays.asList(jp.getArgs());

            System.out.println("Method name: "+methodName+"  with "+l+"  error:"+e);

     }

     @Around("Logging2.logPoint()")//相当于一次代理，用这个可以理解上面的过程

     public Object log5(ProceedingJoinPoint pjp){

         Object result =null;

             try {

             System.out.println("Around 前置");     //前置

                result = pjp.proceed();

                System.out.println("Around 后置");//后置

            } catch (Throwable e) {//异常

                // TODO Auto-generated catch block

                System.out.println("Around 异常");

                e.printStackTrace();

            }

             System.out.println("Around 返回");//返回

         return result;

     }

}

基于xml的配置aspect切面

先声明切面的bean，之后配置AOP 用 aop：config

//删除所有注解注入方式

public class Logging {

    /*

     *   可以缩略成execution(int AOP.Calculator.*(int, int))，代表这个包下所有方法都行。

     *

     * */

    public void log(){

        System.out.println("I am out");

    }

    public void log2(JoinPoint jp){

        String methodName = jp.getSignature().getName();

        List<Object> l = Arrays.asList(jp.getArgs());

        System.out.println("Method name: "+methodName+"  with "+l);

    }

    //@AfterReturning("execution(int AOP.Calculator.*(int, int))",returning="result")

    public void log3(JoinPoint jp,Object result){

        String methodName = jp.getSignature().getName();

        System.out.println("Method name: "+methodName+" end with "+result);

    }

     public void log4(JoinPoint jp,Exception e){//注意这里填写什么异常就捕获什么异常，比如NullPointExcepiton只捕获空指针异常。

         String methodName = jp.getSignature().getName();

            List<Object> l = Arrays.asList(jp.getArgs());

            System.out.println("Method name: "+methodName+"  with "+l+"  error:"+e);

     }

     public Object log5(ProceedingJoinPoint pjp){

         Object result =null;

             try {

             System.out.println("Around 前置");     //前置

                result = pjp.proceed();

                System.out.println("Around 后置");//后置

            } catch (Throwable e) {//异常

                // TODO Auto-generated catch block

                System.out.println("Around 异常");

                e.printStackTrace();

            }

             System.out.println("Around 返回");//返回

         return result;

     }

}

bean 修改如下

<!-- 配置切面的bean -->

<bean id="loggin1" class="AOP.Logging"></bean>

<bean id="loggin2" class="AOP.Logging2"></bean>

<!-- 切面的具体设置 -->

<aop:config>

<aop:pointcut expression="execution(int AOP.Calculator.add(int, int))" id="express"/><!-- 切面需要代理的点 -->

<!-- 一个aspect可以代表一个切面 -->

<aop:aspect ref="loggin1" order="1">

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

<aop:after method="log2" pointcut-ref="express"/>

<aop:after-throwing method="log4" pointcut-ref="express" throwing="e"/>

<aop:after-returning method="log3" pointcut-ref="express" returning="result"/>

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

</aop:aspect>

<aop:aspect ref="loggin2" order="2">

<aop:after method="log1" pointcut-ref="express"/>

</aop:aspect>

</aop:config>