`

AOP 面向方面编程

 
阅读更多

  AOP是Aspect Oriented Programming的缩写,意思是面向方面编程,一种新兴的编程技术。

  AOP实际是GoF设计模式的延续,设计模式孜孜不倦追求的是调用者和被调用者之间的解耦,

  AOP可以说也是这种目标的一种实现。它可以解决OOP和过程化方法不能够很好解决的横切

  (crosscut)问题,

  如:事务、安全、日志等横切关注。当未来系统变得越来越复杂,

  横切关注点就成为一个大问题的时候,AOP就可以很轻松的解决横切关注点这个问题。

  比如有这样一个情景:

 

  

public class AccountManager {
  private static final sysLogger = SystemLogger.getInstance();
  private AuthorizationManager authMgr = new AuthorizationManager();
  public void transferFunds(String from, String to, int amount) {
  sysLogger.log("transfer funds from " + from + " to " + to);
  if(authMgr.accessAble(from) && authMgr.accessAble(to)) {
  sysLogger.log("access successfully");
  CustomerAccount from = findAccount(from);
  CustomerAccount to = findAccount(to);
  from.debit(amount);
  to.credit(amount);
  } else {
  sysLogger.log("access deny");
  }
  sysLogger.log("transfer funds from " + from + " to " + to + " $" + amount + " successfully!");
  }
  }

 

 

  这个例子虽然是很好的面向对象代码,但是在业务处理逻辑中夹杂这日志处理和权限判断,变得复杂混乱.

  在 AOP 中,正交关注点(如安全和日志记录)被识别为系统中的常见横切关注点。说它们是横切,

  是因为它们总是切入模块(如包、类和代码文件)的多个单位。也许横切关注点可能不是核心业务逻辑的一部分,但是它们是应用程序的基本部分。

  AOP的实现主要是通过方法的拦截实现.在不使用AOP框架的情况下,我们可以通过JDK提供的动态代理来实现方法的拦截

  注意:使用JDK提供的动态代理实现

  要求我们的目标对象必须实现接口

  IUserBean接口

 

  

package com.royzhou.aop;
  public interface IUserBean {
  public void getUser();
  public void addUser();
  public void updateUser();
  public void deleteUser();
  }

 

 

  IUserBean实现类 UserBean.java

 

  

package com.royzhou.aop;
  public class UserBean implements IUserBean {
  private String user = null;
  public UserBean() {
  }
  public UserBean(String user) {
  this.user = user;
  }
  public void setUser(String user) {
  this.user = user;
  }
  public void addUser() {
  System.out.println("this is addUser() method!");
  }
  public void deleteUser() {
  System.out.println("this is deleteUser() method!");
  }
  public void getUser() {
  System.out.println("this is getUser() method!");
  }
  public void updateUser() {
  System.out.println("this is updateUser() method!");
  }
  }

 

 

  我们希望在UserBean执行方法之前先检查userName是不是为空,以此做为权限判断.

  当然我们可以在没个方法里面去加这些判断,但是这需要为每个方法都添加同样的判断,维护不便.

  使用JDK提供的动态代理技术可以很方便的实现上面的需求:

  通过java.lang.reflect.Proxy;提供的

  

public static Object newProxyInstance(ClassLoader loader,
  Class[] interfaces,
  InvocationHandler h)

 

 

  方法可以生成一个动态代理对象

  其中

  loader是类装载器

  interfaces是目标对象实现的一系列接口

  h是一个实现InvocationHandler接口的类,我们对代理对象的所有操作都经过它处理

  这样我们就可以拦截到UserBean的方法,在方法执行前先判断是否有权限,如果有则执行方法,

  没有权限的话就不执行方法.

  编写我们的代理类:

  JDKProxy.java

 

  

package com.royzhou.aop;
  import java.lang.reflect.InvocationHandler;
  import java.lang.reflect.Method;
  import java.lang.reflect.Proxy;
  public class JDKProxy implements InvocationHandler {
  private Object targetObject;
  public Object createProxyObject(Object targetObject) {
  this.targetObject = targetObject;
  //生成代理对象
  return Proxy.newProxyInstance(this.targetObject.getClass().getClassLoader(),this.targetObject.getClass().getInterfaces(),this);
  }
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  UserBean userBean = (UserBean) targetObject;
  String userName = userBean.getUserName();
  Object result = null;
  //权限判断
  if(userName!=null && !"".equals(userName)) {
  //调用目标对象的方法
  result = method.invoke(targetObject, args);
  }
  return result;
  }
  }

 

 

  通过调用createProxyObject可以生成代理对象,

  编写测试类如下:

 

 

 package com.royzhou.aop;
  public class TestProxy {
  public static void main(String[] args) {
  JDKProxy jProxy = new JDKProxy();
  IUserBean userBean = (IUserBean) jProxy.createProxyObject(new UserBean("royzhou"));
  userBean.addUser();
  }
  }

 

 

  执行成功后输出:

  this is addUser() method!

  再次修改测试类:

 

  

package com.royzhou.aop;
  public class TestProxy {
  public static void main(String[] args) {
  JDKProxy jProxy = new JDKProxy();
  IUserBean userBean = (IUserBean) jProxy.createProxyObject(new UserBean());
  userBean.addUser();
  }
  }

 

 

  即当用户没有权限时,控制台不输出东西,说明我们拦截方法对其做的权限判断生效了.

  从上面这个例子可以成功拦截了调用的方法并对其做了相应的处理

  如果不使用JDK提供的Proxy类

  通过cglib创建代理类,好处是不要求我们的目标对象实现接口

  Enhancer enhancer = new Enhancer();

  enhancer.setSuperclass(this.targetObject.getClass());

  enhancer.setCallback(this); //回调,参数是一个实现MethodInterceptor接口的类,我们对代理对象的所有操作都经过它处理

  return enhancer.create(); //创建代理对象

  修改UserBean 去掉IUserBean接口

 

  

package com.royzhou.aop;
  public class UserBean {
  private String userName = null;
  public UserBean() {
  }
  public UserBean(String userName) {
  this.userName = userName;
  }
  public void addUser() {
  System.out.println("this is addUser() method!");
  }
  public void deleteUser() {
  System.out.println("this is deleteUser() method!");
  }
  public void getUser() {
  System.out.println("this is getUser() method!");
  }
  public void updateUser() {
  System.out.println("this is updateUser() method!");
  }
  public String getUserName() {
  return userName;
  }
  public void setUserName(String userName) {
  this.userName = userName;
  }
  }

 

 

  通过cglib创建代理类

  CGLibProxy.java

 

  

package com.royzhou.aop;
  import java.lang.reflect.Method;
  import net.sf.cglib.proxy.Enhancer;
  import net.sf.cglib.proxy.MethodInterceptor;
  import net.sf.cglib.proxy.MethodProxy;
  public class CGLibProxy implements MethodInterceptor {
  private Object targetObject;
  public Object createProxyObject(Object targetObject) {
  this.targetObject = targetObject;
  Enhancer enhancer = new Enhancer();
  enhancer.setSuperclass(this.targetObject.getClass()); //非final 进行覆盖
  enhancer.setCallback(this); //回调,通过
  return enhancer.create(); //创建代理对象
  }
  public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
  UserBean userBean = (UserBean) targetObject;
  String userName = userBean.getUserName();
  Object result = null;
  if(userName!=null && !"".equals(userName)) {
  //调用目标对象的方法
  result = methodProxy.invoke(targetObject, args);
  }
  return result;
  }
  }

 

 

  编写测试类:

  

package com.royzhou.aop;
  public class TestProxy {
  public static void main(String[] args) {
  CGLibProxy cProxy = new CGLibProxy();
  UserBean userBean = (UserBean) cProxy.createProxyObject(new UserBean("royzhou"));
  userBean.addUser();
  }
  }

 

 

  输出:

  this is addUser() method!

  当取消用户权限时,控制台不输出任何东西.

  说明通过CGLib成功生成代理对象,拦截了目标对象的方法.

  Spring主要通过代理来实现AOP

  下面是AOP的一些基本概念:

  切面(Aspect):对横切关注点的抽象(类似类对对象的抽象)

  连接点(JoinPoint):被拦截到的点,泛指方法

  切入点(CutPoint):对哪些连接点进行拦截的定义

  通知(Advice):在特定的连接点,AOP框架执行的动作.前置/后置/例外/最终/环绕通知(调用方法之前执行,全部执行完毕之后)

  引入(Introduction): 添加方法或字段到被通知的类。 Spring允许引入新的接口到任何被通知的对象。例如,你可以使用一个引入使任何对象实现 IsModified接口,来简化缓存。

  目标对象(Target Object): 包含连接点的对象。也被称作 被通知或被代理对象。

  AOP代理(AOP Proxy): AOP框架创建的对象,包含通知。 在Spring中,AOP代理可以是JDK动态代理或者CGLIB代理。

  织入(Weaving): 组装方面来创建一个被通知对象。这可以在编译时 完成(例如使用AspectJ编译器),也可以在运行时完成。Spring和其他纯Java AOP框架一样, 在运行时完成织入。

  Adive通知可理解如下:

 

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  UserBean userBean = (UserBean) targetObject;
  String userName = userBean.getUserName();
  Object result = null;
  if(userName!=null && !"".equals(userName)) {
  //调用目标对象的方法
  try {
  //前置通知
  result = method.invoke(targetObject, args);
  //后置通知
  } catch(Exception e) {
  //例外通知
  } finally {
  //最终通知
  }
  }
  //环绕通知(前置通知之后,目标对象方法调用之前执行,全部执行完毕(最终通知)之后)
  return result;
  }

 

 

  Spring提供两种方式实现AOP

  一种是XML配置的方式

  一种是annotation注解的方式

  不管采用哪种方式,都必须在spring的配置文件中配置AOP支持:

  

<beans p="" <="" 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-2.5.xsd
  http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
  http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">

 

  其中表示打开aspect注解处理器

  (aspect的内容具体可查看http://www.ibm.com/developerworks/cn/java/j-aspectj/)

  使用注解方式实现AOP必须引入三个jar包:

  aspectjweaver.jar

  aspectjrt.jar

  cglib.jar

  首先建立好测试用的业务bean

  然后我们需要定义一个切面/定义切入点/通知等

  接口IUserBean.java

 

  

package com.royzhou.aop;
  public interface IUserBean {
  public void getUser();
  public void addUser();
  public void updateUser();
  public void deleteUser();
  }

 

 

  实现类UserBean.java

 

 

 package com.royzhou.aop;
  public class UserBean {
  public void addUser(String userName) {
  System.out.println("this is addUser() method!");
  }
  public void deleteUser(int userId) {
  System.out.println("this is deleteUser() method!");
  }
  public String getUser(String userId) {
  System.out.println("this is getUser() method!");
  return "haha";
  }
  public void updateUser(int userId, String userName) {
  System.out.println("this is updateUser() method!");
  }
  }

 

 

  紧接着我们建立我们的切面类:使用@Aspect注解

  MyInterceptor.java

 

  

package com.royzhou.aop;
  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.Pointcut;
  @Aspect
  public class MyInterceptor {
  /**
  * 定义切入点
  * 第一个*表示方法的返回值,这里使用通配符,只有返回值符合条件的才拦截,(!void表示有返回值)
  * 第一个..表示com.royzhou.aop包及其子包
  * 倒数第二个*表示包下的所有Java类都被拦截
  * 最后一个*表示类的所有方法都被拦截
  * (..)表示方法的参数可以任意多个如[(java.lang.String,java.lang.Integer)表示第一个参数是String,第二个参数是int的方法才会被拦截]
  */
  @Pointcut("execution(* com.royzhou.aop..*.*(..))") //定义一个切入点,名称为pointCutMethod(),拦截类的所有方法
  private void pointCutMethod() {
  }
  @Before("pointCutMethod()") //定义前置通知
  public void doBefore() {
  System.out.println("前置通知");
  }
  @AfterReturning("pointCutMethod()") //定义后置通知
  public void doAfterReturning() {
  System.out.println("后置通知");
  }
  @AfterThrowing("pointCutMethod()") //定义例外通知
  public void doAfterException() {
  System.out.println("异常通知");
  }
  @After("pointCutMethod()") //定义最终通知
  public void doAfter() {
  System.out.println("最终通知");
  }
  @Around("pointCutMethod()") //定义环绕通知
  public Object doAround(ProceedingJoinPoint pjp) throws Throwable {
  System.out.println("进入方法");
  Object object = pjp.proceed(); //必须执行pjp.proceed()方法,如果不执行此方法,业务bean的方法以及后续通知都不执行
  System.out.println("退出方法");
  return object;
  }
  }

 

 

  切面定义好之后我们必须交给Spring管理,配置我们的bean.xml文件如下:

  

<beans p="" <="" xmlns="http://www.springframework.org/schema/beans">
<beans p="" <="" 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-2.5.xsd
  http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
  http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">

  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-2.5.xsd
  http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
  http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">

 

  编写测试类如下:

 

  

package com.royzhou.aop;
  import org.springframework.context.ApplicationContext;
  import org.springframework.context.support.ClassPathXmlApplicationContext;
  public class TestAOP {
  public static void main(String[] args) {
  ApplicationContext ctx = new ClassPathXmlApplicationContext("bean.xml");
  UserBean ub = (UserBean)ctx.getBean("UserBean");
  ub.addUser("royzhou");
  }
  }

 

 

  运行测试类输出:

  前置通知

  进入方法

  this is addUser() method!

  后置通知

  最终通知

  退出方法

  可以看出定义的各个通知的执行顺序,

  例外通知只有在程序异常的情况下才会发生.

  其他通知都会执行.

  我们也可以在环绕通知里面将前面的几个通知实现了.

  如果需要获取方法的参数我们必须在定义通知的时候做响应的设置:

  比如我在前置通知希望获取到输入的参数需要修改MyInterceptor如下:

 

  

package com.royzhou.aop;
  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.Pointcut;
  @Aspect
  public class MyInterceptor {
  /**
  * 定义切入点
  * 第一个*表示方法的返回值,这里使用通配符,只有返回值符合条件的才拦截
  * 第一个..表示com.royzhou.aop包及其子包
  * 倒数第二个*表示包下的所有Java类
  * 最后一个*表示类的所有方法
  * (..)表示方法的参数可以任意多个
  */
  @Pointcut("execution(* com.royzhou.aop..*.*(..))") //定义一个切入点,名称为pointCutMethod(),拦截类的所有方法
  private void pointCutMethod() {
  }
  //需要两个条件同时成立. args(userName)代表只有一个参数且为String类型 名称必须与doBefore方法的参数名称一样
  @Before("pointCutMethod() && args(userName)") //定义前置通知
  public void doBefore(String userName) {
  System.out.println("前置通知" + userName);
  }
  @AfterReturning("pointCutMethod()") //定义后置通知
  public void doAfterReturning() {
  System.out.println("后置通知");
  }
  @AfterThrowing("pointCutMethod()") //定义例外通知
  public void doAfterException() {
  System.out.println("异常通知");
  }
  @After("pointCutMethod()") //定义最终通知
  public void doAfter() {
  System.out.println("最终通知");
  }
  @Around("pointCutMethod()") //定义环绕通知
  public Object doAround(ProceedingJoinPoint pjp) throws Throwable {
  System.out.println("进入方法");
  Object object = pjp.proceed(); //必须执行pjp.proceed()方法,如果不执行此方法,业务bean的方法以及后续通知都不执行
  System.out.println("退出方法");
  return object;
  }
  }

 

 

  重新运行测试类输出:

  前置通知royzhou

  进入方法

  this is addUser() method!

  后置通知

  最终通知

  退出方法

  可见我们成功的获取到了方法的参数

  如果需要获取方法的返回值,则修改如下

 

  

package com.royzhou.aop;
  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.Pointcut;
  @Aspect
  public class MyInterceptor {
  /**
  * 定义切入点
  * 第一个*表示方法的返回值,这里使用通配符,只有返回值符合条件的才拦截
  * 第一个..表示com.royzhou.aop包及其子包
  * 倒数第二个*表示包下的所有Java类
  * 最后一个*表示类的所有方法
  * (..)表示方法的参数可以任意多个
  */
  @Pointcut("execution(* com.royzhou.aop..*.*(..))") //定义一个切入点,名称为pointCutMethod(),拦截类的所有方法
  private void pointCutMethod() {
  }
  //需要两个条件同时成立. args(userName)代表只有一个参数且为String类型 名称必须与doBefore方法的参数名称一样
  @Before("pointCutMethod() && args(userName)") //定义前置通知
  public void doBefore(String userName) {
  System.out.println("前置通知" + userName);
  }
  //配置returning="result", result必须和doAfterReturning的参数一致
  @AfterReturning(pointcut="pointCutMethod()", returning="result") //定义后置通知
  public void doAfterReturning(String result) {
  System.out.println("后置通知" + result);
  }
  @AfterThrowing("pointCutMethod()") //定义例外通知
  public void doAfterReturning() {
  System.out.println("异常通知");
  }
  @After("pointCutMethod()") //定义最终通知
  public void doAfter() {
  System.out.println("最终通知");
  }
  @Around("pointCutMethod()") //定义环绕通知
  public Object doAround(ProceedingJoinPoint pjp) throws Throwable {
  System.out.println("进入方法");
  Object object = pjp.proceed(); //必须执行pjp.proceed()方法,如果不执行此方法,业务bean的方法以及后续通知都不执行
  System.out.println("退出方法");
  return object;
  }
  }

 

 

  输出结果是:

  前置通知1

  进入方法

  this is getUser() method!

  后置通知haha

  最终通知

  退出方法

  可见方法的返回值我们也成功拿到了.

  如需在例外通知中获取例外的详细信息,我们只需要配置:

 

  

package com.royzhou.aop;
  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.Pointcut;
  @Aspect
  public class MyInterceptor {
  /**
  * 定义切入点
  * 第一个*表示方法的返回值,这里使用通配符,只有返回值符合条件的才拦截
  * 第一个..表示com.royzhou.aop包及其子包
  * 倒数第二个*表示包下的所有Java类
  * 最后一个*表示类的所有方法
  * (..)表示方法的参数可以任意多个
  */
  @Pointcut("execution(* com.royzhou.aop..*.*(..))") //定义一个切入点,名称为pointCutMethod(),拦截类的所有方法
  private void pointCutMethod() {
  }
  //需要两个条件同时成立. args(userName)代表只有一个参数且为String类型 名称必须与doBefore方法的参数名称一样
  @Before("pointCutMethod() && args(userName)") //定义前置通知
  public void doBefore(String userName) {
  System.out.println("前置通知" + userName);
  }
  //配置returning="result", result必须和doAfterReturning的参数一致
  @AfterReturning(pointcut="pointCutMethod()", returning="result") //定义后置通知
  public void doAfterReturning(String result) {
  System.out.println("后置通知" + result);
  }
  //类似returning的配置
  @AfterThrowing(pointcut="pointCutMethod()", throwing="e") //定义例外通知
  public void doAfterException(Exception e) {
  System.out.println("异常通知");
  }
  @After("pointCutMethod()") //定义最终通知
  public void doAfter() {
  System.out.println("最终通知");
  }
  @Around("pointCutMethod()") //定义环绕通知
  public Object doAround(ProceedingJoinPoint pjp) throws Throwable {
  System.out.println("进入方法");
  Object object = pjp.proceed(); //必须执行pjp.proceed()方法,如果不执行此方法,业务bean的方法以及后续通知都不执行
  System.out.println("退出方法");
  return object;
  }
  }

 

 

  上面的例子介绍了使用注解方式来实现Spring的AOP

  另外我们可以使用XML来配置:

  使用XML配置Spring的AOP 我们的切面类MyInterceptor不需要做任何注解,就是一个普通的Java类

 

  

package com.royzhou.aop;
  import org.aspectj.lang.ProceedingJoinPoint;
  public class MyInterceptor {
  public void doBefore(String userName) {
  System.out.println("前置通知" + userName);
  }
  public void doAfterReturning(String result) {
  System.out.println("后置通知" + result);
  }
  public void doAfterException(Exception e) {
  System.out.println("异常通知");
  }
  public void doAfter() {
  System.out.println("最终通知");
  }
  public Object doAround(ProceedingJoinPoint pjp) throws Throwable {
  System.out.println("进入方法");
  Object object = pjp.proceed(); //必须执行pjp.proceed()方法,如果不执行此方法,业务bean的方法以及后续通知都不执行
  System.out.println("退出方法");
  return object;
  }
  }

 

 

  接下来我们需要在bean.xml文件中配置我们的切面/切入点/通知等信息

  

<beans p="" <="" 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-2.5.xsd
  http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
  http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">  

 

  

  注意在前置通知中不支持args-name指定参数,必须在pointcut中指定,否则服务器抛出异常:0 formal unbound in pointcut

  总结一下AOP的优点:

  面对方法编程并不是要取代面对对象编程,而是要提高它。AOP程序员一般来说都是90%使用OOP来解决问题,而10%是用AOP来解决OOP不能解决的问题。

  横切关注点(Cross-cutting Concerns)

  很多时候你发现你的类并不能十分清晰和明白的表到你所想表达的功能意义,因为你真正的代码

  大多被其它代码所包围了。如果你想很好的扩展或集成你所想表达的功能意义,你最好就用方面

  的思想来考虑它了。

  开发中的分层(Layering Based on Deployment)

  AOP另外一个很有用的地方就是可以用来为你的应用程序分层。很多时候你希望的一些特殊应用或

  类是可以很好的配置的,但同时也希望这些东西是不臃肿和可以扩展的。AOP提供了很好的途径来

  分层这些复杂的东西。JBOSS AOP提供了XML配置的机制来配置每个方面的开发。最好的例子就是

  缓存服务,它提供了不同的锁机制。这些缓存锁机制可以很好的织入你的类,而不影响你的类的

  代码,这样你的类就是很好的扩展性了。

  透明性(Transparency)

  很多时候你都想把你的程序的焦点集中在商务应用和应用逻辑上,而不是关注于中间件的开发。

  AOP允许你透明的应用中间件而不再使你的代码收到污染。一个很好的例子就是JBOSS AOP中的

  用户认证上面。

  异常处理

  处理异常是AOP提供给我们另外一个很有用的东西。例如,SQLException异常包含了SQL语句的

  异常信息或者数据库的死锁等信息,但这些信息却使用不同错误代码和信息。AOP可以让你拦截

  SQL语句信息,并分类处理数据库死锁信息。

 

分享到:
评论

相关推荐

    Spring AOP面向方面编程原理Spring AOP面向方面编程原理

    ### Spring AOP面向方面编程原理详解 #### 一、引言与定义 Spring AOP(Aspect Oriented Programming)是Spring框架中的一个核心组件,用于实现面向切面编程。AOP是一种编程范式,旨在将横切关注点(Cross-cutting...

    Spring AOP面向方面编程原理:AOP概念

    ### Spring AOP面向方面编程原理:AOP概念详解 #### 一、引言 随着软件系统的日益复杂,传统的面向对象编程(OOP)逐渐暴露出难以应对某些横切关注点(cross-cutting concerns)的问题。为了解决这一挑战,面向方面编程...

    AOP 面向方面编程 技术总结

    面向方面编程(AOP)是一种编程范式,旨在提高软件开发的模块化程度,特别是通过将关注点分离,以便更好地管理复杂系统。AOP的核心概念是“方面”(Aspect),它封装了跨越多个类的横切关注点,如事务管理、日志记录、...

    java Spring aop面向方面编程.rar

    Java Spring AOP(面向方面编程)是Spring框架中的一个重要特性,它允许开发者通过定义切面来模块化横切关注点,如日志、事务管理、性能监控等。这些关注点通常会分散在应用程序的各个部分,AOP提供了一种集中处理...

    AOP面向切面编程总结

    ### AOP面向切面编程详解 #### 一、AOP概览 AOP(Aspect-Oriented Programming,面向切面编程)是一种编程思想和技术,它作为OOP(面向对象编程)的一种补充,主要解决了OOP在处理横切关注点方面的不足。在传统的...

    AOP面向切面编程.ppt

    AOP面向切面编程.ppt

    AOP面向切面编程实例

    面向切面编程(Aspect-Oriented Programming,简称AOP)是一种编程范式,它旨在提高软件的模块化程度,通过将关注点分离到不同的“切面”中来实现。在.NET环境中,AOP通常通过拦截器(Interceptor)或动态代理...

    面向方面编程AOP

    ### 面向方面编程(AOP)详解 #### AOP概述 面向方面编程(Aspect Oriented Programming,简称AOP)是一种程序设计范式,它作为面向对象编程(Object-Oriented Programming,简称OOP)的补充和发展。AOP的核心理念...

    AOP面向横截面编程

    面向横截面编程面向横截面编程面向横截面编程面向横截面编程面向横截面编程

    面向方面编程的Aop介绍

    本教程介绍 AOP 及其基本概念。AOP 及其相关的工具使您可以将基本横切关注点(如日志记录和安全)的代码,与程序的核心应用逻辑相分离。AOP 通过使代码更具有可读性、更不容易出错以及更容易设计和维护,改善了代码...

    AOP——面向服务--面向方面编程

    面向方面编程(AOP,Aspect-Oriented Programming)是一种编程范式,旨在解决传统面向对象编程(OOP)中横切关注点的问题。横切关注点是指那些跨越多个对象或模块,但又不直接属于单一模块职责的功能,如日志记录、...

    AOP面向切面编程

    aop面向切面编程教学ppt

    面向方面编程_AOP_介绍.pdf

    ### 面向方面编程(AOP)介绍 #### 一、面向方面编程产生的背景 在软件开发领域,面向对象编程(OOP)是长期以来的主要编程范式之一。然而,在实际的软件开发过程中,经常会遇到一些跨越多个类或模块的关注点,如...

    Spring-aop面向切面编程实例

    面向切面编程(Aspect-Oriented Programming,AOP)是Spring框架的核心特性之一,它提供了一种优雅的方式来处理系统的横切关注点,如日志、事务管理、性能监控和权限控制等。在Spring中,AOP主要通过代理模式实现,...

    面向方法编程AOP学习之二 —— “原始时代”

    在这一阶段,程序员们开始意识到将程序分解为一系列独立的功能模块或方法的重要性,但尚未发展出如面向切面编程(Aspect-Oriented Programming,AOP)等更为先进的技术。 在面向方法编程的“原始时代”,开发者主要...

    .net AOP 面向切面编程很好的例子

    spect Oriented Programming(AOP),面向切面编程,是一个比较热门的话题。AOP主要实现的目的是针对业务处理过程中的切面进行提取,它所面对的是处理过程中的某个步骤或阶段,以获得逻辑过程中各部分之间低耦合性的...

    aop 面向切面编程 demo

    面向切面编程(AOP)是一种编程范式,它旨在将关注点分离,使得系统中的核心业务逻辑与系统服务(如日志、事务管理、权限控制等)可以解耦。在Android开发中,AOP的应用可以帮助我们更好地组织代码,提高可维护性和...

    Spring中IOC(反转控 制) 和 AOP(面向方面编程)

    在Java世界里,Spring框架是应用最广泛的轻量级框架之一,它的核心特性包括IOC(Inversion of Control,反转控制)和AOP(Aspect Oriented Programming,面向方面编程)。这两个概念是Spring框架的灵魂,极大地提升...

    PHP的AOP库Go!.zip

    是一个 PHP 5.4 库,让 PHP 支持 AOP 面向方面编程方法,无需 PECL 扩展、Runkit、evals 或者 DI 容器支持。可使用 XDebug 轻松调试。 示例代码: // Aspect/MonitorAspect.php namespace Aspect; use Go\...

Global site tag (gtag.js) - Google Analytics