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

 

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

    java中的代理有两种一种是静态代理一种是动态代理，静态代理其实很容易理解，静态代理其实就是个装饰器而已，而动态代理则借助于jvm的支持，在运行时动态生成代理类。
    在这里通过一个UserDao阐述这个问题。现实生活中这是一个很实际的应用。
Color=#cccccc cellSpacing=0 cellPadding=1 width="80%" align=center bgColor=#ffffff border=1 heihgt=""> 
package com.syj.pt.dao;

/**
*
* Title:用户对象数据访问层
*
*
* @author 孙钰佳
* @main [e-mail]
* @date Jun 1, 2008 11:04:26 AM
*/
public interface UserDao {
public void saveUser(Object user);
}
package com.syj.pt.dao.impl.mysql;

import com.syj.pt.dao.UserDao;

/**
*
* Title:mysql版UserDao实现类
*
*
* @author 孙钰佳
* @main [e-mail]
* @date Jun 1, 2008 11:06:39 AM
*/
public class UserDaoImpl implements UserDao {

public void saveUser(Object user) {
  System.out.println("mysql save User");
}

}
package com.syj.pt.dao.impl.oracle;

import com.syj.pt.dao.UserDao;

/**
*
* Title: oracle版UserDao实现类
*
*
* @author 孙钰佳
* @main [e-mail]
* @date Jun 1, 2008 11:06:46 AM
*/
public class UserDaoImpl implements UserDao {

public void saveUser(Object user) {
  System.out.println("oracle save User");
}

}上面分别定义了一个接口两个实现类，分开mysql和oracle对数据库的操作实现下面是非常关键的代理类实现代码

package com.syj.pt.proxy.st;

import com.syj.pt.dao.UserDao;

/**
*
* Title:UserDaoImpl静态代理类
*
*
* @author 孙钰佳
* @main [e-mail]
* @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;

/**
*
* Title:UserDaoImpl动态代理类
*
*
* @author 孙钰佳
* @main [e-mail]
* @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;

/**
*
* Title:用户业务类
*
*
* @author 孙钰佳
* @main [e-mail]
* @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。