运用java动态代理机制实现AOP是丑陋的

你连“AOP还有什么实现原理”都没弄明白就下结论说“使用java动态代理机制实现AOP是丑陋的”？佩服你无畏啊~~~

动态代理丑陋，你就不会封装的漂亮一点吗？自己实现一个spring方式的AOP也不难

感谢回复，希望在不吝批评的同时也给我一些提示和解释。AOP的原理基本的我还是知道的，就是以一种透明的方式来实现一个切面。这样的切面是整个系统中所关注的。比如说日志，权限，事物等。我不了解的更多的是实现的方式和方法。希望各位高手给我一些解释。不吝赐教啊。至于我说使用动态代理的方式比较丑陋，是因为我看到了这样的实现。虽然我们可以封装这部分的操作，但是这个我们透明的希望总是有所违背不是么？

动态代理不丑陋，是你看到的代码写得丑陋吧，你好歹也贴些代码出来，大家才容易砸砖阿。

<p>我把代码贴下来：这段代码是实现了InvocationHandler接口的部分。将日志代码放进去了。</p>
<pre name='code' class='java'>public class LogHandler implements InvocationHandler {

　private Logger logger ＝ Logger.getLogger(this.getClass().getName());
　　private Object delegate;
　　public LogHandler(Object delegate){
　　　this.delegate = delegate;
　　}

　public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
　　Object o = null;
　　try {
　　　logger.info("method stats..." ＋ method);
　　　o = method.invoke(delegate,args);
　　　logger.info("method ends..." + method);
　　} catch (Exception e){
　　　logger.info("Exception happends...");
　　　//excetpion handling.
　　}
　　return o;
　}
} </pre>
<p>下面是客户端调用代码：</p>
<pre name='code' class='java'>BusinessInterface businessImp = new BusinessObject();

InvocationHandler handler = new LogHandler(businessImp);

BusinessInterface proxy = (BusinessInterface) Proxy.newProxyInstance(
　businessImp.getClass().getClassLoader(),
　businessImp.getClass().getInterfaces(),
　handler);

proxy.processBusiness(); </pre>
<p> businessImp是我们的一个业务实现。我为什么说这种方法比较丑陋呢？就是使用了这些和业务无关的接口和Proxy代理类。虽然这些是jdk提供的，但是给我的感觉是我在写一些和我应用无关的代码。当然上面仅仅是一个简单的示例。也可以想一些办法封装这些操作。但是总给我的感觉是有些怪异，所以希望问一下还有其他的什么实现。惭愧。写这些内容的时候，深感自己水平不行，贻笑大方了。不过刚才想想我的这个帖子标题，的确不好，不应该用这种结论式的标题。给人感觉不好。其实我是想和人探讨的。</p>

<div class='quote_title'>clarkhill 写道</div><div class='quote_div'><p>我把代码贴下来：这段代码是实现了InvocationHandler接口的部分。将日志代码放进去了。</p>
<pre name='code' class='java'>public class LogHandler implements InvocationHandler {

　private Logger logger ＝ Logger.getLogger(this.getClass().getName());
　　private Object delegate;
　　public LogHandler(Object delegate){
　　　this.delegate = delegate;
　　}

　public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
　　Object o = null;
　　try {
　　　logger.info("method stats..." ＋ method);
　　　o = method.invoke(delegate,args);
　　　logger.info("method ends..." + method);
　　} catch (Exception e){
　　　logger.info("Exception happends...");
　　　//excetpion handling.
　　}
　　return o;
　}
} </pre>
<p>下面是客户端调用代码：</p>
<pre name='code' class='java'>BusinessInterface businessImp = new BusinessObject();

InvocationHandler handler = new LogHandler(businessImp);

BusinessInterface proxy = (BusinessInterface) Proxy.newProxyInstance(
　businessImp.getClass().getClassLoader(),
　businessImp.getClass().getInterfaces(),
　handler);

proxy.processBusiness(); </pre>
<p> businessImp是我们的一个业务实现。我为什么说这种方法比较丑陋呢？就是使用了这些和业务无关的接口和Proxy代理类。虽然这些是jdk提供的，但是给我的感觉是我在写一些和我应用无关的代码。当然上面仅仅是一个简单的示例。也可以想一些办法封装这些操作。但是总给我的感觉是有些怪异，所以希望问一下还有其他的什么实现。惭愧。写这些内容的时候，深感自己水平不行，贻笑大方了。不过刚才想想我的这个帖子标题，的确不好，不应该用这种结论式的标题。给人感觉不好。其实我是想和人探讨的。</p></div><br/>直接用动态代理代码是这样写的,但是用spring或者其他什么框架,你只需要写invoke里面的代码,其他那些机械式都是封装好的

单单从代码来看，似乎也就是这样做吧？似乎Guice提供了Annotation来替代手工创建proxy的代码，而Spring则是用配置来实现（不清楚Spring是否也提供了annotation）

动态代理可以玩的很花巧，这可能就是楼主所说的“丑陋”，用AspectJ未尝不可，就是多了个学习成本的问题，而spring等框架已经封装的很好了

感觉如果这么实现的话，用不用aop都差不多。

aop不适合做日志

你这么实现不是aop的概念，其实就是代理模式么

这个怎么感觉不像动态代理来着

我认为动态代理要与容器配合使用才能发挥威力，应用程序只关心业务逻辑，而生成代理的过程由容器来自动完成；自己手工写代理代码确实把业务逻辑和代理逻辑混在一起了，维护、扩展都比较麻烦
如果自己把代理逻辑抽象出来，与业务逻辑分离，你会发觉就象是在做一个容器。既然如此，为什么不用现成的、成熟的容器呢？

你可以将业务代码调用动态代理的代码进行封装。这样在业务代码中就没有你所说的那么多丑陋的代码了。。

其实我的意思是，实现aop的方式，动态代码生成，比如使用aspectj或者asm要比使用动态代理要好一些。想问问大家的想法。

我也觉得楼主是否可以尝试用容器呢，比如 Spring ，可以让你的业务代码变得很干净。

spring2.5是可以用aonntation来做aop的~~~

bci当然比dynamic proxy要来的更加的好，运行时怎么也比不过编译时或装载时，不过么有免费的午餐，技术难度也不可同日而语。

可以用spring的封装

本来就无所谓丑陋，优雅的调用总是要封装一些丑陋的代码。

spring可以封装,可以参照一下源码~~~