Spring的AOP思想就是通过代理实现的。 

UserServiceProxyFactory.java（动态代理工厂）：

package cn.xxx.proxy;

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

import cn.xxx.service.UserService;    // 被代理的对象实现的接口
import cn.xxx.service.UserServiceImpl;  // 被代理的对象
//动态代理(被代理的对象必须实现接口),AOP思想,实现事务的控制
public class UserServiceProxyFactory implements InvocationHandler {
	
	public UserServiceProxyFactory(UserService us) {
		super();
		this.us = us;
	}

	private UserService us;  // 被代理的对象
	
	public UserService getUserServiceProxy(){
		//生成动态代理
		UserService usProxy = (UserService) Proxy.newProxyInstance(UserServiceProxyFactory.class.getClassLoader(),
									UserServiceImpl.class.getInterfaces(), 
									this);  // this 其实就是InvocationHandler接口的实现类
		//返回
		return usProxy;  // 返回对象的代理
	}

	@Override
	public Object invoke(Object proxy, Method method, Object[] arg2) throws Throwable {
		System.out.println("打开事务!");  // 执行被代理对象的方法之前的业务逻辑 (AOP思想)
		Object invoke = method.invoke(us, arg2);
		System.out.println("提交事务!");  // 执行被代理对象的方法之后的业务逻辑 (AOP思想)
		return invoke;
	}

}

UserServiceProxyFactory2.java（cglib代理工厂）：

package cn.xxx.proxy;

import java.lang.reflect.Method;

import org.springframework.cglib.proxy.Enhancer;  //需要导入cglib包
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import cn.xxx.service.UserService;
import cn.xxx.service.UserServiceImpl;  // 被代理的对象

//cglib代理(通过继承实现代理;被代理对象不需要实现接口,但不能被final修饰)
public class UserServiceProxyFactory2 implements MethodInterceptor {

	public UserService getUserServiceProxy(){
		
		Enhancer en = new Enhancer(); //帮我们生成代理对象
		
		en.setSuperclass(UserServiceImpl.class); //设置被代理对象
		
		en.setCallback(this); //代理要做什么。 this 其实就是MethodInterceptor接口的实现类
		
		UserService us = (UserService) en.create(); //创建对象的代理 (代理就是目标对象的子类)
		
		return us;
	}

	@Override
	public Object intercept(Object obj, Method method, Object[] arg, MethodProxy methodProxy) throws Throwable {
		// 执行被代理对象的方法之前的业务逻辑 (AOP思想)
		System.out.println("打开事务!");
		// 调用被代理对象的方法
		Object result = methodProxy.invokeSuper(obj, arg); // 参数obj就是被代理对象。
		// 执行被代理对象的方法之后的业务逻辑 (AOP思想)
		System.out.println("提交事务!");
		
		return result;
	}

}

Test.java（测试类）：

package cn.xxx.proxy;

import org.junit.Test;

import cn.xxx.service.UserService;
import cn.xxx.service.UserServiceImpl;

public class Test {
	
	@Test
	//测试动态代理
	public void fun1(){
		UserService us = new UserServiceImpl();
		
		UserServiceProxyFactory factory = new UserServiceProxyFactory(us);
		
		UserService usProxy = factory.getUserServiceProxy();
		
		usProxy.save();
		
		//代理对象与被代理对象实现了相同的接口
		//代理对象 与 被代理对象没有继承关系
		System.out.println(usProxy instanceof UserServiceImpl );//false
	}
	
	@Test
	//测试cglib代理 (通过继承实现代理)
	public void fun2(){
		
		UserServiceProxyFactory2 factory = new UserServiceProxyFactory2();
		
		UserService usProxy = factory.getUserServiceProxy();
		
		usProxy.save();
		
		//判断代理对象是否属于被代理对象类型
		//代理对象继承了被代理对象=>true
		System.out.println(usProxy instanceof UserServiceImpl );//true
	}
}

UserServiceImpl.java（被代理的对象）：

package cn.xxx.service;

public class UserServiceImpl implements UserService {
	@Override
	public void save() {
		System.out.println("保存用户!");
	}
	@Override
	public void delete() {
		System.out.println("删除用户!");
	}
	@Override
	public void update() {
		System.out.println("更新用户!");
	}
	@Override
	public void find() {
		System.out.println("查找用户!");
	}
}