设计模式之动态代理

SpringAOP

AOP（Aspect-Oriented-Programing）面向切面的编程。面向切面的编程是面向对象编程的一个补充。面向切面编程的核心基础就是，动态代理。

动态代理的实现

定义接口

package com.simulation.dao;

/**
 * 定义接口。
 * @author Administrator
 *
 */
public interface UserDao 
{
	/**
	 * 保存方法。
	 * @param user
	 */
	public void save();
}

接口实现

package com.simulation.dao.impl;

import com.simulation.dao.UserDao;

/**
 * 实现接口UserDao，该类的对象便是被代理对象。
 * @author Administrator
 *
 */
public class UserDaoImpl implements UserDao 
{
	
	@Override
	public void save() 
	{
		System.out.println("user saved!");
	}

}

实现InvocationHandler

package com.simulation.aop;

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

/**
 * 定义切面逻辑的处理类。
 * @author Administrator
 *
 */
public class LogInterceptor implements InvocationHandler
{
	/**
	 * 被代理对象。
	 */
	private Object target;
	
	/**
	 * 初始化处理类对象时，传入被代理对象。
	 * @param proxy
	 */
	public LogInterceptor(Object target)
	{
		this.target = target;
	}
	
	/**
	 * 切面需要实现的逻辑。
	 * @param method
	 */
	public void preMethod(Method method)
	{
		System.out.println(method.getName() + " start !");
	}
	
	/**
	 * JDK定义的接口InvocationHandler中的方法。
	 */
	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable
	{
		//切面逻辑。
		preMethod(method);
		
		//执行被代理对象的方法。
		Object object = method.invoke(target, args);
		
		return object;
	}
}

动态代理

package main;

import java.lang.reflect.Proxy;

import com.simulation.aop.LogInterceptor;
import com.simulation.dao.UserDao;
import com.simulation.dao.impl.UserDaoImpl;

public class Test 
{
	/**
	 * 测试。
	 * @param args
	 */
	public static void main(String[] args) 
	{
		//被代理对象。
		UserDao userDao = new UserDaoImpl();
		
		//切面逻辑的处理类对象。
		LogInterceptor logInterceptor = new LogInterceptor(userDao);
		
		//获取代理对象。
		UserDao proxy = (UserDao) Proxy.newProxyInstance(
				userDao.getClass().getClassLoader(),
				userDao.getClass().getInterfaces(), 
				logInterceptor);
		
		//通过代理对象调用方法。
		proxy.save();
	}
}