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

最新推荐文章于 2025-09-29 13:13:59 发布

原创最新推荐文章于 2025-09-29 13:13:59 发布 · 2.7k 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#java #object #exception #dao #user #date

J2SE 专栏收录该内容

29 篇文章

订阅专栏

本文深入探讨Java中的代理模式，包括静态代理与动态代理的区别及应用。通过具体的UserDao接口实例，展示如何使用这两种代理方式，并比较它们之间的差异。

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

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

package com.syj.pt.dao;

/**
 * 
 * Title:用户对象数据访问层
 * 
 * 
 * @author 孙钰佳
 * @main sunyujia@yahoo.cn
 * @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 sunyujia@yahoo.cn
 * @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 sunyujia@yahoo.cn
 * @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 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;

/**
 * 
 * Title:UserDaoImpl动态代理类
 * 
 * 
 * @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;

/**
 * 
 * Title:用户业务类
 * 
 * 
 * @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。