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

          一.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面向切面编程思想有更深的了解。