1. public class ProxyFactoryBean {
   
2.         private Advice advice;
   
3.         private Object target;
   
4.         
   
5.         public void setAdvice(Advice advice) {
   
6.                 this.advice = advice;
   
7.         }
   
8. 
   
9.         public void setTarget(Object target) {
   
10.                 this.target = target;
    
11.         }
    
12.         public Object getProxy() {
    
13.                 return Proxy.newProxyInstance(
    
14.                         target.getClass().getClassLoader(),
    
15.                         target.getClass().getInterfaces(),
    
16.                         new InvocationHandler() {
    
17.                                 @Override
    
18.                                 public Object invoke(Object proxy, Method method, Object[] args)
    
19.                                                 throws Throwable {
    
20.                                         advice.beforeMethod(method);
    
21.                                         Object objVal = method.invoke(target, args);
    
22.                                         advice.afterMethod(method);
    
23.                                         return objVal;
    
24.                                 }
    
25.                         });
    
26.         }
    
27. }

复制代码

代码中定义了两个成员变量，到底动态代理的是哪个变量？ 这两个变量分别代表什么意思？

Jam-l 发表于 2013-9-28 19:07
哦哦，这个是张孝祥老师基础加强的56.实现类似spring的可配置的AOP框架啊，看得我一头雾水，看了你的解释 ...

= =我就说，没看过，我刚好跳过了那个视频。。你明白就好，先把前面的搞懂，不必要没明白就去搞框架

罗凯健 发表于 2013-9-28 18:47
。。你搞清楚代理没有，你这个例子是从哪来的。现在你只要知道主干部分，Proxy.newProxyInstance方法里面 ...

哦哦，这个是张孝祥老师基础加强的56.实现类似spring的可配置的AOP框架啊，看得我一头雾水，看了你的解释我明白点了，谢谢你的热心解释！！

Jam-l 发表于 2013-9-28 17:41
配置文件xxx是ArrayList的话就不使用代理，如果是proxy就使用代理。
那使用了代理以后，还有两个配置就是 ...

。。你搞清楚代理没有，你这个例子是从哪来的。现在你只要知道主干部分，Proxy.newProxyInstance方法里面已经帮你实现接口了，那个Advice和MyAdvice跟生成代理类没有一毛钱的关系，你先不用管那么多。假如不懂先去看看视频，我觉得说的已经够清晰的了

罗凯健 发表于 2013-9-28 15:51
我这样说你可能会比较明白：
target就是需要被代理的类，Advice就是代理类在帮你做事情之后（或之前）还要 ...

配置文件xxx是ArrayList的话就不使用代理，如果是proxy就使用代理。
那使用了代理以后，还有两个配置就是xxx.advice和xxx.target
那这个代理类是xxx.target 的话就是ArrayList类是被代理对象，而这个类而外没写接口和实现类。
但是xxx.advice：MyAdvice写了接口和实现类，那意思是代理可以不用写接口和实现类了？MyAdvice只是而外的建议类？

补充另外两个类BeanFactory类：

1. import java.io.IOException;
   
2. import java.io.InputStream;
   
3. import java.util.Properties;
   
4. 
   
5. public class BeanFactory {
   
6.        
   
7.         Properties props = new Properties();
   
8.         public BeanFactory(InputStream ips){
   
9.                 try {
   
10.                         props.load(ips);
    
11.                 } catch (IOException e) {
    
12.                         e.printStackTrace();
    
13.                 }
    
14.         }
    
15.         public Object getBean(String name){
    
16.                 String        className = props.getProperty(name);
    
17.                 Object bean = null;
    
18.                 try {
    
19.                         Class clazz = Class.forName(className);
    
20.                         bean = clazz.newInstance();
    
21.                 } catch (Exception e) {
    
22.                         e.printStackTrace();
    
23.                 }
    
24.                 if(bean instanceof ProxyFactoryBean){
    
25.                         Object proxy = null;
    
26.                         try {
    
27.                                 ProxyFactoryBean proxyFactoryBean = new ProxyFactoryBean();
    
28.                                 Advice advice = (Advice) Class.forName(props.getProperty(name + ".advice")).newInstance();
    
29.                                 Object target = Class.forName(props.getProperty(name + ".target")).newInstance();
    
30.                                 proxyFactoryBean.setAdvice(advice);
    
31.                                 proxyFactoryBean.setTarget(target);
    
32.                                 proxy = proxyFactoryBean.getProxy();
    
33.                         } catch (Exception e) {
    
34.                                 e.printStackTrace();
    
35.                         }
    
36.                         return proxy;
    
37.                 }
    
38.                 return bean;
    
39.         }
    
40. }

复制代码

AopFrameworkTest 类：

1. 
   
2. public class AopFrameworkTest {
   
3.         public static void main(String[] args) {
   
4.                 InputStream ips = AopFrameworkTest.class.getResourceAsStream("config.properties");
   
5.                 Collection bean = (Collection) new BeanFactory(ips).getBean("xxx");
   
6.                 System.out.println(bean.getClass().getName());
   
7.         }
   
8. }

复制代码

一共就这5个类，在加一个properties配置列表文件

1. xxx = no56.ProxyFactoryBean
   
2. #xxx = java.util.ArrayList
   
3. xxx.advice = no56.MyAdvice
   
4. xxx.target = java.util.ArrayList

复制代码

配置xxx是java.util.ArrayList打印出的类名就是java.util.ArrayList
配置xxx是no56.ProxyFactoryBean打印出的类名就是com.sun.proxy.$Proxy0
这是基础加强里的实现类似spring的可配置的AOP框架，我就是不太明白被代理的对象是哪个? advice和target分别代表什么，起什么作用？

我这样说你可能会比较明白：
target就是需要被代理的类，Advice就是代理类在帮你做事情之后（或之前）还要做的，是面向切面的部分，比如进行系统日志记录，异常信息捕捉输出等等，实际上是一些功能封装起来的类。

代理类就是通过你写的方法创造出来的类，它拥有target的方法，只是在调用这些方法的时候还会额外干点什么。这恰好是代理类的作用

代理可以拦截被代理类的所有方法：代理的是target变量，你的代码不全并不知你的Advice类，不明白的可以http://blog.sina.com.cn/s/blog_c18d53c90101a3so.html到我博客：

a283398689 发表于 2013-9-28 13:28
动态代理是需要4个类的 你才2个，~    按我刚才说的去做 百度复制代码。，

不好意思，一共5个类，因为太多，只发了部分没发全，现在不在家，等下午回去我再补全。

Jam-l 发表于 2013-9-28 13:21
这个是Advice的借口类：这个是自定义Advice类：按理说我觉得Advice是代理对象，但是 method.invoke(targe ...

动态代理是需要4个类的 你才2个，~    按我刚才说的去做 百度复制代码。，


。

接口要去实现的

a283398689 发表于 2013-9-28 13:17
你不需要管那个~  自己百度一下 自己测试最知道，  我简单的告诉你~ 动态代理用去实现接口。，  用jdk的 ...

这个是Advice的借口类：

1. package no56;
   
2. 
   
3. import java.lang.reflect.Method;
   
4. 
   
5. public interface Advice {
   
6.         //定义两个方法
   
7.         public void afterMethod(Method method);
   
8.         public void beforeMethod(Method method);
   
9. }

复制代码

这个是自定义Advice类：

1. import java.lang.reflect.Method;
   
2. 
   
3. public class MyAdvice implements Advice{
   
4.         public void afterMethod(Method method) {
   
5.                 System.out.println(method.getName() + " :running...afterMethod");
   
6.         }
   
7. 
   
8.         public void beforeMethod(Method method) {
   
9.                 System.out.println(method.getName() + " :running...beforeMethod");
   
10.         }
    
11. }

复制代码

按理说我觉得Advice是代理对象，但是 method.invoke(target, args) 方法调用的对象又是target，所以不明白哪个是代理的对象。

  你不需要管那个~  自己百度一下 自己测试最知道，  我简单的告诉你~ 动态代理用去实现接口。，  用jdk的反射机制，  简单的来说。 作用是  类 b  已经实现a 接口。  我不想修改这2个,~  我可以用动态代理 在调用 B 的时候 前面加点处理 后面加点处理 你就明白呢~