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

最新推荐文章于 2023-06-26 22:17:02 发布
最新推荐文章于 2023-06-26 22:17:02 发布
阅读量243 收藏
点赞数

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

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

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

      1.1 接口(Interface)

 

复制代码 
1 package cn.happy.interfaces;
2 
3 public interface Advice {
4 
5     public void fristMethod();
6     
7     public String secondMethod();
8 }
复制代码

         1.2  接口的实现类

复制代码 
 1 package cn.happy.impl;
 2 
 3 import cn.happy.interfaces.Advice;
 4 
 5 public class AdviceImpl implements Advice {
 6 
 7     public void fristMethod() {
 8          System.out.println("==fristMethod==");
 9     }
10 
11     public String secondMethod() {
12         System.out.println("==secondMethod==");
13         return "abc";
14     }
15 
16 }
复制代码

 

 

         1.3 各种通知增强

       1.3.1 前置增强

复制代码 
 1 package cn.happy.advice;
 2 
 3 import java.lang.reflect.Method;
 4 
 5 public class MethodBeforeAdvice implements
 6         org.springframework.aop.MethodBeforeAdvice {
 7 
 8     public void before(Method arg0, Object[] arg1, Object arg2)
 9             throws Throwable {
10         System.out.println("==Before==");
11          
12     }
13 
14 }
复制代码

 

 

        1.3.2  后置增强

复制代码 
 1 package cn.happy.advice;
 2 
 3 import java.lang.reflect.Method;
 4 
 5 import org.springframework.aop.AfterReturningAdvice;
 6 
 7 public class AfterReturningAdvie implements AfterReturningAdvice {
 8 
 9     public void afterReturning(Object arg0, Method arg1, Object[] arg2,
10             Object arg3) throws Throwable {
11         System.out.println("==After==");
12 
13     }
14 
15 }
复制代码

 

 

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

 

qq_39930738
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring AOP面向切面编程实现原理方法详解
08-18
主要介绍了Spring AOP面向切面编程实现原理方法详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Spring与AOP之AspectJ对DAO的实现
huangyuanzhi
11-02 337
对于 AOP 这种编程思想，很多框架都进行了实现。 Spring 就是其中之一， 可以完成面向切面编程。 然而， AspectJ 也实现了 AOP 的功能，且其实现方式更为简捷，使用更为方便，而且还支持注解式开发（在 Spring 中使用 AOP 开发时，一般使用 AspectJ 的实现方式）。 AspectJ 简介 AspectJ 是一个面向切面的框架，它扩展了 Java 语言。 AspectJ 定义了 AOP 语法，它有一个专门的编译器用来生成遵守 Java 字节编码规范的 Class 文件。——百度
AOP(面向切面编程)的三种实现方式
weixin_43392372的博客
08-21 3175
#AOP的实现方式 ##一、基于代理模式的SpringAOP： 1.切面（Advisor）= 切点（Pointcut）+ 通知(Advice) 2.前置通知（MethodBeforeAdvice接口）、后置通知（AfterReturningAdvice接口）、环绕通知（MethodInterceptor接口）、异常通知（throwsAdvice） 3.配置代理工厂 自动配置代理工厂： ##二、纯POJO方式实现AOP ##三、@AspectJ注解驱动的切面 1.注解的使用： （1）切面配置：@As
AOP面向切面编程的三种实现方式
DSL95的博客
10-17 2998
AOP概念 在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 AOP是Spring框架面向切面的编程思想，AOP采用一种称为“横切”的技术，将涉及多业务流程
Spring框架（六）——AOP面向切面编程、AOP三种实现方式
zx123456789kk的博客
02-26 2202
1、 什么是AOP AOP（Aspect Oriented Programming）意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的...
Java实现AOP面向切面编程的实例教程共4页.pdf.z
10-30
Java实现AOP面向切面编程的实例教程共4页.pdf.zip
aop 面向切面编程 demo
11-16
aop 面向切面编程 demo,通过一个小案例来讲解，aop在andriod开发中运用
AOP面向切面编程实例
05-17
AOP面向切面编程实例，可当作业提交。.net代码亲测，完全正确运行。
Spring 面向切面编程AOP实现详解
08-25
主要介绍了Spring 面向切面编程AOP实现详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
spring----IOC注解方式以及AOP
weixin_30725467的博客
06-15 289
技术分析之Spring框架的IOC功能之注解的方式 Spring框架的IOC之注解方式的快速入门 1. 步骤一：导入注解开发所有需要的jar包 * 引入IOC容器必须的6个jar包 * 多引入一个：Spring框架的AOP的jar包，spring-aop的jar包 2. 步骤二：创建对应的包结构，编写Java的类 * UserService ...
面试官：谈谈你对IOC和AOP的理解及AOP四种实现方式
热门推荐
小样yx的博客
05-17 4万+
一、AOP介绍 面向切片编程（AOP—Aspect Oriented Programming）可以说是对OOP（面向对象编程）的补充和完善，面向对象就是将事物的特性和行为抽象为一个对象，如people类有身高、体重、年龄等属性，也有吃饭、睡觉等行为。把这些特性和行为封装成一个类，然后可以统一调用。面向切片也可以举个例子，比如people类有自己的属性和行为，但是有小一部分人生病要去医院看病，看病这个业务逻辑就不属于哪一个类，因为people泛指所有人，所有人不会都看病。AOP就是把医院看病这一个业务逻辑功能
【开发】实现一个简单的切面编程（Aspect）
qq_43014198的博客
08-17 2729
面向切面编程面向切面概念代码部分 面向切面概念 什么是切面？ 切面就是把多个类的公共行为封装起来。（比如日志记录，拦截方法，过滤等操作） 反过来理解就是多个类都需要这个操作，动态地将代码切入到类的指定方法、指定位置上的编程思想就是面向切面的编程。 代码部分 1.首先创建一个切面接口 @Target({ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface APIAESEncryption {
AOP的三种实现方式
qq_51447436的博客
02-09 5249
AOP的三种实现方式
实现AOP的三种方式
Bro_come的博客
03-25 1291
AOP的实现方式
Spring之AOP切面编程
最新发布
从基础到源码解析的学习记录
06-26 612
AOP（Aspect Oriented Programming）是一种设计思想，是软件设计领域中的面向切面编程它是面向对象编程的一种补充和完善它以通过预编译方式和运行期动态代理方式实现在不修改源代码的情况下，给程序动态统一添加额外功能的一种技术。
【Java 初级】Spring核心之面向切面编程(AOP)
激流丶的博客
06-12 2502
AOP（面向切面编程）是一种编程范式，用于将横切关注点（如日志记录、性能统计等）从主要业务逻辑中分离出来。通过将这些横切关注点与业务逻辑分离开来，可以提高代码的可重用性、可维护性和可扩展性。在AOP中，切面是一个模块化的单元，它封装了与横切关注点相关的行为，并可以在多个不同的应用程序中重用。切面可以通过一种称为“织入”的过程将其与主要业务逻辑相结合，从而创建一个完整的应用程序。
AOP面向切面编程是怎么实现的？
06-09
AOP（面向切面编程）的实现主要依赖于代理技术，通常有两种代理方式：静态代理和动态代理。...无论是静态代理还是动态代理，都是通过代理类来实现目标类的方法增强，从而实现AOP面向切面编程的效果。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值