1.许可审批

tangzy

2021-08-20 6dc323321275c3206acbd1fbdc14812db6e2ae90

1.许可审批

 pom.xml

@@ -210,6 +210,20 @@
            <artifactId>pinyin4j</artifactId>
            <version>2.5.1</version>
        </dependency>
        <dependency>
            <groupId>commons-net</groupId>
            <artifactId>commons-net</artifactId>
            <version>1.4.1</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.47</version>
        </dependency>
        <dependency>
            <groupId>org.testng</groupId>
            <artifactId>testng</artifactId>
        </dependency>
    </dependencies>

    <build>

 src/main/java/org/springblade/common/utils/FtpMain.java

New file
@@ -0,0 +1,38 @@
package org.springblade.common.utils;

import java.io.FileNotFoundException;

public class FtpMain {
    public static void main(String[] args) throws FileNotFoundException {
        //ftp服务器IP地址
        String ftpHost = "192.168.0.105";
        //ftp服务器端口
        int ftpPort = 21;
        //ftp服务器用户名
        String ftpUserName = "yly";
        //ftp服务器密码
        String ftpPassword = "Yly@123";
        //ftp服务器路径
        String ftpPath = "";
        //本地路径
        String localPath = "D:\\anbao";
        //文件名
        String fileName = "sql.json";


        //下载
        //将ftp根目录下的文件下载至E盘
        FtpUtil.downloadFtpFile(ftpHost, ftpUserName, ftpPassword, ftpPort, ftpPath, localPath, fileName);

        //上传
        //将E盘的文件上传至ftp根目录
        //FileInputStream in=new FileInputStream(new File("D:\\" + fileName));
        //FtpUtil.uploadFile(ftpHost, ftpPort, ftpUserName, ftpPassword, "anbao/", "/", fileName, in);

        //删除
        //删除ftp根目录下的文件
        //FtpUtil.deleteFile(ftpHost, ftpPort, ftpUserName, ftpPassword, "anbao/", "fz.py");


    }
}

 src/main/java/org/springblade/common/utils/FtpUploadFile.java

New file
@@ -0,0 +1,134 @@
package org.springblade.common.utils;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.commons.net.ftp.FTP;
import org.apache.commons.net.ftp.FTPClient;
import org.apache.commons.net.ftp.FTPReply;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.SocketException;

public class FtpUploadFile {
    private final static Log logger = LogFactory.getLog(FtpUploadFile.class);
    /**
     * 获取ftpClient对象
     * @param ftpHost FTP服务器地址
     * @param ftpUserName 登录FTP服务器用户名
     * @param ftpPassword 登录FTP服务器密码
     * @param ftpPort FTP服务器端口
     * @return
     */
    public static FTPClient getFTPClient(String ftpHost, String ftpUserName, String ftpPassword, int ftpPort) {
        FTPClient ftpClient = new FTPClient();
        //ftpClient.setControlEncoding("GBK"); // 传输的字符编码（防止乱码）,自带的编码是ISO-8859-1,一般不会出现乱码
        //超时时间（防止僵死）
        //ftpClient.setDataTimeout(1000*60);
        //ftpClient.setDefaultTimeout(1000*60);
        //工作流的大小
        //ftpClient.setBufferSize(1024*4);
        //主被动模式（应对FTP服务器的相关安全设置）
        ftpClient.enterLocalPassiveMode();
        //ftpClient.enterLocalActiveMode();
        try {
            ftpClient.connect(ftpHost, ftpPort);  // 连接FTP服务器
            if(ftpClient.isConnected()) {
                //使用用户名和密码登录
                if(ftpClient.login(ftpUserName, ftpPassword)) {
                    //判断FTP连接是否可用，源码中是通过判断ReplyCode值（200=< reply <300)
                    if(FTPReply.isPositiveCompletion(ftpClient.getReplyCode())) {
                        logger.info("FTP连接成功。");
                        System.out.println("FTP登录成功,ftpHost: ftp:/"+ftpClient.getRemoteAddress());
                        ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE);
                    }
                }else {
                    logger.info("未连接到FTP，用户名或密码错误。");
                    ftpClient.disconnect();
                }
            }
        } catch (SocketException e) {
            e.printStackTrace();
            logger.info("FTP的IP地址可能错误，请正确配置。");
        } catch (IOException e) {
            e.printStackTrace();
            logger.info("FTP的端口错误,请正确配置。");
        }
        return ftpClient;
    }

    /**
     * 上传文件
     * @param ftpHost FTP服务器地址
     * @param ftpUserName 登录FTP服务器用户名
     * @param ftpPassword 登录FTP服务器密码
     * @param ftpPort FTP服务器端口
     * @param ftpPath 上传到FTP服务器的指定目录
     * @param filename 上传的文件名
     * @param input 文件输入流
     * @return 成功返回true，否则返回false
     */
    public static boolean uploadFile(String ftpHost, String ftpUserName, String ftpPassword, int ftpPort, String ftpPath, String filename, InputStream input) {
        boolean result = false;
        FTPClient ftpClient = getFTPClient(ftpHost, ftpUserName, ftpPassword, ftpPort);
        try {
            int reply;
            reply = ftpClient.getReplyCode(); //用户名密码错误时,值是530

            if (!FTPReply.isPositiveCompletion(reply)) { //判断是否成功登录
                //ftpClient.disconnect(); //用户名密码错误时报空指针,是因为在用户名密码不正确时，在上面已执行disconnect操作
                return result;
            }

            ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE);
            ftpClient.makeDirectory(ftpPath); //目录不存在则创建目录
            ftpClient.changeWorkingDirectory(ftpPath); //切换到要上传的目录
            //编码文件名，支持中文文件名
            filename = new String(filename.getBytes("GBK"), FTP.DEFAULT_CONTROL_ENCODING);
            //上传文件
            if (!ftpClient.storeFile(filename, input)) {
                System.out.println("文件已存在"); //应该是判断文件是否已存在服务器上
                return result;
            }
            input.close();
            ftpClient.logout();
            result = true;
        } catch (IOException e) {
            e.printStackTrace();
        } catch (NullPointerException e){
            e.printStackTrace();
        } finally {
            if (ftpClient.isConnected()) {
                try {
                    ftpClient.disconnect();
                } catch (IOException e) {}
            }
        }
        return result;
    }

    public static void main(String[] args) {
        String ftpHost = "192.168.0.105";
        String ftpUserName = "yly";
        String ftpPassword = "Yly@123";
        int ftpPort = 21;
        //String ftpPath = "";  //目录名， ""表示根目录
        String ftpPath = "";  //目录名最好是英文，中文目录暂时还未成功上传
        String fileName = "fz.py"; //要上传的文件名

        //上传文件
        try{
            FileInputStream in=new FileInputStream(new File("D:\\" + fileName)); //要上传的文件所在的目录，这里放的是D盘的根目录下
            Boolean result = FtpUploadFile.uploadFile(ftpHost, ftpUserName,  ftpPassword, ftpPort, ftpPath, fileName, in);
            if(result){
                System.out.println(fileName+"文件上传成功");
            }else{
                System.out.println(fileName+"文件上传失败");
            }
        } catch (Exception e){
            e.printStackTrace();
        }
    }
}

 src/main/java/org/springblade/common/utils/FtpUtil.java

New file
@@ -0,0 +1,296 @@
package org.springblade.common.utils;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.commons.net.ftp.FTP;
import org.apache.commons.net.ftp.FTPClient;
import org.apache.commons.net.ftp.FTPReply;

import java.io.*;
import java.net.SocketException;

/**
 * ftp工具类
 * @author lijj
 */

public class FtpUtil {

    private final static Log logger = LogFactory.getLog(FtpUtil.class);
    /** 本地字符编码 */
    private static String LOCAL_CHARSET = "GBK";

    // FTP协议里面，规定文件名编码为iso-8859-1
    private static String SERVER_CHARSET = "ISO-8859-1";

    /**
     * 获取FTPClient对象
     *
     * @param ftpHost
     *            FTP主机服务器
     *
     * @param ftpPassword
     *            FTP 登录密码
     *
     * @param ftpUserName
     *            FTP登录用户名
     *
     * @param ftpPort
     *            FTP端口 默认为21
     *
     * @return
     */
    public static FTPClient getFTPClient(String ftpHost, int ftpPort, String ftpUserName, String ftpPassword) {
        FTPClient ftpClient = null;
        try {
            ftpClient = new FTPClient();
            ftpClient.connect(ftpHost, ftpPort);// 连接FTP服务器
            ftpClient.login(ftpUserName, ftpPassword);// 登陆FTP服务器
            if (!FTPReply.isPositiveCompletion(ftpClient.getReplyCode())) {
                logger.info("未连接到FTP，用户名或密码错误。");
                ftpClient.disconnect();
            } else {
                logger.info("FTP连接成功。");
            }
        } catch (SocketException e) {
            e.printStackTrace();
            logger.info("FTP的IP地址可能错误，请正确配置。");
        } catch (IOException e) {
            e.printStackTrace();
            logger.info("FTP的端口错误,请正确配置。");
        }
        return ftpClient;
    }

    /**
     * 从FTP服务器下载文件
     *
     * @param ftpHost FTP IP地址
     *
     * @param ftpUserName FTP 用户名
     *
     * @param ftpPassword FTP用户名密码
     *
     * @param ftpPort FTP端口
     *
     * @param ftpPath FTP服务器中文件所在路径 格式： ftptest/aa
     *
     * @param localPath 下载到本地的位置 格式：H:/download
     *
     * @param fileName 文件名称
     */
    public static void downloadFtpFile(String ftpHost, String ftpUserName, String ftpPassword, int ftpPort,
                                       String ftpPath, String localPath, String fileName) {

        FTPClient ftpClient = null;

        try {
            ftpClient = getFTPClient(ftpHost, ftpPort, ftpUserName, ftpPassword);
            // 设置上传文件的类型为二进制类型
            if (FTPReply.isPositiveCompletion(ftpClient.sendCommand("OPTS UTF8", "ON"))) {// 开启服务器对UTF-8的支持，如果服务器支持就用UTF-8编码，否则就使用本地编码（GBK）.
                LOCAL_CHARSET = "UTF-8";
            }
            ftpClient.setControlEncoding(LOCAL_CHARSET);
            ftpClient.enterLocalPassiveMode();// 设置被动模式
            ftpClient.setFileType(FTP.BINARY_FILE_TYPE);// 设置传输的模式
            // 上传文件
            //对中文文件名进行转码，否则中文名称的文件下载失败
            String fileNameTemp = new String(fileName.getBytes(LOCAL_CHARSET), SERVER_CHARSET);
            ftpClient.changeWorkingDirectory(ftpPath);

            InputStream retrieveFileStream = ftpClient.retrieveFileStream(fileNameTemp);

            // 第一种方式下载文件(推荐)
              //File localFile = new File(localPath + File.separatorChar + fileName);
              //OutputStream os = new FileOutputStream(localFile);
              //ftpClient.retrieveFile(fileName, os); os.close();


            // 第二种方式下载：将输入流转成字节，再生成文件，这种方式方便将字节数组直接返回给前台jsp页面
            byte[] input2byte = input2byte(retrieveFileStream);
            byte2File(input2byte, localPath, fileName);

            if(null != retrieveFileStream){
                retrieveFileStream.close();
            }
        } catch (FileNotFoundException e) {
            logger.error("没有找到" + ftpPath + "文件");
            e.printStackTrace();
        } catch (SocketException e) {
            logger.error("连接FTP失败.");
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
            logger.error("文件读取错误。");
            e.printStackTrace();
        } finally {

            if (ftpClient.isConnected()) {
                try {
                    //退出登录
                    ftpClient.logout();
                    //关闭连接
                    ftpClient.disconnect();
                } catch (IOException e) {
                }
            }
        }
    }


    public static boolean uploadFile(String ftpHost, int ftpPort, String ftpUserName, String ftpPassword,
                                     String basePath, String filePath, String filename, InputStream input) {
        boolean result = false;
        FTPClient ftpClient = null;
        try {
            int reply;
            ftpClient = getFTPClient(ftpHost, ftpPort, ftpUserName, ftpPassword);
            reply = ftpClient.getReplyCode();
            if (!FTPReply.isPositiveCompletion(reply)) {
                ftpClient.disconnect();
                return result;
            }
            // 切换到上传目录
            if (!ftpClient.changeWorkingDirectory(basePath + filePath)) {
                // 如果目录不存在创建目录
                String[] dirs = filePath.split("/");
                String tempPath = basePath;
                for (String dir : dirs) {
                    if (null == dir || "".equals(dir))
                        continue;
                    tempPath += "/" + dir;
                    if (!ftpClient.changeWorkingDirectory(tempPath)) {
                        if (!ftpClient.makeDirectory(tempPath)) {
                            return result;
                        } else {
                            ftpClient.changeWorkingDirectory(tempPath);
                        }
                    }
                }
            }
            // 设置上传文件的类型为二进制类型
            if (FTPReply.isPositiveCompletion(ftpClient.sendCommand("OPTS UTF8", "ON"))) {// 开启服务器对UTF-8的支持，如果服务器支持就用UTF-8编码，否则就使用本地编码（GBK）.
                LOCAL_CHARSET = "UTF-8";
            }
            ftpClient.setControlEncoding(LOCAL_CHARSET);
            ftpClient.enterLocalPassiveMode();// 设置被动模式
            ftpClient.setFileType(FTP.BINARY_FILE_TYPE);// 设置传输的模式
            // 上传文件
            filename = new String(filename.getBytes(LOCAL_CHARSET), SERVER_CHARSET);
            if (!ftpClient.storeFile(filename, input)) {
                return result;
            }

            if(null != input){
                input.close();
            }

            result = true;
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (ftpClient.isConnected()) {
                try {
                    //退出登录
                    ftpClient.logout();
                    //关闭连接
                    ftpClient.disconnect();
                } catch (IOException ioe) {
                }
            }
        }
        return result;
    }


    public static boolean deleteFile(String ftpHost, int ftpPort, String ftpUserName, String ftpPassword, String pathname,
                                     String filename) {
        boolean flag = false;
        FTPClient ftpClient = new FTPClient();
        try {
            ftpClient = getFTPClient(ftpHost, ftpPort, ftpUserName, ftpPassword);
            // 验证FTP服务器是否登录成功
            int replyCode = ftpClient.getReplyCode();
            if (!FTPReply.isPositiveCompletion(replyCode)) {
                return flag;
            }
            // 切换FTP目录
            ftpClient.changeWorkingDirectory(pathname);
            // 设置上传文件的类型为二进制类型
            if (FTPReply.isPositiveCompletion(ftpClient.sendCommand("OPTS UTF8", "ON"))) {// 开启服务器对UTF-8的支持，如果服务器支持就用UTF-8编码，否则就使用本地编码（GBK）.
                LOCAL_CHARSET = "UTF-8";
            }
            ftpClient.setControlEncoding(LOCAL_CHARSET);
            ftpClient.enterLocalPassiveMode();// 设置被动模式
            ftpClient.setFileType(FTP.BINARY_FILE_TYPE);// 设置传输的模式
            //对中文名称进行转码
            filename = new String(filename.getBytes(LOCAL_CHARSET), SERVER_CHARSET);
            ftpClient.dele(filename);
            flag = true;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (ftpClient.isConnected()) {
                try {
                    //退出登录
                    ftpClient.logout();
                    //关闭连接
                    ftpClient.disconnect();
                } catch (IOException e) {
                }
            }
        }
        return flag;
    }

    // 将字节数组转换为输入流
    public static final InputStream byte2Input(byte[] buf) {
        return new ByteArrayInputStream(buf);
    }

    // 将输入流转为byte[]
    public static final byte[] input2byte(InputStream inStream) throws IOException {
        ByteArrayOutputStream swapStream = new ByteArrayOutputStream();
        byte[] buff = new byte[100];
        int rc = 0;
        while ((rc = inStream.read(buff, 0, 100)) > 0) {
            swapStream.write(buff, 0, rc);
        }
        byte[] in2b = swapStream.toByteArray();
        return in2b;
    }

    // 将byte[]转为文件
    public static void byte2File(byte[] buf, String filePath, String fileName) {
        BufferedOutputStream bos = null;
        FileOutputStream fos = null;
        File file = null;
        try {
            File dir = new File(filePath);
            if (!dir.exists() && dir.isDirectory()) {
                dir.mkdirs();
            }
            file = new File(filePath + File.separator + fileName);
            fos = new FileOutputStream(file);
            bos = new BufferedOutputStream(fos);
            bos.write(buf);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (bos != null) {
                try {
                    bos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

 src/main/java/org/springblade/common/utils/MysqlCenlint.java

New file
@@ -0,0 +1,50 @@
package org.springblade.common.utils;


import java.io.File;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;

public class MysqlCenlint {

    /**
     * 连接mysql数据库 新增
     * @param sql
     */
    public static void inster(String sql) {
        try {
            int ColumnCount;
            //int RowCount;
            String driver = "com.mysql.jdbc.Driver";
            String url = "jdbc:mysql://223.82.109.183:2083/zhba"; //换成要连接的数据库信息
            String user = "root";
            String password = "zhba0728";
            Class.forName ( driver );
            Connection conn = (Connection) DriverManager.getConnection ( url, user, password );
            if (!conn.isClosed ()) {
                System.out.println ( "数据库连接成功：" );
                String sqls = sql; //sql
                PreparedStatement ps = conn.prepareStatement ( sqls );
                boolean execute = ps.execute();
                ps.close ();
                conn.close ();
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace ();
        } catch (SQLException e) {
            e.printStackTrace ();
        }
    }

    /**
     * 删除本地文件
     */
    public  static  void delete(){
        File file = new File("D:\\anbao\\sql.json");
        if (file.isFile() && file.exists()) {
            file.delete();
        }
    }
}

 src/main/java/org/springblade/common/utils/OutJson.java

New file
@@ -0,0 +1,141 @@
package org.springblade.common.utils;

import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;
import java.io.Writer;

public class OutJson {
    /**
     * 生成.json格式文件
     */
    public static boolean createJsonFile(String jsonString, String filePath, String fileName) {
        // 标记文件生成是否成功
        boolean flag = true;

        // 拼接文件完整路径
        String fullPath = filePath + File.separator + fileName + ".json";

        // 生成json格式文件
        try {
            // 保证创建一个新文件
            File file = new File(fullPath);
            if (!file.getParentFile().exists()) { // 如果父目录不存在，创建父目录
                file.getParentFile().mkdirs();
            }
            if (file.exists()) { // 如果已存在,删除旧文件
                file.delete();
            }
            file.createNewFile();

            // 格式化json字符串
            jsonString = OutJson.formatJson(jsonString);

            // 将格式化后的字符串写入文件
            Writer write = new OutputStreamWriter(new FileOutputStream(file), "UTF-8");
            write.write(jsonString);
            write.flush();
            write.close();
        } catch (Exception e) {
            flag = false;
            e.printStackTrace();
        }

        // 返回是否成功的标记
        return flag;
    }
    /**
     * 单位缩进字符串。
     */
    private static String SPACE = "   ";

    /**
     * 返回格式化JSON字符串。
     *
     * @param json 未格式化的JSON字符串。
     * @return 格式化的JSON字符串。
     */
    public static String formatJson(String json) {
        StringBuffer result = new StringBuffer();

        int length = json.length();
        int number = 0;
        char key = 0;

        // 遍历输入字符串。
        for (int i = 0; i < length; i++) {
            // 1、获取当前字符。
            key = json.charAt(i);

            // 2、如果当前字符是前方括号、前花括号做如下处理：
            if ((key == '[') || (key == '{')) {
                // （1）如果前面还有字符，并且字符为“：”，打印：换行和缩进字符字符串。
                if ((i - 1 > 0) && (json.charAt(i - 1) == ':')) {
                    result.append('\n');
                    result.append(indent(number));
                }

                // （2）打印：当前字符。
                result.append(key);

                // （3）前方括号、前花括号，的后面必须换行。打印：换行。
                result.append('\n');

                // （4）每出现一次前方括号、前花括号；缩进次数增加一次。打印：新行缩进。
                number++;
                result.append(indent(number));

                // （5）进行下一次循环。
                continue;
            }

            // 3、如果当前字符是后方括号、后花括号做如下处理：
            if ((key == ']') || (key == '}')) {
                // （1）后方括号、后花括号，的前面必须换行。打印：换行。
                result.append('\n');

                // （2）每出现一次后方括号、后花括号；缩进次数减少一次。打印：缩进。
                number--;
                result.append(indent(number));

                // （3）打印：当前字符。
                result.append(key);

                // （4）如果当前字符后面还有字符，并且字符不为“，”，打印：换行。
                if (((i + 1) < length) && (json.charAt(i + 1) != ',')) {
                    result.append('\n');
                }

                // （5）继续下一次循环。
                continue;
            }

            // 4、如果当前字符是逗号。逗号后面换行，并缩进，不改变缩进次数。
            if ((key == ',')) {
                result.append(key);
                result.append('\n');
                result.append(indent(number));
                continue;
            }

            // 5、打印：当前字符。
            result.append(key);
        }

        return result.toString();
    }

    /**
     * 返回指定次数的缩进字符串。每一次缩进三个空格，即SPACE。
     *
     * @param number 缩进次数。
     * @return 指定缩进次数的字符串。
     */
    private static String indent(int number) {
        StringBuffer result = new StringBuffer();
        for (int i = 0; i < number; i++) {
            result.append(SPACE);
        }
        return result.toString();
    }
}

 src/main/java/org/springblade/modules/information/controller/InformationController.java

@@ -24,6 +24,8 @@

import org.springblade.common.cache.DictCache;
import org.springblade.common.enums.DictEnum;
import org.springblade.common.utils.FtpUtil;
import org.springblade.common.utils.MysqlCenlint;
import org.springblade.core.cache.utils.CacheUtil;
import org.springblade.core.mp.support.Condition;
import org.springblade.core.mp.support.Query;
@@ -47,7 +49,14 @@
import org.springblade.modules.information.service.IInformationService;
import org.springblade.core.boot.ctrl.BladeController;
import springfox.documentation.annotations.ApiIgnore;
import java.sql.*;
import java.sql.DriverManager; //需要这个jar包 mysql-connector-java-5.1.49.jar
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;

import java.io.*;
import java.util.*;

import static org.springblade.core.cache.constant.CacheConstant.SYS_CACHE;
@@ -925,4 +934,65 @@
        return R.data(lists);
    }

//    public static void main(String[] args) throws Exception {
//        //ftp服务器IP地址
//        String ftpHost = "192.168.0.105";
//        //ftp服务器端口
//        int ftpPort = 21;
//        //ftp服务器用户名
//        String ftpUserName = "yly";
//        //ftp服务器密码
//        String ftpPassword = "Yly@123";
//        //ftp服务器路径
//        String ftpPath = "";
//        //本地路径
//        String localPath = "D:\\anbao";
//        //文件名
//        String fileName = "sql.json";
//        FtpUtil.downloadFtpFile(ftpHost, ftpUserName, ftpPassword, ftpPort, ftpPath, localPath, fileName);
//        String s = TestJson();
//        String sql = stringReplace(s);
//        MysqlCenlint.inster(sql);
//        MysqlCenlint.delete();
//    }
    public static String stringReplace(String str) {
        //去掉" "号
        String strs= str.replace("\"", "");
        return strs ;

    }
    public static String TestJson(){
        File file = new File("D:\\anbao\\sql.json");
        StringBuilder localStrBulider = new StringBuilder();
        if(file.isFile() && file.exists()) {
            try {
                InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream(file), "utf-8");
                BufferedReader bufferReader = new BufferedReader(inputStreamReader);
                String lineStr = null;
                try {
                    while((lineStr = bufferReader.readLine()) != null) {
                        localStrBulider.append(lineStr);
                    }
                    bufferReader.close();
                    inputStreamReader.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    System.out.println("file read error!");
                    e.printStackTrace();
                }
            } catch (UnsupportedEncodingException e) {
                // TODO Auto-generated catch block
                System.out.println("file catch unsupported encoding!");
                e.printStackTrace();
            } catch (FileNotFoundException e) {
                // TODO Auto-generated catch block
                System.out.println("file not found!");
                e.printStackTrace();
            }
        }else {
            System.out.println("file is not a file or file is not existing!");
        }
        return  localStrBulider.toString();
    }

}

 src/main/java/org/springblade/modules/record/entity/Record.java

@@ -149,5 +149,10 @@
    private Integer id;
    private String deptid;
    private String examinetime;
    private String representativecell;
    private String contacts;
    private String contactscell;
    private String approve;


}

 src/main/java/org/springblade/modules/record/mapper/RecordMapper.xml

@@ -25,6 +25,10 @@
        <result column="officetime" property="officetime"/>
        <result column="deptid" property="deptid"/>
        <result column="examinetime" property="examinetime"/>
        <result column="representativecell" property="representativecell"/>
        <result column="contacts" property="contacts"/>
        <result column="contactscell" property="contactscell"/>
        <result column="approve" property="approve"/>
    </resultMap>



 src/main/java/org/springblade/modules/recordk/entity/Recordk.java

@@ -147,5 +147,9 @@
    @TableId(value = "id", type = IdType.AUTO)
    private Integer id;
    private String deptid;
    private String representativecell;
    private String contacts;
    private String contactscell;
    private String approve;

}

 src/main/java/org/springblade/modules/recordk/mapper/RecordkMapper.xml

@@ -24,6 +24,10 @@
        <result column="offices" property="offices"/>
        <result column="officetime" property="officetime"/>
        <result column="deptid" property="deptid"/>
        <result column="representativecell" property="representativecell"/>
        <result column="contacts" property="contacts"/>
        <result column="contactscell" property="contactscell"/>
        <result column="approve" property="approve"/>
    </resultMap>



 src/main/java/org/springblade/modules/revoke/entity/Revoke.java

@@ -139,4 +139,8 @@
    @DateTimeFormat(pattern = "yyyy-MM-dd")
    private Date ctime;
    private String deptid;
    private String representativecell;
    private String contacts;
    private String contactscell;
    private String approve;
}

 src/main/java/org/springblade/modules/revoke/mapper/RevokeMapper.xml

@@ -23,6 +23,10 @@
        <result column="reason" property="reason"/>
        <result column="ctime" property="ctime"/>
        <result column="deptid" property="deptid"/>
        <result column="representativecell" property="representativecell"/>
        <result column="contacts" property="contacts"/>
        <result column="contactscell" property="contactscell"/>
        <result column="approve" property="approve"/>
    </resultMap>