java代理模式提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档
一、代理模式
代理模式是什么？例子
房东委托中介出租房子。你要结婚 使用代理的原则：常见代理模式 二、静态代理
静态代理代理的三要素静态代理的特点示例
你要结婚
输出 出租房子
输出 三、动态代理
动态代理
两种方式：动态代理的特点 JDK动态代理
实例(接上静态代理)JDK动态代理 这里来讲一下invoke（）方法为什么会调用
首先可以查看idea中JDK动态代理文件的生成JDK动态代理文件
我们就看结婚案例 目录会生成$Proxy0 类我们来看下
$Proxy0 类 Proxy newProxyInstance(ClassLoader loader,Class[] interfaces, InvocationHandler h))
结论 CGLB 动态代理CGLB添加依赖Test DK代理与CGLIB代理的区别 总结
提示：以下是本篇文章正文内容，下面案例可供参考
一、代理模式 代理模式是什么？代理模式在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("你要结婚了");
}
}
//继承 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元");
}
}
//代理对象
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.代理对象会增强目标对象的行为
public interface Marry {
//目标行为 （去结婚）
public void toMarry ();
}
//委托
//继承 Marry 共同行为
public class you implements Marry{
@Override
public void toMarry() {
System.out.println("你要结婚了");
}
}
//继承 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元");
}
}
//代理对象
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 Object getProxy(){
return Proxy.newProxyInstance(this.getClass().getClassLoader(),target.getClass().getInterfaces(), this);
}
@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);
}
// 这里传了个intfs 接口数组 然后去遍历这个数组 然后去实现
//使用Proxy.getProxtClass(loader,class)方法来获取一个类的字节码
Class cl = getProxyClass0(loader, intfs);
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() {
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（）。
JDK的动态代理机制只能代理实现了接口的类，而不能实现接口的类就不能使用JDK的动态代理，CGLB是针对类来实现代理的，它的原理是对指定的目标类生成一个子类，并覆盖其中方法实现增强，但因为采用的是继承，所以不能对final修饰的类进行代理。
添加依赖cglib cglib 2.2.2
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 enhancer = new Enhancer();
enhancer.setSuperclass(target.getClass());
enhancer.setCallback(this);
return enhancer.create();
}
@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代理 总结
那么对于代理模式有了解了嘛
