代理模式
定义： 代理模式的定义： 代理模式给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。通俗的来讲代理模式就是我们生活中常见的中介。
为什么要用代理模式？
一是保护目标对象，二是增强目标对象
- 中介隔离作用： 在某些情况下，一个客户类不想或者不能直接引用一个委托对象，而代理类对象可以在客户类和委托对象之间起到中介的作用，其特征是代理类和委托类实现相同的接口。
- 开闭原则，增加功能： 代理类除了是客户类和委托类的中介之外，我们还可以通过给代理类增加额外的功能来扩展委托类的功能，这样做我们只需要修改代理类而不需要再修改委托类，符合代码设计的开闭原则。代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后对返回结果的处理等。代理类本身并不真正实现服务，而是同过调用委托类的相关方法，来提供特定的服务。真正的业务功能还是由委托类来实现，但是可以在业务功能执行的前后加入一些公共的服务。例如我们想给项目加入缓存、日志这些功能，我们就可以使用代理类来完成，而没必要打开已经封装好的委托类。
代理模式
静态代理：程序员行前已经创建了.class编译文件
动态代理：通过反射动态创建
反射不会的自己去学 我在这不教奥
静态代理
package inter;
public interface BuyHouse {
void buyHosue();
}package inter;
public class BuyHouseImpl implements BuyHouse {
public void buyHosue() {
System.out.println("我要买房");
}
}package proxy;
import inter.BuyHouse;
public class BuyHouseProxy implements BuyHouse {
private BuyHouse buyHouse;
public BuyHouseProxy(final BuyHouse buyHouse) {
this.buyHouse = buyHouse;
}
public void buyHosue() {
System.out.println("买房前准备");
buyHouse.buyHosue();
System.out.println("买房后装修");
}
}package test;
import inter.BuyHouse;
import inter.BuyHouseImpl;
import proxy.BuyHouseProxy;
public class ProxyTest {
public static void main(String[] args) {
BuyHouse buyHouse = new BuyHouseImpl();
buyHouse.buyHosue();
BuyHouseProxy buyHouseProxy = new BuyHouseProxy(buyHouse);
buyHouseProxy.buyHosue();
}
}优点：可以做到在符合开闭原则的情况下对目标对象进行功能扩展。
缺点：我们得为每一个服务都得创建代理类，工作量太大，不易管理。同时接口一旦发生改变，代理类也得相应修改。
动态代理
程序运行时通过反射进行的代理类创建
jdk动态代理例子
1.InvocationHandler接口是proxy代理实例的调用处理程序实现的一个接口，每一个proxy代理实例都有一个关联的调用处理程序；在代理实例调用方法时，方法调用被编码分派到调用处理程序的invoke方法。
2.Proxy类就是用来创建一个代理对象的类，它提供了很多方法，但是我们最常用的是newProxyInstance方法。这个方法的作用就是创建一个代理类对象，它接收三个参数，我们来看下几个参数的含义
其实proxy类只是一个连接桥，把代理(InvocationHandler)与被代理类关联起来。真正的班长是InvocationHandler，处理交班费以及交班费之外的事情
public class ProxyHandler implements InvocationHandler {
private Object object;
public ProxyHandler(Object object){
this.object = object;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("Before invoke " + method.getName());
method.invoke(object, args);
System.out.println("After invoke " + method.getName());
return null;
}
}public class Main {
public static void main(String[] args) {
System.getProperties().setProperty("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
BuyHouse hello = new BuyHouseImpl();
InvocationHandler handler = new ProxyHandler(hello);
BuyHouse proxyHello = (BuyHouse) Proxy
.newProxyInstance(hello.getClass().getClassLoader(), hello.getClass().getInterfaces(), handler);
proxyHello.buyHosue();
}
}看看new proxy 干了啥
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
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);
}
//生成代理类对象
Class<?> cl = getProxyClass0(loader, intfs);
//使用指定的调用处理程序获取代理类的构造函数对象
try {
if (sm != null) {
checkNewProxyPermission(Reflection.getCallerClass(), cl);
}
final Constructor<?> cons = cl.getConstructor(constructorParams);
final InvocationHandler ih = h;
//如果Class作用域为私有，通过 setAccessible 支持访问
if (!Modifier.isPublic(cl.getModifiers())) {
AccessController.doPrivileged(new PrivilegedAction<Void>() {
public Void run() {
cons.setAccessible(true);
return null;
}
});
}
//获取Proxy Class构造函数，创建Proxy代理实例。
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);
}
}// 利用getProxyClass0(loader, intfs)生成代理类Proxy的Class对象。
private static Class<?> getProxyClass0(ClassLoader loader,
Class<?>... interfaces) {
//如果接口数量大于65535，抛出非法参数错误
if (interfaces.length > 65535) {
throw new IllegalArgumentException("interface limit exceeded");
}
//如果指定接口的代理类已经存在与缓存中，则不用新创建，直接从缓存中取即可；
//如果缓存中没有指定代理对象，则通过ProxyClassFactory来创建一个代理对象。
return proxyClassCache.get(loader, interfaces);
} //ProxyClassFactory内部类创建、定义代理类，返回给定ClassLoader 和interfaces的代理类。
private static final class ProxyClassFactory
implements BiFunction<ClassLoader, Class<?>[], Class<?>>{
// 代理类的名字的前缀统一为“$Proxy”
private static final String proxyClassNamePrefix = "$Proxy";
// 每个代理类前缀后面都会跟着一个唯一的编号，如$Proxy0、$Proxy1、$Proxy2
private static final AtomicLong nextUniqueNumber = new AtomicLong();
@Override
public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
for (Class<?> intf : interfaces) {
//验证类加载器加载接口得到对象是否与由apply函数参数传入的对象相同
Class<?> interfaceClass = null;
try {
interfaceClass = Class.forName(intf.getName(), false, loader);
} catch (ClassNotFoundException e) {
}
if (interfaceClass != intf) {
throw new IllegalArgumentException(
intf + " is not visible from class loader");
}
//验证这个Class对象是不是接口
if (!interfaceClass.isInterface()) {
throw new IllegalArgumentException(
interfaceClass.getName() + " is not an interface");
}
if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
throw new IllegalArgumentException(
"repeated interface: " + interfaceClass.getName());
}
}
String proxyPkg = null; // package to define proxy class in
int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
/*
* Record the package of a non-public proxy interface so that the
* proxy class will be defined in the same package. Verify that
* all non-public proxy interfaces are in the same package.
*/
for (Class<?> intf : interfaces) {
int flags = intf.getModifiers();
if (!Modifier.isPublic(flags)) {
accessFlags = Modifier.FINAL;
String name = intf.getName();
int n = name.lastIndexOf('.');
String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
if (proxyPkg == null) {
proxyPkg = pkg;
} else if (!pkg.equals(proxyPkg)) {
throw new IllegalArgumentException(
"non-public interfaces from different packages");
}
}
}
if (proxyPkg == null) {
// if no non-public proxy interfaces, use com.sun.proxy package
proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
}
/*
* Choose a name for the proxy class to generate.
*/
long num = nextUniqueNumber.getAndIncrement();
String proxyName = proxyPkg + proxyClassNamePrefix + num;
/*
*
* 生成指定代理类的字节码文件
*/
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
proxyName, interfaces, accessFlags);
try {
return defineClass0(loader, proxyName,
proxyClassFile, 0, proxyClassFile.length);
} catch (ClassFormatError e) {
/*
* A ClassFormatError here means that (barring bugs in the
* proxy class generation code) there was some other
* invalid aspect of the arguments supplied to the proxy
* class creation (such as virtual machine limitations
* exceeded).
*/
throw new IllegalArgumentException(e.toString());
}
}
}//一系列检查后，调用ProxyGenerator.generateProxyClass来生成字节码文件
public static byte[] generateProxyClass(final String var0, Class<?>[] var1, int var2) {
ProxyGenerator var3 = new ProxyGenerator(var0, var1, var2);
// 真正用来生成代理类字节码文件的方法在这里
final byte[] var4 = var3.generateClassFile();
// 保存代理类的字节码文件
if(saveGeneratedFiles) {
AccessController.doPrivileged(new PrivilegedAction<Void>() {
public Void run() {
try {
int var1 = var0.lastIndexOf(46);
Path var2;
if(var1 > 0) {
Path var3 = Paths.get(var0.substring(0, var1).replace('.', File.separatorChar), new String[0]);
Files.createDirectories(var3, new FileAttribute[0]);
var2 = var3.resolve(var0.substring(var1 + 1, var0.length()) + ".class");
} else {
var2 = Paths.get(var0 + ".class", new String[0]);
}
Files.write(var2, var4, new OpenOption[0]);
return null;
} catch (IOException var4x) {
throw new InternalError("I/O exception saving generated file: " + var4x);
}
}
});
}
return var4;
}字节码生成后，调用defineClass0来解析字节码，生成了Proxy的Class对象。在了解完代理类动态生成过程后，生产的代理类是怎样的，谁来执行这个代理类。
其中，在ProxyGenerator.generateProxyClass函数中 saveGeneratedFiles定义如下，其指代是否保存生成的代理类class文件，默认false不保存。
cglib动态代理
当一对象发生某事件时，它通常需向其它相关对象发送“消息”，请求它们作出一些处理。 这时，发生事件并向其它对象请求处理的对象被称为“事件对象”，而处理事件的对象被称为“回调对象”。回调对象对事件的处理称为“回调函数”。
在这里大家感兴趣的可以进行然后生成 然后进行反编译 去看看生成的文件中有什么东西
提示 由于cglib是通过动态创建子类实现的代理，所以final方法无法进行代理
public class MyMethodInterceptor implements MethodInterceptor {
/**
* sub：cglib生成的代理对象
* method：被代理对象方法
* objects：方法入参
* methodProxy: 代理方法
*/
@Override
public Object intercept(Object sub, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
System.out.println("======插入前置通知======");
Object object = methodProxy.invokeSuper(sub, objects);
System.out.println("======插入后者通知======");
return object;
}
}
public class HelloService {
public HelloService() {
System.out.println("HelloService构造");
}
public void sayHello() {
System.out.println("HelloService:sayHello");
}
}cglib和jdk代理的区别图
jdk
cglib
动态代理简陋aop
package aop.pojo;
/**
* Created by Yifan Jia on 2018/6/5.
*/
public class ManWaiter implements Waiter {
@Override
public void server() {
System.out.println("服务中");
}
}
package aop.pojo;
/**
* Created by Yifan Jia on 2018/6/5.
*/
//服务生
public interface Waiter {
//服务方法
public void server();
}package aop.service;
public interface AfterAdvice {
public void after();
}package aop.service;
/**
* 前置增强
*/
public interface BeforeAdvice {
public void before();
}package aop.factory;
/**
* ProxFactory用来生成代理对象
* 它需要所有的参数：目标对象，增强，
* Created by Yifan Jia on 2018/6/5.
*/
import aop.service.AfterAdvice;
import aop.service.BeforeAdvice;
import java.lang.reflect.Method;
import net.sf.cglib.proxy.InvocationHandler;
import net.sf.cglib.proxy.Proxy;
/**
* 1、创建代理工厂
* 2、给工厂设置目标对象、前置增强、后置增强
* 3、调用creatProxy()得到代理对象
* 4、执行代理对象方法时，先执行前置增强，然后是目标方法，最后是后置增强
*/
//其实在Spring中的AOP的动态代理实现的一个织入器也是叫做ProxyFactory
public class ProxyFactory {
private Object targetObject;//目标对象
private BeforeAdvice beforeAdvice;//前值增强
private AfterAdvice afterAdvice;//后置增强
/**
* 用来生成代理对象
* @return
*/
public Object creatProxy() {
/**
* 给出三个参数
*/
ClassLoader classLoader = this.getClass().getClassLoader();
//获取当前类型所实现的所有接口类型
Class[] interfaces = targetObject.getClass().getInterfaces();
InvocationHandler invocationHandler = new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
/**
* 在调用代理对象的方法时，会执行这里的内容
*/
if(beforeAdvice != null) {
beforeAdvice.before();
}
Object result = method.invoke(targetObject, args);//调用目标对象的目标方法
//执行后续增强
afterAdvice.after();
//返回目标对象的返回值
return result;
}
};
/**
* 2、得到代理对象
*/
Object proxyObject = Proxy.newProxyInstance(classLoader, interfaces, invocationHandler);
return proxyObject;
}
//get和set方法略
public Object getTargetObject() {
return targetObject;
}
public void setTargetObject(Object targetObject) {
this.targetObject = targetObject;
}
public BeforeAdvice getBeforeAdvice() {
return beforeAdvice;
}
public void setBeforeAdvice(BeforeAdvice beforeAdvice) {
this.beforeAdvice = beforeAdvice;
}
public AfterAdvice getAfterAdvice() {
return afterAdvice;
}
public void setAfterAdvice(AfterAdvice afterAdvice) {
this.afterAdvice = afterAdvice;
}
}
package demo3;
import aop.factory.ProxyFactory;
import aop.pojo.ManWaiter;
import aop.pojo.Waiter;
import aop.service.AfterAdvice;
import aop.service.BeforeAdvice;
import org.junit.jupiter.api.Test;
/**
* Created by Yifan Jia on 2018/6/5.
*/
public class Demo3 {
@Test
public void tset1() {
ProxyFactory proxyFactory = new ProxyFactory();//创建工厂
proxyFactory.setTargetObject(new ManWaiter());//设置目标对象
//设置前置增强
proxyFactory.setBeforeAdvice(new BeforeAdvice() {
@Override
public void before() {
System.out.println("客户你好");
}
});
//设置后置增强
proxyFactory.setAfterAdvice(new AfterAdvice() {
@Override
public void after() {
System.out.println("客户再见");
}
});
Waiter waiter = (Waiter) proxyFactory.creatProxy();
waiter.server();
}
}
代理和装饰的区别
在代理模式中我们增强方法是通过直接使用代理类，实际上我们代理的类对外是隐藏的，只能看到代理类。而装饰模式是通过自己传入需要被装饰的对象，然后再使用装饰过后的对象的增强方法。(两者都是对类的方法进行增强，但装饰器模式强调的是增强自身，在被装饰之后你能够够在被增强的类上使用增强后的方法。增强过后还是你，只不过能力变强了。而代理模式则强调要别人帮你去做一些本身与你业务没有太多关系的职责。代理模式是为了实现对象的控制，因为被代理的对象往往难以直接获得或者是其内部不想暴露出来。)括号里这段解释是看到知乎上一位大佬的回答
扩展知识(感兴趣的可以自行了解)
1.动态代理cglib和jdk性能比较
在老版本jdk的时候 cglib的性能远高于jdk，不过因为jdk版本升级，所对应的jdk性能优化很多 在1.8版本甚至超过cglib，感兴趣的可以从此方面搜一些资料。
2.适用场景
JDK动态代理
优点
不依赖第三方jar包, 使用方便
随着JDK的升级，JDK动态代理的性能在稳步提升
缺点
只能代理实现了接口的类
执行速度较慢
适用场景
如果你的程序需要频繁、反复地创建代理对象，则JDK动态代理在性能上更占优。
cglib
优点
由于是动态生成字节码实现代理，因此代理对象的执行速度较快, 约为JDK动态代理的1.5 ~ 2倍(后jdk被优化)
可以代理没有实现接口的对象
缺点
不能代理final类
动态生成字节码虽然执行较快，但是生成速度很慢，根据网上一些人的测试结果，cglib创建代理对象的速度要比JDK慢10 ~ 15倍。
适用场景
不需要频繁创建代理对象的应用，如Spring中默认的单例bean，只需要在容器启动时生成一次代理对象。
3.对于什么叫动态生成字节码(debug)
我们知道，我们编写的 Java 代码都是要被编译成字节码后才能放到 JVM 里执行的，而字节码一旦被加载到虚拟机中，就可以被解释执行。
字节码文件(.class)就是普通的二进制文件，它是通过 Java 编译器生成的。而只要是文件就可以被改变，如果我们用特定的规则解析了原有的字节码文件，对它进行修改或者干脆重新定义，这不就可以改变代码行为了么。
Java 生态里有很多可以动态生成字节码的技术，像 BCEL、Javassist、ASM、CGLib 等，它们各有自己的优势。有的使用复杂却功能强大、有的简单确也性能些差。
asm框架
可以动态修改类、方法，甚至可以重新定义类，连 CGLib 底层都是用 ASM 实现的。
Instrument库
jvm可能不会理会我们做出的定义修改所以要用到：
instrument 是 JVM 提供的一个可以修改已加载类文件的类库。1.6以前，instrument 只能在 JVM 刚启动开始加载类时生效，之后，instrument 更是支持了在运行时对类定义的修改
jvm TI
JVM TI(JVM Tool Interface)JVM 工具接口是 JVM 提供的一个非常强大的对 JVM 操作的工具接口，通过这个接口，我们可以实现对 JVM 多种组件的操作，从JVMTM Tool Interface 这里我们认识到 JVM TI 的强大，它包括了对虚拟机堆内存、类、线程等各个方面的管理接口。
624
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
