java中的静态代理与动态代理

java中的静态代理与动态代理

本来打算今天写点jpa方面的东西，结果搞上了代理，索性就把研究成果放出来吧，java中的代理有两种一种是静态代理一种是动态代理，静态代理其实很容易理解，静态代理其实就是个装饰器而已，而动态代理则借助于jvm的支持，在运行时动态生成代理类。

在这里我通过一个UserDao阐述这个问题。现实生活中这是一个很实际的应用。

package com.syj.pt.proxy.st;   
  
import com.syj.pt.dao.UserDao;   
  
/**  
 * <P>  
 * Title:UserDaoImpl静态代理类  
 * </P>  
 *   
 * @author 孙钰佳  
 * @main sunyujia@yahoo.cn  
 * @date Jun 1, 2008 11:08:24 AM  
 */  
public class UserDaoImplProxy implements UserDao{   
    private UserDao userDao;   
    public UserDaoImplProxy() {   
        super();   
    }   
    public UserDaoImplProxy(UserDao userDao) {   
        super();   
        this.userDao = userDao;   
    }   
  
  
    public void saveUser(Object user) {   
        System.out.println("before save");   
        userDao.saveUser(user);   
        System.out.println("after save");   
    }   
}   
package com.syj.pt.proxy.dy;   
  
import java.lang.reflect.InvocationHandler;   
import java.lang.reflect.Method;   
import java.lang.reflect.Proxy;   
  
/**  
 * <P>  
 * Title:UserDaoImpl动态代理类  
 * </P>  
 *   
 * @author 孙钰佳  
 * @main sunyujia@yahoo.cn  
 * @date Jun 1, 2008 11:08:24 AM  
 */  
public class UserDaoImplProxy implements InvocationHandler {   
    private Object obj;   
  
    public UserDaoImplProxy() {   
        super();   
    }   
  
    public UserDaoImplProxy(Object obj) {   
        super();   
        this.obj = obj;   
    }   
  
    public Object invoke(Object proxy, Method method, Object[] args)   
            throws Throwable {   
        System.out.println("before save");   
        Object o = method.invoke(obj, args);   
        System.out.println("after save");   
        return o;   
    }   
  
    public static Object factory(Object obj) {   
        Class cls = obj.getClass();   
        return Proxy.newProxyInstance(cls.getClassLoader(),   
                cls.getInterfaces(), new UserDaoImplProxy(obj));   
    }   
}

静态代理类implements UserDao而动态代理类implements InvocationHandler 实际上这里就可以体现出静态代理的局限性了，静态代理必须实现接口的方法，而动态代理不用，最后来个test测试下。



package com.syj.pt.server;

import com.syj.pt.dao.UserDao;

/**
* <P>
* Title:用户业务类
* </P>
*
* @author 孙钰佳
* @main sunyujia@yahoo.cn
* @date Jun 1, 2008 11:13:01 AM
*/
public class UserServer {
private UserDao userDao;

public void saveUser(Object user) {
userDao.saveUser(user);
}

public UserDao getUserDao() {
return userDao;
}

public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}

/**
* 取得静态代理对象
*
* @return
* @throws Exception
*/
public static UserDao getStProxy() throws Exception {
UserDao dao = (UserDao) UserServer.class.getClassLoader().loadClass(
"com.syj.pt.dao.impl.mysql.UserDaoImpl").newInstance();
com.syj.pt.proxy.st.UserDaoImplProxy proxy = new com.syj.pt.proxy.st.UserDaoImplProxy(
dao);
return proxy;
}

/**
* 取得动态代理对象
*
* @return
* @throws Exception
*/
public static UserDao getDyProxy() throws Exception {
UserDao dao = (UserDao) UserServer.class.getClassLoader().loadClass(
"com.syj.pt.dao.impl.oracle.UserDaoImpl").newInstance();
UserDao proxy = (UserDao) com.syj.pt.proxy.dy.UserDaoImplProxy
.factory(dao);
return proxy;
}

public static void main(String[] args) throws Exception {
UserServer ts = new UserServer();
// 测试静态代理
ts.setUserDao(getStProxy());
ts.saveUser(new Object());
// 测试动态代理
ts.setUserDao(getDyProxy());
ts.saveUser(new Object());
}
}




输出结果为

before save

mysql save User

after save

before save

oracle save User

after save

这也是代理模式最常见的应用场景，aop。