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

面向切面编程（AOP）原理以及Helloworld 收藏
      拿出抓斗→从船上下抓斗→抓头穿过海底,沉入海底→抓斗达到海底抓取沉积物→抓斗穿出海面→取下抓斗，把抓斗收好。
一、如果对于结构化编程：拿抓斗()→丢抓斗()→抓物品()→拉抓斗()→回收抓斗()

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

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