properties和json格式文件解析

properties文件解析

public static void loadProps(String propertiesUrl) {
    props = new Properties();
    InputStream in = null;
    try {
        in =new BufferedInputStream(new FileInputStream(propertiesUrl));
        props.load(in);
    } catch (FileNotFoundException e) {
        logger.error("jdbc.properties⽂件未找到");
    } catch (IOException e) {
        logger.error("出现IOException");
    } finally {
        try {
            if (null != in) {
                in.close();
            }
        } catch (IOException e) {
            logger.error("jdbc.properties⽂件流关闭出现异常");
        }
    }
    logger.debug("加载properties⽂件内容完成...........");
    logger.debug("properties⽂件内容：" + props);
}
public static String getProperty(String key) {
if (null == props) {
logger.debug("加载配置⽂件出错");
}
return props.getProperty(key);
}

json文件解析

public static void loadJSON(String jsonUrl) {
        InputStream in = null;
        try {
            in = new FileInputStream(jsonUrl);
            List<CmDynamicModelReflect> allDynamic = JSON.parseArray(IoUtil.read(in, "utf-8"), CmDynamicModelReflect.class);
            if(allDynamic!=null&&allDynamic.size()>0){
                for(CmDynamicModelReflect dynamicBean:allDynamic){
                    dynamicModelReflect.put(dynamicBean.getFileKeyWord(),dynamicBean.getModelName());
                }
            }
        } catch (FileNotFoundException e) {
            logger.error("cm_dynamic_model_reflect⽂件未找到");
        } finally {
            try {
                if (null != in) {
                    in.close();
                }
            } catch (IOException e) {
                logger.error("cm_dynamic_model_reflect⽂件流关闭出现异常");
            }
        }
        logger.debug("cm_dynamic_model_reflect⽂件内容完成...........");
        System.out.println("cm_dynamic_model_reflect⽂件内容：" + props);
    }

iotUtil工具类

import cn.hutool.core.convert.Convert;
import cn.hutool.core.exceptions.UtilException;
import cn.hutool.core.lang.Assert;
import cn.hutool.core.util.CharsetUtil;
import cn.hutool.core.util.HexUtil;
import cn.hutool.core.util.StrUtil;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.Closeable;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.Flushable;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PushbackInputStream;
import java.io.PushbackReader;
import java.io.Reader;
import java.io.Serializable;
import java.io.Writer;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.MappedByteBuffer;
import java.nio.channels.Channels;
import java.nio.channels.FileChannel;
import java.nio.channels.ReadableByteChannel;
import java.nio.channels.WritableByteChannel;
import java.nio.channels.FileChannel.MapMode;
import java.nio.charset.Charset;
import java.util.Collection;
import java.util.Objects;
import java.util.zip.CRC32;
import java.util.zip.CheckedInputStream;
import java.util.zip.Checksum;

public class IoUtil {
    public static final int DEFAULT_BUFFER_SIZE = 8192;
    public static final int DEFAULT_MIDDLE_BUFFER_SIZE = 16384;
    public static final int DEFAULT_LARGE_BUFFER_SIZE = 32768;
    public static final int EOF = -1;

    public IoUtil() {
    }

    public static long copy(Reader reader, Writer writer) throws IORuntimeException {
        return copy((Reader)reader, (Writer)writer, 8192);
    }

    public static long copy(Reader reader, Writer writer, int bufferSize) throws IORuntimeException {
        return copy((Reader)reader, (Writer)writer, bufferSize, (StreamProgress)null);
    }

    public static long copy(Reader reader, Writer writer, int bufferSize, StreamProgress streamProgress) throws IORuntimeException {
        char[] buffer = new char[bufferSize];
        long size = 0L;
        if (null != streamProgress) {
            streamProgress.start();
        }

        int readSize;
        try {
            while((readSize = reader.read(buffer, 0, bufferSize)) != -1) {
                writer.write(buffer, 0, readSize);
                size += (long)readSize;
                writer.flush();
                if (null != streamProgress) {
                    streamProgress.progress(size);
                }
            }
        } catch (Exception var9) {
            throw new IORuntimeException(var9);
        }

        if (null != streamProgress) {
            streamProgress.finish();
        }

        return size;
    }

    public static long copy(InputStream in, OutputStream out) throws IORuntimeException {
        return copy((InputStream)in, (OutputStream)out, 8192);
    }

    public static long copy(InputStream in, OutputStream out, int bufferSize) throws IORuntimeException {
        return copy((InputStream)in, (OutputStream)out, bufferSize, (StreamProgress)null);
    }

    public static long copy(InputStream in, OutputStream out, int bufferSize, StreamProgress streamProgress) throws IORuntimeException {
        Assert.notNull(in, "InputStream is null !", new Object[0]);
        Assert.notNull(out, "OutputStream is null !", new Object[0]);
        if (bufferSize <= 0) {
            bufferSize = 8192;
        }

        byte[] buffer = new byte[bufferSize];
        if (null != streamProgress) {
            streamProgress.start();
        }

        long size = 0L;

        int readSize;
        try {
            while((readSize = in.read(buffer)) != -1) {
                out.write(buffer, 0, readSize);
                size += (long)readSize;
                out.flush();
                if (null != streamProgress) {
                    streamProgress.progress(size);
                }
            }
        } catch (IOException var8) {
            throw new IORuntimeException(var8);
        }

        if (null != streamProgress) {
            streamProgress.finish();
        }

        return size;
    }

    public static long copyByNIO(InputStream in, OutputStream out, int bufferSize, StreamProgress streamProgress) throws IORuntimeException {
        return copy(Channels.newChannel(in), Channels.newChannel(out), bufferSize, streamProgress);
    }

    public static long copy(FileInputStream in, FileOutputStream out) throws IORuntimeException {
        Assert.notNull(in, "FileInputStream is null!", new Object[0]);
        Assert.notNull(out, "FileOutputStream is null!", new Object[0]);
        FileChannel inChannel = null;
        FileChannel outChannel = null;

        long var4;
        try {
            inChannel = in.getChannel();
            outChannel = out.getChannel();
            var4 = inChannel.transferTo(0L, inChannel.size(), outChannel);
        } catch (IOException var9) {
            throw new IORuntimeException(var9);
        } finally {
            close((Closeable)outChannel);
            close((Closeable)inChannel);
        }

        return var4;
    }

    public static long copy(ReadableByteChannel in, WritableByteChannel out) throws IORuntimeException {
        return copy((ReadableByteChannel)in, (WritableByteChannel)out, 8192);
    }

    public static long copy(ReadableByteChannel in, WritableByteChannel out, int bufferSize) throws IORuntimeException {
        return copy((ReadableByteChannel)in, (WritableByteChannel)out, bufferSize, (StreamProgress)null);
    }

    public static long copy(ReadableByteChannel in, WritableByteChannel out, int bufferSize, StreamProgress streamProgress) throws IORuntimeException {
        Assert.notNull(in, "InputStream is null !", new Object[0]);
        Assert.notNull(out, "OutputStream is null !", new Object[0]);
        ByteBuffer byteBuffer = ByteBuffer.allocate(bufferSize <= 0 ? 8192 : bufferSize);
        long size = 0L;
        if (null != streamProgress) {
            streamProgress.start();
        }

        try {
            while(in.read(byteBuffer) != -1) {
                byteBuffer.flip();
                size += (long)out.write(byteBuffer);
                byteBuffer.clear();
                if (null != streamProgress) {
                    streamProgress.progress(size);
                }
            }
        } catch (IOException var8) {
            throw new IORuntimeException(var8);
        }

        if (null != streamProgress) {
            streamProgress.finish();
        }

        return size;
    }

    public static BufferedReader getReader(InputStream in, String charsetName) {
        return getReader(in, Charset.forName(charsetName));
    }

    public static BufferedReader getReader(InputStream in, Charset charset) {
        if (null == in) {
            return null;
        } else {
            InputStreamReader reader;
            if (null == charset) {
                reader = new InputStreamReader(in);
            } else {
                reader = new InputStreamReader(in, charset);
            }

            return new BufferedReader(reader);
        }
    }

    public static BufferedReader getReader(Reader reader) {
        if (null == reader) {
            return null;
        } else {
            return reader instanceof BufferedReader ? (BufferedReader)reader : new BufferedReader(reader);
        }
    }

    public static PushbackReader getPushBackReader(Reader reader, int pushBackSize) {
        return reader instanceof PushbackReader ? (PushbackReader)reader : new PushbackReader(reader, pushBackSize);
    }

    public static OutputStreamWriter getWriter(OutputStream out, String charsetName) {
        return getWriter(out, Charset.forName(charsetName));
    }

    public static OutputStreamWriter getWriter(OutputStream out, Charset charset) {
        if (null == out) {
            return null;
        } else {
            return null == charset ? new OutputStreamWriter(out) : new OutputStreamWriter(out, charset);
        }
    }

    public static String read(InputStream in, String charsetName) throws IORuntimeException {
        FastByteArrayOutputStream out = read(in);
        return StrUtil.isBlank(charsetName) ? out.toString() : out.toString(charsetName);
    }

    public static String read(InputStream in, Charset charset) throws IORuntimeException {
        FastByteArrayOutputStream out = read(in);
        return null == charset ? out.toString() : out.toString(charset);
    }

    public static String read(ReadableByteChannel channel, Charset charset) throws IORuntimeException {
        FastByteArrayOutputStream out = read(channel);
        return null == charset ? out.toString() : out.toString(charset);
    }

    public static FastByteArrayOutputStream read(InputStream in) throws IORuntimeException {
        FastByteArrayOutputStream out = new FastByteArrayOutputStream();
        copy((InputStream)in, (OutputStream)out);
        return out;
    }

    public static FastByteArrayOutputStream read(ReadableByteChannel channel) throws IORuntimeException {
        FastByteArrayOutputStream out = new FastByteArrayOutputStream();
        copy(channel, Channels.newChannel(out));
        return out;
    }

    public static String read(Reader reader) throws IORuntimeException {
        StringBuilder builder = StrUtil.builder();
        CharBuffer buffer = CharBuffer.allocate(8192);

        try {
            while(-1 != reader.read(buffer)) {
                builder.append(buffer.flip().toString());
            }
        } catch (IOException var4) {
            throw new IORuntimeException(var4);
        }

        return builder.toString();
    }

    public static String readUtf8(FileChannel fileChannel) throws IORuntimeException {
        return read(fileChannel, CharsetUtil.CHARSET_UTF_8);
    }

    public static String read(FileChannel fileChannel, String charsetName) throws IORuntimeException {
        return read(fileChannel, CharsetUtil.charset(charsetName));
    }

    public static String read(FileChannel fileChannel, Charset charset) throws IORuntimeException {
        MappedByteBuffer buffer;
        try {
            buffer = fileChannel.map(MapMode.READ_ONLY, 0L, fileChannel.size()).load();
        } catch (IOException var4) {
            throw new IORuntimeException(var4);
        }

        return StrUtil.str(buffer, charset);
    }

    public static byte[] readBytes(InputStream in) throws IORuntimeException {
        return readBytes(in, true);
    }

    public static byte[] readBytes(InputStream in, boolean isCloseStream) throws IORuntimeException {
        FastByteArrayOutputStream out = new FastByteArrayOutputStream();
        copy((InputStream)in, (OutputStream)out);
        if (isCloseStream) {
            close((Closeable)in);
        }

        return out.toByteArray();
    }

    public static byte[] readBytes(InputStream in, int length) throws IORuntimeException {
        if (null == in) {
            return null;
        } else if (length <= 0) {
            return new byte[0];
        } else {
            byte[] b = new byte[length];

            int readLength;
            try {
                readLength = in.read(b);
            } catch (IOException var5) {
                throw new IORuntimeException(var5);
            }

            if (readLength > 0 && readLength < length) {
                byte[] b2 = new byte[length];
                System.arraycopy(b, 0, b2, 0, readLength);
                return b2;
            } else {
                return b;
            }
        }
    }

    public static String readHex(InputStream in, int length, boolean toLowerCase) throws IORuntimeException {
        return HexUtil.encodeHexStr(readBytes(in, length), toLowerCase);
    }

    public static String readHex28Upper(InputStream in) throws IORuntimeException {
        return readHex(in, 28, false);
    }

    public static String readHex28Lower(InputStream in) throws IORuntimeException {
        return readHex(in, 28, true);
    }

    public static <T> T readObj(InputStream in) throws IORuntimeException, UtilException {
        if (in == null) {
            throw new IllegalArgumentException("The InputStream must not be null");
        } else {
            try {
                ObjectInputStream ois = new ObjectInputStream(in);
                T obj = ois.readObject();
                return obj;
            } catch (IOException var3) {
                throw new IORuntimeException(var3);
            } catch (ClassNotFoundException var4) {
                throw new UtilException(var4);
            }
        }
    }

    public static <T extends Collection<String>> T readUtf8Lines(InputStream in, T collection) throws IORuntimeException {
        return readLines(in, CharsetUtil.CHARSET_UTF_8, collection);
    }

    public static <T extends Collection<String>> T readLines(InputStream in, String charsetName, T collection) throws IORuntimeException {
        return readLines(in, CharsetUtil.charset(charsetName), collection);
    }

    public static <T extends Collection<String>> T readLines(InputStream in, Charset charset, T collection) throws IORuntimeException {
        return readLines(getReader(in, charset), (Collection)collection);
    }

    public static <T extends Collection<String>> T readLines(Reader reader, T collection) throws IORuntimeException {
        readLines(reader, collection::add);
        return collection;
    }

    public static void readUtf8Lines(InputStream in, LineHandler lineHandler) throws IORuntimeException {
        readLines(in, CharsetUtil.CHARSET_UTF_8, lineHandler);
    }

    public static void readLines(InputStream in, Charset charset, LineHandler lineHandler) throws IORuntimeException {
        readLines(getReader(in, charset), (LineHandler)lineHandler);
    }

    public static void readLines(Reader reader, LineHandler lineHandler) throws IORuntimeException {
        Assert.notNull(reader);
        Assert.notNull(lineHandler);
        BufferedReader bReader = getReader(reader);

        try {
            String line;
            while((line = bReader.readLine()) != null) {
                lineHandler.handle(line);
            }

        } catch (IOException var5) {
            throw new IORuntimeException(var5);
        }
    }

    public static ByteArrayInputStream toStream(String content, String charsetName) {
        return toStream(content, CharsetUtil.charset(charsetName));
    }

    public static ByteArrayInputStream toStream(String content, Charset charset) {
        return content == null ? null : toStream(StrUtil.bytes(content, charset));
    }

    public static ByteArrayInputStream toUtf8Stream(String content) {
        return toStream(content, CharsetUtil.CHARSET_UTF_8);
    }

    public static FileInputStream toStream(File file) {
        try {
            return new FileInputStream(file);
        } catch (FileNotFoundException var2) {
            throw new IORuntimeException(var2);
        }
    }

    public static ByteArrayInputStream toStream(byte[] content) {
        return content == null ? null : new ByteArrayInputStream(content);
    }

    public static BufferedInputStream toBuffered(InputStream in) {
        return in instanceof BufferedInputStream ? (BufferedInputStream)in : new BufferedInputStream(in);
    }

    public static BufferedOutputStream toBuffered(OutputStream out) {
        return out instanceof BufferedOutputStream ? (BufferedOutputStream)out : new BufferedOutputStream(out);
    }

    public static InputStream toMarkSupportStream(InputStream in) {
        if (null == in) {
            return null;
        } else {
            return (InputStream)(!in.markSupported() ? new BufferedInputStream(in) : in);
        }
    }

    public static PushbackInputStream toPushbackStream(InputStream in, int pushBackSize) {
        return in instanceof PushbackInputStream ? (PushbackInputStream)in : new PushbackInputStream(in, pushBackSize);
    }

    public static void write(OutputStream out, boolean isCloseOut, byte[] content) throws IORuntimeException {
        try {
            out.write(content);
        } catch (IOException var7) {
            throw new IORuntimeException(var7);
        } finally {
            if (isCloseOut) {
                close((Closeable)out);
            }

        }

    }

    public static void writeUtf8(OutputStream out, boolean isCloseOut, Object... contents) throws IORuntimeException {
        write(out, CharsetUtil.CHARSET_UTF_8, isCloseOut, contents);
    }

    public static void write(OutputStream out, String charsetName, boolean isCloseOut, Object... contents) throws IORuntimeException {
        write(out, CharsetUtil.charset(charsetName), isCloseOut, contents);
    }

    public static void write(OutputStream out, Charset charset, boolean isCloseOut, Object... contents) throws IORuntimeException {
        OutputStreamWriter osw = null;

        try {
            osw = getWriter(out, charset);
            Object[] var5 = contents;
            int var6 = contents.length;

            for(int var7 = 0; var7 < var6; ++var7) {
                Object content = var5[var7];
                if (content != null) {
                    osw.write(Convert.toStr(content, ""));
                    osw.flush();
                }
            }
        } catch (IOException var12) {
            throw new IORuntimeException(var12);
        } finally {
            if (isCloseOut) {
                close((Closeable)osw);
            }

        }

    }

    public static void writeObjects(OutputStream out, boolean isCloseOut, Serializable... contents) throws IORuntimeException {
        ObjectOutputStream osw = null;

        try {
            osw = out instanceof ObjectOutputStream ? (ObjectOutputStream)out : new ObjectOutputStream(out);
            Serializable[] var4 = contents;
            int var5 = contents.length;

            for(int var6 = 0; var6 < var5; ++var6) {
                Object content = var4[var6];
                if (content != null) {
                    osw.writeObject(content);
                    osw.flush();
                }
            }
        } catch (IOException var11) {
            throw new IORuntimeException(var11);
        } finally {
            if (isCloseOut) {
                close((Closeable)osw);
            }

        }

    }

    public static void flush(Flushable flushable) {
        if (null != flushable) {
            try {
                flushable.flush();
            } catch (Exception var2) {
            }
        }

    }

    public static void close(Closeable closeable) {
        if (null != closeable) {
            try {
                closeable.close();
            } catch (Exception var2) {
            }
        }

    }

    public static void close(AutoCloseable closeable) {
        if (null != closeable) {
            try {
                closeable.close();
            } catch (Exception var2) {
            }
        }

    }

    public static void closeIfPosible(Object obj) {
        if (obj instanceof AutoCloseable) {
            close((AutoCloseable)obj);
        }

    }

    public static boolean contentEquals(InputStream input1, InputStream input2) throws IORuntimeException {
        if (!(input1 instanceof BufferedInputStream)) {
            input1 = new BufferedInputStream((InputStream)input1);
        }

        if (!(input2 instanceof BufferedInputStream)) {
            input2 = new BufferedInputStream((InputStream)input2);
        }

        try {
            int ch2;
            for(int ch = ((InputStream)input1).read(); -1 != ch; ch = ((InputStream)input1).read()) {
                ch2 = ((InputStream)input2).read();
                if (ch != ch2) {
                    return false;
                }
            }

            ch2 = ((InputStream)input2).read();
            return ch2 == -1;
        } catch (IOException var4) {
            throw new IORuntimeException(var4);
        }
    }

    public static boolean contentEquals(Reader input1, Reader input2) throws IORuntimeException {
        Reader input1 = getReader(input1);
        BufferedReader input2 = getReader(input2);

        try {
            int ch2;
            for(int ch = input1.read(); -1 != ch; ch = input1.read()) {
                ch2 = input2.read();
                if (ch != ch2) {
                    return false;
                }
            }

            ch2 = input2.read();
            return ch2 == -1;
        } catch (IOException var4) {
            throw new IORuntimeException(var4);
        }
    }

    public static boolean contentEqualsIgnoreEOL(Reader input1, Reader input2) throws IORuntimeException {
        BufferedReader br1 = getReader(input1);
        BufferedReader br2 = getReader(input2);

        try {
            String line1 = br1.readLine();

            String line2;
            for(line2 = br2.readLine(); line1 != null && line1.equals(line2); line2 = br2.readLine()) {
                line1 = br1.readLine();
            }

            return Objects.equals(line1, line2);
        } catch (IOException var6) {
            throw new IORuntimeException(var6);
        }
    }

    public static long checksumCRC32(InputStream in) throws IORuntimeException {
        return checksum(in, new CRC32()).getValue();
    }

    public static Checksum checksum(InputStream in, Checksum checksum) throws IORuntimeException {
        Assert.notNull(in, "InputStream is null !", new Object[0]);
        if (null == checksum) {
            checksum = new CRC32();
        }

        try {
            in = new CheckedInputStream((InputStream)in, (Checksum)checksum);
            copy((InputStream)in, (OutputStream)(new NullOutputStream()));
        } finally {
            close((Closeable)in);
        }

        return (Checksum)checksum;
    }
}

Bean

public class CmDynamicModelReflect {
    private Integer id;

    private String fileKeyWord;

    private String modelName;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getFileKeyWord() {
        return fileKeyWord;
    }

    public void setFileKeyWord(String fileKeyWord) {
        this.fileKeyWord = fileKeyWord;
    }

    public String getModelName() {
        return modelName;
    }

    public void setModelName(String modelName) {
        this.modelName = modelName;
    }
}