spring（IOC+AOP）

Spring是一个开源框架。由Rod Johnson创建。为了简化企业及系统开发而诞生的。使用Spring,你可以使用简单的javabeans来实现那些以前只有EJB才能实现的功能。

简单的说，Spring是一个轻量级的Ioc和AOP 容器 框架。

A)轻量级

无论从大小还是系统开支来说，Spring都算是轻量级的。整个Spring框架也就是1M多一点的Jar包。Spring的处理开支也非常小。它是非侵入式的：基于Spring开发的系统的对象一般不依赖于Spring的类。

B)反向控制（Ioc）

使用Ioc,对象是被动接受依赖类，而不是主动去寻找。这点和JNDI恰好相反。也就是在容器实例化对象的时候主动将它的依赖注入给它。所以说Spring是通过Ioc(控制反转)来实现依赖注入的。

Ioc意味着关于对象如何得到它的协作对象的责任反转了！

C)面向切面(AOP)

通过AOP,将我们的业务逻辑从系统服务（事务管理，Log日志）中分离出来，将我们的关注点只放在业务逻辑部分。在需要系统服务的地点，时间再将系统服务注入进来。

D)容器

Spring是一个容器，是因为它包含并且管理系统对象的生命周期和配置。可以通过配置来设定你的Bean是单一实例（singleton）还是每次请求产生一个实例（prototype）.

E)框架

使用简单的组件配置组合成一个复杂的系统。也就是说，通过XML文件配置，要啥有啥！

3）Spring的7个模块

Spring由7个模块组成，注意:这7个模块根据系统的需求进行取舍。

AOP模块，O/R映射模块，JDBC和DAO模块，Web Context和Utility模块，Application Context模块，MVC模块，核心容器和支持工具。

A)核心容器

 Spring核心容器为Spring框架提供了基础功能。在后面我们会讲到BeanFactory类，它是Spring框架系统的核心。BeanFactory采用工厂模式来实现Ioc.

B)Application Context模块

如果说BeanFactory使Spring成为容器的话，那么Application Context模块就是让Spring成为框架的原因。它在BeanFactory基础上进行了扩展，添加了对I18N，系统生命周期事件以及验证的支持。另外，还提供了很多企业级服务，如电子邮件服务，JNDI访问，EJB集成，远程调用以及定时服务。

C)Spring的AOP模块

是Spring应用系统开发切面的基础。

D)JDBC抽象及DAO模块

我记得我以前做的项目中，涉及到数据库操作的时候，总是在程序中写一大堆和业务不相干的代码，什么获得连接，创建语句，处理结果，关闭连接。杂乱不堪！！！

现在Spring的JDBC和DAO模块把这些样板代码抽象出来，让我们的数据库代码变得简单明了。另外，这个模块还创建了一个数据库异常层。

E)O/R映射集成模块

Spring并没有实现自己的ORM解决方案，它为许多流行的ORM框架提供了支持。

F)Spring的Web模块

它是建立在Application Context基础之上，提供了适合Web系统的上下文。该模块还支持多项其他面向Web的任务。还包括对Struts的集成支持。

G)Spring MVC框架

虽然Spring可以和其他MVC框架（struts,Web Work）集成，但它也提供了全功能的MVC框架。

    上篇博客简单介绍了Spring的一些优点，现在来说一下Spring这些优点实现的基础：控制反转和依赖注入。

控制反转

    IoC（Inversion of Control），我们可以把它理解为面向对象编程的一个名词概念。直白的说，就是：本来是你该控制的事，现在交由其他人控制，即权利或责任的反转。在编程中，常见的实例是，A对象需要依赖B对象（在A中new一个B），本该是A控制这个过程，现在交由系统处理，这种做法的优势是A与B的耦合性降低；如果这种依赖关系可以控制，也提高了程序的灵活性。

依赖注入

    DI（Dependency Injection），控制反转是一个概念，如何什么手段实现？依赖注入是一个靠谱的方案，依赖注入的主要实现靠的是反射和面向接口编程，常见的如：

[java]  view plain  copy

 print ?

1. UserDao userDao=new userDao4Mysql();  

    依赖注入，就是把这个实例化的过程分为两步：

• 第一步：UserDao userDao;
• 第二步：userDao=new userDao4Mysql();

    然后将第二步分离出来，写入到XML文件中，再使用反射原理将new出来的userDao4Mysql对象注入。这一步可以有两种做法：构造函数和setter。

    XML

    将使用到的userDao注入到UserManagerImpl中。

[html]  view plain  copy

 print ?

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <beans xmlns="http://www.springframework.org/schema/beans"  
3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
4.          xmlns:aop="http://www.springframework.org/schema/aop"  
5.          xmlns:tx="http://www.springframework.org/schema/tx"  
6.          xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd  
7.            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd  
8.            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd">  
9.     <bean id="userDaoMysql" class="com.tgb.spring.dao.UserDao4MysqlImpl"/>  
10.       
11.     <bean id="userDaoOracle" class="com.tgb.spring.dao.UserDao4OracleImpl"/>  
12.       
13.     <bean id="userManager" class="com.tgb.spring.manager.UserManagerImpl">  
14.         <property name="userDao" ref="userDao4Mysql"/>  
15.     </bean>  
16. </beans>  

    构造函数方式

[java]  view plain  copy

 print ?

1. public class UserManagerImpl implements UserManager {  
2.   
3.     private UserDao userDao;  
4.       
5.     public UserManagerImpl(UserDao userDao){  
6.         this.userDao=userDao;  
7.     }  
8.   
9. }  

    Set方式

[java]  view plain  copy

 print ?

1. public class UserManagerImpl implements UserManager {  
2.   
3.     private UserDao userDao;  
4.       
5.     public void setUserDao(UserDao userDao) {  
6.         this.userDao = userDao;  
7.     }  
8.   
9. }  

总结

    如上所见，耦合性降低同时灵活性提升：

• 耦合性降低体现在UserManagerImpl不必再直接关联UserDao4MysqlImpl。
• 灵活体现在userDao4Mysql在配置文件中，可按需要修改,如替换为UserDao4OracleImpl。

    以上说的是优点，那么缺点呢？

• 手写XML易产生拼写错误。
• 反射本身生成对象会有一些效率问题（一倍多于直接new）。

   以上就是Spring的核心控制反转和依赖注入，下篇博客会说到Spring与Struts1的集成。

    上篇博客中说到了Spring的核心实现，这篇博客就是根据这些来说一下Spring对Struts1的集成。

Struts1的问题

    来看一下Struts1的实现流程图：

    

    在这没有Spring介入时，常见的Struts1的Action代码如下：

[java] view plain copy

 print?

1. LoginActionForm laf=(LoginActionForm)form;  
2. String username=laf.getUsername();  
3. String password=laf.getPassword();  
4. UserManager userManager=new UserManager();  
5. try {  
6.     userManager.login(username, password);  
7.   
8.              }   

    和上篇说到的一样，这种通过new的方式，写的很“死”，Spring如何解决这个问题？

第一种方案

    使用查找方式在Action中获取UserManager：

    

    代码为：

[java] view plain copy

 print?

1. BeanFactory factory = new ClassPathXmlApplicationContext("applicationContext.xml");  
2.   
3. UserManager userManager = (UserManager)factory.getBean("userManager");  

    这种方法虽然解决了new的问题，也使用了查找的方式，但是很明显，Spring配置文件的读取与逻辑本身没有太大关联，需要分离出来。

    再优化

    将factory的生成放到容器启动时，web.xml配置文件：

[html] view plain copy

 print?

1. <context-param>  
2.     <param-name>contextConfigLocation</param-name>  
3.     <param-value>classpath:applicationContext-*.xml</param-value>  
4. </context-param>  
5.   
6. <listener>   
7.     <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>  
8. </listener>  

    注意contextConfigLocation不能更改，获取所有Spring的配置文件，然后通过listener的方式，在容器启动时，即加载Spring配置文件，按照配置进行对象的依赖注入。

    然后通过以下代码得到factory。

[java] view plain copy

 print?

1. BeanFactory factory = WebApplicationContextUtils.getRequiredWebApplicationContext(request.getSession().getServletContext());  

    但是仍然存在问题，无论如何都不能避免BeanFactory factory……，因为是主动查找，而非注入，即Struts仍然依赖Spring的API，如何解决？

第二种方案

    以上问题出现的原因是Action并没有纳入Ioc容器，无法对其进行注入，所以想解决以上问题，务必要将Action纳入Spring管理中，新方案如下：

    

    为此，需要将struts的配置文件修改为：

[html] view plain copy

 print?

1. <action-mappings>  
2.     <action path="/login"  
3.             type="org.springframework.web.struts.DelegatingActionProxy"  
4.             name="loginForm"  
5.             scope="request"  
6.     >  
7.         <forward name="success" path="/login_success.jsp"/>  
8.     </action>  
9. </action-mappings>  

    同时在Spring配置文件中添加：

[html] view plain copy

 print?

1. <bean name="/login" class="com.tgb.usermgr.web.actions.LoginAction" scope="prototype">  
2.     <property name="userManager" ref="userManager"/>  
3. </bean>  
4.   
5. <bean id="userManager" class="com.tgb.usermgr.manager.UserManagerImpl"/>  

    此时流程变为：

• DelegatingActionProxy接受ActionServlet转发过来的请求
  
• DelegatingActionProxy将请求转发给Spring下同名的Bean，即真正的Action
  
• 接下来的流程与Struts1处理相同

    说一下DelegatingActionProxy，这个类为代理类，它的作用是将请求转发给Spring下管理的Action，此时在LoginAction中，即可完成UserManagerImpl的注入。

总结

    Spring与Struts的集成，主要体现在代理类上面，通过代理类，将真正的Action纳入到IoC容器的管理，进而进行对象注入。

AOP

概念：

AOP是Aspect Oriented Programming的缩写，意思是面向切面编程

 

功能：

日志记录，性能统计，安全控制，事务处理，异常处理等

 

原理：

AOP通过反射机制实现动态代理，具体看下面举例吧。

 

举例：

在业务方法执行前后加日志记录

业务类接口IHello.java

Java代码  

1. package demo.aop;  
2.   
3. public interface IHello {  
4.     /** 
5.      * 业务处理A 
6.      *  
7.      * @param name 
8.      */  
9.     void sayHello(String name);  
10.   
11.     /** 
12.      * 业务处理B 
13.      *  
14.      * @param name 
15.      */  
16.     void sayGoodBye(String name);  
17. }  

 IHello.java的一个实现类

Java代码  

1. package demo.aop;  
2.   
3. public class Hello implements IHello{  
4.   
5.     public void sayHello(String name) {  
6.         System.out.println("hello " + name);  
7.     }  
8.   
9.     public void sayGoodBye(String name) {  
10.         System.out.println(name + " goodbye!");  
11.     }  
12.   
13. }  

 

日志记录相关的类：Logger类和Level枚举

Java代码  

1. package demo.aop;  
2.   
3. public enum Level {  
4.     DEBUG, INFO  
5. }  

 

Java代码  

1. package demo.aop;  
2.   
3. import java.util.Date;  
4.   
5. public class Logger {  
6.     public static void logging(Level level, String context) {  
7.         if (Level.DEBUG.equals(level)) {  
8.             System.out.println("DEBUG\t" + new Date().toString() + "\t"  
9.                     + context);  
10.         } else if (Level.INFO.equals(level)) {  
11.             System.out.println("INFO\t" + new Date().toString() + "\t"  
12.                     + context);  
13.         }  
14.     }  
15. }  

 

 下面我们为这个sayHello业务方法加上日志记录的业务，我们在不改变原代码的情况下实现该功能

思路1：写一个类实现IHello接口，并依赖Hello这个类

Java代码  

1. package demo.aop;  
2.   
3. /** 
4.  * Hello代理类 
5.  *  
6.  * @author ydc 
7.  * @date 6:55:42 PM Jul 31, 2013 
8.  */  
9. public class ProxyHello implements IHello {  
10.     private IHello hello;  
11.   
12.     public ProxyHello(IHello hello) {  
13.         this.hello = hello;  
14.     }  
15.   
16.     public void sayHello(String name) {  
17.         Logger.logging(Level.DEBUG, "sayHello method start");  
18.         hello.sayHello(name);  
19.         Logger.logging(Level.INFO, "sayHello method end");  
20.     }  
21.   
22.     public void sayGoodBye(String name) {  
23.         hello.sayGoodBye(name);  
24.     }  
25.   
26. }  

 测试一下

Java代码  

1. package demo.aop;  
2.   
3. public class AopTest {  
4.     public static void main(String[] args) {  
5.         new AopTest().test1();  
6.     }  
7.   
8.     public void test1() {  
9.         // 无日志记录功能  
10.         IHello hello1 = new Hello();  
11.   
12.         // 有日志记录功能  
13.         IHello hello2 = new ProxyHello(new Hello());  
14.   
15.         hello1.sayHello("wallet white");  
16.         System.out.println("------------------------------");  
17.         hello2.sayHello("wallet white");  
18.           
19.     }  
20. }  

 结果输出：

Java代码  

1. hello wallet white  
2. ------------------------------  
3. DEBUG   Wed Jul 31 21:46:38 CST 2013    sayHello method start  
4. hello wallet white  
5. INFO    Wed Jul 31 21:46:38 CST 2013    sayHello method end  

 

 缺点：如果像Hello这样的类很多，那么我们就要写很多个ProxyHello这样的类

 

思路2：在jdk1.3以后，jdk提供了一个API java.lang.reflect.InvocationHandler的类，这个类可以让我们在JVM调用某个类的方法时动态的为这些方法做些其他事

 

写一个代理类实现DynaProxyHello实现InvocationHandler接口

Java代码  

1. package demo.aop;  
2.   
3. import java.lang.reflect.InvocationHandler;  
4. import java.lang.reflect.Method;  
5. import java.lang.reflect.Proxy;  
6.   
7. /** 
8.  * Hello动态代理类 代理对象与被代理对像解藕 
9.  *  
10.  * @author ydc 
11.  * @date 6:56:27 PM Jul 31, 2013 
12.  */  
13. public class DynaProxyHello implements InvocationHandler {  
14.     /** 
15.      * 要处理的对象 
16.      */  
17.     private Object delegate;  
18.   
19.     /** 
20.      * 动态生成方法被处理过后的对象(写法固定) 
21.      *  
22.      * @param delegate 
23.      * @return Object 
24.      */  
25.     public Object bind(Object delegate) {  
26.         this.delegate = delegate;  
27.         return Proxy.newProxyInstance(  
28.                 this.delegate.getClass().getClassLoader(), this.delegate  
29.                         .getClass().getInterfaces(), this);  
30.     }  
31.   
32.     /** 
33.      * 要处理的对象中的每个方法会被此方法送去JVM调用，也就是说， 要处理的对象的方法只能通过此方法調用，此方法是动态的 
34.      */  
35.     public Object invoke(Object proxy, Method method, Object[] args)  
36.             throws Throwable {  
37.         Object result = null;  
38.         try {  
39.             // 执行原来的方法之前记录日志  
40.             Logger.logging(Level.DEBUG, method.getName() + " method start");  
41.   
42.             // JVM通过这条语句执行原来的方法(反射机制)  
43.             result = method.invoke(this.delegate, args);  
44.   
45.             // 执行原来的方法之后记录日志  
46.             Logger.logging(Level.INFO, method.getName() + " method end");  
47.         } catch (Exception e) {  
48.             e.printStackTrace();  
49.         }  
50.   
51.         // 返回方法返回值给调用者  
52.         return result;  
53.   
54.     }  
55. }  

 测试一下

Java代码  

1. package demo.aop;  
2.   
3. public class AopTest {  
4.     public static void main(String[] args) {  
5.         new AopTest().test2();  
6.     }  
7.       
8.     public void test2() {  
9.         IHello hello = (IHello) new DynaProxyHello().bind(new Hello());  
10.         hello.sayHello("wallet white");  
11.                 System.out.println("------------------");  
12.         hello.sayGoodBye("wallet white");  
13.     }  
14. }  

 结果输出：

Java代码  

1. DEBUG   Wed Jul 31 21:57:49 CST 2013    sayHello method start  
2. hello wallet white  
3. INFO    Wed Jul 31 21:57:49 CST 2013    sayHello method end  
4. ------------------  
5. DEBUG   Wed Jul 31 21:57:49 CST 2013    sayGoodBye method start  
6. wallet white goodbye!  
7. INFO    Wed Jul 31 21:57:49 CST 2013    sayGoodBye method end  

 

由此可知，采用面向接口编程，对于任何对象的方法执行之前要加上记录日志的操作都是可以的。

代理对象(DynaProxyHello)自动去代理执行被代理对象(Hello)中的每一个方法，一个InvocationHandler接口就把我们的代理对象和被代理对象解藕了。

 

问题：要是为不同的业务方法前加的日志记录不同，就需要写多个DynaProxyHello类

 

加强版：把DynaProxyHello对象和日志操作对象(Logger)解藕

我们要在被代理对象的方法前面或者后面加上日志操作代码 ，那么我们可以抽象一个接口，该接口就只有两个方法

Java代码  

1. package demo.aop;  
2.   
3. import java.lang.reflect.Method;  
4.   
5. public interface IOperation {  
6.     /** 
7.      * 方法执行之前的操作 
8.      *  
9.      * @param method 
10.      */  
11.     void start(Method method);  
12.   
13.     /** 
14.      * 方法执行之后的操作 
15.      *  
16.      * @param method 
17.      */  
18.     void end(Method method);  
19. }  

 写一个实现上面接口的类，把他作为真正的操作者，

Java代码  

1. package demo.aop;  
2.   
3. import java.lang.reflect.Method;  
4. /** 
5.  * 该类将代理者与操作者解藕 
6.  *  
7.  * @author ydc 
8.  * @date 7:22:24 PM Jul 31, 2013 
9.  */  
10. public class LoggerOperation implements IOperation {  
11.   
12.     public void end(Method method) {  
13.         Logger.logging(Level.DEBUG, method.getName() + "method end");  
14.     }  
15.   
16.     public void start(Method method) {  
17.         Logger.logging(Level.INFO, method.getName() + "method start");  
18.   
19.     }  
20.   
21. }  

 新建一个代理对象DynaProxyHello2

Java代码  

1. package demo.aop;  
2.   
3. import java.lang.reflect.InvocationHandler;  
4. import java.lang.reflect.Method;  
5. import java.lang.reflect.Proxy;  
6.   
7. /** 
8.  * Hello动态代理类 代理对象与被代理对像解藕 
9.  *  
10.  * @author ydc 
11.  * @date 6:56:27 PM Jul 31, 2013 
12.  */  
13. public class DynaProxyHello2 implements InvocationHandler {  
14.     /** 
15.      * 操作者 
16.      */  
17.     private Object proxy;  
18.   
19.     /** 
20.      * 要处理的对象 
21.      */  
22.     private Object delegate;  
23.   
24.     /** 
25.      * 动态生成方法被处理过后的对象(写法固定) 
26.      *  
27.      * @param delegate 
28.      * @param proxy 
29.      * @return Object 
30.      */  
31.     public Object bind(Object delegate, Object proxy) {  
32.         this.delegate = delegate;  
33.         this.proxy = proxy;  
34.         return Proxy.newProxyInstance(  
35.                 this.delegate.getClass().getClassLoader(), this.delegate  
36.                         .getClass().getInterfaces(), this);  
37.     }  
38.   
39.     /** 
40.      * 要处理的对象中的每个方法会被此方法送去JVM调用，也就是说， 要处理的对象的方法只能通过此方法調用，此方法是动态的 
41.      */  
42.     @SuppressWarnings("unchecked")  
43.     public Object invoke(Object proxy, Method method, Object[] args)  
44.             throws Throwable {  
45.         Object result = null;  
46.         try {  
47.             // 反射得到操作者的实例  
48.             Class clazz = this.proxy.getClass();  
49.             // 反射得到操作者的start方法  
50.             Method start = clazz.getDeclaredMethod("start",  
51.                     new Class[]{Method.class});  
52.             // 反射执行start方法  
53.             start.invoke(this.proxy, new Object[]{method});  
54.   
55.             // JVM通过这条语句执行原来的方法(反射机制)  
56.             result = method.invoke(this.delegate, args);  
57.   
58.             // 反射得到操作者的end方法  
59.             Method end = clazz.getDeclaredMethod("end",  
60.                     new Class[]{Method.class});  
61.             // 反射执行end方法  
62.             end.invoke(this.proxy, new Object[]{method});  
63.         } catch (Exception e) {  
64.             e.printStackTrace();  
65.         }  
66.   
67.         // 返回方法返回值给调用者  
68.         return result;  
69.   
70.     }  
71. }  

 测试一下

Java代码  

1. package demo.aop;  
2.   
3. public class AopTest {  
4.     public static void main(String[] args) {  
5.         new AopTest().test3();  
6.     }  
7.     public void test3() {  
8.         IHello hello = (IHello) new DynaProxyHello2().bind(new Hello(),  
9.                 new LoggerOperation());  
10.         hello.sayHello("wallet white");  
11.         System.out.println("------------------");  
12.         hello.sayGoodBye("wallet white");  
13.     }  
14. }  

 结果输出：

Java代码  

1. INFO    Wed Jul 31 22:12:08 CST 2013    sayHellomethod start  
2. hello wallet white  
3. DEBUG   Wed Jul 31 22:12:08 CST 2013    sayHellomethod end  
4. ------------------  
5. INFO    Wed Jul 31 22:12:08 CST 2013    sayGoodByemethod start  
6. wallet white goodbye!  
7. DEBUG   Wed Jul 31 22:12:08 CST 2013    sayGoodByemethod end  

 

本文主要参考了下面列出的参考文献的第2篇文章

文章最后留下一个问题：如果不想让所有方法都被日志记录，我们应该怎么去解藕？

也给了一个明确的思路：将需要日志记录的方法写在配置文件里

我在这里做法如下：

---------------------------------------------------------------------------------------------

在馆内添加一个配置文件aop.xml(demo.aop)

Xml代码  

1. <?xml version="1.0" encoding="gbk"?>  
2. <aop>  
3.     <clazz name="demo.aop.Hello">  
4.         <method name="sayHello" />  
5.     </clazz>  
6.     <clazz name="demo.aop.Hello2">  
7.         <method name="sayHello" />  
8.         <method name="sayGoodBye" />  
9.     </clazz>  
10. </aop>  

 在这里是完全匹配，由配置可以看出，对于类demo.aop.Hello内的sayHello方法和类demo.aop.Hello2内的sayHello,sayGoodBye方法添加日志记录功能

 

添加一个读取配置文件的工具类

Java代码  

1. package demo.aop;  
2.   
3. import java.io.File;  
4. import java.util.ArrayList;  
5. import java.util.HashMap;  
6. import java.util.List;  
7. import java.util.Map;  
8.   
9. import javax.xml.parsers.DocumentBuilder;  
10. import javax.xml.parsers.DocumentBuilderFactory;  
11.   
12. import org.w3c.dom.Document;  
13. import org.w3c.dom.Element;  
14. import org.w3c.dom.Node;  
15. import org.w3c.dom.NodeList;  
16.   
17. public class AopUtil {  
18.   
19.     private static Map<String, List<String>> aopMap = null;  
20.   
21.     public static Map<String, List<String>> initConfig() {  
22.         if (aopMap != null) {  
23.             return aopMap;  
24.         }  
25.         aopMap = new HashMap<String, List<String>>();  
26.         String filePath = Class.class.getClass().getResource(  
27.                 "/demo/aop/aop.xml").getPath();  
28.         File f = new File(filePath);  
29.   
30.         Element element = null;  
31.         DocumentBuilder db = null;  
32.         DocumentBuilderFactory dbf = null;  
33.         try {  
34.             dbf = DocumentBuilderFactory.newInstance();  
35.             db = dbf.newDocumentBuilder();  
36.             Document dt = db.parse(f);  
37.             element = dt.getDocumentElement(); // 根元素 aop  
38.             NodeList clazzNodes = element.getChildNodes(); // 根元素下的子节点 clazz  
39.             int cLen = clazzNodes.getLength();  
40.   
41.             // 遍历包名.类名 clazz  
42.             for (int i = 0; i < cLen; i++) {  
43.                 Node node1 = clazzNodes.item(i);  
44.                 if ("clazz".equals(node1.getNodeName())) {  
45.                     String clazzName = node1.getAttributes().getNamedItem(  
46.                             "name").getNodeValue();  
47.                     NodeList nodeDetail = node1.getChildNodes();  
48.   
49.                     List<String> methodList = new ArrayList<String>();  
50.   
51.                     // 遍历方法名  
52.                     for (int j = 0; j < nodeDetail.getLength(); j++) {  
53.                         Node detail = nodeDetail.item(j);  
54.                         if ("method".equals(detail.getNodeName())) {  
55.                             String methodName = detail.getAttributes()  
56.                                     .getNamedItem("name").getNodeValue();  
57.                             methodList.add(methodName);  
58.                         }  
59.                     }  
60.                     aopMap.put(clazzName, methodList);  
61.                 }  
62.             }  
63.         } catch (Exception e) {  
64.             e.printStackTrace();  
65.         }  
66.   
67. //      for (Map.Entry<String, List<String>> entry : aopMap.entrySet()) {  
68. //          System.out.println(entry.getKey());  
69. //          List<String> mList = entry.getValue();  
70. //          if (mList != null)  
71. //              for (String s : mList) {  
72. //                  System.out.println(s);  
73. //              }  
74. //      }  
75.   
76.         return aopMap;  
77.     }  
78. }  

 

修改动态代理类

Java代码  

1. package demo.aop;  
2.   
3. import java.lang.reflect.InvocationHandler;  
4. import java.lang.reflect.Method;  
5. import java.lang.reflect.Proxy;  
6. import java.util.List;  
7. import java.util.Map;  
8.   
9. /** 
10.  * Hello动态代理类 代理对象与被代理对像解藕 
11.  *  
12.  * @author ydc 
13.  * @date 6:56:27 PM Jul 31, 2013 
14.  */  
15. public class DynaProxyHello3 implements InvocationHandler {  
16.     /** 
17.      * 操作者 
18.      */  
19.     private Object proxy;  
20.   
21.     /** 
22.      * 要处理的对象 
23.      */  
24.     private Object delegate;  
25.   
26.     /** 
27.      * 动态生成方法被处理过后的对象(写法固定) 
28.      *  
29.      * @param delegate 
30.      * @param proxy 
31.      * @return Object 
32.      */  
33.     public Object bind(Object delegate, Object proxy) {  
34.         this.delegate = delegate;  
35.         this.proxy = proxy;  
36.         return Proxy.newProxyInstance(  
37.                 this.delegate.getClass().getClassLoader(), this.delegate  
38.                         .getClass().getInterfaces(), this);  
39.     }  
40.   
41.     /** 
42.      * 要处理的对象中的每个方法会被此方法送去JVM调用，也就是说， 要处理的对象的方法只能通过此方法調用，此方法是动态的 
43.      */  
44.     @SuppressWarnings("unchecked")  
45.     public Object invoke(Object proxy, Method method, Object[] args)  
46.             throws Throwable {  
47.         Object result = null;  
48.         try {  
49.             // 初始化配置文件  
50.             Map<String, List<String>> aopMap = AopUtil.initConfig();  
51.   
52.             // 要执行的方法所在包与类名  
53.             String clazzName = this.delegate.getClass().getName();  
54.             String methodName = method.getName();  
55.   
56.             // 是否调用日志记录的标志  
57.             boolean isOpen = false;  
58.   
59.             for (Map.Entry<String, List<String>> entry : aopMap.entrySet()) {  
60.                 // 匹配方法所在的包名与类名  
61.                 if (clazzName.equals(entry.getKey())) {  
62.                     List<String> mList = entry.getValue();  
63.                     if (mList != null) {  
64.                         for (String m : mList) {  
65.                             if (methodName.equals(m)) {  
66.                                 isOpen = true;  
67.                                 break;  
68.                             }  
69.                         }  
70.                     }  
71.                 }  
72.             }  
73.   
74.             // 反射得到操作者的实例  
75.             Class clazz = this.proxy.getClass();  
76.             if (isOpen) {  
77.                 // 反射得到操作者的start方法  
78.                 Method start = clazz.getDeclaredMethod("start",  
79.                         new Class[]{Method.class});  
80.                 // 反射执行start方法  
81.                 start.invoke(this.proxy, new Object[]{method});  
82.             }  
83.   
84.             // JVM通过这条语句执行原来的方法(反射机制)  
85.             result = method.invoke(this.delegate, args);  
86.   
87.             if (isOpen) {  
88.                 // 反射得到操作者的end方法  
89.                 Method end = clazz.getDeclaredMethod("end",  
90.                         new Class[]{Method.class});  
91.                 // 反射执行end方法  
92.                 end.invoke(this.proxy, new Object[]{method});  
93.             }  
94.         } catch (Exception e) {  
95.             e.printStackTrace();  
96.         }  
97.   
98.         // 返回方法返回值给调用者  
99.         return result;  
100.   
101.     }  
102. }  

 

这样，再对上述代码进行测试：

Java代码  

1. package demo.aop;  
2.   
3. public class AopTest {  
4.     public static void main(String[] args) {  
5.         new AopTest().test4();  
6.     }  
7.     public void test4() {  
8.         IHello hello = (IHello) new DynaProxyHello3().bind(new Hello(),  
9.                 new LoggerOperation());  
10.   
11.         hello.sayHello("wallet white");  
12.         System.out.println("------------------");  
13.         hello.sayGoodBye("wallet white");  
14.     }  
15. }  

 结果输出：

Java代码  

1. INFO    Thu Aug 01 09:35:03 CST 2013    sayHellomethod start  
2. hello wallet white  
3. DEBUG   Thu Aug 01 09:35:03 CST 2013    sayHellomethod end  
4. ------------------  
5. wallet white goodbye!  

 在这里我们看到 Hello类内的sayGoodBye方法没有日志记录功能。

 

参考：

1.http://baike.baidu.com/view/73626.htm

2.http://www.blogjava.net/DoubleJ/archive/2008/03/04/183796.html

3.http://www.cnblogs.com/200911/archive/2012/10/09/2716882.html