序列化与反序列化

两个服务之间要传输一个数据对象，就需要将对象转换成二进制流，通过网络传输到对方服务，再转换成对象，供服务方法调用。这个编码和解码的过程称之为序列化和反序列化。所以序列化就是把Java对象变成二进制形式，本质上就是一个byte[]数组。将对象序列化之后，就可以写入磁盘进行保存或者通过网络输出给远程服务了。反之，反序列化可以将从网络或者磁盘中读取的字节数组，反序列化成对象，在程序中使用。

序列化优点：

永久性保存对象：将对象转为字节流存储到硬盘上，即使JVM停机，字节流还会在硬盘上等待，等待下一次JVM启动时，反序列化为原来的对象，并且序列化的二进制序列能够减少存储空间。
方便网络传输：序列化成字节流形式的对象可以方便网络传输（二进制形式），节约网络带宽。
通过序列化可以在进程间传递对象。

Java原生序列化：

Java默认通过Serializable接口实现序列化，只要实现了该接口，该类就会自动实现序列化与反序列化，该接口没有任何方法，只起标识作用。Java序列化保留了对象类的元数据（如类、成员变量、继承类信息等），以及对象数据等，兼容性最好，但不支持跨语言，而且性能一般。

实现Serializable接口的类建议设置serialVersionUID字段值，如果不设置，那么每次运行时，编译器会根据类的内部实现，包括类名、接口名、方法和属性等来自动生成serialVersionUID。如果类的源代码被修改，那么重新编译后serialVersionUID的取值可能会发生变化。因此实现Serializable接口的类一定要显式地定义serialVersionUID属性值。serialVersionUID主要用于验证对象在反序列化过程中，序列化对象是否加载了与序列化兼容的类，如果是具有相同类名的不同版本号的类，在反序列化中是无法获取对象的。

其它详情请阅读此博客：序列化与反序列化_张维鹏的博客-CSDN博客

零拷贝

传统的IO模式：

用户空间的应用程序发出read系统调用，会导致用户空间到内核空间的上下文切换，然后再通过DMA将磁盘文件中的数据读取到内核空间缓冲区。
接着将内核空间缓存区的数据拷贝到用户空间的数据缓冲区，然后read系统调用返回，而系统调用的返回又会导致一次内核空间到用户空间的上下文切换。
write系统调用，用户空间到内核空间的上下文再次切换；接着将用户空间缓冲区的数据复制到内核空间的socket缓冲区（也是内核缓冲区，只不过是给socket使用），然后write系统调用返回，再次触发上下文切换。
最后异步传输socket缓冲区的数据到网卡，也就是说write系统调用的返回并不保证数据被传输到网卡。

在传统的数据IO模式中，读取一个磁盘文件，并发送到远程端的服务，就共有四次用户空间与内核空间的上下文切换，四次数据复制，分别是两次CPU数据复制，两次DMA数据复制。但两次CPU数据复制才是最消耗资源和时间的，这个过程还需要内核态和用户态之间的来回切换，而CPU资源十分宝贵，要拷贝大量的数据，还要处理大量的任务，如果能把CPU的这两次拷贝给去除掉，既能节省CPU资源，还可以避免内核态和用户态之间的切换。而零拷贝技术就是为了解决这个问题。

**DMA（Direct Memory Access）直接存储器存储：**外部设备不通过CPU而直接与系统内存进行数据交换的技术。

什么是零拷贝？

零拷贝指在进行数据IO或传输时，数据在用户态下经历了零次拷贝，并非不拷贝数据。通过减少数据传输过程中内核缓冲区和用户进程缓冲区间不必要的CPU数据拷贝与用户态和内核态的上下文切换次数，降低CPU在这两方面的开销，释放CPU执行其它任务，更有效的利用系统资源，提高传输效率，同时还减少了内存的占用，也提升了应用程序的性能。

Linux中的零拷贝方式

mmap+write实现的零拷贝：

此方式的核心是操作系统会把内核缓存区与应用程序共享，可以将一段用户空间内存映射到内核空间，当映射成功后，用户对这段内存区域的修改可以直接反映到内核空间；同样地，内核空间对这段区域的修改也能直接反映到用户空间。正因为有这样的映射关系，就不需要在用户态与内核态之间拷贝数据，提高了数据传输的效率，这就是内存直接映射技术。具体示意图如下：

发出mmap系统调用，导致用户空间到内核空间的上下文切换；然后通过DMA将磁盘文件中的数据复制到内核空间缓冲区
mmap系统调用返回，导致内核空间到用户空间的上下文切换
这里不需要将数据从内核空间复制到用户空间，因为用户空间和内核空间共享了这个缓冲区
发出write系统调用，导致用户空间和内核空间的上下文切换。将数据从内核空间缓冲区复制到内核空间socket缓存区；write系统调用返回，导致内核空间到用户空间的上下文切换

mmap的零拷贝I/O进行了4次用户空间与内核空间的上下文切换，以及3次数据拷贝；其中3次数据拷贝中包括了2次DMA拷贝和1次CPU拷贝。

sendfile实现的零拷贝：

只要代码执行了read或者write系统调用，就一定会发生2次上下文切换：首先从用户态切换到内核态，当内核执行完任务后，再切换回用户态交由进程代码执行。因此，如果想减少上下文切换次数，就一定要减少系统调用的次数，解决方案就是把read、write两次系统调用合并成一次，在内核中完成磁盘与网卡的数据交换。在Linux2.1版本内核开始引入的sendfile就是通过这种方式来实现零拷贝的，具体流程图如下：

发出sendfile系统调用，导致用户空间到内核空间的上下文切换；然后通过DMA将磁盘文件中的内容复制到内核空间缓存区中
接着再将数据从内核空间缓冲区复制到socket缓存区
sendfile系统调用返回，导致内核空间到用户空间的上下文切换
DMA异步将内核空间socket缓冲区中的数据传递到网卡

通过sendfile实现的零拷贝I/O使用了2次用户空间与内核空间的上下文切换，以及3次数据的拷贝。其中3次数据拷贝中包括了2次DMA拷贝和1次CPU拷贝。

带有DMA收集拷贝功能的sendfile实现的零拷贝：

Linux2.4版本开始支持，操作系统提供scatter和gather的SG-DMA方式，直接从内核空间缓冲区中将数据读取到网卡，无需将内核空间缓冲区的数据再复制一份到socket缓冲区。

发出sendfile系统调用，导致用户空间到内核空间的上下文切换；接着通过DMA将磁盘文件中的内容复制到内核空间缓冲区
这里没把数据复制到socket缓冲区，而是将相应的描述符信息复制到socket缓冲区，该描述符包含了两种信息：内核缓冲区的内存地址、内核缓冲区的偏移量
sendfile系统调用返回，导致内核空间到用户空间的上下文切换
DMA根据socket缓冲区中描述符提供的地址和偏移量直接将内核缓冲区中的数据复制到网卡

带有DMA收集拷贝功能的sendfile实现的I/O使用了2次用户空间与内核空间的上下文切换，以及2次数据的拷贝，而且这2次的数据拷贝都是非CPU拷贝，这样就实现了最理想的零拷贝I/O传输了，不需要任何一次的CPU拷贝，以及最少的上下文切换。

备注：需要注意的是，零拷贝有一个缺点，就是不允许进程对文件内容作一些加工再发送，比如数据压缩后在发送。

参考：

什么是零拷贝？_张维鹏的博客-CSDN博客

IO模型详解

详情请阅读此文章：IO 模型详解 | JavaGuide

非阻塞同步队列采用的Reactor网络模型解析：什么是 Reactor 网络模型？_张维鹏的博客-CSDN博客

异步网络模型Proactor：什么是 Proactor 网络模型？_张维鹏的博客-CSDN博客

Java代理模式详解

代理模式是一种比较好理解的设计模式。简单来说就是使用代理对象来代替对真实对象的访问，这样就可以在不修改原目标对象的前提下，提供额外的功能操作，扩展目标对象的功能。代理模式的主要作用是扩展目标对象的功能，比如说在目标对象的某个方法执行前后可以增加一些自定义的操作。

静态代理

静态代理中，其对目标对象的每个方法的增强都是手动完成的，非常不灵活（比如接口一旦新增加方法，目标对象和代理对象都要进行修改）且麻烦（需要对每个目标类都单独写一个代理类）。实际应用场景非常非常少，日常开发集合看不到使用静态代理的场景。

从JVM层面来说，静态代理在编译时就将接口、实现类、代理类这些都变成了一个个实际的class文件。

静态代理实现步骤：

定义一个接口及其实现类；
创建一个代理类同样实现这个接口；
将目标对象注入进代理类，然后在代理类的对应方法调用目标类中的对应方法。这样的话，我们就可以通过代理类屏蔽对目标对象的访问，并且可以在目标方法执行前后做一些自己想做的事情。

定义发送短信的接口

public interface SmsService {
    String send(String message);
}

实现发送短信的接口

public class SmsServiceImpl implements SmsService {
    public String send(String message) {
        System.out.println("send message:" + message);
        return message;
    }
}

创建代理类并同样实现发送短信的接口

public class SmsProxy implements SmsService {

    private final SmsService smsService;

    public SmsProxy(SmsService smsService) {
        this.smsService = smsService;
    }

    @Override
    public String send(String message) {
        //调用方法之前，我们可以添加自己的操作
        System.out.println("before method send()");
        smsService.send(message);
        //调用方法之后，我们同样可以添加自己的操作
        System.out.println("after method send()");
        return null;
    }
}

实际使用：

public class Main {
    public static void main(String[] args) {
        SmsService smsService = new SmsServiceImpl();
        SmsProxy smsProxy = new SmsProxy(smsService);
        smsProxy.send("java");
    }
}

运行上述代码之后，控制台打印出：

before method send()
send message:java
after method send()

动态代理

相比于静态代理来说，动态代理更加灵活。不需要针对每个目标类都单独创建一个代理类，并且也不需要我们必须实现接口，可以直接代理实现类（CGLIB动态代理机制）。从JVM角度来说，动态代理是在运行时动态生成类字节码，并加载到JVM中。

JDK动态代理机制

在Java动态代理机制中InvocationHandler接口和Proxy类是核心。

Proxy类中使用频率最高的方法是：newProxyInstance()，这个方法主要用来生成一个代理对象。

public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {
        ......
    }

loader：类加载器，用于加载代理对象
interfaces：被代理类实现的一些接口
h：实现了InvocationHandler接口的对象

要实现动态代理的话，还必须实现 InvocationHandler来自定义处理逻辑。当我们的动态代理对象调用一个方法时，这个方法的调用就会被转发到实现 InvocationHandler接口类的invoke方法来调用。

public interface InvocationHandler {

    /**
     * 当你使用代理对象调用方法的时候实际会调用到这个方法
     */
    public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable;
}

proxy：动态生成的代理类
method：与代理类对象调用的方法相对应的方法
args：当前method方法的参数

通过Proxy类的newProxyInstance()创建的代理对象在调用方法的时候，实际会调用到实现InvocationHandler接口的类的invoke()方法。因此可以在invoke()方法中自定义处理逻辑。

JDK动态代理类使用步骤：

定义一个接口及其实现类
自定义InvocationHandler并重写invoke()方法，在invoke()方法中会调用原生方法（被代理类的方法）并自定义一些处理逻辑
通过 Proxy.newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)方法创建代理对象

定义发送短信的接口

public interface SmsService {
    String send(String message);
}

实现发送短信的接口

public class SmsServiceImpl implements SmsService {
    public String send(String message) {
        System.out.println("send message:" + message);
        return message;
    }
}

定义一个JDK动态代理类

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 * @author shuang.kou
 * @createTime 2020年05月11日 11:23:00
 */
public class DebugInvocationHandler implements InvocationHandler {
    /**
     * 代理类中的真实对象
     */
    private final Object target;

    public DebugInvocationHandler(Object target) {
        this.target = target;
    }


    public Object invoke(Object proxy, Method method, Object[] args) throws InvocationTargetException, IllegalAccessException {
        //调用方法之前，我们可以添加自己的操作
        System.out.println("before method " + method.getName());
        Object result = method.invoke(target, args);
        //调用方法之后，我们同样可以添加自己的操作
        System.out.println("after method " + method.getName());
        return result;
    }
}

invoke()方法：当动态代理对象调用原生方法的时候，最终实际上调用的是invoke()方法，然后invoke()方法代替我们去调用了被代理对象的原生方法。

获取代理对象的工厂类

public class JdkProxyFactory {
    public static Object getProxy(Object target) {
        return Proxy.newProxyInstance(
                target.getClass().getClassLoader(), // 目标类的类加载
                target.getClass().getInterfaces(),  // 代理需要实现的接口，可指定多个
                new DebugInvocationHandler(target)   // 代理对象对应的自定义 InvocationHandler
        );
    }
}

getProxy()：主要通过Proxy.newProxyInstance()方法获取某个类的代理对象

实际使用：

SmsService smsService = (SmsService) JdkProxyFactory.getProxy(new SmsServiceImpl());
smsService.send("java");

运行上述代码之后，控制台打印出：

before method send
send message:java
after method send

CGLIB动态代理机制

CGLIB是一个基于ASM的字节码生成库，它允许在运行时对字节码进行修改和动态生成。在CGLIB动态代理机制中MethodInterceptor接口和Enhancer类是核心。

你需要自定义MethodInterceptor并重写intercept方法，intercept用于拦截增强被代理类的方法。

public interface MethodInterceptor
extends Callback{
    // 拦截被代理类中的方法
    public Object intercept(Object obj, java.lang.reflect.Method method, Object[] args,
                               MethodProxy proxy) throws Throwable;
}

obj：被代理的对象（需要增强的对象）
method：被拦截的方法（需要增强的方法）
args：方法入参
proxy：用于调用原始方法

可以通过Enhancer类来动态获取被代理类，当代理类调用方法的时候，实际调用的是methodInterceptor中的intercept方法。

CGLIB动态代理类使用步骤：

定义一个类
自定义MethodInterceptor并重写intercept方法，intercept用于拦截增强被代理类的方法，和JDK动态代理中的invoke方法类似
通过Enhancer类的create()创建代理类

添加依赖

<dependency>
  <groupId>cglib</groupId>
  <artifactId>cglib</artifactId>
  <version>3.3.0</version>
</dependency>

实现一个使用阿里云发送短信的类

package github.javaguide.dynamicProxy.cglibDynamicProxy;

public class AliSmsService {
    public String send(String message) {
        System.out.println("send message:" + message);
        return message;
    }
}

自定义MethodInterceptor（方法拦截器）

import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 * 自定义MethodInterceptor
 */
public class DebugMethodInterceptor implements MethodInterceptor {


    /**
     * @param o           代理对象（增强的对象）
     * @param method      被拦截的方法（需要增强的方法）
     * @param args        方法入参
     * @param methodProxy 用于调用原始方法
     */
    @Override
    public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        //调用方法之前，我们可以添加自己的操作
        System.out.println("before method " + method.getName());
        Object object = methodProxy.invokeSuper(o, args);
        //调用方法之后，我们同样可以添加自己的操作
        System.out.println("after method " + method.getName());
        return object;
    }

}

获取代理类

import net.sf.cglib.proxy.Enhancer;

public class CglibProxyFactory {

    public static Object getProxy(Class<?> clazz) {
        // 创建动态代理增强类
        Enhancer enhancer = new Enhancer();
        // 设置类加载器
        enhancer.setClassLoader(clazz.getClassLoader());
        // 设置被代理类
        enhancer.setSuperclass(clazz);
        // 设置方法拦截器
        enhancer.setCallback(new DebugMethodInterceptor());
        // 创建代理类
        return enhancer.create();
    }
}

实际使用：

AliSmsService aliSmsService = (AliSmsService) CglibProxyFactory.getProxy(AliSmsService.class);
aliSmsService.send("java");

运行上述代码之后，控制台打印出：

before method send
send message:java
after method send

JDK动态代理和CGLIB动态代理对比

JDK动态代理只能代理实现了接口的类或者直接代理接口，而CGLIB可以代理未实现任何接口的类。另外，CGLIB动态代理是通过生成一个被代理类的子类来拦截被代理类的方法调用，因此不能代理声明为final类型的类和方法。
就二者的效率来说，大部分情况都是JDK动态代理更优秀，随着JDK版本的升级，这个优势更加明显。

静态代理和动态代理的对比

灵活性：动态代理更加灵活，不需要必须实现接口，可以直接代理实现类，并且可以不需要针对每个目标类都创建一个代理类。另外，静态代理中，接口一旦新增加方法，目标对象和代理对象都要进行修改，这是非常麻烦的。
JVM层面：静态代理在编译时就将接口、实现类、代理类这些都变成了一个个实际的class文件。而动态代理是在运行时动态生成类字节码，并加载到JVM中的。

javaIO

序列化与反序列化

零拷贝

Linux中的零拷贝方式

IO模型详解

Java代理模式详解

静态代理

动态代理

JDK动态代理机制

CGLIB动态代理机制