转载出处：http://www.cnblogs.com/cenyu/ 作者：岑宇
一、代理模式--三种
静态代理
1、静态代理在使用时，需要定义接口或者父类，被代理对象与代理对象一起实现相同的接口或者是继承相同父类
静态代理的总结
1、优点：可以做到不修改目标对象的功能前提下，对目标功能扩展
2、缺点：因为代理对象需要与目标对象实现一样的接口，所以会有很多代理类，代理类太多。同时，一旦接口增加方法，目标对象与代理对象都要维护
代码示例：
/**
* 接口
* @author
*
*/
public interface IUserDao {
void save();
}
/** * 接口实现，目标对象
*@author * */
public class UserDao implements IUserDao {
@Override public void save() {
System.out.println("已经保存数据");
}
}
/**
* 代理对象，静态代理
* @author
*
*/
public class UserDaoProxy implements IUserDao {
//接收保存目标对象
private UserDao target;
public UserDaoProxy(UserDao target) {
this.target=target;
}
@Override
public void save() {
System.out.println("开启事务");
target.save(); //执行目标对象的方法
System.out.println("结束事务");
}
}
测试类
public class Test {
public static void main(String[] args) {
//目标对象
UserDao target=new UserDao();
//代理对象，将目标对象传给代理对象，建立代理关系
UserDaoProxy proxy=new UserDaoProxy(target);
//执行的是代理的方法
proxy.save();
}
}
动态代理
特点：
1、代理对象，不需要实现接口
2、代理对象的生成是利用JDK的API,动态的在内存中构建代理对象（需要我们指定创建代理对象/目标对象实现的接口的类型）
3、动态代理也叫做：JDK代理，接口代理
代码示例：
/**
* 接口
* @author
*
*/
public interface IUserDao {
void save();
void update();
}
/**
* 接口实现，目标对象
* @author
*
*/
public class UserDao implements IUserDao {
@Override
public void save() {
System.out.println("已经保存数据");
}
@Override
public void update() {
System.out.println("已经更新数据");
}
}
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
* 创建动态代理对象
* 动态代理不需要实现接口，但需要指定接口类型
* @author
*
*/
public class ProxyFactory {
//维护一个目标对象
private Object target;
public ProxyFactory(Object target){
this.target=target;
}
//给目标对象生成代理对象
public Object getProxyInstance(){
return Proxy.newProxyInstance(
target.getClass().getClassLoader(), //指定当前目标对象使用类加载器，获取加载器的方法是固定的
target.getClass().getInterfaces(), //目标对象实现的接口的类型，使用泛型方式确认类型
/**
* 事件处理，执行目标对象的方法时，会触发事件处理器的方法，会把当前执行目标对象的方法作为参数
*/
new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("开始事务2");
//执行目标对象方法
Object returnValue = method.invoke(target, args);
System.out.println("提交事务2");
return null;
}
});
}
}
/**
* 测试类
*/
public class Test {
public static void main(String[] args) {
//目标对象
IUserDao target = new UserDao();
//【原始的类型 class com.sunj.dynamic.proxy.UserDao】
System.out.println(target.getClass());
//给目标对象，创建代理对象
IUserDao proxy = (IUserDao) new ProxyFactory(target).getProxyInstance();
//class $Proxy0内存中动态生成的对象
System.out.println(proxy.getClass());
//执行方法 【代理对象】
proxy.save();
proxy.update();
}
}
Cglib代理
Cglib代理最大的特点是目标对象可以不实现接口，而静态代理和动态代理必须实现接口
代码示例：
/**
* 目标对象，没有实现任何接口
* @author
*
*/
public class UserDao {
public void save(){
System.out.println("数据已经保存");
}
public void update(){
System.out.println("数据已经更新");
}
}
import java.lang.reflect.Method;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
/**
* Cglib子类代理工厂
* 对UserDao在内存中动态构建一个子类对象
* @author
*
*/
public class ProxyFactory implements MethodInterceptor{
//维护目标对象
private Object target;
public ProxyFactory(Object target) {
this.target = target;
}
//给目标对象创建一个代理对象
public Object getProxyInstance(){
//1.工具类
Enhancer en = new Enhancer();
//2.设置父类
en.setSuperclass(target.getClass());
//3.设置回调函数
en.setCallback(this);
//4.创建子类（代理对象）
return en.create();
}
@Override
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
System.out.println("开始事务...");
//执行目标对象的方法
Object returnValue = method.invoke(target,args);
System.out.println("提交事务...");
return returnValue;
}
}
import org.junit.Test;
public class App {
@Test
public void test() {
//目标对象
UserDao target = new UserDao();
//代理对象
UserDao proxy = (UserDao) new ProxyFactory(target).getProxyInstance();
//执行代理对象的方法
proxy.save();
proxy.update();
}
}
看完这三个代理模式，自己得出的结论就是动态代理和Cglib代理的实现只是在创建目标对象时不同，其他的都是相同的，在以后的开发中两种方式可以互补使用。