AOP思考

最新推荐文章于 2020-03-27 14:02:41 发布
最新推荐文章于 2020-03-27 14:02:41 发布
阅读量1.4k 收藏 3
点赞数 1
分类专栏： JavaEE
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/karl5421/article/details/17266799
版权
最近在帮一个同事解决AOP异常时，对自己的AOP理解做了一个提纲总结，便于以后回忆。

1. AOP理解

     1）AOP是什么

          AOP，面向切面编程思想。该思想提倡将各组件间具有横切性质的公共逻辑用“切面”封装起来，通过代理以“切入”的方式调用，实现代码的分层、解耦。

     2）AOP解决什么问题
     
          AOP解决的问题是代码逻辑的解耦和分层、公共逻辑的封装和调用问题。

     3）AOP如何解决问题

          首先，按照OOP思想将公共逻辑用对象（切面）封装起来；
          然后，构建业务组件的代理对象，供调用者使用，实现“偷梁换柱”；
          最后，代理根据配置，在调用业务组件前后”智能“的执行切面逻辑；
       
     4）AOP解决问题优势

          业务代码和公共代码在封装和调用方面均实现分层，解耦；
          提高了业务组件的复用度；
          提高了公共逻辑的复用度

     5）AOP与OOP的区别

          从上面看出，AOP是先按照OOP思想来解决问题的，但是传统OOP思想不能解决逻辑分层和解耦问题，于是AOP通过代理手段解决该问题。

          所以，AOP是OOP的补充，AOP=OOP+代理模式。


2. AOP应用

     1）Spring AOP组件

          目标对象：封装了业务逻辑的组件，例如Spring里的普通Service、Dao等Bean；
          代理对象：目标对象的代理，运行时动态生成（JDK动态代理和CGLIB动态代理）
          切面：      封装了公用逻辑的组件，一个切面包含三个元素：通知、切入点、引入；
          通知：      封装了公共逻辑的切面方法（前置、后置、完成、环绕、异常）
          引入：      封装了新增逻辑的组件；
          切入点：   封装了连接点匹配规则的组件，常用的匹配规则有execution/args/within；  
          连接点：   目标对象的方法；

     2）Spring AOP编程

          一个登陆服务组件，其提供login操作；

          在不改变该组件代码的前提下，加强其login操作逻辑、新增注册功能逻辑；


用户信息 
package com.sample.domain;

public class User {
	
	private String name;
	private String password;
	
	public User(){}
	
	public User(String name,String password){
		this.name = name;
		this.password = password;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getPassword() {
		return password;
	}

	public void setPassword(String password) {
		this.password = password;
	}
	
	public String toString(){
		return "用户名：<"+name+">密码：<"+password+">";
	}
	
}
 
登陆服务组件接口 
package com.sample.service;

import com.sample.domain.User;

public interface LoginAndoutService {
	
	
	public String logIn(User user);
	
	public void logOut(User user);
	

}

登陆服务组件实现 
package com.sample.service.impl;

import org.springframework.stereotype.Service;

import com.sample.domain.User;
import com.sample.service.LoginAndoutService;

@Service
public class LoginAndoutServiceImpl implements LoginAndoutService {

	@Override
	public String logIn(User user) {
		
		if(null == user)
		throw new RuntimeException("用户不能为空");	
		
		return "用户<"+user.getName()+">登录成功，密码<"+user.getPassword()+">";
	}

	@Override
	public void logOut(User user) {
		
		System.out.println("用户<"+user.getName()+">退出!");
		
	}

}


登陆服务组件切面 
package com.sample.aop.aspect;

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.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.DeclareParents;
import org.springframework.stereotype.Component;

import com.sample.aop.introduction.LogInAndOutStrong;
import com.sample.aop.introduction.impl.LogInAndOutStrongImpl;
import com.sample.domain.User;

@Component
@Aspect
public class LogInAndOutAspect {
	
	
	@DeclareParents(value="com.sample.service.*+",
            defaultImpl=LogInAndOutStrongImpl.class)
	public static LogInAndOutStrong stronger;
	
	
	@Before("com.sample.aop.pointcut.LogInAndOutPoint.logIn_Out_Point() && args(user)")
	public void checkArgs(User user){
		
		if(null == user)
		throw new RuntimeException("用户不能为空！");
		
		System.out.println("开始,检查参数值--->"+user);
		
	}
	
	
	@AfterReturning(pointcut="com.sample.aop.pointcut.LogInAndOutPoint.logIn_Out_Point()",
					returning="rs")
	public void checkResult(String rs){
		
		if( null == rs)
			rs = "方法为void类型，无返回值";
		
		System.out.println("返回，接收返回值--->"+rs);
		
	}
	
	
	@After("com.sample.aop.pointcut.LogInAndOutPoint.logIn_Out_Point()")
	public void finish(){
		
		System.out.println("结束，方法调用完毕--->");
		
	}
	
	
	@AfterThrowing(pointcut="com.sample.aop.pointcut.LogInAndOutPoint.logIn_Out_Point()",
					throwing="ex")
	public void handException(Exception ex){
		
		System.out.println("异常，处理异常--->"+ex);
		
	}
	
	
	@Around("com.sample.aop.pointcut.LogInAndOutPoint.logIn_Out_Point()")
	public Object process(ProceedingJoinPoint pjp) throws Throwable{
		
		System.out.println("环绕，调用方法--->"+pjp.getKind());
		
		return pjp.proceed();
		
	}
	
}


切面引入接口 
package com.sample.aop.introduction;

import com.sample.domain.User;

public interface LogInAndOutStrong {
	
	public String regist(User user);

}


切面引入实现 
package com.sample.aop.introduction.impl;

import com.sample.aop.introduction.LogInAndOutStrong;
import com.sample.domain.User;

public class LogInAndOutStrongImpl implements LogInAndOutStrong {

	@Override
	public String regist(User user) {
		
		return "用户<"+user.getName()+">注册成功！";
	}

}


切入点定义 
package com.sample.aop.pointcut;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;


@Component
@Aspect
public class LogInAndOutPoint {

	@Pointcut("execution (* com.sample.service.impl.LoginAndoutServiceImpl.log*(..))")
	public void logIn_Out_Point(){}
	
}

Spring配置文件 
<?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"
	xmlns:task="http://www.springframework.org/schema/task"
	xmlns:tx="http://www.springframework.org/schema/tx" 
	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
    http://www.springframework.org/schema/task   
    http://www.springframework.org/schema/task/spring-task-3.0.xsd
    http://www.springframework.org/schema/tx  
    http://www.springframework.org/schema/tx/spring-tx.xsd">

	<!-- 启用Spring AOP相关特性 -->
	<aop:aspectj-autoproxy/>
	
	
	<!-- 启用Spring 组件扫描识别特性 -->
	<context:component-scan base-package="com.sample" />
	
</beans>


测试类 
package com.sample;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.sample.aop.introduction.LogInAndOutStrong;
import com.sample.domain.User;
import com.sample.service.LoginAndoutService;

public class Test {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		
		User user = new User("张三","123456");
		
		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
		
		LoginAndoutService service = (LoginAndoutService)context.getBean("loginAndoutServiceImpl");
		System.out.println(service.logIn(user));
		
		
		LogInAndOutStrong stronger = (LogInAndOutStrong)service;
		System.out.println(stronger.regist(user));
		
	}

}

测试结果 
环绕，调用方法--->method-execution
开始,检查参数值--->用户名：<张三>密码：<123456>
返回，接收返回值--->用户<张三>登录成功，密码<123456>
结束，方法调用完毕--->
用户<张三>登录成功，密码<123456>
用户<张三>注册成功！




karl1235
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
AOP技术基础
03-04
2.1AOP技术起源AOP技术的诞生并不算晚，早在1990年开始，...就在PARC对于面向方面编程进行研究的同时，美国NortheasternUniversity的博士生CristinaLopes和其同事也开始了类似的思考。最终，美国国防先进技术研究计划
尝试用AOP解决OOP和设计模式问题(2)
lithe的Blog
02-22 2691
Csdn dotnet blog 专家群  JGTM我们在这一篇文字中将从另一个角度考虑原文中提出的问题，并深入探索.NET/CLR中提供的相关技术机制，最终以一种AOP的形式达成同样的结果。为了让你能够尽快进入状态，我们先简要回顾一下前文中已经探讨的内容： 在文章的第一部分，我们从一个非常简单的虚构的业务操作类（Calculator）开始，结合企业开发中经常会面临的种种非功能性需求（
Spring AOP 习题练习
qq_42009262的博客
03-27 8109
Spring AOP 习题练习 简答题 1.请简述AOP如何解决传统OOP思想可能出现的问题。 答案：在传统的业务处理代码中，通常都会进行事务处理、日志记录等操作。虽然使用OOP可以通过组合或者继承的方式来达到代码的重用，但如果要实现某个功能（如日志记录），同样的代码仍然会分散到各个方法中。这样，如果想要关闭某个功能，或者对其进行修改，就必须要修改所有的相关方法。这不但增加了开发人员的工作量，而且...
A Taste of AOP from Solving Problems with OOP and Design Patterns (Part I)
阿赖.NET
06-24 1279
原文出处：http://blog.joycode.com/jgtm2000/posts/12103.aspx 在展开问题之前我们首先设定一个例子，在这个示例中我将使用尽可能简单的逻辑实现所有功能需求，这将更突出我们所要解决的核心问题。例子是一个简单计算器类： ? public class Calculator{? public int Add(int x, int y) { return x +
AOP与OOP的摘要
u012671435的博客
07-18 538
AOP的原理剖析      切面：Aspect    连接点：Join Point    通知：Advice    切入点：Point Cut    引入点：Introduction     目标对象：Target Object     织入：Weaving   AOP的通俗理解    一个组件A，不关心其他常用的服务组件B，但是这个组件A使用组件B的时候，不是组件A自身调用，而是...
AOP OOP概念问题
02-04 690
AOP是什么？ Aspect 方面 oriented 面向 programming 程序 　　AOP是OOP的延续，是Aspect Oriented Programming的缩写，意思是面向方面编程。AOP实际是GoF设计模式的延续，设计模式孜孜不倦追求的是调用者和被调用者之间的解耦，AOP可以说也是这种目标的一种实现。 oop是什么？ object 对象 oritented
AOP在大规模软件开发项目应用的尝试与思考
02-04
在此我们将对曾经面临过的一些实际问题与困难进行分析，试图引发关于面向方面软件开发(AOSD)的一些更深层次的思考。本文的作者将站在开发者的角度做出客观的判断，既不是AOP的狂热鼓吹者，同样也不是AOP反对阵营的一...
spring aop 拦截器简单实现
05-13
非常简单的aop例子，可以从该离子出发隐身出很多其他的问题的思考。
简单介绍aop思想
caoPengFlying的博客
12-24 994
什么是aop？ aop(Aspect Oriented Programming) 即面向切面编程。aop是一种编程思想，比如过滤器和拦截器。 解决的问题： 面向对象的特点是，封装、继承和多态。虽然方便了我们对类的使用，但是会多了一些重复代码，比如在servlet中。每个servlet都要设置编码问题，那么一般情况下有多少个servlet类就要写多少个解决编码的代码。增加了很多的重复代码。有
aop示例spring 的aop思想解决项目中多次出现的同一个问题
12-02
spring 的aop思想解决项目中多次出现的同一个问题，如事务，用户验证等问题，
AOP、OOP的理解
坚持而不浮躁
03-10 295
    AOP与OOP是面向两种不同的领域设计思想，OOP(面向对象编程)针对业务处理过程的实体及其属性和行为进行封装，以 获得更加清晰的逻辑单元划分。       AOP则是针对业务处理过程中的切面进行提取，它所面对的是处理过程中某个步骤或子阶段，以获得逻辑过程中各部分之间 低耦合性的隔离效果。这两种设计思想在目标上有本质的差异。        AOP是与源码组成无关性的，也就是说业...
A Taste of AOP from Solving Problems with OOP and Design Patterns (Part II)
阿赖.NET
06-24 1461
继续文章的第一部分，我们在这一篇文字中将从另一个角度考虑原文中提出的问题，并深入探索.NET/CLR中提供的相关技术机制，最终以一种AOP的形式达成同样的结果。为了让你能够尽快进入状态，我们先简要回顾一下前文中已经探讨的内容：   在文章的第一部分，我们从一个非常简单的虚构的业务操作类（Calculator）开始，结合企业开发中经常会面临的种种非功能性需求（操作日志、权限控制、性能监测等等），用
OOP与AOP的理解
qq_39037047的博客
11-26 975
    本人是搞android开发的，平时对OOP运用比较多，对其思想也自然比较熟悉。相比之下大多数android开发者对AOP的比较默认，所以这里来总结一下两者的区别 1.概念 OOP是面向对象编程，核心思想是将客观存在的不同事物抽象成相互独立的类，然后把与事物相关的属性和行为封装到类里，并通过继承和多态来定义类彼此间的关系，最后通过操作类的实例来完成实际业务逻辑的功能求。 AOP是面向切...
AOP是什么？与OOP的区别
Logica的专栏
04-18 1万+
Aop是什么？ AOP(Aspect Oriented Programming) 面向切面编程，是目前软件开发中的一个热点，是Spring框架内容，利用AOP可以对业务逻辑的各个部分隔离，从而使的业务逻辑各部分的耦合性降低，提高程序的可重用性，踢开开发效率，主要功能：日志记录，性能统计，安全控制，事务处理，异常处理等。 AOP实现原理是java动态代理，但是jdk的动态代理必须实现接口，所
简述MVC、MVT、OOP、AOP
生有涯，知无涯
06-24 908
1.MVC MVC是一种流行的框架模式。其核心思想是分工、解耦，让不同的代码块之间降低耦合，增强代码的可扩展性和可移植性，实现向后兼容。 M全拼为Model，主要封装对数据库层的访问，对数据库中的数据进行增、删、改、查操作。 V全拼为View，用于封装结果，生成页面展示的html内容。 C全拼为Controller，用于接收请求，处理业务逻辑，与Model和View交互，返回结果。 2.MV...
简单理解AOP（面向切面编程）
weixin_34377919的博客
07-29 298
　　AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。 　　AOP与OOP是面向不同领域的两种设计思想。 　　OOP（面向对象编程）针对业务处理过程的实体及其属性和行为进行抽象封装，以获得更加清晰高效的逻辑单元划分。 　　AOP则是针对业务处理过程中的切面进行提取，它所面对的是处理过程中的...
谈谈对AOP的理解 一——认识AOP
热门推荐
王勇霞 信息技术提高班九期
05-30 1万+
前几篇博客我们说了JAVA的代理模式，从静态代理到动态代理，又到CGLIB代理。从静态代理到动态代理是一种进步，JDK的动态代理和CGLIB的代理，却是各有优缺点，在使用过程中，不是非要决出个胜负，根据不同的情景，使用不同的代理；也可以根据情况，两者结合使用，代码是我们写出来的，我们才是创造者，知其然，知其所以然，然可用之。       一、AOP        这篇博客，我们接着代理模式，继
spring aop aopalliance
最新发布
08-07
Spring AOP是基于AOP联盟（aopalliance）的API构建的框架。AOP联盟定义了一系列的接口，用于实现面向切面编程的功能。在Spring框架中，将AOP联盟的接口以内嵌的形式放到了spring-aop包中，同时也引入了spring...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值