代理模式
基础介绍
代理模式:为一个对象提供一个替身,以控制对这个对象的访问。即通过代理对象访问目标对象.这样做的好处是:可以在目标对象实现的基础上,增强额外的
功能操作,即扩展目标对象的功能。
代理模式有不同的形式, 主要有三种 静态代理、动态代理 (JDK代理、接口代理)和 Cglib代理 (可以在内存动态的创建对象,而不需要实现接口, 他是属于
动态代理的范畴) 。
静态代理
需求,在一个用户新增操作前后增加一些操作。
第一步:定义一个接口:IUserDao
public interface IUserDao {
public void saveUser();
}
第二步:目标对象UserDao实现接口IUserDao
public class UserDao implements IUserDao{
@Override
public void saveUser() {
System.out.println("新增用户");
}
}
第三步:使用静态代理方式,就需要在代理对象UserDaoProxy中也实现IUserDao
public class UserDaoProxy implements IUserDao{
private IUserDao target;
public UserDaoProxy(IUserDao target) {
this.target = target;
}
@Override
public void saveUser() {
System.out.println("新增之前 进行业务处理");
target.saveUser();
System.out.println("新增之后 进行业务处理");
}
}
第四步:调用的时候通过调用代理对象的方法来调用目标对象
public class Client {
public static void main(String[] args) {
//目标对象
UserDao userDao = new UserDao();
//代理对象
UserDaoProxy userDaoProxy = new UserDaoProxy(userDao);
userDaoProxy.saveUser();
}
}
运行结果:
总结
优点:
在不修改目标对象的功能前提下, 能通过代理对象对目标功能扩展
缺点:
1)因为代理对象需要与目标对象实现一样的接口,所以会有很多代理类
2) 一旦接口增加方法,目标对象与代理对象都要维护
动态代理
jdk动态代理
第一步:定义一个接口:IUserDao
public interface IUserDao {
public void saveUser();
}
第二步:目标对象UserDao实现接口IUserDao
public class UserDao implements IUserDao{
@Override
public void saveUser() {
System.out.println("新增用户");
}
}
第三步:创建代理对象生成工厂
public class ProxyFactory {
//目标对象
private Object target;
public ProxyFactory(Object target) {
this.target = target;
}
//给目标对象生产代理对象
public Object getProxyInstance() {
/**
* public static Object newProxyInstance(ClassLoader loader,
* Class<?>[] interfaces,
* InvocationHandler h)
* ClassLoader loader:指定当前目标对象使用的类加载器,获取加载器的方法固定。
* Class<?>[] interfaces:目标对象实现的接口类型,使用泛型方式确认类型。
* InvocationHandler h:事件处理,执行目标对象的方法时,会触发事情处理器方法,
* 会把当前执行的目标对象方法作为参数传入。
*/
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("jdk动态代理开始");
Object invoke = method.invoke(target,args);
System.out.println("jdk动态代理结束");
return invoke;
}
});
}
}
测试
public class Client {
public static void main(String[] args) {
//目标对象
IUserDao userDao = new UserDao();
//给目标对象创建代理对象
IUserDao proxyInstance = (IUserDao)new ProxyFactory(userDao).getProxyInstance();
proxyInstance.saveUser();
}
}
运行结果:
Cglib动态代理
第一步:创建目标对象
public class UserDao{
public void saveUser() {
System.out.println("新增用户");
}
}
第二步:创建代理对象生成工厂
public class PoxyFactory implements MethodInterceptor {
//维护一个目标对象
private Object target;
public PoxyFactory(Object target) {
this.target = target;
}
//返回一个代理对象,是target 对象的代理对象
public Object getPoxyInstance() {
//1.创建一个工具类
Enhancer enhancer = new Enhancer();
//2.设置父类
enhancer.setSuperclass(target.getClass());
//3.设置回调函数
enhancer.setCallback(this);
//4.创建子类对象,即代理对象
return enhancer.create();
}
@Override
public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
System.out.println("Cglib代理模式开始---");
Object invoke = method.invoke(target, args);
System.out.println("Cglib代理模式结束---");
return invoke;
}
}
测试:
public class Client {
public static void main(String[] args) {
UserDao userDao = new UserDao();
UserDao poxyInstance = (UserDao)new PoxyFactory(userDao).getPoxyInstance();
poxyInstance.saveUser();
}
}
运行结果:
总结
1)静态代理需要自己写代理类,动态代理则是动态生成代理对象。
2)如何选择代理模式:1. 目标对象需要实现接口,用JDK代理2. 目标对象不需要实现接口,用Cglib代理。
3)JDK动态代理只能对实现了接口的类生成代理,而不能针对类
4)Cglib是针对类实现代理,主要是对指定的类生成一个子类,覆盖其中的方法,并覆盖其中方法的增强,但是因为采用的是继承,所以该类或方法最好不要生成final,对于final类或方法,是无法继承的