APP表情java后台处理

今天项目遇到的一个问题，APP订单评论提交emoji表情的话会报错，由于需要实现emoji表情评论的功能，根据自己实现的方式以及查询的实现方式，现总结为一下几种

mysql的utf8编码的一个字符最多3个字节，但是一个emoji表情为4个字节，所以utf8不支持存储emoji表情。

实现方式一

对APP传入后端的数据包括字符串和emoji表情，把emoji表情和String都进行Base64转换，存储在数据库中，取的时候再转换回来即可解决上述问题，这是最快也是最简单的解决方法。

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;

/**
 * <p>
 * Base64 encoding and decoding utility methods, both for binary and textual
 * informations.
 * </p>
 * 
 * @author Carlo Pelliccia
 * @since 1.1
 * @version 1.3
 */
public class Base64 {

    /**
     * <p>
     * Encodes a string.
     * </p>
     * <p>
     * Before the string is encoded in Base64, it is converted in a binary
     * sequence using the system default charset.
     * </p>
     *
     * @param str
     *            The source string.
     * @return The encoded string.
     * @throws RuntimeException
     *             If an unexpected error occurs.
     */
    public static String encode(String str) throws RuntimeException {
        byte[] bytes = str.getBytes();
        byte[] encoded = encode(bytes);
        try {
            return new String(encoded, "ASCII");
        } catch (UnsupportedEncodingException e) {
            throw new RuntimeException("ASCII is not supported!", e);
        }
    }

    /**
     * <p>
     * Encodes a string.
     * </p>
     * <p>
     * Before the string is encoded in Base64, it is converted in a binary
     * sequence using the supplied charset.
     * </p>
     *
     * @param str
     *            The source string
     * @param charset
     *            The charset name.
     * @return The encoded string.
     * @throws RuntimeException
     *             If an unexpected error occurs.
     * @since 1.2
     */
    public static String encode(String str, String charset)
            throws RuntimeException {
        byte[] bytes;
        try {
            bytes = str.getBytes(charset);
        } catch (UnsupportedEncodingException e) {
            throw new RuntimeException("Unsupported charset: " + charset, e);
        }
        byte[] encoded = encode(bytes);
        try {
            return new String(encoded, "ASCII");
        } catch (UnsupportedEncodingException e) {
            throw new RuntimeException("ASCII is not supported!", e);
        }
    }

    /**
     * <p>
     * Decodes the supplied string.
     * </p>
     * <p>
     * The supplied string is decoded into a binary sequence, and then the
     * sequence is encoded with the system default charset and returned.
     * </p>
     *
     * @param str
     *            The encoded string.
     * @return The decoded string.
     * @throws RuntimeException
     *             If an unexpected error occurs.
     */
    public static String decode(String str) throws RuntimeException {
        byte[] bytes;
        try {
            bytes = str.getBytes("ASCII");
        } catch (UnsupportedEncodingException e) {
            throw new RuntimeException("ASCII is not supported!", e);
        }
        byte[] decoded = decode(bytes);
        return new String(decoded);
    }

    /**
     * <p>
     * Decodes the supplied string.
     * </p>
     * <p>
     * The supplied string is decoded into a binary sequence, and then the
     * sequence is encoded with the supplied charset and returned.
     * </p>
     *
     * @param str
     *            The encoded string.
     * @param charset
     *            The charset name.
     * @return The decoded string.
     * @throws RuntimeException
     *             If an unexpected error occurs.
     * @since 1.2
     */
    public static String decode(String str, String charset)
            throws RuntimeException {
        byte[] bytes;
        try {
            bytes = str.getBytes("ASCII");
        } catch (UnsupportedEncodingException e) {
            throw new RuntimeException("ASCII is not supported!", e);
        }
        byte[] decoded = decode(bytes);
        try {
            return new String(decoded, charset);
        } catch (UnsupportedEncodingException e) {
            throw new RuntimeException("Unsupported charset: " + charset, e);
        }
    }

    /**
     * <p>
     * Encodes a binary sequence.
     * </p>
     * <p>
     * If data are large, i.e. if you are working with large binary files,
     * consider to use a {@link Base64OutputStream} instead of loading too much
     * data in memory.
     * </p>
     *
     * @param bytes
     *            The source sequence.
     * @return The encoded sequence.
     * @throws RuntimeException
     *             If an unexpected error occurs.
     * @since 1.2
     */
    public static byte[] encode(byte[] bytes) throws RuntimeException {
        return encode(bytes, 0);
    }

    /**
     * <p>
     * Encodes a binary sequence, wrapping every encoded line every
     * <em>wrapAt</em> characters. A <em>wrapAt</em> value less than 1 disables
     * wrapping.
     * </p>
     * <p>
     * If data are large, i.e. if you are working with large binary files,
     * consider to use a {@link Base64OutputStream} instead of loading too much
     * data in memory.
     * </p>
     *
     * @param bytes
     *            The source sequence.
     * @param wrapAt
     *            The max line length for encoded data. If less than 1 no wrap
     *            is applied.
     * @return The encoded sequence.
     * @throws RuntimeException
     *             If an unexpected error occurs.
     * @since 1.2
     */
    public static byte[] encode(byte[] bytes, int wrapAt)
            throws RuntimeException {
        ByteArrayInputStream inputStream = new ByteArrayInputStream(bytes);
        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
        try {
            encode(inputStream, outputStream, wrapAt);
        } catch (IOException e) {
            throw new RuntimeException("Unexpected I/O error", e);
        } finally {
            try {
                inputStream.close();
            } catch (Throwable t) {
                ;
            }
            try {
                outputStream.close();
            } catch (Throwable t) {
                ;
            }
        }
        return outputStream.toByteArray();
    }

    /**
     * <p>
     * Decodes a binary sequence.
     * </p>
     * <p>
     * If data are large, i.e. if you are working with large binary files,
     * consider to use a {@link Base64InputStream} instead of loading too much
     * data in memory.
     * </p>
     *
     * @param bytes
     *            The encoded sequence.
     * @return The decoded sequence.
     * @throws RuntimeException
     *             If an unexpected error occurs.
     * @since 1.2
     */
    public static byte[] decode(byte[] bytes) throws RuntimeException {
        ByteArrayInputStream inputStream = new ByteArrayInputStream(bytes);
        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
        try {
            decode(inputStream, outputStream);
        } catch (IOException e) {
            throw new RuntimeException("Unexpected I/O error", e);
        } finally {
            try {
                inputStream.close();
            } catch (Throwable t) {
                ;
            }
            try {
                outputStream.close();
            } catch (Throwable t) {
                ;
            }
        }
        return outputStream.toByteArray();
    }

    /**
     * <p>
     * Encodes data from the given input stream and writes them in the given
     * output stream.
     * </p>
     * <p>
     * The supplied input stream is read until its end is reached, but it's not
     * closed by this method.
     * </p>
     * <p>
     * The supplied output stream is nor flushed neither closed by this method.
     * </p>
     *
     * @param inputStream
     *            The input stream.
     * @param outputStream
     *            The output stream.
     * @throws IOException
     *             If an I/O error occurs.
     */
    public static void encode(InputStream inputStream, OutputStream outputStream)
            throws IOException {
        encode(inputStream, outputStream, 0);
    }

    /**
     * <p>
     * Encodes data from the given input stream and writes them in the given
     * output stream, wrapping every encoded line every <em>wrapAt</em>
     * characters. A <em>wrapAt</em> value less than 1 disables wrapping.
     * </p>
     * <p>
     * The supplied input stream is read until its end is reached, but it's not
     * closed by this method.
     * </p>
     * <p>
     * The supplied output stream is nor flushed neither closed by this method.
     * </p>
     *
     * @param inputStream
     *            The input stream from which clear data are read.
     * @param outputStream
     *            The output stream in which encoded data are written.
     * @param wrapAt
     *            The max line length for encoded data. If less than 1 no wrap
     *            is applied.
     * @throws IOException
     *             If an I/O error occurs.
     */
    public static void encode(InputStream inputStream,
            OutputStream outputStream, int wrapAt) throws IOException {
        Base64OutputStream aux = new Base64OutputStream(outputStream, wrapAt);
        copy(inputStream, aux);
        aux.commit();
    }

    /**
     * <p>
     * Decodes data from the given input stream and writes them in the given
     * output stream.
     * </p>
     * <p>
     * The supplied input stream is read until its end is reached, but it's not
     * closed by this method.
     * </p>
     * <p>
     * The supplied output stream is nor flushed neither closed by this method.
     * </p>
     *
     * @param inputStream
     *            The input stream from which encoded data are read.
     * @param outputStream
     *            The output stream in which decoded data are written.
     * @throws IOException
     *             If an I/O error occurs.
     */
    public static void decode(InputStream inputStream, OutputStream outputStream)
            throws IOException {
        copy(new Base64InputStream(inputStream), outputStream);
    }

    /**
     * <p>
     * Encodes data from the given source file contents and writes them in the
     * given target file, wrapping every encoded line every <em>wrapAt</em>
     * characters. A <em>wrapAt</em> value less than 1 disables wrapping.
     * </p>
     *
     * @param source
     *            The source file, from which decoded data are read.
     * @param target
     *            The target file, in which encoded data are written.
     * @param wrapAt
     *            The max line length for encoded data. If less than 1 no wrap
     *            is applied.
     * @throws IOException
     *             If an I/O error occurs.
     * @since 1.3
     */
    public static void encode(File source, File target, int wrapAt)
            throws IOException {
        InputStream inputStream = null;
        OutputStream outputStream = null;
        try {
            inputStream = new FileInputStream(source);
            outputStream = new FileOutputStream(target);
            Base64.encode(inputStream, outputStream, wrapAt);
        } finally {
            if (outputStream != null) {
                try {
                    outputStream.close();
                } catch (Throwable t) {
                    ;
                }
            }
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (Throwable t) {
                    ;
                }
            }
        }
    }

    /**
     * <p>
     * Encodes data from the given source file contents and writes them in the
     * given target file.
     * </p>
     *
     * @param source
     *            The source file, from which decoded data are read.
     * @param target
     *            The target file, in which encoded data are written.
     * @throws IOException
     *             If an I/O error occurs.
     * @since 1.3
     */
    public static void encode(File source, File target) throws IOException {
        InputStream inputStream = null;
        OutputStream outputStream = null;
        try {
            inputStream = new FileInputStream(source);
            outputStream = new FileOutputStream(target);
            Base64.encode(inputStream, outputStream);
        } finally {
            if (outputStream != null) {
                try {
                    outputStream.close();
                } catch (Throwable t) {
                    ;
                }
            }
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (Throwable t) {
                    ;
                }
            }
        }
    }

    /**
     * <p>
     * Decodes data from the given source file contents and writes them in the
     * given target file.
     * </p>
     *
     * @param source
     *            The source file, from which encoded data are read.
     * @param target
     *            The target file, in which decoded data are written.
     * @throws IOException
     *             If an I/O error occurs.
     * @since 1.3
     */
    public static void decode(File source, File target) throws IOException {
        InputStream inputStream = null;
        OutputStream outputStream = null;
        try {
            inputStream = new FileInputStream(source);
            outputStream = new FileOutputStream(target);
            decode(inputStream, outputStream);
        } finally {
            if (outputStream != null) {
                try {
                    outputStream.close();
                } catch (Throwable t) {
                    ;
                }
            }
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (Throwable t) {
                    ;
                }
            }
        }
    }

    /**
     * Copies data from a stream to another.
     *
     * @param inputStream
     *            The input stream.
     * @param outputStream
     *            The output stream.
     * @throws IOException
     *             If a unexpected I/O error occurs.
     */
    private static void copy(InputStream inputStream, OutputStream outputStream)
            throws IOException {
        // 1KB buffer
        byte[] b = new byte[1024];
        int len;
        while ((len = inputStream.read(b)) != -1) {
            outputStream.write(b, 0, len);
        }
    }

}

实现方式二

mysql 字符集utf8的超集utf8mb4一个字符最多能有4字节，所以能支持emoji表情的存储。只要修改mysql数据库的编码格式变为utf8mb4即可
具体方法可参考连接
这种方式后台不用再做额外的操作，直接正常存储即可，但是修改数据库会比较麻烦

实现方式三

通过emoji-Java解决数据库不能存储4字节表情符号
参考这篇文章，这里不再叙述