代理模式
代理提供了对目标对象的另外的访问方式，即通过代理对象访问目标对象，这样可以扩展目标对象的功能。
java有三种代理模式，分别为静态代理、动态代理、cglib代理
代理模式的关键点是:代理对象与目标对象.代理对象是对目标对象的扩展,并会调用目标对象
1、静态代理
静态代理在使用时,需要定义接口或者父类,被代理对象与代理对象一起实现相同的接口或者是继承相同父类
接口
public interface IUserDao {
public void add();
}
目标对象
public class UserDao implements IUserDao {
@Override
public void add() {
System.out.println("添加方法");
}}
代理对象
public class UserProxy implements IUserDao{
private IUserDao userDao;
public UserProxy(IUserDao userDao) {
super();
this.userDao = userDao;
}@Override
public void add() {
System.out.println("开始事务");
userDao.add();//执行目标对象的方法
System.out.println("提交事务");
}}
测试类
public static void main(String[] args) {
User user = new User();
//目标对象
UserDao userDao = new UserDao();
//把目标对象传给代理对象
UserProxy proxy = new UserProxy(userDao);
//执行的是代理的方法
proxy.add();
}
静态代理优缺点：
优点：可以做到在不修改目标对象的功能前提下,对目标功能扩展.
缺点：因为代理对象需要与目标对象实现一样的接口,所以会有很多代理类,类太多.同时,一旦接口增加方法,目标对象与代理对象都要维护
要克服静态代理的缺点就需要用到动态代理
2、动态代理
接口和实现类同上静态代理
动态代理需要增加一个代理工厂ProxyFactory
public class ProxyFactory {
private Object target;public ProxyFactory(Object target) {
super();
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("开始事务");
//执行目标对象方法
Object invoke = method.invoke(target, args);
System.out.println("提交事务");
return invoke;
}
});
}
}
测试类
public static void main(String[] args) {
UserDao userDao = new UserDao();
//给目标对象生成代理对象，注意此处用的是接口而不是实现类，否则会报转换错误
IUserDao proxy =(IUserDao) new ProxyFactory(userDao).getProxyInstance();
User user = new User();
//代理对象执行方法
proxy.add();
}
动态代理中，代理类并不是在Java代码中实现，而是在运行时期生成，相比静态代理，动态代理可以很方便的对委托类的方法进行统一处理，如添加方法调用次数、添加日志功能等等
3、cglib代理
cglib代理也叫子类代理，静态代理和动态代理都需要目标对象实现一个接口，但是实际情况可能是目标函数没有实现接口，此时就可以用cglib代理，它可以在内存中构建一个子类对象来对目标对象的函数来进行扩展
目标对象
public class CglibDao {
public void save() {
System.out.println("执行保存方法");
}
}
创建一个代理工厂,需要引入一个cglib的依赖
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>3.2.6</version>
</dependency>
import java.lang.reflect.Method;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;public class ProxyFactory2 implements MethodInterceptor{
private Object target;
public ProxyFactory2(Object target) {
super();
this.target = target;
}
public Object getProxyInstance(){
//工具类
Enhancer en = new Enhancer();
//设置父类
en.setSuperclass(target.getClass());
//设置回调函数
en.setCallback(this);
//创建子类（代理对象）
return en.create();
}
@Override
public Object intercept(Object obj, Method method, Object[] arg2, MethodProxy arg3) throws Throwable {
System.out.println("开始事务");
//执行目标类方法，此处的的invoke的第一个参数为target而不是代理对象obj，否则会不断递归调用intercept方法而导致内存溢出
Object invoke = method.invoke(target, arg2);
System.out.println("提交事务");
return invoke;
}
}
测试类
public static void main(String[] args) {
CglibDao cglibDao = new CglibDao();
//给目标对象生成代理对象
CglibDao proxy =(CglibDao) new ProxyFactory2(cglibDao).getProxyInstance();
//代理对象执行方法
proxy.save();
}
cglib也有局限，它也跳不出jdk的继承机制，对final类无能为力
