关于sping的aop的实现

本帖最后由佟亚鹏于 2012-9-6 08:25 编辑

我正在自己写一个像sping这样的框架，现在实现了注入，但是aop的实现，只能代理接口，并且代理接口里的所有方法，sping里面既可以代理接口也可以代理类，并且可以代理到一个具体的方法上面，写到这个地方卡壳了，大家能给点思路吗，我使用的是java对动态代理的支持，貌似只支持代理接口。我把项目打包上传，大家可以看看，给点意见，里面还有一个简单的数据库连接池的实现

AngieFans85 · AngieFans85

佟亚鹏发表于 2012-9-6 19:44
怎么给你说呢，这个产生代理的类，写好就不改的，把所有的处理逻辑都放在Advice，那个类只是一个工具类而 ...

我只是说Advice接口中那四个方法的参数是多余的,要获取方法名,参数名什么的都是直接在InvocationHandler接口中的invoke()方法实现的.
跟你说的这些没有任何关系啊.你还不是一样可以把所有的处理逻辑放在Advice接口中,你要弄明白的是,我只是强调:
你的Advice接口中定义的方法中的参数,不需要Object proxy,Method method,Object[] args这三个参数.

佟亚鹏 · 佟亚鹏

马镱洵发表于 2012-9-6 19:38
"另外那些个参数是有意思的，只是例子程序中没有用到而已，你可以把方法名，参数打印出来"

你要打印方法 ...

怎么给你说呢，这个产生代理的类，写好就不改的，把所有的处理逻辑都放在Advice，那个类只是一个工具类而已，比如说，使用spring，想加点逻辑不至于去修改它的源码吧

AngieFans85 · AngieFans85

佟亚鹏发表于 2012-9-6 19:32
那个return 返回createProxy()中产生的代理，是createProxy()的重载，另外那些个参数是有意思的，只是例 ...

"另外那些个参数是有意思的，只是例子程序中没有用到而已，你可以把方法名，参数打印出来"

你要打印方法名,参数名,也不需要在接口中的方法定义那些参数啊,这些功能是在InvocationHandler接口的invoke()方法里实现的啊,见代码:

public Object createProxy() {
AdviceImpl adviceImpl = new AdviceImpl();
getProxy(adviceImpl, adviceImpl);
Object proxyObj = Proxy.newProxyInstance(target.getClass()
.getClassLoader(), target.getClass().getInterfaces(),
new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method,
Object[] args) throws Throwable {
Object result = null;
try {
advice.beforeAndAfter();
advice.before();
result = method.invoke(target, args);
advice.after();
advice.beforeAndAfter();
// 这句代码就是打印方法名了
System.out.println(method.getName());
} catch (Exception e) {
advice.exception();
}
return result;
}
});
return proxyObj;
}

复制代码

佟亚鹏 · 佟亚鹏

马镱洵发表于 2012-9-6 19:06
另外,你这四个方法中的参数全是多余的吧,根本用不上的.

那个return 返回createProxy()中产生的代理，是createProxy()的重载，另外那些个参数是有意思的，只是例子程序中没有用到而已，你可以把方法名，参数打印出来，看看结果，这些参数，如果需要的话可以在Advice中进行处理下，这个只是对jdk的动态代理进行了封装，为了就是使编程接口变的好用一些，这个类是我自己写的模仿spring的框架中拿出来的，它的原貌在哪个附件中有哦

AngieFans85 · AngieFans85

佟亚鹏发表于 2012-9-6 18:23
呵呵你说的对啊，这个方法确实写错了，我想写一个重载的，一时糊涂搞成这个样子了，不是需要转为Advice ...

public class AdviceImpl implements Advice {
@Override
public void before(Object proxy, Method method, Object[] args) {
System.out.println("before");
}
@Override
public void after(Object proxy, Method method, Object[] args) {
System.out.println("after");
//为了测试处理异常的方法是否执行，自己搞出来一个异常
Integer.parseInt("黑马程序员");
}
@Override
public void exception(Object proxy, Method method, Object[] args) {
System.out.println("exception");
}
@Override
public void beforeAndAfter(Object proxy, Method method, Object[] args) {
System.out.println("beforeAndAfter");
}
}

复制代码

另外,你这四个方法中的参数全是多余的吧,根本用不上的.

AngieFans85 · AngieFans85

public Object createProxy(Object target,Advice advice) {
this.target = target;
this.advice = advice;
return
createProxy ();
}

复制代码

return createProxy ();
这个return语句用来干什么用的?你是用来返回真实的被代理对象吗?
真实的被代理的对象是通过Proxy.newProxyInstance()方法取得的,而不是自己写的.你只能是说需要定义一个实现了某个接口的实现类,然后Proxy.newProxyInstance()方法的参数里需要用到这个实现类的对象(你的代码中,target就是实现了Advice接口的类的对象.),请看代码:

public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)

复制代码

第一个参数loader(就是实现了Advice接口的实现类所属的Class对象的类加载器),就应该为target.getClass().getClassLoader().
第二个参数interfaces(可以是target对象所实现的所有接口的Class对象,也可以是单独一人接口的Class对象.),按照你前面代码的流程,那么此处就应该为target.getClass().getInterfaces().
第三个参数h(就是需要传入一个实现了InvocationHandler接口的对象,不过你在前面的代码中是传入的一个匿名类对象,当然效果一样.),这个InvocationHandler接口里的invoke()方法就是JDK动态代理模式的核心了.

佟亚鹏 · 佟亚鹏

嗯对只能转为他所现在的接口哦，你的速度好快啊，呵呵

AngieFans85 · AngieFans85

佟亚鹏发表于 2012-9-6 18:23
呵呵你说的对啊，这个方法确实写错了，我想写一个重载的，一时糊涂搞成这个样子了，不是需要转为Advice ...

"不是需要转为Advice接口,而是把被代理对象传递过来，就是那个target，然后转为被代理对象所实现的那个接口使用"

我的意思就是说:需要把被代理的真实对象转换为它所实现的那个接口,然后再通过这个接口的引用,调用接口中所定义的方法,当然,接口中定义的方法都是抽象方法,实际上是调用的被代理的对象所实现接口的相对应的方法.
比如说:

ITest t= (ITest) new ProxyFactory().createProxy();
t.test();

复制代码

这里只能将取得的真实被代理对象强转为ITest接口,再通过接口的引用来调用test()方法.
如果要是将取得的真实被代理对象强转为ITestImpl实现类,再通过强转后的ITestImpl类的引用来调用test()方法,就会报错.

佟亚鹏 · 佟亚鹏

马镱洵发表于 2012-9-6 14:32
你这个方法是不是写错了,再说你这个方法是多余的(这个方法和setAdvice()方法与setTarget()方法重复了),你的 ...

public Object getProxy(Object target,Advice advice) {
this.target = target;
this.advice = advice;
return getProxy();
}

复制代码

呵呵你说的对啊，这个方法确实写错了，我想写一个重载的，一时糊涂搞成这个样子了，

public Object createProxy(Object target,Advice advice) {
this.target = target;
this.advice = advice;
return
createProxy ();
}

复制代码

不是需要转为Advice接口,而是把被代理对象传递过来，就是那个target，然后转为被代理对象所实现的那个接口使用
比如接口

public inteface ITest {
void test();
}

复制代码

实现类ITestImpl

public class ITestImpl implements ITest{
void test() {
System.out.println("黑马");
}
}

复制代码

AdviceImpl

public class AdviceImpl implements Advice {
@Override
public void before(Object proxy, Method method, Object[] args) {
System.out.println("before");
}
@Override
public void after(Object proxy, Method method, Object[] args) {
System.out.println("after");
//为了测试处理异常的方法是否执行，自己搞出来一个异常
Integer.parseInt("黑马程序员");
}
@Override
public void exception(Object proxy, Method method, Object[] args) {
System.out.println("exception");
}
@Override
public void beforeAndAfter(Object proxy, Method method, Object[] args) {
System.out.println("beforeAndAfter");
}
}

复制代码

测试代码，

<blockquote>public class Test {

复制代码

输出的结果：
beforeAndAfter
before
黑马
after
exception

AngieFans85 · AngieFans85

public Object getProxy(Object target,Advice advice) {
this.target = target;
this.advice = advice;
return getProxy();
}

复制代码

你这个方法是不是写错了,再说你这个方法是多余的(这个方法和setAdvice()方法与setTarget()方法重复了),你的这种方案,确实可以达到"在同一个接口里除了可以实现必须要实现的方法之外,还可以在实现必须要实现方法之前与之后做一些其他的事情"的目的.不过你只要在调用createProxy()方法之前,必须要先给ProxyFactory类的target成员与advice成员同时赋上一个实现了Advice接口的类的对象,然后在外部调用createProxy()方法,返回的结果就是实际的代理对象,但是如果要真正成功调用到接口里的方法,必须要将这个所返回的代理对象转型成为Advice接口才可以.以下见具体代码:

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
interface Advice {
void before(Object proxy, Method method, Object[] args);
void after(Object proxy, Method method, Object[] args);
void exception(Object proxy, Method method, Object[] args);
void beforeAndAfter(Object proxy, Method method, Object[] args);
/**
* 真正必须要实现的方法
*/
void print();
}
class AdviceImpl implements Advice {
@Override
public void before(Object proxy, Method method, Object[] args) {
System.out.println("before");
}
@Override
public void after(Object proxy, Method method, Object[] args) {
System.out.println("after");
}
@Override
public void exception(Object proxy, Method method, Object[] args) {
System.out.println("exception");
}
@Override
public void beforeAndAfter(Object proxy, Method method, Object[] args) {
System.out.println("beforeAndAfter");
}
@Override
public void print() {
System.out.println("真正想要实现的方法: print()");
}
}
// 还有一个代理类生成工厂
class ProxyFactory {
private Object target;
private Advice advice;
public Object createProxy() {
AdviceImpl adviceImpl = new AdviceImpl();
getProxy(adviceImpl, adviceImpl);
Object proxyObj = Proxy.newProxyInstance(target.getClass()
.getClassLoader(), target.getClass().getInterfaces(),
new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method,
Object[] args) throws Throwable {
Object result = null;
try {
advice.beforeAndAfter(proxy, method, args);
advice.before(proxy, method, args);
result = method.invoke(target, args);
advice.after(proxy, method, args);
advice.beforeAndAfter(proxy, method, args);
} catch (Exception e) {
advice.exception(proxy, method, args);
}
return result;
}
});
return proxyObj;
}
/**
* 这个方法我给你改一下,就不需要后面的几个方法了.
*
* @param target
* @param advice
* @return
*/
public void getProxy(Object target, Advice advice) {
this.target = target;
this.advice = advice;
// return getProxy(this.target, this.advice);
}
// public Object getTarget() {
// return target;
// }
//
// public void setTarget(Object target) {
// this.target = target;
// }
//
// public Advice getAdvice() {
// return advice;
// }
//
// public void setAdvice(Advice advice) {
// this.advice = advice;
// }
}
public class AdviceTest {
public static void main(String[] args) {
Advice ai = (Advice) new ProxyFactory().createProxy();
ai.print();
}
}

复制代码

佟亚鹏 · 佟亚鹏

马镱洵发表于 2012-9-5 19:43
不客气,第二种方案确实是最好的方案.implementationer就是你的真正的实现接口的类的对象,在外部调用creat ...

这个是我写的模仿sping的用jdk代理api生成代理的代码，可以在方法前后都加入逻辑，以及异常处理
有一个接口advice,里面包括四个方法，实现的功能看方法名
public interface Advice {
void before(Object proxy, Method method, Object[] args);
void after(Object proxy, Method method, Object[] args);
void exception(Object proxy, Method method, Object[] args);
void beforeAndAfter(Object proxy, Method method, Object[] args);
}

还有一个代理类生成工厂
public class ProxyFactory {

private Object target;
private Advice advice;

public Object createProxy() {
Object proxyObj = Proxy.newProxyInstance(
target.getClass().getClassLoader(),
target.getClass().getInterfaces(),
new InvocationHandler(){
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
Object result = null;
try {
advice.beforeAndAfter(proxy, method, args);
advice.before(proxy, method, args);
result = method.invoke(target, args);
advice.after(proxy, method, args);
advice.beforeAndAfter(proxy, method, args);
} catch (Exception e) {
advice.exception(proxy, method, args);
}
return result;
}
});

return proxyObj;
}
public Object getProxy(Object target,Advice advice) {
this.target = target;
this.advice = advice;
return getProxy();
}
public Object getTarget() {
return target;
}
public void setTarget(Object target) {
this.target = target;
}
public Advice getAdvice() {
return advice;
}
public void setAdvice(Advice advice) {
this.advice = advice;
}
}
这样做了一层封装，使接口更加好用了，有时间咱俩讨论下自己写代理类，这样不用再局限于Java提供的支持了。。

AngieFans85 · AngieFans85

佟亚鹏发表于 2012-9-5 18:32
自己写代理程序非常麻烦，需要拼java代码，还需要动态编译，目前就使用第二种方案吧，另外代理到具体某个 ...

不客气,第二种方案确实是最好的方案.

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
class MyDynamicProxy implements InvocationHandler {
private Object implementationer;
// public MyDynamicProxy(Object Implementationer) {
// this.Implementationer = Implementationer;
// }
public Object getImplementationer() {
return implementationer;
}
public void setImplementationer(Object implementationer) {
this.implementationer = implementationer;
}
public Object creatTrueRole(Object object) {
this.implementationer = object;
return Proxy.newProxyInstance(implementationer.getClass()
.getClassLoader(), object.getClass().getInterfaces(), this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
Object o = null;
o = method.invoke(this.implementationer, args);
// proxy只是接口的实例,不是接口实现类的实例.
// System.out.println("proxy: " + (proxy instanceof IPrint2));
return o;
}
}

复制代码

implementationer就是你的真正的实现接口的类的对象,在外部调用creatTrueRole()方法时,要传入一个实现了你自己定义的接口的一个实例进去,返回的结果就是动态代理机制所代理的对象,不过要想直接使用这个代理对象,要先把这个返回的代理对象转型为相应的接口,再通过接口的引用来调用已实现的方法.

public class DynamicProxyTest {
public static void main(String[] args) {
IPrint mo = (IPrint) new MyDynamicProxy().creatTrueRole(new MyOne());
IPrint2 mo2 = (IPrint2) new MyDynamicProxy().creatTrueRole(new MyOne());
// 以下注释掉的代码是错误代码,不能将用动态代理生成的对象转型为实现接口的类的类型.
// MyOne mo = (MyOne) new MyDynamicProxy().creatTrueRole(new MyOne());
// MyOne mo2 = (MyOne) new MyDynamicProxy().creatTrueRole(new MyOne());
mo.print();
mo.print2();
mo.print3();
mo2.print4();
mo2.print5();
mo2.print6();
}
}
class MyOne implements IPrint, IPrint2 {
@Override
public void print() {
System.out.println("print");
}
@Override
public void print2() {
System.out.println("print2");
}
@Override
public void print3() {
System.out.println("print3");
}
@Override
public void print4() {
System.out.println("print4");
}
@Override
public void print5() {
System.out.println("print5");
}
@Override
public void print6() {
System.out.println("print6");
}
}
interface IPrint {
// @MyAnnotation(b = "two")
void print();
void print2();
// @MyAnnotation(b = "bb")
void print3();
}
interface IPrint2 {
void print4();
void print5();
void print6();
}

复制代码

佟亚鹏 · 佟亚鹏

马镱洵发表于 2012-9-5 14:35
两种解决方案:
1 那就自己写一个代理类,不借助JDK的动态代理功能.
2 另外定义一个接口,比如IPrint2接口, ...

自己写代理程序非常麻烦，需要拼java代码，还需要动态编译，目前就使用第二种方案吧，另外代理到具体某个方法我自己在琢磨琢磨，谢谢你的回答

AngieFans85 · AngieFans85

佟亚鹏发表于 2012-9-5 14:25
我想实现即可以代理类也可以代理接口，还有不止把接口里的所有方法都代理，还可以代理到具体的一个方法， ...

两种解决方案:
1 那就自己写一个代理类,不借助JDK的动态代理功能.
2 另外定义一个接口,比如IPrint2接口,在该接口里定义你想要的方法,再将你的实例类又实现这个新定义的接口,用Proxy.newInstance()方法生成一个实例,将这个生成的实例转型为IPrint2类型,这样就可以了.

佟亚鹏 · 佟亚鹏

马镱洵发表于 2012-9-5 14:05
用JDK的动态代理的东西的话,需要记住三个要点:
1 定义自己的接口.例如IPrint接口,该接口有一个print()方法. ...

我想实现即可以代理类也可以代理接口，还有不止把接口里的所有方法都代理，还可以代理到具体的一个方法，

AngieFans85 · AngieFans85

用JDK的动态代理的东西的话,需要记住三个要点:
1 定义自己的接口.例如IPrint接口,该接口有一个print()方法.
2 定义一个实现接口的类,例如IPrintImpl类,该类要有print()方法的具体实现.
3 最后用Proxy.newInstance()方法生成一个实例,如果要调用print()方法,那么这个实例不能转型为IPrintImp类型,只能转型为IPrint类型,才能调用print()方法.

佟亚鹏 · 佟亚鹏

没有人吗，自己先顶下。。。。。{:soso_e135:}

帐号		自动登录	找回密码
密码			加入黑马

关于sping的aop的实现

17 个回复

评分

评分

评分