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(IOC+AOP)_第1张图片

    在这没有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:

    spring(IOC+AOP)_第2张图片

    代码为:

[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>contextConfigLocationparam-name>  
  3.     <param-value>classpath:applicationContext-*.xmlparam-value>  
  4. context-param>  
  5.   
  6. <listener>   
  7.     <listener-class>org.springframework.web.context.ContextLoaderListenerlistener-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管理中,新方案如下:

    spring(IOC+AOP)_第3张图片

    为此,需要将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> aopMap = null;  
  20.   
  21.     public static Map> initConfig() {  
  22.         if (aopMap != null) {  
  23.             return aopMap;  
  24.         }  
  25.         aopMap = new HashMap>();  
  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 methodList = new ArrayList();  
  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> entry : aopMap.entrySet()) {  
  68. //          System.out.println(entry.getKey());  
  69. //          List 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> 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> entry : aopMap.entrySet()) {  
  60.                 // 匹配方法所在的包名与类名  
  61.                 if (clazzName.equals(entry.getKey())) {  
  62.                     List 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




你可能感兴趣的:(java)