提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档
提示：以下是本篇文章正文内容，下面案例可供参考
一、代理模式
代理模式是什么？
代理模式在Java开发中是一种比较常见的设计模式。设计目的旨在为服务类与客户类之间插入其他功能，插入的功能对于调用者是透明的，起到伪装控制的作用 。
为某一个对象（委托类）提供一个代理类，用来控制对象的访问。委托类和代理类有一个共同的父类或父接口。代理类会对请求做预处理、过滤，将请求给指定的对象。
例子
房东委托中介出租房子。
- 目标行为 即为出租房子
- 房东 即委托类
- 中介 即代理类
你要结婚
- 目标行为 即为结婚
- 你 即委托类
- 婚庆公司 即代理类
使用代理的原则：
1.代理类 与 委托类 具有相似的行为（共同目标）
2.代理类增强委托类的行为。
常见代理模式
静态代理
动态代理
二、静态代理
静态代理
某个对象提供一个代理，代理角色固定，以控制对这个对象的访问。代理类和委托类有共同的父类或父接口，这样在任何使用委托类对象的地方都可以用代理对象替代。代理类负责请求的预处理、过滤、将请求分派给委托类处理、以及委托类执行完请求后的后续处理。
代理的三要素
a、有共同的行为(结婚)–接口
b、目标角色(新人)–实现行为
c、代理角色(婚庆公司)-实现行为增强目标对象行为
静态代理的特点
1.目标角色固定
2.在应用程序之前就得知目标角色
3.代理对象会增强目标对象的行为
4.有可能存在多个代理，产生"类爆炸”(缺点)
示例
你要结婚
public interface Marry {
//目标行为 （去结婚）
public void toMarry ();
}
//委托
//继承 Marry 共同行为
public class you implements Marry{
@Override
public void toMarry() {
System.out.println("你要结婚了");
}
}
/**
* 静态对象->代理角色(婚庆公司)
* 1．实现行为 2．增强用户行为
*/
//继承 Marry 共同行为
public class MarryCompanyProxy implements Marry {
//目标对象 （多态）
private Marry marry;
//带参构造获取目标对象
public MarryCompanyProxy(Marry marry) {
this.marry = marry;
}
@Override
public void toMarry() {
//增强行为
before();
//调用目标行为的方法
marry.toMarry();
//增强行为
after();
}
private void after() {
System.out.println("后");
}
private void before() {
System.out.println("前");
}
}
/**
*静态方法调用
*/
public class StaticProxy {
public static void main(String[] args) {
//目标对象
you y = new you();
//代理对象
MarryCompanyProxy marryCompanyProxy = new MarryCompanyProxy(y);
//通过代理对象调用目标对象的方法 并在中 调用增强方法 即增强行为
marryCompanyProxy.toMarry();
}
输出
前
你要结婚了
后
出租房子
//目标行为 (出租房子)
public interface RentHouse {
public void toRentHouse ();
}
//委托类 房东
public class Owner implements RentHouse{
@Override
public void toRentHouse() {
System.out.println("三室两厅 5000元");
}
}
/**
* 静态对象->代理角色
* 1．实现行为2．增强用户行为
*/
//代理对象
public class AgentProxy implements RentHouse {
//目标对象 （多态）
private RentHouse rentHouse;
//带参构造获取目标对象
public AgentProxy(RentHouse rentHouse) {
this.rentHouse = rentHouse;
}
@Override
public void toRentHouse() {
System.out.println("中介赚差价");
rentHouse.toRentHouse(); //调用目标行为方法
System.out.println("中介找人推销");
}
}
public class StaticProxy {
public static void main(String[] args) {
//目标对象
Owner owner =new Owner();
//代理对象
AgentProxy agentProxy = new AgentProxy(owner);
//通过代理对象调用目标对象的方法 并在中 调用增强方法 即增强行为
agentProxy.toRentHouse();
}
}
输出
中介赚差价
三室两厅 5000元
中介找人推销
三、动态代理
动态代理
相比于静态代理，动态代理在创建代理对象上更加的灵活，动态代理类的字节码在程序运行时，由Java反射机制动态产生。它会根据需要，通过反射机制在程序运行期，动态的为目标对象创建代理对象，无需程序员手动编写它的源代码。动态代理不仅简化了编程工作，而且提高了软件系统的可扩展性，因为反射机制可以生成任意类型的动态代理类。代理的行为可以代理多个方法，即满足生产需要的同时又达到代码通用的目的。
两种方式：
JDK动态代理 CGLIB动态代理
动态代理的特点
1.目标对象不固定
2.在程序运行时，动态创建目标对象
3.代理对象会增强目标对象的行为
JDK动态代理
实例(接上静态代理)
public interface Marry {
//目标行为 （去结婚）
public void toMarry ();
}
//委托
//继承 Marry 共同行为
public class you implements Marry{
@Override
public void toMarry() {
System.out.println("你要结婚了");
}
}
/**
* 静态对象->代理角色(婚庆公司)
* 1．实现行为 2．增强用户行为
*/
//继承 Marry 共同行为
public class MarryCompanyProxy implements Marry {
//目标对象 （多态）
private Marry marry;
//带参构造获取目标对象
public MarryCompanyProxy(Marry marry) {
this.marry = marry;
}
@Override
public void toMarry() {
//增强行为
before();
//调用目标行为的方法
marry.toMarry();
//增强行为
after();
}
private void after() {
System.out.println("后");
}
private void before() {
System.out.println("前");
}
}
//目标行为 (出租房子)
public interface RentHouse {
public void toRentHouse ();
}
//委托类 房东
public class Owner implements RentHouse{
@Override
public void toRentHouse() {
System.out.println("三室两厅 5000元");
}
}
/**
* 静态对象->代理角色
* 1．实现行为2．增强用户行为
*/
//代理对象
public class AgentProxy implements RentHouse {
//目标对象 （多态）
private RentHouse rentHouse;
//带参构造获取目标对象
public AgentProxy(RentHouse rentHouse) {
this.rentHouse = rentHouse;
}
@Override
public void toRentHouse() {
System.out.println("中介赚差价");
rentHouse.toRentHouse(); //调用目标行为方法
System.out.println("中介找人推销");
}
}
JDK动态代理
//JDK代理对象 继承 InvocationHandler
public class JDKProxy implements InvocationHandler {
//目标对象
private Object target;
//带参构造获取目标对象
public JDKProxy(Object target) {
this.target = target;
}
/**
* 获得代理对象
* public static Object newProxyInstance(ClassLoader loader,
* Class<?>[] interfaces,
* InvocationHandler h)
(类加载器)ClassLoader loader,
* （接口数组） Class<?>[] interfaces,
* （接口）传入接口的实现类 InvocationHandler h
*/
public Object getProxy(){
return Proxy.newProxyInstance(this.getClass().getClassLoader(),target.getClass().getInterfaces(), this);
}
/**
* 调用目标对象方法（返回Object）
* * 增强目标对象行为
* @param proxy 调用该方法的代理实例
* @param method 目标对象的方法
* @param args 目标对象的方法所需要的参数
* @return
* @throws Throwable
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//增强行为
System.out.println("增强行为。。调用目标行为的方法前");
//调用目标行为的方法
Object object = method.invoke(target, args);
//增强行为
System.out.println("增强行为。。 调用目标行为的方法后");
return object;
}
}
public class Test {
public static void main(String[] args) {
//结婚
//目标对象
you you = new you();
//代理类
JDKProxy jdkProxy =new JDKProxy(you);
//得到代理对象
Marry marry =(Marry) jdkProxy.getProxy();
marry.toMarry();
//租房子
Owner owner = new Owner();
JDKProxy jdkProxy1 =new JDKProxy(owner);
RentHouse rentHouse = (RentHouse) jdkProxy1.getProxy();
rentHouse.toRentHouse();
}
}
增强行为。。调用目标行为的方法前
你要结婚了
增强行为。。 调用目标行为的方法后
增强行为。。调用目标行为的方法前
三室两厅 5000元
增强行为。。 调用目标行为的方法后
这里来讲一下invoke（）方法为什么会调用
首先可以查看idea中JDK动态代理文件的生成JDK动态代理文件
1.必须在main方法中执行，直接用junit的test方法调用无法生成
2.在main方法最前面增加配置 System.getProperties().put(“sun.misc.ProxyGenerator.saveGeneratedFiles” , “true”);
这样会输出代理class文件
我们就看结婚案例
public class Test {
public static void main(String[] args) {
System. getProperties() .put("sun.misc.ProxyGenerator.saveGeneratedFiles" , "true");
//目标对象
you you = new you();
//代理类
JDKProxy jdkProxy =new JDKProxy(you);
//得到代理对象
Marry marry =(Marry) jdkProxy.getProxy();
marry.toMarry();
}
}
目录会生成$Proxy0 类
我们来看下
$Proxy0 类
package com.sun.proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
import org.example.Marry;
// 这里实现了 Marry 接口 继承了 Proxy
public final class $Proxy0 extends Proxy implements Marry {
private static Method m1;
private static Method m2;
private static Method m3;
private static Method m0;
public $Proxy0(InvocationHandler var1) throws {
super(var1);
}
public final boolean equals(Object var1) throws {
try {
return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
public final String toString() throws {
try {
return (String)super.h.invoke(this, m2, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
//这里调用了 Marry 接口的方法
public final void toMarry() throws {
try {
// super.h 指的是 父类Poxy.h 那这个 h 也是从Proxy.newProxyInstance（）的第三个参数即传入 接口的实现类 InvocationHandler h 也是JDkProxy 。就可以调用 JDkProxy 的invoke（）的方法
super.h.invoke(this, m3, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
public final int hashCode() throws {
try {
return (Integer)super.h.invoke(this, m0, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
static {
try {
m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
m2 = Class.forName("java.lang.Object").getMethod("toString");
m3 = Class.forName("org.example.Marry").getMethod("toMarry");
m0 = Class.forName("java.lang.Object").getMethod("hashCode");
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
}
Proxy newProxyInstance(ClassLoader loader,Class<?>[] interfaces, InvocationHandler h))
@CallerSensitive
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,//这是从JDKProxy target.getClass().getInterfaces() 传过来的接口数组
//传入接口的实现类 InvocationHandler h)
throws IllegalArgumentException
{
Objects.requireNonNull(h);
final Class<?>[] intfs = interfaces.clone(); //这里复制了一份
final SecurityManager sm = System.getSecurityManager();
if (sm != null) {
checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
}
/*
* Look up or generate the designated proxy class.
*/
// 这里传了个intfs 接口数组 然后去遍历这个数组 然后去实现
//使用Proxy.getProxtClass(loader,class)方法来获取一个类的字节码
Class<?> cl = getProxyClass0(loader, intfs);
/*
* Invoke its constructor with the designated invocation handler.
*/
try {
if (sm != null) {
checkNewProxyPermission(Reflection.getCallerClass(), cl);
}
//通过反射 创建一个构造器对象 constructorParams这个参数点进去看发现的是 { InvocationHandler.class };
final Constructor<?> cons = cl.getConstructor(constructorParams);
// h 指的就是 JDKProxy 赋值给InvocationHandler
final InvocationHandler ih = h;
if (!Modifier.isPublic(cl.getModifiers())) {
AccessController.doPrivileged(new PrivilegedAction<Void>() {
public Void run() {
cons.setAccessible(true);
return null;
}
});
}
return cons.newInstance(new Object[]{h});
} catch (IllegalAccessException|InstantiationException e) {
throw new InternalError(e.toString(), e);
} catch (InvocationTargetException e) {
Throwable t = e.getCause();
if (t instanceof RuntimeException) {
throw (RuntimeException) t;
} else {
throw new InternalError(t.toString(), t);
}
} catch (NoSuchMethodException e) {
throw new InternalError(e.toString(), e);
}
}
private static void checkNewProxyPermission(Class<?> caller, Class<?> proxyClass) {
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
if (ReflectUtil.isNonPublicProxyClass(proxyClass)) {
ClassLoader ccl = caller.getClassLoader();
ClassLoader pcl = proxyClass.getClassLoader();
// do permission check if the caller is in a different runtime package
// of the proxy class
int n = proxyClass.getName().lastIndexOf('.');
String pkg = (n == -1) ? "" : proxyClass.getName().substring(0, n);
n = caller.getName().lastIndexOf('.');
String callerPkg = (n == -1) ? "" : caller.getName().substring(0, n);
if (pcl != ccl || !pkg.equals(callerPkg)) {
sm.checkPermission(new ReflectPermission("newProxyInPackage." + pkg));
}
}
}
}
结论
我们在 Test 中marry.toMarry(); 调用这个方法，对应在生成的代理类中的也会去调用toMarry()，
在调这个方法的时候 super.h.invoke h 也就是从Proxy.newProxyInstance 传过来的JDkProxy
来调用invoke（）。
CGLB 动态代理
CGLB
JDK的动态代理机制只能代理实现了接口的类，而不能实现接口的类就不能使用JDK的动态代理，CGLB是针对类来实现代理的，它的原理是对指定的目标类生成一个子类，并覆盖其中方法实现增强，但因为采用的是继承，所以不能对final修饰的类进行代理。
添加依赖
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>2.2.2</version>
</dependency>
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
public class CglibTest implements MethodInterceptor {
private Object target;
public CglibTest(Object target) {
this.target = target;
}
/**
* 获取代理对象
*/
public Object getProxy(){
/**
* 通过 enhancer.create();生成一个类
*/
Enhancer enhancer = new Enhancer();
/**
* 设置父类。将目标类作为代理类的父类
*/
enhancer.setSuperclass(target.getClass());
/**
* 设置拦截器 。回调对象为本身对象
*/
enhancer.setCallback(this);
return enhancer.create();
}
/**
* 拦截器
* @param o cglib 动态生成的代理类的实例
* @param method 实体类所调用的被代理的方法应用
* @param objects 参数列表
* @param methodProxy
* @return
* @throws Throwable
*/
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
//增强行为
System.out.println("增强行为");
//调用目标类的方法
Object object = methodProxy.invoke(target, objects);
//增强行为
System.out.println("增强行为");
return object;
}
}
Test
public class Test {
public static void main(String[] args) {
you you = new you();
CglibTest cglibTest =new CglibTest(you);
Marry proxy = (Marry) cglibTest.getProxy();
proxy.toMarry();
}
DK代理与CGLIB代理的区别
JDK代理与CGLIB代理的区别
- JDK动态代理实现接口，Cglib动态代理继承思想
- JDK动态代理（目标对象存在接口时)执行效率高于Ciglib
- 如果目标对象有接口实现，选择JDK代理，如果没有接口实现选择Cglib代理
总结
那么对于代理模式有了解了嘛
扫一扫
1414
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
