AOP原理简介

1.     面向切面编程（AOP）原理以及Helloworld



对于AOP我们可以这样类比。

如果我们要测量挖掘海底的沉积物，我们在海平面放一个船，船投下一个抓头，抓斗穿过厚厚的海水达到海底，抓到物质，然后再次穿越厚厚的海水，把沉积物拉到船上。

这个过程中

拿出抓斗，从船上下抓斗è抓头穿过海底,沉入海底è抓斗达到海底抓取沉积物è抓斗穿出海面è取下抓斗，把抓斗收好



如果对于结构化编程

拿抓斗()è丢抓斗()è抓物品()è拉抓斗()è回收抓斗()



对于面向对象

船员.拿抓斗è船员.丢抓斗()è抓斗.抓物品()è船员.拉抓斗()è船员.回收抓斗()



对于面向切面编程

有船员这个切面

船员:船员.拿抓斗è船员.丢抓斗()è船员.拉抓斗()è船员.回收抓斗()

抓斗: 抓斗.抓物品()



从比较中，我们可以发现，结构化编程是效率最高的，面向对象最大的优势是方便维护，面向切面不仅仅方便维护，虽然整体流程复杂了，但是对于程序来说，仅仅只要完成抓斗的代码，其他的代码交给Spring这些AOP框架去处理。而且AOP解耦的程度比OOP要高很多。



例如，我们写一个数据操作的时候，一般的流程就是先打开数据库，然后执行操作，最后释放资源和关闭连接，对于不同的业务，主要是执行的操作的变化，而打开数据库和释放资源一般都是类型的。而这种代码在业务中，会分散程序员的注意力。如果我们程序只需要执行里面的操作，不需要把精力放在资源释放和关闭连接上，那对程序员来说就是一种解脱。



2.     AOP Helloworld



定义接口

package com.greysh.aop.service;

public interface HelloWorld {

    public void say();

}



对应的实现为

package com.greysh.aop.service.impl;

import com.greysh.aop.service.HelloWorld;

public class HelloWorldImpl implements HelloWorld {

    public void say() {

       System.out.println("Say HelloWorld");

    }

}



程序调用的时候

package com.greysh.aop.test;

import com.greysh.aop.factory.ProxyFactory;

import com.greysh.aop.service.HelloWorld;

import com.greysh.aop.service.impl.HelloWorldImpl;

public class TestHelloWorld {

    public static void main(String[] args) {

       HelloWorld mb = new HelloWorldImpl();

       HelloWorld bi = (HelloWorld) ProxyFactory.getProxy(mb);

       bi.say();

    }

}



工厂

package com.greysh.aop.factory;

import java.lang.reflect.Proxy;

import com.greysh.aop.proxy.ProxyHandler;

public class ProxyFactory {

    public static Object getProxy(Object obj) {

       ProxyHandler bn = new ProxyHandler();

       bn.setTarget(obj);

       return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), bn);

    }

}



代理和反射类

package com.greysh.aop.proxy;

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

public class ProxyHandler implements InvocationHandler {

    private Object target;

    public void setTarget(Object target) {

       this.target = target;

    }

    @Override

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

       System.out.println("Before Helloworld");

       @SuppressWarnings("unused")

       Object result = method.invoke(target, args);

       System.out.println("Finish Helloworld");

       return null;

    }

}

                                                                                                                                                                                 

程序运行时候的结果是

Before Helloworld

Say HelloWorld

Finish Helloworld



如果不是用AOP，那么打印的结果

Say HelloWorld



这5个文件构成一个最简单的AOP的DEMO

类似Struts2的拦截器

如果两个类实现同一个接口，但是用的时候用一个类代替另一个类，这就是代理模式

上述就用了代理模式

当我们调用bi.say()，其实并不是直接用HelloWorldImpl的say()，

而是

HelloWorld bi = (HelloWorld) ProxyFactory.getProxy(mb);

这样ProxyFactory先用ProxyHandler将对象赋值，这里需要调用reflect包，重写里面的invoke方向，这里的invoke在调用的时候先执行

System.out.println("Before Helloworld");

然后用反射

Object result = method.invoke(target, args);

和我们一般写程序不同，

不是

对象.方法()

而是

方法.(对象)

然后用代理类生产一个实例

方法为：

Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), bn);

当然，第一个参数为类加载器，第二个参数为方法加载器，要加载前面那个类的所有接口。因���用代理模式的���候，真正去操作的时候是用原始类的代理类，要代理原始类的方法，所以要知道接口，当然用代理类会造成类膨胀，Spring底层用的cglib动态代理。

在代理类中先处理完一些程序的初始化，然后交给原始类的方法去处理，最后用代理类的方法去资源回收，这样就实现了AOP的面向切面编程

例如上面的demo中

1）System.out.println("Before Helloworld");

2）Object  result = method.invoke(target, args);

3）System.out.println("Finish Helloworld");

可以类比为    



1）船员:船员.拿抓斗è船员.丢抓斗()

2）抓斗: 抓斗.抓物品()

3）船员.拉抓斗()è船员.回收抓斗()



程序员要写的就是

抓斗: 抓斗.抓物品()



以上就是AOP的简单实现和底层原理

评论

1 楼 东东乐乐 2011-03-25  

[face16][face17][face18][face19][face20][face21][face22][face23][face24][face25][face26][face27][face28][face29][face30]
[face31][face32][face33][face34][face35][face36][face37][face38][face39][face40][face41][face42][face43][face44][face45]
[face46][face47][face48][face49][face50][face51][face52][face53][face54][face55][face56][face57][face58][face59][face60]
[face61][face62][face63][face64][face65][face66][face67][face68][face69][face70][face71][face72][face73][face74][face75]
[face76][face77][face78][face79][face80][face81][face82][face83][face84][face85][face86][face87][face88][face89][face90]
[face91][face92][face93][face94][face95][face96][face97][face98][face99][face100][face101][face102][face103][face104][face105]