基于AspectJ的AOP开发

AspectJ简介

图片.png

AspectJ提供不同的通知类型

@Before 前置通知，相当于BeforeAdvice
@AfterReturning 后置通知，相当于AfterReturningAdvice
@Around 环绕通知相当于 MethodInterceptor （可以阻止原方法执行，可用于事务处理）
@AfterThrowing异常抛出通知，相当于ThrowAdvice
@After 最终final通知，不管是否异常，该通知都会执行。（类似finally）
@DeclareParents 引介通知

通过execution函数，定义切入点的方法

图片.png

AspectJ的注解开发AOP:入门案例

目标类

package com.alan.aspectj.demo1;

public class ProductDao {

    public  void save(){
        System.out.println("保存商品。。。");
    }

    public  void update(){
        System.out.println("保存商品。。。");
    }

    public  void delete(){
        System.out.println("删除商品。。。");
    }

    public  void findOne(){
        System.out.println("查找单个商品。。。");
    }

    public  void findAll(){
        System.out.println("查找所有商品商品。。。");
    }
}

AspectJ注解方式的切面类

package com.alan.aspectj.demo1;


import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

/**
 * AspectJ注解方式的切面类
 */

@Aspect
public class MyAspectAnno {


    @Before(value = "execution(* com.alan.aspectj.demo1.ProductDao.save(..))")
    public void before(){
        System.out.println("前置通知================");
    }
}

<?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:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"> <!-- bean definitions here -->


    <!--开启AspectJ的注解开发，自动代理===========-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

    <!--目标类-->
    <bean id="productDao" class="com.alan.aspectj.demo1.ProductDao">
    </bean>

    <!--定义切面，可以不写id，因为xml并没有使用，采用注解方式-->
    <bean class="com.alan.aspectj.demo1.MyAspectAnno"></bean>

</beans>

测试类

package com.alan.aspectj.demo1;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;


@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class SpringDemo1 {

    //实现方式一
    @Autowired
    @Qualifier("productDao")
    private ProductDao productDao;

    @Test
    public void demo1(){

        //实现方式二
//        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
//        ProductDao productDao = (ProductDao) applicationContext.getBean("productDao");

        productDao.delete();
        productDao.update();
        productDao.save();
        productDao.findOne();
        productDao.findAll();

    }
}

AspectJ的注解开发AOP:前置通知

@Before前置通知
可以在方法参数中传入JoinPoint对象，用来获得切点信息

@Aspect
public class MyAspectAnno {


    @Before(value = "execution(* com.alan.aspectj.demo1.ProductDao.save(..))")
    public void before(JoinPoint joinPoint){
        System.out.println("前置通知================" + joinPoint);
    }


}

控制台输出切入点信息

图片.png

AspectJ的注解开发AOP:后置通知

方法

    public  String update(){
        System.out.println("修改商品。。。");
        return "hello";
    }

切面配置

    //returning可以对当前方法对返回参数进行处理
    @AfterReturning(value = "execution(* com.alan.aspectj.demo1.ProductDao.update(..))",returning = "result")
    public void afterReturning(Object result){
        System.out.println("后置通知==================" + result);
    }

运行效果

图片.png

AspectJ的注解开发AOP:环绕通知

around方法的返回值就是目标代理方法执行返回值
通过参数ProceedingJoinPoint可以对目标方法进行拦截
切面配置

    //不用返回值确实可以，在执行上不会有错误。
    //只是如果作用到了一个有返回值的方法，而环绕通知方法却没有返回值，那么这个方法的返回值就会为null
    @Around(value = "execution(* com.alan.aspectj.demo1.ProductDao.delete(..))")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {

        System.out.println("环绕前通知===========");
        //执行目标方法，如果不调用的话，目标方法就会被拦截了。
        Object object = joinPoint.proceed();
        System.out.println("环绕后通知============");
        return object;
    }

运行效果

图片.png

AspectJ的注解开发AOP:异常抛出通知

方法

    public  void findOne(){
        System.out.println("查找单个商品。。。");
        int i = 1/0;
    }

切面配置

    @AfterThrowing(value = "execution(* com.alan.aspectj.demo1.ProductDao.findOne())",throwing = "e")
    public void afterThrowing(Throwable e){

        System.out.println("异常抛出通知。。。。"+e.getMessage());//打印异常名称
    }

输出结果

图片.png

AspectJ的注解开发AOP:最终通知

切面配置

//无论方法是否有异常，都会执行最终通知中的处理
    @After(value = "execution(* com.alan.aspectj.demo1.ProductDao.findAll(..))")
    public void after(){
        System.out.println("最终通知===================");
    }

输出结果

图片.png

AspectJ的注解开发AOP:切点命令

通过@Pointcut为切点命名

图片.png
原有配置方式

    @Before(value = "execution(* com.alan.aspectj.demo1.ProductDao.save(..))")
    public void before(JoinPoint joinPoint){
        System.out.println("前置通知================" + joinPoint);
    }

采用Pointcut配置方式

   @Before(value = "myPointcut()")
   public void before(JoinPoint joinPoint){
       System.out.println("前置通知================" + joinPoint);
   }

   @Pointcut(value = "execution(* com.alan.aspectj.demo1.ProductDao.save(..))")
//此方法没有意义，为了Pointcut传值使用
   private void myPointcut(){};

多个切面配置之前用||分开

    @Before(value = "myPointcut() || myPointcut2()")
    public void before(JoinPoint joinPoint){
        System.out.println("前置通知================" + joinPoint);
    }

    @Pointcut(value = "execution(* com.alan.aspectj.demo1.ProductDao.save(..))")
    private void myPointcut(){};

    @Pointcut(value = "execution(* com.alan.aspectj.demo1.ProductDao.update(..))")
    private void myPointcut2(){};

AspectJ的xml方式开发AOP:入门案例

接口类和实现类

package com.alan.aspectj.demo2;

public interface CustomerDao {

    public void save();
    public void update();
    public void delete();
    public void findOne();
    public void findAll();


}

package com.alan.aspectj.demo2;

public class CustomerDaoImpl implements CustomerDao {
    @Override
    public void save() {
        System.out.println("保存客户。。。。");
    }

    @Override
    public void update() {
        System.out.println("更新客户。。。");

    }

    @Override
    public void delete() {

        System.out.println("删除客户。。。");
    }

    @Override
    public void findOne() {
        System.out.println("查找单个客户。。。");

    }

    @Override
    public void findAll() {
        System.out.println("查找多个客户。。。");

    }
}

切面类

package com.alan.aspectj.demo2;

public class MyAspectXml {


    //前置通知
    public void before(){
        System.out.println("XML方式的前置通知。。。");
    }
}

<?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:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"> <!-- bean definitions here -->



    <!--XML的配置方式完成AOP的开发==================-->

    <!--配置目标类-->
    <bean id="customerDao" class="com.alan.aspectj.demo2.CustomerDaoImpl"></bean>


    <!--配置切面类-->
    <bean id="myAspectXml" class="com.alan.aspectj.demo2.MyAspectXml"></bean>

    <!--aop的相关配置===============-->
    <aop:config>
        <!--配置切入点-->
        <aop:pointcut id="pointcut1" expression="execution(* com.alan.aspectj.demo2.CustomerDaoImpl.save())"></aop:pointcut>
        <!--配置AOP的切面类-->
        <aop:aspect ref="myAspectXml">
            <!--配置前置通知-->
            <aop:before method="before" pointcut-ref="pointcut1" ></aop:before>
        </aop:aspect>
    </aop:config>

</beans>

XML方式开发AOP

接口类和实现类

package com.alan.aspectj.demo2;

public interface CustomerDao {

    public void save();
    public String update();
    public void delete();
    public void findOne();
    public void findAll();


}

package com.alan.aspectj.demo2;

public class CustomerDaoImpl implements CustomerDao {
    @Override
    public void save() {
        System.out.println("保存客户。。。。");
    }

    @Override
    public String update() {
        System.out.println("更新客户。。。");
        return "spring";

    }

    @Override
    public void delete() {

        System.out.println("删除客户。。。");
    }

    @Override
    public void findOne() {
        System.out.println("查找单个客户。。。");
        //int i = 1/0;

    }

    @Override
    public void findAll() {
        System.out.println("查找多个客户。。。");

    }
}

切面类

package com.alan.aspectj.demo2;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;

public class MyAspectXml {


    //前置通知
    public void before(JoinPoint joinPoint){
        System.out.println("XML方式的前置通知。。。" + joinPoint);
    }


    //后置通知
    public void afterReturning(Object result){
        System.out.println("XML方式的后置通知。。。。" + result);
    }

    //环绕通知

    public Object round(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {

        System.out.println("XML方式的环绕前通知。。。" );

        Object object = proceedingJoinPoint.proceed();

        System.out.println("XML方式的环绕后通知。。。" );

        return object;
    }

    //异常抛出通知
    public void afterThrowing(){
        System.out.println("XML方式异常抛出通知。。。");
    }

    //最终通知
    public void after(){
        System.out.println("XML方式的最终通知。。。。");
    }
}

XML配置

<?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:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"> <!-- bean definitions here -->



    <!--XML的配置方式完成AOP的开发==================-->

    <!--配置目标类-->
    <bean id="customerDao" class="com.alan.aspectj.demo2.CustomerDaoImpl"></bean>


    <!--配置切面类-->
    <bean id="myAspectXml" class="com.alan.aspectj.demo2.MyAspectXml"></bean>

    <!--aop的相关配置===============-->
    <aop:config>
        <!--配置切入点-->
        <aop:pointcut id="pointcut1" expression="execution(* com.alan.aspectj.demo2.CustomerDaoImpl.save(..))"></aop:pointcut>
        <aop:pointcut id="pointcut2" expression="execution(* com.alan.aspectj.demo2.CustomerDaoImpl.update(..))"></aop:pointcut>
        <aop:pointcut id="pointcut3" expression="execution(* com.alan.aspectj.demo2.CustomerDaoImpl.delete(..))"></aop:pointcut>
        <aop:pointcut id="pointcut4" expression="execution(* com.alan.aspectj.demo2.CustomerDaoImpl.findOne())"></aop:pointcut>
        <aop:pointcut id="pointcut5" expression="execution(* com.alan.aspectj.demo2.CustomerDaoImpl.findAll())"></aop:pointcut>
        <!--配置AOP的切面类-->
        <aop:aspect ref="myAspectXml">
            <!--配置前置通知-->
            <aop:before method="before" pointcut-ref="pointcut1" ></aop:before>
            <!--配置后置通知-->
            <aop:after-returning method="afterReturning" pointcut-ref="pointcut2" returning="result"></aop:after-returning>
            <!--环绕通知-->
            <aop:around method="round" pointcut-ref="pointcut3"></aop:around>
            <!--异常抛出通知-->
            <aop:after-throwing method="afterThrowing" pointcut-ref="pointcut4"></aop:after-throwing>
            <!--最终通知-->
            <aop:after method="after" pointcut-ref="pointcut5" ></aop:after>
        </aop:aspect>
    </aop:config>

</beans>

测试类

package com.alan.aspectj.demo2;


import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(value = "classpath:applicationContext2.xml")
public class SpringDemo2 {


    @Autowired
    @Qualifier("customerDao")
    private CustomerDao customerDao;


    @Test
    public void demo1(){

        customerDao.delete();
        customerDao.findAll();
        customerDao.findOne();
        customerDao.save();
        customerDao.update();
    }
}

基于AspectJ的AOP开发

AspectJ简介

AspectJ提供不同的通知类型

通过execution函数，定义切入点的方法

AspectJ的注解开发AOP:入门案例

AspectJ的注解开发AOP:前置通知

AspectJ的注解开发AOP:后置通知

AspectJ的注解开发AOP:环绕通知

AspectJ的注解开发AOP:异常抛出通知

AspectJ的注解开发AOP:最终通知

AspectJ的注解开发AOP:切点命令

AspectJ的xml方式开发AOP:入门案例

XML方式开发AOP

推荐阅读更多精彩内容