求Java中AOP的理解和用处

[★々疯男人ˇ]

小弟学这个的时候，没有听明白为什么要使用AOP和使用AOP的好处体现在哪里？求大哥们给小弟解释一下？先谢谢了！

[火龙果被占用了]

下面这个是我用 JDK 动态代理 API 写的简单的 AOP 程序。把下面的代码复制到 AopTest.java 中，编译运行，看看执行结果后慢慢理解吧，呵呵。

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class AopTest {

    public static void main(String[] args) {
        
        Before before = new Before() {
            public void before() {
                System.out.println("...before...");                
            }            
        };
        
        After after = new After() {
            public void after() {
                System.out.println("...after...");                
            }            
        };
        
        Hello hello = null;
        
        // 普通方法执行
        System.out.println("-------------普通执行-------------");
        hello = new HelloEnglish();
        hello.sayHello("bao110908");
        hello.sayHi("bao110908");
        System.out.println();                
        
        // 切入方法执行前（前置增强）
        System.out.println("-------------前置增强-------------");
        hello = HelloAopManager.getHelloProxy(new HelloEnglish(), before);
        hello.sayHello("bao110908");
        hello.sayHi("bao110908");        // sayHi 方法没有标注 @Enhancement 所以不会进行代码切入
        System.out.println();
        
        // 切入方法执行后（后置增强）
        System.out.println("-------------后置增强-------------");
        hello = HelloAopManager.getHelloProxy(new HelloEnglish(), after);
        hello.sayHello("bao110908");
        hello.sayHi("bao110908");
        System.out.println();
        
        // 切入方法执行前和执行后（环绕增强）
        System.out.println("-------------环绕增强-------------");
        hello = HelloAopManager.getHelloProxy(new HelloEnglish(), before, after);
        hello.sayHello("bao110908");
        hello.sayHi("bao110908");
        System.out.println();
    }
}



@Retention(RetentionPolicy.RUNTIME)
@interface Enhancement {    
}

interface Hello {
    @Enhancement
    public void sayHello(String name);
    public void sayHi(String name);
}

class HelloChinese implements Hello {
    public void sayHello(String name) {
        System.out.println(name + "，您好");
    }
    public void sayHi(String name) {
        System.out.println("哈啰，" + name);
    }
}

class HelloEnglish implements Hello {
    public void sayHello(String name) {
        System.out.println("Hello, " + name);
    }
    public void sayHi(String name) {
        System.out.println("hi, " + name);
    }
}

class HelloAopManager {
    private HelloAopManager(){        
    }
    
    public static Hello getHelloProxy(Hello hello, Before before) {
        return getHelloProxy(hello, before, null);
    }
    
    public static Hello getHelloProxy(Hello hello, After after) {
        return getHelloProxy(hello, null, after);
    }
    
    public static Hello getHelloProxy(Hello hello, Before before, After after) {
        HelloHandler handler = new HelloHandler();
        if(before != null) {        
            handler.setBefore(before);
        }
        if(after != null) {
            handler.setAfter(after);
        }
        return handler.bind(hello);
    }       
}

/**
 * 前置增强接口
 */
interface Before {
    public void before();
}

/**
 * 后置增强接口
 */
interface After {
    public void after();
}

class HelloHandler implements InvocationHandler {   
    
    /**
     * 需要进行代理的实例
     */
    private Hello hello = null;
    
    /**
     * 前置增强
     */
    private Before before = null;
    
    /**
     * 后置增强
     */
    private After after = null;

    /**
     * InvocationHandler 接口的实现方法，进行动态代理
     */
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        // 看看接口中方法是否标注了需要 Enhancement
        boolean b = method.isAnnotationPresent(Enhancement.class);
        if(!b){
            // 没有标注的话，按原方法执行
            return method.invoke(hello, args);
        }
        // 有标注的话，进行方法的前置和后置增强
        if(before != null) {
            before.before();
        }
        Object obj = method.invoke(hello, args);
        if(after != null) {
            after.after();
        }
        return obj;
    }
    
    /**
     * 将传入的 Hello 与 InvocationHandler 进行绑定，以获得代理类的实例
     * @param hello
     * @return
     */
    public Hello bind(Hello hello) {
        this.hello = hello;
        Hello helloProxy = (Hello)Proxy.newProxyInstance(
                hello.getClass().getClassLoader(),
                hello.getClass().getInterfaces(),
                this
            );
        return helloProxy;
    }
    
    public void setAfter(After after) {
        this.after = after;
    }

    public void setBefore(Before before) {
        this.before = before;
    }
}

[微甜灬呼吸]

没觉得有啥用

[寻道的 Programmer]

AOP就是面向切面编程，AOP是OOP的延续，什么时候回用到呢，就是当你想对原有的逻辑进行一些处理，而又不想影响原有的逻辑，面向切面就弥补了面向对象的不足，使用代理对原有的逻辑进行一些事务处理啊，异常处理啊，等等……
这样做的好处就是把本身不属于业务逻辑这块代码拿到外面去，是不相干的逻辑和业务逻辑彻底分离，spring中就采用了这样的方式，我们进行事务处理的时候，在xml中配置一下就好了，当然内部是用动态代理的方式实现的，这只是我的理解！

[xiluhua]

aop(aspect oriented programming 面向切面编程),他吧一个业务流程分成几个部分,比方说,权限验证(validate),业务处理(Action),日志记录(log4),每个部分单独处理,然后再组装起来完成整个业务功能.
他的作用与Servlet的Filter类似,本人就把它当成Filter,
与Filter的最大区别就是他更加灵活,aop不仅可以在web程序,也可以在application.swing程序中使用,另外,他处理的内容能够更加深入,Filter只能在Servlet前后使用,而aop能够深入到方法前后,exception前后,这是filter根本无法企及的...本人也是新手这是我自己的理解...谢谢,别忘了给分啊

[零起跑线]

至少我现在在已经做好的系统中加入权限控制的时候就体会到了ＡＯＰ的好处
[Quote=引用 4 楼 ayanami001 的回复:]
没觉得有啥用
[/Quote]

[★々疯男人ˇ]

谢谢各位，AOP是不是用到权限控制这块比较多啊？上课时，我们老师给我们举的例子就控制用户权限的，希望各位能给出个相应的示例，简单就好，我会加分的。。。谢谢了

[★々疯男人ˇ]

呵呵，再请教一个不足问题的问题，如果看见自己满意的答案了怎么给分的啊？难道直接结贴就可以给分了吗？

[animshuod521]

AOP权限的地方用的比较多，他的用处还是很多的。如果要在某一点加上限制，AOP就有用处了

[ousyuryu]

AOP用白话说成是闹新事儿分离编程，他就好像OOP的一个助手一样。OOP是你把万事万物看成对象来设计你的程序，可是无论你怎么设计有些处理怎么看都不是对象应该有的。像异常处理，日志处理等等。由于这些烦人的处理造成了在设计对象的时候还要考虑好多根对象本身无关的东西。
AOP帮你解决了这个问题，AOP不管对象不对像的它只管处理一些琐碎的处理。而在你想用的时候直接调用就可以了。
这是一种概念上的差别，有用没用是看你用的好不好。
从实质上讲AOP让你的对象更加纯净，让你的程序更加清晰。
从开发效率上讲，OOP和AOP可以同时开发提高效率。