使用Java的动态代理实现Spring AOP的原理

众所周知，Spring的诞生为Java Web业务层的开发带来了极大的便利，表现最为突出的就是它的两点：一、IOC（控制反转或依赖注入）；二、AOP（切面编程）
IOC的用法比较简单，它通过配置文件的方式将一个个对象在WEB容器加载时创建并传递给注入对象使用。
　　而AOP的核心思想就是将一些与业务无关的代码块（如，日志管理或事务管理）单独抽出，以动态代理的方式以切面的形式植入调用业务代码的前后。下面我们将以一个简单的Java动态代理的例子来解释ＡＯＰ的原理。
　　此部分代码分为四个类：
　　一、IUserService接口，在此接口中提供一些常用的业务方法，如添加或是删除用户。
　　二、UserServiceImpl类，实现IUserService接口。
　　三、UserServiceFactory类，一个实现了Singleton模式的工厂类，运用动态代理的机制生产IUserService对象。
　　四、ProxyTest类，该类用于测试。

　　以下是四个类中的代码，
// IUserService.java
package com.pattern.proxy;

public interface IUserService {
public void createUser();
public void updateUser();
}

// UserServiceImpl.java
package com.pattern.proxy;

public class UserServiceImpl implements IUserService {

@Override
public void createUser() {
System.out.println("Create User Successfully");
}

@Override
public void updateUser() {
System.out.println("Update User Successfully");
}

}

// UserServiceFactory
package com.pattern.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
*
* @author zhanxiao
* @date 2009-11-28
*
* To product UserService instance
*
*/
public class UserServiceFactory {
private static UserServiceFactory instance = new UserServiceFactory();

private UserServiceFactory() {
// TODO Auto-generated constructor stub
}

/**
*
* @return
* zhanxiao
*/
public static UserServiceFactory getInstance() {
if (instance == null) {
instance = new UserServiceFactory();
}
return instance;
}

// Get a IUserService instance
public IUserService createUserService() {
return (IUserService) Proxy.newProxyInstance(IUserService.class
.getClassLoader(), new Class[] { IUserService.class },
new ServiceHandler("com.pattern.proxy.UserServiceImpl"));
}

/**
* A inner class implements InvocationHandler interface
* @author zhanxiao
* @date 2009-12-5
*/
private class ServiceHandler implements InvocationHandler {
private String className;

/**
*
* @param className Proxy ClassName including package name
*/
public ServiceHandler(String className) {
this.className = className;
}

@Override
/**
* invoke the proxy class's method
*/
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
System.out.println("Proxy is working...");
return method.invoke(Class.forName(className).newInstance(), args);
}
}
}

// ProxyTest.java
package com.pattern.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class ProxyTest {

public static void main(String[] args) throws Exception {
UserServiceFactory.getInstance().createUserService().createUser();
}
}

测试结果如下：
Proxy is working...
Create User Successfully

小结：在createUserService中我们使用了Proxy类的newProxyInstance方法为目标对象（UserServiceImpl）生成了一个代理对象。值得注意的是该方法的几个参数：第一个参数为代理对象的类加载器，第二个参数是个类型为Class的数组，这里数组只有一个元素，即为代理类，而第三个参数为一个代理的处理类，我们可以把诸如日志管理等代码放在这个类的invoke方法里实现。

本人小菜一个，希望大虾指正。（QQ:226313711）