aop 订阅
在软件业,AOP为Aspect Oriented Programming的缩写,意为:面向切面编程,通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续,是软件开发中的一个热点,也是Spring框架中的一个重要内容,是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高了开发的效率。 展开全文
在软件业,AOP为Aspect Oriented Programming的缩写,意为:面向切面编程,通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续,是软件开发中的一个热点,也是Spring框架中的一个重要内容,是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高了开发的效率。
信息
衍生范型
函数式编程
又    意
葡萄酒
简    称
AOP
中文名
面向切面编程
属    性
软件开发技术
外文名
Aspect Oriented Programming
AOP名称含义
Aspect Oriented Programming(AOP)是较为热门的一个话题。AOP,国内大致译作“面向切面编程”。“面向切面编程”,这样的名字并不是非常容易理解,且容易产生一些误导。有些人认为“OOP/OOD11即将落伍,AOP是新一代软件开发方式”。显然,发言者并没有理解AOP的含义。Aspect,的确是“方面”的意思。不过,汉语传统语义中的“方面”,大多数情况下指的是一件事情的不同维度、或者说不同角度上的特性,比如我们常说:“这件事情要从几个方面来看待”,往往意思是:需要从不同的角度来看待同一个事物。这里的“方面”,指的是事物的外在特性在不同观察角度下的体现。而在AOP中,Aspect的含义,可能更多的理解为“切面”比较合适。可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术。AOP实际是GoF设计模式的延续,设计模式孜孜不倦追求的是调用者和被调用者之间的解耦,提高代码的灵活性和可扩展性,AOP可以说也是这种目标的一种实现。在Spring中提供了面向切面编程的丰富支持,允许通过分离应用的业务逻辑与系统级服务(例如审计(auditing)和事务(transaction)管理)进行内聚性的开发。应用对象只实现它们应该做的——完成业务逻辑——仅此而已。它们并不负责(甚至是意识)其它的系统级关注点,例如日志或事务支持。日志记录,性能统计,安全控制,事务处理,异常处理等等。将日志记录,性能统计,安全控制,事务处理,异常处理等代码从业务逻辑代码中划分出来,通过对这些行为的分离,我们希望可以将它们独立到非指导业务逻辑的方法中,进而改变这些行为的时候不影响业务逻辑的代码。
收起全文
精华内容
参与话题
问答
  • SpringAop

    千次阅读 2017-04-25 18:37:53
    SpringAop面向切面的思想 就是在某个方法之前和之后插入 package biz; import java.lang.reflect.Method; import java.util.Arrays; import org.springframework.aop.AfterReturningAdvice; public class ...

    SpringAop面向切面的思想

    就是在某个方法之前和之后插入

    package biz;
    
    import java.lang.reflect.Method;
    import java.util.Arrays;
    
    import org.springframework.aop.AfterReturningAdvice;
    
    public class MyAfter implements AfterReturningAdvice{
    
    	public void afterReturning(Object arg0, Method arg1, Object[] arg2,
    			Object arg3) throws Throwable {
    		System.out.println("------------后置增强----------------");
    		System.out.println("在"+arg3+"对象上的"+arg1.getName()+"方法");
    		System.out.println("传入参数"+Arrays.toString(arg2));
    		System.out.println("返回的结果"+arg0);
    		
    	}
    
    }
    

    package biz;
    
    import java.lang.reflect.Method;
    import java.util.Arrays;
    
    import org.springframework.aop.MethodBeforeAdvice;
    
    public class MyBefore  implements MethodBeforeAdvice{
    
    	public void before(Method arg0, Object[] arg1, Object arg2)
    			throws Throwable {
    		System.out.println("------------前置增强-------------");
    		System.out.println("在"+arg2+"对象上的"+arg0.getName()+"方法");
    		System.out.println("传入参数"+Arrays.toString(arg1));
    		System.out.println("---------------------------");
    		
    	}
    
    }
    
    	
    	<bean id="before" class="biz.MyBefore"/>
    	<bean id="after" class="biz.MyAfter"/>
    	<aop:config>
    	<aop:pointcut id="cutpiont" expression="execution(public void print(String))"/>
    	<aop:advisor pointcut-ref="cutpiont" advice-ref="before"/>
    		<aop:advisor pointcut-ref="cutpiont" advice-ref="after"/>
    	</aop:config>


    
    

    展开全文
  • AOP

    万次阅读 多人点赞 2019-04-10 14:07:17
    AOP(Aspect Oriented Programming),是面向切面编程的技术。AOP基于IOC基础,是对OOP的有益补充。 AOP将应用系统拆分为个部分:核心业务逻辑及横向的通用逻辑,也就是所谓的切面。 举例:所有大中型应用都要涉及到...

    AOP(Aspect Oriented Programming),是面向切面编程的技术。AOP基于IOC基础,是对OOP的有益补充。

    AOP将应用系统拆分为个部分:核心业务逻辑及横向的通用逻辑,也就是所谓的切面。

    举例:所有大中型应用都要涉及到的持久化管理、事务管理、权限管理、日志管理和调试管理等。使用AOP技术可以让开发人员只专注核心业务,而通用逻辑则使用AOP技术进行横向切入,由专人去处理这些通用逻辑,会使得任务简单明了,提高开发和调试的效率。

    Target:目标类

    Joinpoint:连接点是指所有可能织入通知的方法理论上大部分方法都是连接点

    Pointcut:切入点,已经被增强的方法

    Advice:通知,增强的方法

    Aspect:切面,通知所在的类就叫切面。

    Weaving:织入,将通知应用到目标对象来创建新的代理对象的过程。

     通知的类型: 前置通知 后置通知 返回通知 异常通知 环绕通知

    各类通知的执行顺序: 前置通知 2.执行目标方法 3.执行后置通知 4.返回通知||异常通知

    前置通知,后置通知,返回通知,异常通知都可以接受一个JoinPoint类型的对象作为参数。该对象封装了连接点的相关信息。主要关注:方法参数和方法签名。

    返回通知的returning属性可以将目标方法的返回值定义一个名字,然后在返回通知的形参上声明一个同名的Object类型的参数,来访问方法的返回结果。

    <aop:after-returning method=”afterReturnLog” pointcut-ref=”userDaoPointccut” returning=”result” /> 环绕通知 环绕通知必须要有返回值(Object类型)

    环绕通知必须要有形参(ProceedingJoinPoint pjp)

    在环绕通知中,通过pjp.proceed()方法显示调用目标对象的切点并将结果返回出去。

    使用注解配置aop

    引入约束 beans context aop 扫描包 开启注解式的aop <aop:aspectj-autoproxy proxy-target-class="true"></aop:aspectj-autoproxy>

    在业务类上加上注解(@Component)

    在属性上加@Autowired注解

    在切面类上加注解 (@Component  @Aspect)

    在通知上加上相应的注解 @Before(value="")

    @AfterReturning(returning="目标切点返回值的名字") 在通知方法参数只能为Object

    @AfterThrowing(throwing="异常的名字") 在通知方法参数可以为Object也可为Exception

    重用切入点表达式: 在切面中定义一个空的方法,在方法上加@Pointcut注解,在value属性中指定切入点表达式 @Pointcut(value=“execution(* com.cdsxt.dao.*.*(..))”) Public void pointcutExpression(){} @Before(value="pointcutExpression()")

    在面对多个切面时可以在类上加@Order(1)数字越小越优先执行

    AOP两种代理的区别:

    AOP支持2种代理,jdk的动态代理和CGLIB实现机制。

    jdk基于接口实现:jdk动态代理对实现了接口的类进行代理。

    CGLIB基于继承:CGLIB代理可以对类代理,主要对指定的类生成一个子类,因为是继承,所以目标类最好不要使用final声明。

    通常情况下,鼓励使用jdk代理,因为业务一般都会抽象出一个接口,而且不用引入新的东西。如果是遗留的系统,以前没有实现接口,那么只能使用CGLIB。

     

    展开全文
  • java技术——Spring Aop

    万次阅读 多人点赞 2016-04-21 21:58:57
    AOP(Aspect Orient Programming),也就是面向切面编程。可以这样理解,面向对象编程(OOP)是从静态角度考虑...下面是一个spring aop的零配置的例子(用maven构建)。 配置文件 Source code  

    AOP(Aspect Orient Programming),也就是面向切面编程。可以这样理解,面向对象编程(OOP)是从静态角度考虑程序结构,面向切面编程(AOP)是从动态角度考虑程序运行过程。

    AOP原理图

    1335430298_1017

    下面是一个spring aop的零配置的例子(用maven构建)。

    配置文件

    Source code    
    <?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-3.0.xsd
     
     
    http://www.springframework.org/schema/context
     
     
    http://www.springframework.org/schema/context/spring-context-3.0.xsd
     
     
    http://www.springframework.org/schema/aop
     
     http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
    	<!-- 指定自动搜索 Bean 组件、自动搜索方面类 -->
    	<context:component-scan base-package="com.bobohe">
    		<context:include-filter type="annotation"
    			expression="org.aspectj.lang.annotation.Aspect" />
    	</context:component-scan>
    	<!-- 启动 @AspectJ 支持 -->
    	<aop:aspectj-autoproxy />
    </beans>

     

    目标对象类

    Source code    
    package com.bobohe.test01;
     
    import org.springframework.beans.factory.annotation.Qualifier;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.stereotype.Component;
     
    import javax.annotation.Resource;
     
    /**
     * Hello world!
     *
     */
     
    @Component("app")
    public class App implements AppInterface
    {
    	public void testAspectJ(String param){
    		System.out.println("do test AspectJ:" + param);
    	}
    }

    目标对象接口

    Source code    
    package com.bobohe.test01;
     
    public interface AppInterface {
    	public void testAspectJ(String param);
    }

    junit测试类

    Source code    
    package com.bobohe.test01;
     
    import com.bobohe.test01.App;
     
    import org.springframework.beans.factory.BeanFactory;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
     
    import junit.framework.Test;
    import junit.framework.TestCase;
    import junit.framework.TestSuite;
     
    /**
     * Unit test for simple App.
     */
    public class AppTest extends TestCase {
     
    	public void testApp() {
    		BeanFactory bf = new ClassPathXmlApplicationContext("ApplicationContext.xml");
    		AppInterface at = (AppInterface) bf.getBean("app");
    		at.testAspectJ("real params");
    		System.out.println(at.getClass());
    		assertTrue(true);
    	}
     
    }

    pom.xml

    Source code    
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    	<modelVersion>4.0.0</modelVersion>
     
    	<groupId>com.bobohe</groupId>
    	<artifactId>springtest</artifactId>
    	<version>0.0.1-SNAPSHOT</version>
    	<packaging>jar</packaging>
     
    	<name>springtest</name>
    	<url>http://maven.apache.org</url>
     
    	<properties>
    		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    	</properties>
     
    	<dependencies>
    		<dependency>
    			<groupId>junit</groupId>
    			<artifactId>junit</artifactId>
    			<version>3.8.1</version>
    			<scope>test</scope>
    		</dependency>
     
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-context</artifactId>
    			<version>4.1.4.RELEASE</version>
    			<scope>runtime</scope>
    		</dependency>
     
    		<dependency>
    			<groupId>javax</groupId>
    			<artifactId>javaee-api</artifactId>
    			<version>6.0</version>
    		</dependency>
     
    		<dependency>
    			<groupId>org.aspectj</groupId>
    			<artifactId>aspectjrt</artifactId>
    			<version>1.8.3</version>
    		</dependency>
    		<dependency>
    			<groupId>org.aspectj</groupId>
    			<artifactId>aspectjweaver</artifactId>
    			<version>1.8.3</version>
    			<scope>runtime</scope>
    		</dependency>
     
    	</dependencies>
     
     
    </project>

    输出结果

    Source code    
    执行目标方法之前,模拟开始事务 ...
    do test AspectJ:被改变的参数
    执行目标方法之后,模拟结束事务 ...
    class sun.proxy.$Proxy8

    从输出结果看,在这个例子中spring用的jdk的动态代理来创建aop代理的。但是当我们的被代理的对象类没有继承接口是,spring会使用cglib来生成aop代理。这一层是spring帮我们处理的。spring会根据实际情况自动切换。

    实例代码下载地址http://pan.baidu.com/s/1sjHO7mP


    展开全文
  • springaop

    千次阅读 2011-08-07 22:19:35
    springaop入门
    springaop入门
    展开全文
  • Spring原理/SpringMVC原理/IOC/AOP原理

    千次阅读 2019-05-27 10:03:34
    Spring原理/SpringMVC原理/IOC/IOP原理我的微型IOC框架实现 我的微型IOC框架实现 当你打开这本书的时候我要告诉你的第一句话就是认真把前言读完,因为前言概括的本书的大纲以及思想。 本书适合什么读者阅读呢?适合...
  • Spring AOP切面中启用新事务

    万次阅读 多人点赞 2019-07-31 19:16:01
    sping的声明式事务就是靠AOP来实现的,一般事务都在业务层中启用,那如果要在AOP的逻辑中启用一个新的事务要怎么做呢?比如下面的例子: //定义一个切点,这里指com.lidehang.remote包下所有的类的方法...
  • SpringAop两种代理模式-源码分析

    万次阅读 2020-03-24 18:42:08
    这个类就可以找到答案:org.springframework.aop.framework.DefaultAopProxyFactory 由源码可得: JDK动态代理:当代理类为接口时采用Jdk动态代理 Cglib动态代理:cglib是针对类来实现代理的 2.jdk动态代理为什么...
  • 细说Spring——AOP详解(AOP概览)

    万次阅读 多人点赞 2018-05-30 18:29:25
    一、对AOP的初印象 首先先给出一段比较专业的术语(来自百度): 在软件业,AOP为Aspect ...热点,也是Spring框架中的一个重要内容,是函数式编程的一种衍生范型。利用AOP可以对业务逻辑 的各个部分进行隔离,从而...
  • AOP(Aspect Oriented Programming) 1.概念 AOP:全称是 Aspect Oriented Programming即:面向切面编程。
  • spring boot AOPspring boot统一异常处理

    千次阅读 2017-10-20 14:33:42
    一,spring AOPspring boot使用AOP,代码如下,代码比较简单就不细说了,直接上代码,可以使用AOP做日志处理package com.qwrt.fire.sensor.aop; import com.alibaba.fastjson.JSONArray; import ...
  • Spring

    千次阅读 多人点赞 2020-02-04 17:41:35
    Spring里是如何管理事务的? Spring里的声明式事务的做法和优点?...DI3.Spring AOP4.Spring事务什么叫延迟加载? 1.Spring 1.1搭建 Spring 运行时环境 加入 JAR 包 在 Spring Tool Suit...
  • Spring AOP

    千次阅读 2018-11-08 19:33:28
    Spring AOP   主要内容: AOP是什么? 为什么需要AOP? 什么场景适用AOPAOP的几个核心概念 Spring AOP源码使如何实现的? 如何使用 Spring AOP?   1. AOP是什么? AOP (Aspect-oriented ...
  • Spring boot2 配置AOP日志

    万次阅读 2019-01-04 16:57:14
    Spring boot2 配置AOP前置增强,后置增强,异常增强,环绕增强,最终增强 关于AOP切面相关具体概念不做过多阐述(概念弄懂有利于理解思想),这是配置AOP的各种增强日志,解决日志嵌套在业务代码的麻烦和不科学 先来个Git ...
  • Spring Aop 扫盲

    千次阅读 2019-09-09 08:00:00
    如果欣赏,还请关注这是 cxuan 的第31篇原创文章关于AOP面向切面编程(Aspect-oriented Programming,俗称AOP)提供了一种面向对象编程...
  • Spring AOP 概述

    千次阅读 2017-04-07 08:02:05
     在以前的项目中,很少去关注spring aop的具体实现与理论,只是简单了解了一下什么是aop具体怎么用,看到了一篇博文写得还不错,就转载来学习一下,博文地址:http://www.cnblogs.com/xrq730/p/4919025.html ...
  • Spring Aop Demo

    千次阅读 2016-06-12 17:23:22
    端午节的时候回想这件事,发现AOP不正是职业解决这种事情的吗!而且用AOP打日志,原有的业务代码省去了日志代码,更加精简。 先写了个AOP的demo体验下功能。导入aop相关的依赖 3.2.0.RELEASE 1.1.36
  • AOP——SpringAOP(最重要)

    万次阅读 2017-06-19 12:50:16
    一、AOP: 是对OOP编程方式的一种补充。翻译过来为“面向切面编程”。 可以理解为一个拦截器框架,但是这个拦截器会非常武断,如果它拦截一个类,那么它就会拦截这个类中的所有方法。如对一个目标列的代理,增强了...
  • spring aop 拦截spring mvc controller

    千次阅读 2013-11-25 11:02:03
    spring aop 拦截spring mvc controller
  • Java AOP & Spring AOP 原理和实现

    千次阅读 2017-08-08 20:15:07
    AOP(Aspect Oriented Programming),即面向切面编程,可以说是OOP(Object Oriented Programming,面向对象编程)的补充和完善。OOP引入封装、继承、多态等概念来建立一种对象层次结构,用于模拟公共行为的一个...
  • 7 基于XML配置的Spring AOP基于XML配置的Spring AOP需要引入AOP配置的Schema,然后我们就可以使用AOP Schema下定义的config、aspect、pointcut等标签进行Spring AOP配置了。 <beans xmlns="http://www.spring...
  • 关于 Spring AOP (AspectJ) 你该知晓的一切

    万次阅读 多人点赞 2017-02-21 08:00:47
    【版权申明】未经博主同意,谢绝转载!(请尊重原创,博主保留追究权) ... 出自【zejian的博客】 关联文章: ...关于 Spring AOP (AspectJ) 你该知晓的一切本篇是年后第一篇博文,由于博主用了不少
  • SpringAOP与Spring事务处理总结

    千次阅读 2015-12-12 14:02:05
    spring用到的另外一项技术就是AOP(Aspect-Oriented Programming, 面向切面编程),它是一种新的方法论, 是对传统 OOP(Object-Oriented Programming, 面向对象编程)的补充。AOP 的主要编程对象是切面(aspect), 而切面...
  • 一:XML形式配置 ...<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" xmlns:context
  • Spring AOP 实现原理

    万次阅读 多人点赞 2013-09-24 15:23:43
    什么是AOP AOP(Aspect-OrientedProgramming,面向方面编程),可以说是OOP(Object-Oriented Programing,面向对象编程)的补充和完善。OOP引入封装、继承和多态性等概念来建立一种对象层次结构,用以模拟公共行为...
  • aopspring aop,aspectj区别与联系

    千次阅读 2014-08-26 13:07:34
    aop类似于oop,是一种编程思想。
  • Spring MVC和Spring配置AOP

    千次阅读 2016-01-09 12:48:56
    所以要想给Spring MVC的Controller添加AOP的话,得在Spring MVC的配置文件中配置,要想给Service和Repository添加AOP的话得在Spring的配置文件中配置。 2.以一个例子说明,有人配置了Service层的事务AOP之后,事务...
  • Spring Aop(一)——Aop简介

    千次阅读 2017-09-26 22:56:07
    1 Aop简介AOP的全称是Aspect ...AOP框架中对AOP支持最完整的是Aspectj,Spring Aop是基于Aspectj实现的专门针对于Spring自身支持的Aop,它的功能没有Aspectj那么完整,它只作用于Spring bean容器中bean对象的某个方
  • 手动实现Spring Aop

    千次阅读 2017-01-22 22:13:05
    AOP是OOP的延续,是软件开发中的一个热点,也是Spring框架中的一个重要内容,是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,提高程序的可重用性

空空如也

1 2 3 4 5 ... 20
收藏数 117,022
精华内容 46,808
关键字:

aop