spring动态代理与静态代理

今天整理复习一下spring的代理实现机制,动态代理与静态代理,一个基于接口,一个基于实现类
spring基本配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
	<!--静态代理类,需要构造子的实现,对应相应代理接口 -->
	<bean id="staticProxy" class="com.kangkang.proxy.StaticProxy">
		<constructor-arg ref="userDaoImp"></constructor-arg>
	</bean>
	<!--动态代理类 -->
	<bean id="dynaProxy" class="com.kangkang.proxy.DynaProxy"></bean>

	<!--接口实现类 -->
	<bean id="userDaoImp" class="com.kangkang.daoimp.UserDAOIMP"></bean>


	<!--业务测试 -->
	<bean id="userAction" class="com.kangkang.server.UserAction">
		<property name="userDAOIMP" ref="userDaoImp"></property>
		<property name="user" ref="user"></property>
	</bean>
	<!--vo对象 -->
	<bean id="user" class="com.kangkang.vo.User"></bean>
</beans>

接口类:

public interface UserDAO {
	boolean insert(User user);
	void test();
}

接口实现类:

public class UserDAOIMP implements UserDAO {

	public boolean insert(User user) {
		System.out.println("UserDAOIMP的insert方法被调用");
		return false;
	}

	public void test() {
		System.out.println("UserDAOIMP的test方法被调用");
		
	}


}

静态代理类:

public class StaticProxy implements UserDAO {
	public UserDAO userDAO;
	/**
	 * 构造子构造被代理对象
	 * @param userDAO
	 */
	public StaticProxy(UserDAO userDAO) {
		this.userDAO = userDAO;
	}

	public boolean insert(User user) {
		// TODO Auto-generated method stub
		return userDAO.insert(user);
	}

	public void test() {
		// TODO Auto-generated method stub
		doBefore();
		userDAO.test();
		doAfter();
	}

	private void doAfter() {
		// TODO Auto-generated method stub
		System.out.println("执行方法完毕");
	}

	private void doBefore() {
		// TODO Auto-generated method stub
	  System.out.println("开始执行方法");	
	}

}

动态代理类;

public class DynaProxy implements InvocationHandler {

	private Object obj;
	/**
	 * 创建代理对象
	 * @param obj
	 * @return
	 */
	public Object createObject(Object obj){
		this.obj=obj;
		return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(),this);
	
	}
	/**
	 * 通过反射机制执行被代理对对象方法
	 * @param proxy
	 * @param method
	 * @param args
	 */
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		doBefore();
		Object object =method.invoke(obj, args);
		doAfter();
		return object;
	}

	private void doBefore(){
		System.out.println("开始执行方法");
	}
	private void doAfter(){
		System.out.println("方法执行完毕");
		
	}
}