AOP面向切面编程的四种实现

2022-12-07 08:05:10

一.AOP(面向切面编程)的四种实现分别为最原始的经典AOP、代理工厂bean(ProxyFacteryBean)和默认自动代理DefaultAdvisorAutoProxyCreator以及BeanNameAutoProxyCreator代理、Aspectj的注解和xml配置文件。

1.代理工厂bean(ProxyFacteryBean)的方式

1.1 接口(Interface)

 package cn.happy.interfaces;

 public interface Advice {

     public void fristMethod();

     public String secondMethod();

 }

1.2 接口的实现类

 package cn.happy.impl;

 import cn.happy.interfaces.Advice;

 public class AdviceImpl implements Advice {

     public void fristMethod() {

          System.out.println("==fristMethod==");

     }

     public String secondMethod() {

         System.out.println("==secondMethod==");

         return "abc";

     }

 }

1.3 各种通知增强

1.3.1 前置增强

 package cn.happy.advice;

 import java.lang.reflect.Method;

 public class MethodBeforeAdvice implements

         org.springframework.aop.MethodBeforeAdvice {

     public void before(Method arg0, Object[] arg1, Object arg2)

             throws Throwable {

         System.out.println("==Before==");

     }

 }

1.3.2 后置增强

 package cn.happy.advice;

 import java.lang.reflect.Method;

 import org.springframework.aop.AfterReturningAdvice;

 public class AfterReturningAdvie implements AfterReturningAdvice {

     public void afterReturning(Object arg0, Method arg1, Object[] arg2,

             Object arg3) throws Throwable {

         System.out.println("==After==");

     }

 }

1.3.3 环绕增强

package cn.happy.aroundadvice;

import org.aopalliance.intercept.MethodInterceptor;

import org.aopalliance.intercept.MethodInvocation;

public class MyInterceptor implements MethodInterceptor{

    public Object invoke(MethodInvocation invocation) throws Throwable {

        System.out.println("==before==");

        String result= (String)invocation.proceed();

        System.out.println("==after==");

        return result;

    }

}

1.3.4 异常增强

package cn.happy.exception;

import org.springframework.aop.ThrowsAdvice;

public class MyException implements ThrowsAdvice {

    public void afterThrowing(Exception ex){

        System.out.println("异常通知");

    }

}

1.4 配置文件

<?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:context="http://www.springframework.org/schema/context"

    xsi:schemaLocation="

        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd

        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

        <!-- 实现类的引入 -->

        <bean id="adviceimpl" class="cn.happy.impl.AdviceImpl"></bean>

       <!-- 前置增强  通知-->

        <bean id="advicebefore" class="cn.happy.advice.MethodBeforeAdvice"></bean>

        <!-- 后置增强  通知-->

        <bean id="adviceafter" class="cn.happy.advice.AfterReturningAdvie"></bean>

        <!-- 环绕增强 -->

        <bean id="around" class="cn.happy.aroundadvice.MyInterceptor"></bean>

        <!-- 关联  代理工厂bean ProxyFacteryBean 通知 -->

        <!--<bean id="serviceProxy" class="org.springframework.aop.framework.ProxyFactoryBean">

           <property name="targetName" value="adviceimpl"></property>

           <property name="interceptorNames" value="advicebefore,adviceafter"></property>

        </bean>-->

        <!-- 环绕增强 代理工厂 顾问包装通知 -->

        <bean id="aroundserviceProxy" class="org.springframework.aop.framework.ProxyFactoryBean">

           <property name="target" ref="adviceimpl"></property>

           <property name="interceptorNames" value="beforeadvisor"></property>

        </bean>

        <!-- 切面  通知  -->

        <bean id="beforeadvice" class="cn.happy.mymethodbefore.MyMethodBeforeAdvice"></bean>

        <!-- 顾问  包装advice -->

        <bean id="beforeadvisor" class="org.springframework.aop.support.NameMatchMethodPointcutAdvisor">

         <property name="advice" ref="beforeadvice"></property>

         <property name="mappedNames" value="fristMethod,secondMethod"></property>

        </bean>

        <!-- 顾问  包装advice 正则表达式-->

        <!--<bean id="beforeadvisor1" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">

         <property name="advice" ref="beforeadvice"></property>

         <property name="pattern" value=".*Method.*"></property>

        </bean>-->

        <!-- 默认自动代理  默认只找通知-->

        <!--<bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"></bean>-->

        <!-- beanname自动代理 可以选择顾问或者通知-->

        <bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">

          <property name="beanNames" value="adviceimpl"></property>

          <property name="interceptorNames" value="beforeadvisor"></property>

        </bean>

</beans>

1.5 测试类

package cn.happy.test;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import cn.happy.interfaces.Advice;

public class Test {

    /**

     * 通知的前置和后置测试

     */

    public static void main(String[] args) {

        //解析配置文件

        ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");

        Advice advice= (Advice)ctx.getBean("adviceimpl"); //自动代理beanname的方式

        advice.fristMethod();

        advice.secondMethod();

    }

}

2. 最原始的经典AOP

2.1 最基本分层模式dao、biz、service以及最后测试Test

2.1.1DAO层

package cn.happy.dao;

import cn.happy.entity.User;

   //接口

public interface UDao {

    //保存方法

    public void save(User user);

}

 //实现类

package cn.happy.dao;

import cn.happy.entity.User;

public class UserDaoImpl implements UDao{

    public void save(User user) {

        System.out.println("保存成功");

    }

}

2.1.2 BIZ层

package cn.happy.biz;

import cn.happy.entity.User;

  //业务接口

public interface UBiz {

    //保存方法

    public void save2(User user);

}

  //业务实现类

package cn.happy.biz;

import cn.happy.dao.UDao;

import cn.happy.entity.User;

public class UserBiz implements UBiz{

    //dao的对象

    private UDao udao;

    public void save2(User user) {

        udao.save(user);

    }

    public UDao getUdao() {

        return udao;

    }

    public void setUdao(UDao udao) {

        this.udao = udao;

    }

}

2.1.3 AOP模块即service层

package cn.happy.logger;

import java.lang.reflect.Method;

import org.springframework.aop.MethodBeforeAdvice;

  //前置内容

public class LoggerBefore implements MethodBeforeAdvice {

    public void before(Method arg0, Object[] arg1, Object arg2)

            throws Throwable {

        System.out.println("save前置内容");

    }

}

//后置内容

package cn.happy.logger;

import java.lang.reflect.Method;

import org.springframework.aop.AfterReturningAdvice;

public class LoggerAfter implements AfterReturningAdvice{

    public void afterReturning(Object arg0, Method arg1, Object[] arg2,

            Object arg3) throws Throwable {

        System.out.println("save后置内容");

    }

}

2.1.4 经典的配置文件

<?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-4.1.xsd">

        <!-- 业务biz与dao接口对象的实现 -->

        <bean id="dao" class="cn.happy.dao.UserDaoImpl"></bean>

        <bean id="biz" class="cn.happy.biz.UserBiz">

            <property name="udao" ref="dao"></property>

        </bean>

        <!-- 前置与后置内容的配置 -->

        <bean id="before" class="cn.happy.logger.LoggerBefore"></bean>

        <bean id="after" class="cn.happy.logger.LoggerAfter"></bean>

        <!-- aop的配置 -->

        <aop:config>

          <aop:pointcut expression="execution(public void save2(cn.happy.entity.User))" id="pointcut"/>

          <!-- 在切入点处插入增强处理、完成"织入" -->

          <aop:advisor advice-ref="before" pointcut-ref="pointcut"/>

          <aop:advisor advice-ref="after" pointcut-ref="pointcut"/>

        </aop:config>

</beans>

2.1.5 测试类

package cn.happy.test;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import cn.happy.biz.UBiz;

import cn.happy.entity.User;

public class AOPTest {

    public static void main(String[] args) {

        ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");

        UBiz ubiz=(UBiz)context.getBean("biz");

        User user=new User();

        ubiz.save2(user);

        System.out.println("save~ok");

    }

}

3. 然后就是Aspectj的注解以及xml配置文件的两种方式了。

3.1 Aspectj注解

3.1.1 接口和实现类

package cn.happy.impl;

//接口

public interface AspectDao {

    public void add();

    public void delete();

}

//实现类

package cn.happy.impl;

public class AspectjIpml implements AspectDao{

    //添加

    public void add() {

        System.out.println("==ADD==");

    }

    //删除

    public void delete() {

        System.out.println("==DELETE==");

    }

}

3.1.2 注解类Aspect

package cn.happy.aspectj;

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.Before;

@org.aspectj.lang.annotation.Aspect

public class Aspect {

    //前置增强

     @Before(value="execution(public * *(..))")

    public void asBefore(){

        System.out.println("这是前置增强");

    }

   //后置增强

     @AfterReturning(value="execution(public * *(..))")

    public void asAfterReturning(){

        System.out.println("这是后置增强");

    }

   //环绕增强

     @Around(value="execution(public * *(..))")

    public void asAround(ProceedingJoinPoint pj){

         System.out.println("这是环绕前置增强");

         try {

            pj.proceed();

        } catch (Throwable e) {

            //抓捕异常

            e.printStackTrace();

        }

        System.out.println("这是环绕后置增强");

    }

   //异常增强

     @AfterThrowing(value="execution(public * *(..))")

    public void asThorws(){

        System.out.println("这是异常增强");

    }

   //最终增强

     @After(value="execution(public * *(..))")

    public void asAfter(){

        System.out.println("这是最终增强");

    }

}

3.1.3 注解的配置文件

<?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: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.xsd

        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd

        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

   <!-- 目标对象 -->

   <bean id="aspectimpl" class="cn.happy.impl.AspectjIpml"></bean>

   <!-- 增强类 -->

   <bean id="aspectj" class="cn.happy.aspectj.Aspect"></bean>

   <!-- 扫描整个项目 关联注解类和实现类 -->

   <aop:aspectj-autoproxy />

</beans>

3.1.4 测试类

package cn.happy.test;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import cn.happy.impl.AspectDao;

public class AspectjTest {

    /**

     * 注解测试 */

    public static void main(String[] args) {

        // 解析配置文件

        ApplicationContext ctx = new ClassPathXmlApplicationContext(

                "applicationContext.xml");

        AspectDao aspect = (AspectDao) ctx.getBean("aspectimpl");

        aspect.add();

        aspect.delete();

    }

}

4. Aspectj的XML配置法,其他的基本都一样只要修改Aspectj增强类和配置文件就行了

4.1 Aspect增强类只需将那些注解消去即可

package cn.happy.aspectj;

import org.aspectj.lang.ProceedingJoinPoint;

public class Aspect {

    //前置增强

    public void asBefore(){

        System.out.println("这是前置增强");

    }

    //后置增强

    public void asAfterReturning(){

        System.out.println("这是后置增强");

    }

  //环绕增强

    public void asAround(ProceedingJoinPoint pj){

        System.out.println("这是环绕前置增强");

        try {

            pj.proceed();

        } catch (Throwable e) {

            //抓捕异常

            e.printStackTrace();

        }

        System.out.println("这是环绕后置增强");

    }

  //异常增强

    public void asThorws(){

        System.out.println("这是异常增强");

    }

  //最终增强

    public void asAfter(){

        System.out.println("这是最终增强");

    }

}

4.2 XML的配置文件会稍微会复杂一点,但大致的还是跟对原始的经典aop实现方式相同

<?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: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.xsd

        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd

        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

   <!-- 目标对象 -->

   <bean id="aspectimpl" class="cn.happy.impl.AspectjIpml"></bean>

   <!-- 增强类 -->

   <bean id="aspectj" class="cn.happy.aspectj.Aspect"></bean>

   <!-- Aspectj的XML配置文件 -->

   <aop:config>

    <aop:pointcut expression="execution(public * *(..))" id="pointcut"/>

    <aop:aspect ref="aspectj">

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

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

     <aop:after-returning method="asAround(org.aspectj.lang.ProceedingJoinPoint)" pointcut-ref="pointcut"/>

     </aop:aspect>

   </aop:config>

</beans>

好了，这就是AOP(面向切面编程)的四种实现方式了。希望你们看了之后能让你们对AOP面向切面编程思想有更深的了解。

码农公寓

相关文章