本机运行无误，线上死活不行

    前两天调用集成的某服务商API，本机测试通过后部署线上，却毫无反响。日志打了一大堆，balabala都没问题，但一到调用该服务商jar包的时候就悄无声息。本机启动时候程序又哗哗的跑，真是气死个人。初以为线上服务器环境或权限有问题，删了重安各种折腾，一通下来居然依旧不行。心灰意冷之下看了看线上服务器启动脚本，嗯，jdk1.7。再瞅了一眼本地测试环境，嗯，1.8。。。

    卧槽？！！难道是jdk版本，话说现在兼容性这么强，支持1.8的居然无法支持1.7？臆测是没用的，去代码里看看吧。

this.baseToken =new String(Base64.getEncoder().encode(code.getBytes()));

    嗯，之前的都是初始化，无关紧要。莫非是这句base64编码？于是我在线下切成了1.7环境……咦？怎么没这个包了？

    居然，就是因为base64编码使用的是jdk1.8自带的包，而1.7没有！枉我头疼了大半天找原因。话说如果只有这么一个地方不支持1.7的话。用外部的包编码不就好了吗！跑去问客服，回答的竟然也是，我们只支持1.8，不支持1.7。。迷一样的API。

    最后贴出来1.8的base64编码学习一下吧~

public static Encoder getEncoder() {
         return Encoder.RFC4648;
} 

 static final Encoder RFC4648 = new Encoder(false, null, -1, true);

  public byte[] encode(byte[] src) {
            int len = outLength(src.length);          // dst array size
            byte[] dst = new byte[len];
            int ret = encode0(src, 0, src.length, dst);
            if (ret != dst.length)
                 return Arrays.copyOf(dst, ret);
            return dst;
  }

private final int outLength(int srclen) {
            int len = 0;
            if (doPadding) {
                len = 4 * ((srclen + 2) / 3);
            } else {
                int n = srclen % 3;
                len = 4 * (srclen / 3) + (n == 0 ? 0 : n + 1);
            }
            if (linemax > 0)                                  // line separators
                len += (len - 1) / linemax * newline.length;
            return len;
 }

 private int encode0(byte[] src, int off, int end, byte[] dst) {
            char[] base64 = isURL ? toBase64URL : toBase64;
            int sp = off;
            int slen = (end - off) / 3 * 3;
            int sl = off + slen;
            if (linemax > 0 && slen  > linemax / 4 * 3)
                slen = linemax / 4 * 3;
            int dp = 0;
            while (sp < sl) {
                int sl0 = Math.min(sp + slen, sl);
                for (int sp0 = sp, dp0 = dp ; sp0 < sl0; ) {
                    int bits = (src[sp0++] & 0xff) << 16 |
                               (src[sp0++] & 0xff) <<  8 |
                               (src[sp0++] & 0xff);
                    dst[dp0++] = (byte)base64[(bits >>> 18) & 0x3f];
                    dst[dp0++] = (byte)base64[(bits >>> 12) & 0x3f];
                    dst[dp0++] = (byte)base64[(bits >>> 6)  & 0x3f];
                    dst[dp0++] = (byte)base64[bits & 0x3f];
                }
                int dlen = (sl0 - sp) / 3 * 4;
                dp += dlen;
                sp = sl0;
                if (dlen == linemax && sp < end) {
                    for (byte b : newline){
                        dst[dp++] = b;
                    }
                }
            }
            if (sp < end) {               // 1 or 2 leftover bytes
                int b0 = src[sp++] & 0xff;
                dst[dp++] = (byte)base64[b0 >> 2];
                if (sp == end) {
                    dst[dp++] = (byte)base64[(b0 << 4) & 0x3f];
                    if (doPadding) {
                        dst[dp++] = '=';
                        dst[dp++] = '=';
                    }
                } else {
                    int b1 = src[sp++] & 0xff;
                    dst[dp++] = (byte)base64[(b0 << 4) & 0x3f | (b1 >> 4)];
                    dst[dp++] = (byte)base64[(b1 << 2) & 0x3f];
                    if (doPadding) {
                        dst[dp++] = '=';
                    }
                }
            }
            return dp;
        }
    }

 public static byte[] copyOf(byte[] original, int newLength) {
        byte[] copy = new byte[newLength];
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
    }

    以上就是我被坑的过程，记录一下，免得以后再犯找不到原因。