1. public class BeanFactory {
   
2. 
   
3.         Properties props = new Properties();
   
4. 
   
5.         public BeanFactory(InputStream ips) {
   
6.                 try {
   
7.                         props.load(ips);
   
8.                 } catch (IOException e) {
   
9.                         e.printStackTrace();
   
10.                 }
    
11.         }
    
12. 
    
13.         public Object getBean(String name) throws Exception{
    
14.                
    
15.                 String className=props.getProperty(name);
    
16.                 Class clazz=Class.forName(className);
    
17.                 Object bean=clazz.newInstance();
    
18.                 if(bean instanceof ProxyFactoryBean){
    
19.                         ProxyFactoryBean proxyFactoryBean=(ProxyFactoryBean) bean;
    
20.                        
    
21.                         Advice advice=(Advice) Class.forName((String) props.get(name+".advice")).newInstance();
    
22.                         Object taget=Class.forName((String) props.get(name+".advice")).newInstance() ;                           //                                  两个相同的代码。
    
23.                        
    
24.                         proxyFactoryBean.setAdvice(advice);
    
25.                         proxyFactoryBean.setTaget(taget);
    
26.                         Object proxy=(proxyFactoryBean).getProxy();
    
27.                                         return proxy;
    
28.                 }
    
29.                 return bean;
    
30.                
    
31.         }
    
32. }
    

复制代码

首先我对于动态代理不是很了解，对于spring也是没明白，很简单  张老师在讲课中解释了上面代码的重复问题，，但是始终我没能够明白到底是什么问题造成了代码相同 也就是第二段代码也是".advice"也能够正常运行。

有解释不？ 自己做沙发感觉很不好啊  

动态代理的理解：

一个类在实现目标方法(业务逻辑)的时候，还需要添加一些其他的功能，如安全检查，权限验证，日志记录灯，

如调用每一个方法时都需要做这些额外的事，代码重复性高，这些额外功能就是切面代码。这时可将这些额外的

事情交给一个与目标实现类相同接口的代理类管理，当代理类对象调用方法时，它不仅实现目标方法，还

会自动完成这些额外的功能。

代理实现原理：

该代理类的构造方法接收一个类型为InvocationHandler的子类对象，这个类其实就是目标类，将这个子类对象通过参数

传给代理类，返回一个代理类对象，代理对象调用和子类中相同的某一方法时，会自动执行invocationHandler接口实现类

中的invoke方法，在这个方法中就会进行额外事物的处理，而目标方法的实际调用还是由子类对象完成的，并把结果返回给

代理对象，也就是说，子类对象只需要关注业务逻辑，其他事由代理对象完成。

张东健 发表于 2014-2-23 19:57
代理实现原理：

该代理类的构造方法接收一个类型为InvocationHandler的子类对象，这个类其实就是目标类， ...

有点小小的复杂……还得慢慢理解呀