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

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

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

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

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

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

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

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

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

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

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

1. import java.lang.reflect.InvocationHandler;
   
2. import java.lang.reflect.Method;
   
3. import java.lang.reflect.Proxy;
   
4. 
   
5. class MyDynamicProxy implements InvocationHandler {
   
6.         private Object implementationer;
   
7. 
   
8.         // public MyDynamicProxy(Object Implementationer) {
   
9.         // this.Implementationer = Implementationer;
   
10.         // }
    
11. 
    
12.         public Object getImplementationer() {
    
13.                 return implementationer;
    
14.         }
    
15. 
    
16.         public void setImplementationer(Object implementationer) {
    
17.                 this.implementationer = implementationer;
    
18.         }
    
19. 
    
20.         public Object creatTrueRole(Object object) {
    
21.                 this.implementationer = object;
    
22.                 return Proxy.newProxyInstance(implementationer.getClass()
    
23.                                 .getClassLoader(), object.getClass().getInterfaces(), this);
    
24.         }
    
25. 
    
26.         @Override
    
27.         public Object invoke(Object proxy, Method method, Object[] args)
    
28.                         throws Throwable {
    
29.                 Object o = null;
    
30.                 o = method.invoke(this.implementationer, args);
    
31. 
    
32.                 // proxy只是接口的实例,不是接口实现类的实例.
    
33.                 // System.out.println("proxy: " + (proxy instanceof IPrint2));
    
34. 
    
35.                 return o;
    
36.         }
    
37. }

复制代码

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

1. 
   
2. public class DynamicProxyTest {
   
3.         public static void main(String[] args) {
   
4.                 IPrint mo = (IPrint) new MyDynamicProxy().creatTrueRole(new MyOne());
   
5.                 IPrint2 mo2 = (IPrint2) new MyDynamicProxy().creatTrueRole(new MyOne());
   
6. 
   
7.                 // 以下注释掉的代码是错误代码,不能将用动态代理生成的对象转型为实现接口的类的类型.
   
8.                 // MyOne mo = (MyOne) new MyDynamicProxy().creatTrueRole(new MyOne());
   
9.                 // MyOne mo2 = (MyOne) new MyDynamicProxy().creatTrueRole(new MyOne());
   
10. 
    
11.                 mo.print();
    
12.                 mo.print2();
    
13.                 mo.print3();
    
14.                 mo2.print4();
    
15.                 mo2.print5();
    
16.                 mo2.print6();
    
17.         }
    
18. }
    
19. 
    
20. class MyOne implements IPrint, IPrint2 {
    
21.         @Override
    
22.         public void print() {
    
23.                 System.out.println("print");
    
24.         }
    
25. 
    
26.         @Override
    
27.         public void print2() {
    
28.                 System.out.println("print2");
    
29.         }
    
30. 
    
31.         @Override
    
32.         public void print3() {
    
33.                 System.out.println("print3");
    
34.         }
    
35. 
    
36.         @Override
    
37.         public void print4() {
    
38.                 System.out.println("print4");
    
39.         }
    
40. 
    
41.         @Override
    
42.         public void print5() {
    
43.                 System.out.println("print5");
    
44.         }
    
45. 
    
46.         @Override
    
47.         public void print6() {
    
48.                 System.out.println("print6");
    
49.         }
    
50. }
    
51. 
    
52. interface IPrint {
    
53.         // @MyAnnotation(b = "two")
    
54.         void print();
    
55. 
    
56.         void print2();
    
57. 
    
58.         // @MyAnnotation(b = "bb")
    
59.         void print3();
    
60. }
    
61. 
    
62. interface IPrint2 {
    
63.         void print4();
    
64. 
    
65.         void print5();
    
66. 
    
67.         void print6();
    
68. }

复制代码

马镱洵 发表于 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提供的支持了。。

1. public Object getProxy(Object target,Advice advice) {
   
2.                 this.target = target;
   
3.                 this.advice = advice;
   
4.                 return getProxy();
   
5.         }
   

复制代码

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

1. import java.lang.reflect.InvocationHandler;
   
2. import java.lang.reflect.Method;
   
3. import java.lang.reflect.Proxy;
   
4. 
   
5. interface Advice {
   
6. 
   
7.         void before(Object proxy, Method method, Object[] args);
   
8. 
   
9.         void after(Object proxy, Method method, Object[] args);
   
10. 
    
11.         void exception(Object proxy, Method method, Object[] args);
    
12. 
    
13.         void beforeAndAfter(Object proxy, Method method, Object[] args);
    
14. 
    
15.         /**
    
16.          * 真正必须要实现的方法
    
17.          */
    
18.         void print();
    
19. 
    
20. }
    
21. 
    
22. class AdviceImpl implements Advice {
    
23. 
    
24.         @Override
    
25.         public void before(Object proxy, Method method, Object[] args) {
    
26.                 System.out.println("before");
    
27.         }
    
28. 
    
29.         @Override
    
30.         public void after(Object proxy, Method method, Object[] args) {
    
31.                 System.out.println("after");
    
32.         }
    
33. 
    
34.         @Override
    
35.         public void exception(Object proxy, Method method, Object[] args) {
    
36.                 System.out.println("exception");
    
37.         }
    
38. 
    
39.         @Override
    
40.         public void beforeAndAfter(Object proxy, Method method, Object[] args) {
    
41.                 System.out.println("beforeAndAfter");
    
42.         }
    
43. 
    
44.         @Override
    
45.         public void print() {
    
46.                 System.out.println("真正想要实现的方法: print()");
    
47.         }
    
48. 
    
49. }
    
50. 
    
51. // 还有一个代理类生成工厂
    
52. class ProxyFactory {
    
53. 
    
54.         private Object target;
    
55.         private Advice advice;
    
56. 
    
57.         public Object createProxy() {
    
58.                 AdviceImpl adviceImpl = new AdviceImpl();
    
59.                 getProxy(adviceImpl, adviceImpl);
    
60.                 Object proxyObj = Proxy.newProxyInstance(target.getClass()
    
61.                                 .getClassLoader(), target.getClass().getInterfaces(),
    
62.                                 new InvocationHandler() {
    
63.                                         @Override
    
64.                                         public Object invoke(Object proxy, Method method,
    
65.                                                         Object[] args) throws Throwable {
    
66.                                                 Object result = null;
    
67.                                                 try {
    
68.                                                         advice.beforeAndAfter(proxy, method, args);
    
69.                                                         advice.before(proxy, method, args);
    
70.                                                         result = method.invoke(target, args);
    
71.                                                         advice.after(proxy, method, args);
    
72.                                                         advice.beforeAndAfter(proxy, method, args);
    
73.                                                 } catch (Exception e) {
    
74.                                                         advice.exception(proxy, method, args);
    
75.                                                 }
    
76.                                                 return result;
    
77.                                         }
    
78.                                 });
    
79.                 return proxyObj;
    
80.         }
    
81. 
    
82.         /**
    
83.          * 这个方法我给你改一下,就不需要后面的几个方法了.
    
84.          *
    
85.          * @param target
    
86.          * @param advice
    
87.          * @return
    
88.          */
    
89.         public void getProxy(Object target, Advice advice) {
    
90.                 this.target = target;
    
91.                 this.advice = advice;
    
92.                 // return getProxy(this.target, this.advice);
    
93.         }
    
94. 
    
95.         // public Object getTarget() {
    
96.         // return target;
    
97.         // }
    
98.         //
    
99.         // public void setTarget(Object target) {
    
100.         // this.target = target;
     
101.         // }
     
102.         //
     
103.         // public Advice getAdvice() {
     
104.         // return advice;
     
105.         // }
     
106.         //
     
107.         // public void setAdvice(Advice advice) {
     
108.         // this.advice = advice;
     
109.         // }
     
110. 
     
111. }
     
112. 
     
113. public class AdviceTest {
     
114. 
     
115.         public static void main(String[] args) {
     
116.                 Advice ai = (Advice) new ProxyFactory().createProxy();
     
117.                 ai.print();
     
118.         }
     
119. 
     
120. }

复制代码

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

1.   public Object getProxy(Object target,Advice advice) {
   
2.                 this.target = target;
   
3.                 this.advice = advice;
   
4.                 return getProxy();
   
5.         }

复制代码

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

1. public Object createProxy(Object target,Advice advice) {
   
2.       this.target = target;
   
3.       this.advice = advice;
   
4.       return
   
5. createProxy ();
   
6. }

复制代码

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

1. public inteface ITest {
   
2.      void test();
   
3. }

复制代码

实现类ITestImpl

1. public class ITestImpl  implements ITest{
   
2.       void test() {
   
3.            System.out.println("黑马");
   
4.        }
   
5. }

复制代码

AdviceImpl

1. public class AdviceImpl implements Advice {
   
2.        
   
3.         @Override
   
4.         public void before(Object proxy, Method method, Object[] args) {
   
5.                 System.out.println("before");
   
6.         }
   
7. 
   
8.         @Override
   
9.         public void after(Object proxy, Method method, Object[] args) {
   
10.                 System.out.println("after");
    
11.                 //为了测试处理异常的方法是否执行，自己搞出来一个异常
    
12.                 Integer.parseInt("黑马程序员");
    
13.         }
    
14. 
    
15.         @Override
    
16.         public void exception(Object proxy, Method method, Object[] args) {
    
17.                 System.out.println("exception");
    
18.         }
    
19. 
    
20.         @Override
    
21.         public void beforeAndAfter(Object proxy, Method method, Object[] args) {
    
22.                 System.out.println("beforeAndAfter");
    
23.         }
    
24. 
    
25. }

复制代码

测试代码，

1. <blockquote>public class Test {

复制代码

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

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

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

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

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

复制代码

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

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

1. public Object createProxy(Object target,Advice advice) {
   
2.       this.target = target;
   
3.       this.advice = advice;
   
4.       return
   
5. createProxy ();
   
6. }

复制代码

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

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

复制代码

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

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

1. public class AdviceImpl implements Advice {
   
2.         
   
3.         @Override
   
4.         public void before(Object proxy, Method method, Object[] args) {
   
5.                 System.out.println("before");
   
6.         }
   
7. 
   
8.         @Override
   
9.         public void after(Object proxy, Method method, Object[] args) {
   
10.                 System.out.println("after");
    
11.                 //为了测试处理异常的方法是否执行，自己搞出来一个异常
    
12.                 Integer.parseInt("黑马程序员");
    
13.         }
    
14. 
    
15.         @Override
    
16.         public void exception(Object proxy, Method method, Object[] args) {
    
17.                 System.out.println("exception");
    
18.         }
    
19. 
    
20.         @Override
    
21.         public void beforeAndAfter(Object proxy, Method method, Object[] args) {
    
22.                 System.out.println("beforeAndAfter");
    
23.         }
    
24. 
    
25. }

复制代码

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

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

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

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

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

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

1. public Object createProxy() {
   
2.                 AdviceImpl adviceImpl = new AdviceImpl();
   
3.                 getProxy(adviceImpl, adviceImpl);
   
4.                 Object proxyObj = Proxy.newProxyInstance(target.getClass()
   
5.                                 .getClassLoader(), target.getClass().getInterfaces(),
   
6.                                 new InvocationHandler() {
   
7.                                         @Override
   
8.                                         public Object invoke(Object proxy, Method method,
   
9.                                                         Object[] args) throws Throwable {
   
10.                                                 Object result = null;
    
11.                                                 try {
    
12.                                                         advice.beforeAndAfter();
    
13.                                                         advice.before();
    
14.                                                         result = method.invoke(target, args);
    
15.                                                         advice.after();
    
16.                                                         advice.beforeAndAfter();
    
17. 
    
18.                                                         // 这句代码就是打印方法名了
    
19.                                                         System.out.println(method.getName());
    
20.                                                 } catch (Exception e) {
    
21.                                                         advice.exception();
    
22.                                                 }
    
23.                                                 return result;
    
24.                                         }
    
25.                                 });
    
26.                 return proxyObj;
    
27.         }

复制代码

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

你要打印方法 ...

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

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

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