不知道起什么标题系列1

package org.apache.kafka.common.record;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;
import java.nio.ByteBuffer;
import java.util.zip.GZIPInputStream;
import java.util.zip.GZIPOutputStream;
import org.apache.kafka.common.KafkaException;
import org.apache.kafka.common.utils.ByteBufferInputStream;
import org.apache.kafka.common.utils.ByteBufferOutputStream;

public enum CompressionType {
    NONE(0, "none", 1.0F) {
        public OutputStream wrapForOutput(ByteBufferOutputStream buffer, byte messageVersion) {
            return buffer;
        }

        public InputStream wrapForInput(ByteBuffer buffer, byte messageVersion, BufferSupplier decompressionBufferSupplier) {
            return new ByteBufferInputStream(buffer);
        }
    },
    GZIP(1, "gzip", 1.0F) {
        public OutputStream wrapForOutput(ByteBufferOutputStream buffer, byte messageVersion) {
            try {
                return new BufferedOutputStream(new GZIPOutputStream(buffer, 8192), 16384);
            } catch (Exception var4) {
                throw new KafkaException(var4);
            }
        }

        public InputStream wrapForInput(ByteBuffer buffer, byte messageVersion, BufferSupplier decompressionBufferSupplier) {
            try {
                return new BufferedInputStream(new GZIPInputStream(new ByteBufferInputStream(buffer), 8192), 16384);
            } catch (Exception var5) {
                throw new KafkaException(var5);
            }
        }
    },
    SNAPPY(2, "snappy", 1.0F) {
        public OutputStream wrapForOutput(ByteBufferOutputStream buffer, byte messageVersion) {
            try {
                return CompressionType.SnappyConstructors.OUTPUT.invoke(buffer);
            } catch (Throwable var4) {
                throw new KafkaException(var4);
            }
        }

        public InputStream wrapForInput(ByteBuffer buffer, byte messageVersion, BufferSupplier decompressionBufferSupplier) {
            try {
                return CompressionType.SnappyConstructors.INPUT.invoke(new ByteBufferInputStream(buffer));
            } catch (Throwable var5) {
                throw new KafkaException(var5);
            }
        }
    },
    LZ4(3, "lz4", 1.0F) {
        public OutputStream wrapForOutput(ByteBufferOutputStream buffer, byte messageVersion) {
            try {
                return new KafkaLZ4BlockOutputStream(buffer, messageVersion == 0);
            } catch (Throwable var4) {
                throw new KafkaException(var4);
            }
        }

        public InputStream wrapForInput(ByteBuffer inputBuffer, byte messageVersion, BufferSupplier decompressionBufferSupplier) {
            try {
                return new KafkaLZ4BlockInputStream(inputBuffer, decompressionBufferSupplier, messageVersion == 0);
            } catch (Throwable var5) {
                throw new KafkaException(var5);
            }
        }
    };

    public final int id;
    public final String name;
    public final float rate;

    private CompressionType(int id, String name, float rate) {
        this.id = id;
        this.name = name;
        this.rate = rate;
    }

    public abstract OutputStream wrapForOutput(ByteBufferOutputStream var1, byte var2);

    public abstract InputStream wrapForInput(ByteBuffer var1, byte var2, BufferSupplier var3);

    public static CompressionType forId(int id) {
        switch(id) {
        case 0:
            return NONE;
        case 1:
            return GZIP;
        case 2:
            return SNAPPY;
        case 3:
            return LZ4;
        default:
            throw new IllegalArgumentException("Unknown compression type id: " + id);
        }
    }

    public static CompressionType forName(String name) {
        if (NONE.name.equals(name)) {
            return NONE;
        } else if (GZIP.name.equals(name)) {
            return GZIP;
        } else if (SNAPPY.name.equals(name)) {
            return SNAPPY;
        } else if (LZ4.name.equals(name)) {
            return LZ4;
        } else {
            throw new IllegalArgumentException("Unknown compression name: " + name);
        }
    }

    private static MethodHandle findConstructor(String className, MethodType methodType) {
        try {
            return MethodHandles.publicLookup().findConstructor(Class.forName(className), methodType);
        } catch (ReflectiveOperationException var3) {
            throw new RuntimeException(var3);
        }
    }

    private static class SnappyConstructors {
        static final MethodHandle INPUT;
        static final MethodHandle OUTPUT;

        private SnappyConstructors() {
        }

        static {
            INPUT = CompressionType.findConstructor("org.xerial.snappy.SnappyInputStream", MethodType.methodType(Void.TYPE, InputStream.class));
            OUTPUT = CompressionType.findConstructor("org.xerial.snappy.SnappyOutputStream", MethodType.methodType(Void.TYPE, OutputStream.class));
        }
    }
}

首先是枚举，居然可以这样写，就是写个抽象的方法，然后在每个美剧后面用{}扩住，在本例子中就是用来区分不同的方式创建不同类型的实例。

然后是一些很陌生的类，比如
MethodHandle
InputStream
OutputStream
ByteBufferOutputStream
后面可以每个查下是啥意思；