最近看了一下spring的aop和java的动态代理，下边利用个小例子，简单的表述一下。
spring中的aop实现
一，什么是aop呢：
aop是aspect oriented programming的缩写，意思是面向方面编程。aop实际是gof设计模式的延续，
设计模式孜孜不倦追求的是调用者和被调用者之间的解耦，aop可以说也是这种目标的一种实现。
二,spring中的aop
spring中的aop运用了java中的动态代理来实现的，下边是我写的个小例子，便于理解，如有问题请提出。
1，需求：
我们经常遇到这样的情况，在很多不同的操做开始和结尾要做相同的操做。举个例子，比如你要实现一个对象
bybus（乘坐公共汽车旅游）这个对象有一个seat()函数和一个rob()函数.如果你要正常乘车，在上车seat()之前
须要买票，在下车之前须要查票。如果你要做霸王车rob(),可以不用买票，也不用查票。
这个时候我们可以有以下两种实现方法。
1
方法一。
2 更改seat()方法，在这个方法的第一句加上
3 system.out.println("buy ticket ");
4 最后一句加上
5 system.out.println("check ticket ");
6 然後调用
7 bybus bb = new bybus();
8 bb.seat();
9 bb.rob();
10方法二。
11 再调用之前加上
12 bybus bb = new bybus();
13 system.out.println("buy ticket ");
14 bb.seat();
15 system.out.println("check ticket ");
16 bb.seat();
17方法三。
18 利用代理模式,定义一个接口ibybus . bybus实现接口 ，定义一个代理类，实现ibybus接口
19
public class proxybybus implements ibybus
{
20
private ibybus bybus;
21
public proxybybus(ibybus bybus){
22 this.bybus = bybus;
23
}
24 public void seat(){
25 system.out.println("buy ticket ");
26 bybus.seat();
27 system.out.println("check ticket ");
28 }
29 public void rob(){
30 bybus.rob();
31 }
32
}
33
以上三种方法都面临一个问题，如果函数很多，类也很多，以上几种方式的实现都不是很美观。那没有没有更好的
方式呢，这个时候java的动态代理加入.能较好的解决这个问题，例如我们要加入一种旅游方式bytrain
定义ibytrain接口,下边是利用动态代理的实现：
定义一个使用动态代理的类
1package proxy;
2
3import java.lang.reflect.invocationhandler;
4import java.lang.reflect.method;
5import java.lang.reflect.proxy;
6
7public class txhandler implements invocationhandler{
8 private object originalobject;
9 public object bind(object obj){
10 this.originalobject = obj;
11 return proxy.newproxyinstance(obj.getclass().getclassloader(),
12 obj.getclass().getinterfaces(),this);
13 }
14 //加入buy ticket ,check ticket
15 public object invoke(object proxy, method method, object[] args) throws throwable {
16 object result = null;
17 if(method.getname().startswith("seat")){
18 system.out.println("buy ticket");
19 result = method.invoke(originalobject, args);
20 system.out.println("check ticket");
21 }else{
22 result = method.invoke(originalobject, args);
23 }
24 return result;
25 }
26}
27定义一个辅助类
28package proxy;
29
30public class util {
31 public static object getobject(string name){
32 object obj= null;
33 try{
34 class clazz = class.forname(name);
35 obj = clazz.newinstance();
36
37 txhandler th = new txhandler();
38 obj = th.bind(obj);
39 }catch(exception e){
40 }
41 return obj;
42 }
43}
44
45然後测试一下结果:
46package proxy;
47import java.lang.reflect.method;
48public class test {
49 public static void main(string[] args) {
50 try{
51 string name1 ="proxy.bybusimpl";
52 ibybus bybus = (ibybus)util.getobject(name1);
53 bybus.seat();
54 bybus.rob();
55 //加入一种旅游方式
56 string name2 ="proxy.bytrainimpl";
57 ibytrain bytrain = (ibytrain)util.getobject(name2);
58 bytrain.seat();
59 bytrain.rob();
60
61 }catch(exception e){
62 e.printstacktrace();
63 }
64 }
65}
ok我们也实现了同样的效果，看看代码量比前几种的更多，但是试想一下如果我们的旅游方式变的越来越多，
byair by...等等是否这中方式更简单了呢。
理解了java的动态代理,再回到spring,
spring的ioc就类似util类的作用，根据配制文件（本例中的字符串)，在运行时自动生成代理类。
spring的aop就类似txhandler类的作用，须要的函数例如seat()之前，之后都加入一写东西，
spring加入的是
1 try{
2 //之前加入（类似buy ticket)
3 transation.begin();
4
5 //调用你的函数.
6
7 //之后加入(类似check ticket)
8 transation.commit()
9 }catch(exception e){
10 //加入
11 transation.rollback();
12 }
13
这样你就能在配制文件中来管理事务了。
本文提供实例source下载，见这里:参考文献：夏昕的springguide