Java工具代码

 

RSAUtil

依赖

    <dependency>
      <groupId>org.bouncycastle</groupId>
      <artifactId>bcprov-jdk15on</artifactId>
      <version>1.68</version>
    </dependency>

工具类代码

package com.pm.util;

import org.apache.tomcat.util.codec.binary.Base64;
import org.springframework.util.StringUtils;

import javax.crypto.Cipher;
import java.io.UnsupportedEncodingException;
import java.math.BigInteger;
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.security.*;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.util.HashMap;
import java.util.Map;

/**
 * 备注，解密前台公钥加密的数据，请调用decryptWithPrivate方法
 * 每次重启之后，都会生成一个一对新的公私钥
 */
public class RSAUtil {

    //秘钥大小
    private static final int KEY_SIZE = 1024;

    //后续放到常量类中去
    public static final String PRIVATE_KEY = "privateKey";
    public static final String PUBLIC_KEY = "publicKey";

    private static KeyPair keyPair;

    private static Map<String, String> rsaMap;

    private static org.bouncycastle.jce.provider.BouncyCastleProvider bouncyCastleProvider = null;

    //BouncyCastleProvider内的方法都为静态方法，GC不会回收
    public static synchronized org.bouncycastle.jce.provider.BouncyCastleProvider getInstance() {
        if (bouncyCastleProvider == null) {
            bouncyCastleProvider = new org.bouncycastle.jce.provider.BouncyCastleProvider();
        }
        return bouncyCastleProvider;
    }

    //生成RSA，并存放
    static {
        try {
            //通过以下方法，将每次New一个BouncyCastleProvider，可能导致的内存泄漏
   /*         Provider provider =new org.bouncycastle.jce.provider.BouncyCastleProvider();
            Security.addProvider(provider);
            KeyPairGenerator generator = KeyPairGenerator.getInstance("RSA", provider);*/
            //解决方案
            KeyPairGenerator generator = KeyPairGenerator.getInstance("RSA", getInstance());
            SecureRandom random = new SecureRandom();
            generator.initialize(KEY_SIZE, random);
            keyPair = generator.generateKeyPair();
            //将公钥和私钥存放，登录时会不断请求获取公钥
            //建议放到redis的缓存中，避免在分布式场景中，出现拿着server1的公钥去server2解密的问题
            storeRSA();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
    }

    /**
     * 将RSA存入缓存
     */
    private static void storeRSA() {
        rsaMap = new HashMap<String, String>();
        PublicKey publicKey = keyPair.getPublic();
        String publicKeyStr = new String(Base64.encodeBase64(publicKey.getEncoded()));
        rsaMap.put(PUBLIC_KEY, publicKeyStr);

        PrivateKey privateKey = keyPair.getPrivate();
        String privateKeyStr = new String(Base64.encodeBase64(privateKey.getEncoded()));
        rsaMap.put(PRIVATE_KEY, privateKeyStr);
    }

    /**
     * 私钥解密(解密前台公钥加密的密文)
     *
     * @param encryptText 公钥加密的数据
     * @return 私钥解密出来的数据
     * @throws Exception e
     */
    public static String decryptWithPrivate(String encryptText) throws Exception {
        if (StringUtils.isEmpty(encryptText)) {
            return null;
        }
        byte[] en_byte = Base64.decodeBase64(encryptText.getBytes());
        //可能导致内存泄漏问题
     /*   Provider provider = new org.bouncycastle.jce.provider.BouncyCastleProvider();
        Security.addProvider(provider);
        Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding", provider);*/
        Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding", getInstance());
        PrivateKey privateKey = keyPair.getPrivate();
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        byte[] res = cipher.doFinal(en_byte);
        return new String(res);
    }

    /**
     * java端 使用公钥加密(此方法暂时用不到)
     *
     * @param plaintext 明文内容
     * @return byte[]
     * @throws UnsupportedEncodingException e
     */
    public static byte[] encrypt(String plaintext) throws UnsupportedEncodingException {
        String encode = URLEncoder.encode(plaintext, "utf-8");
        RSAPublicKey rsaPublicKey = (RSAPublicKey) keyPair.getPublic();
        //获取公钥指数
        BigInteger e = rsaPublicKey.getPublicExponent();
        //获取公钥系数
        BigInteger n = rsaPublicKey.getModulus();
        //获取明文字节数组
        BigInteger m = new BigInteger(encode.getBytes());
        //进行明文加密
        BigInteger res = m.modPow(e, n);
        return res.toByteArray();

    }

    /**
     * java端 使用私钥解密(此方法暂时用不到)
     *
     * @param cipherText 加密后的字节数组
     * @return 解密后的数据
     * @throws UnsupportedEncodingException e
     */
    public static String decrypt(byte[] cipherText) throws UnsupportedEncodingException {
        RSAPrivateKey prk = (RSAPrivateKey) keyPair.getPrivate();
        // 获取私钥参数-指数/系数
        BigInteger d = prk.getPrivateExponent();
        BigInteger n = prk.getModulus();
        // 读取密文
        BigInteger c = new BigInteger(cipherText);
        // 进行解密
        BigInteger m = c.modPow(d, n);
        // 解密结果-字节数组
        byte[] mt = m.toByteArray();
        //转成String,此时是乱码
        String en = new String(mt);
        //再进行编码,最后返回解密后得到的明文
        return URLDecoder.decode(en, "UTF-8");
    }

    /**
     * 获取公钥
     *
     * @return 公钥
     */
    public static String getPublicKey() {
        return rsaMap.get(PUBLIC_KEY);
    }

    /**
     * 获取私钥
     *
     * @return 私钥
     */
    public static String getPrivateKey() {
        return rsaMap.get(PRIVATE_KEY);
    }

    public static void main(String[] args) throws UnsupportedEncodingException {
        System.out.println(RSAUtil.getPrivateKey());
        System.out.println(RSAUtil.getPublicKey());
        byte[] usernames = RSAUtil.encrypt("username");
        System.out.println(RSAUtil.decrypt(usernames));
    }
}

 

JSON

导包

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;

代码

/**
 * 格式化输出JSON字符串
 * @return 格式化后的JSON字符串
 */
private static String toPrettyFormat(String json) {
    JsonParser jsonParser = new JsonParser();
    JsonObject jsonObject = jsonParser.parse(json).getAsJsonObject();
    Gson gson = new GsonBuilder().setPrettyPrinting().create();
    return gson.toJson(jsonObject);
}

 

 日志

package com.jiajian.start.util;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.Marker;

import java.io.File;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * 封装日志工具
 *
 * @author jiajian
 * @date 2023/4/13 9:32
 */
public class MyLogger {

    private Logger logger;
    private String logDir = ".\\log\\";
    private String logPath = null;
    private String name;

    // 临时存储日志
    private List<String> logCache = new ArrayList<>();
    // 当前存在的写入线程
    private WriteThread writeThread = null;
    // 写入日志线程的刷新标志
    private boolean isFlush = false;
    // 文件写入工具
    private FileUtil fileUtil = new FileUtil();
    // 日期工具
    private DateUtil dateUtil = new DateUtil();
    // 字符串工具
    private StringUtil stringUtil = new StringUtil();

    /**
     * @Function: 初始化
     * @Param:
     * @Return:
    */
    public MyLogger(String name){
        this.name = name;
        logger = LoggerFactory.getLogger(name);
        // 创建当天日志的文件夹
        logDir = logDir + dateUtil.getFormatDate(new Date(),dateUtil.shortBarFormat) + "\\";
        File file = new File(logDir);
        if(!file.exists()){
            System.out.println("------------日志文件夹不存在，创建文件夹"+file.getAbsolutePath());
            file.mkdirs();
        }
        // 生成日志文件路径
        logPath = logDir + String.format("%s_%s.txt",name,dateUtil.getFormatDate(new Date(),1));
    }

    /**
     * @Function: 每次写入日志唤醒的文件写入线程，出现一条日志后，线程会等待两秒，两秒内出现新日志会刷新等待时间，两秒内没有新日志出现则写入日志
     * @Param:
     * @Return:
    */
    private class WriteThread extends Thread{

        @Override
        public void run() {
            super.run();
            // 第一次写入日志命令出现，开始计时
            long startTime = new Date().getTime();
            while (true){
                // 开始循环等待下一条消息到来或两秒时间结束
                if(isFlush){
                    // 新消息出现，刷新计时
                    startTime = new Date().getTime();
                    isFlush = false;
                    continue;
                }
                // 判断两秒时间是否结束
                long endTime = new Date().getTime();
                if(endTime - startTime > 2000){
                    break;
                }
            }
            // 两秒内未出现新日志，开始写入日志
            try {
                fileUtil.writeIntoFile(String.join("\n",logCache)+"\n",logPath);
                writeThread = null;
                isFlush = false;
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
    }

    /**
     * @Function: 添加日志，查看日志写入进程状态，调用日志写入进程
     * @Param:
     * @Return:
    */
    private void addLog(String s){
        // 将日志添加进缓存
        logCache.add(s);
        // 查看是否存在写入线程在等待
        if (null != writeThread){
            isFlush = true;
        }else {
            writeThread = new WriteThread();
            writeThread.start();
        }
    }

    /**
     * @Function: 组装info日志
     * @Param:
     * @Return:
    */
    private void i(String s){
        s = String.format("%s\tINFO\t%s\t:%s",
                dateUtil.getFormatDate(new Date(),5),
                name,
                s
                );
        addLog(s);
    }

    /**
     * @Function: 组装error日志
     * @Param:
     * @Return:
     */
    private void e(String s){
        s = String.format("%s\tERROR\t%s\t:%s",
                dateUtil.getFormatDate(new Date(),5),
                name,
                s
        );
        addLog(s);
    }

    /**
     * @Function: 组装debug日志
     * @Param:
     * @Return:
     */
    private void d(String s){
        s = String.format("%s\tDEBUG\t%s\t:%s",
                dateUtil.getFormatDate(new Date(),5),
                name,
                s
        );
        addLog(s);
    }

    /**
     * @Function: 组装track日志
     * @Param:
     * @Return:
     */
    private void t(String s){
        s = String.format("%s\tTRACK\t%s\t:%s",
                dateUtil.getFormatDate(new Date(),5),
                name,
                s
        );
        addLog(s);
    }

    /**
     * @Function: 组装warn日志
     * @Param:
     * @Return:
     */
    private void w(String s){
        s = String.format("%s\tWARN\t%s\t:%s",
                dateUtil.getFormatDate(new Date(),5),
                name,
                s
        );
        addLog(s);
    }

    public void trace(String s) {
        logger.trace(s);
        t(s);
    }

    public void trace(String s, Object... objects) {
        logger.trace(s,objects);
        t(stringUtil.parseFormatString(s,"{}",objects));
    }

    public void trace(String s, Throwable throwable) {
        logger.trace(s,throwable);
        t(s);
    }


    public void debug(String s) {
        logger.debug(s);
        d(s);
    }

    public void debug(String s, Object... objects) {
        logger.debug(s, objects);
        d(stringUtil.parseFormatString(s,"{}",objects));
    }

    public void debug(String s, Throwable throwable) {
        logger.debug(s, throwable);
        d(s);
    }

    public void info(String s) {
        logger.info(s);
        i(s);
    }

    public void info(String s, Object... objects) {
        logger.info(s, objects);
        i(stringUtil.parseFormatString(s,"{}",objects));
    }

    public void info(String s, Throwable throwable) {
        logger.info(s, throwable);
        i(s);
    }

    public void warn(String s) {
        logger.warn(s);
        w(s);
    }

    public void warn(String s, Object... objects) {
        logger.warn(s, objects);
        w(stringUtil.parseFormatString(s,"{}",objects));
    }

    public void warn(String s, Throwable throwable) {
        logger.warn(s, throwable);
        w(s);
    }

    public void error(String s) {
        logger.error(s);
        e(s);
    }

    public void error(String s, Object... objects) {
        logger.error(s, objects);
        e(stringUtil.parseFormatString(s,"{}",objects));
    }

    public void error(String s, Throwable throwable) {
        logger.error(s, throwable);
        e(s);
    }

}
 

字符串

package com.jiajian.start.util;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * TODO:
 *
 * @author jiajian
 * @date 2023/4/11 10:29
 */
public class StringUtil {

    List<String> uppers = Stream.iterate((int)'A',(x)->(x+1)).limit(26).
            map(x->String.valueOf((char) ((int)x))).collect(Collectors.toList());
    List<String> lowers = Stream.iterate((int)'a',(x)->(x+1)).limit(26).
            map(x->String.valueOf((char) ((int)x))).collect(Collectors.toList());
    List<String> numbers = Stream.iterate(0,(x)->x+1).limit(10).map(x->String.valueOf(x)).collect(Collectors.toList());

    /**
     * @Function: 将含有占位符的字符串的占位符转换为替换占位符后的字符串
     * @Param:
     * @Return:
    */
    public String parseFormatString(String sourceString,String format,Object...objects){
        sourceString = sourceString.replace(format,"%s");
        return String.format(sourceString,objects);
    }

    /**
     * 制造一个由数字，大小写字母组合成的字符串
     * [length]
     * @return java.lang.String
     * @throw
     */
    public String getRandomString(int length){
        ArrayList<String> results =  new ArrayList<>();
        Random random = new Random();
        // 随机字符源
        List<String> sources = new ArrayList<>();
        sources.addAll(uppers);
        sources.addAll(lowers);
        sources.addAll(numbers);
        for (int i = 0; i < length; i++) {
            int index = random.nextInt(62);
            results.add(sources.get(index));
        }
        return String.join("",results);
    }

    /**
     * @Param: 下划线规则字符串，是否首字母大写
     * @Function: 将下划线规则字符串转换为驼峰规则
     * @Return: 驼峰规则字符串
     */
    public String getHumpFromUnderLineString(String sourceString,boolean isFirstCharUpper){
        // 截断为几个单个字符串
        String[] stringArray = sourceString.split("_");
        int i = 1;
        if(isFirstCharUpper){
            // 如果首字母大写
            i = 0;
        }
        for (; i < stringArray.length; i++) {
            // 后续部分逐个大写首字母
            stringArray[i] = getFirstCharUp(stringArray[i]);
        }

        // 组装返回
        return String.join("",stringArray);
    }

    /**
     * @Param: 普通字符串
     * @Function: 将首字母大写
     * @Return: 首字母大写的对应字符串
     */
    public String getFirstCharUp(String sourceString){
        return sourceString.substring(0,1).toUpperCase() + sourceString.substring(1);
    }

    public static void main(String[] args) {
        StringUtil stringUtil = new StringUtil();
        // stringUtil.getRandomString(18);
        // System.out.println(stringUtil.getHumpFromUnderLineString("sjhs_hj_icds",true));;
    }
}

文件

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;

/**
 * 文件工具类
 *
 * @author jiajian
 * @date 2023/4/11 14:06
 */
public class FileUtil {
    /**
     * 将内容写进文件
     * [string]
     * @return void
     * @throw
     */
    public void writeIntoFile(String string,String targetPath) throws Exception{
        // 存储sql语句的文件
        File sqlFile = new File(targetPath);
        if (sqlFile.exists()){
            sqlFile.createNewFile();
        }
        // 写进文件
        try(BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(targetPath))){
            bufferedWriter.append(string);
            bufferedWriter.flush();
        }
    }
}

时间

import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * TODO:
 *
 * @author jiajian
 * @date 2023/4/12 17:28
 */
public class DateUtil {
    public final String[] format = new String[]{
            "yyyy/MM/dd",
            "yyyy-MM-dd",
            "yyyy/MM/dd HH:mm:ss",
            "yyyy-MM-dd HH:mm:ss",
            "yyyy/MM/dd HH:mm:ss.sss",
            "yyyy-MM-dd HH:mm:ss.sss"
    };

    public final int shortSlashFormat = 0;
    public final int shortBarFormat = 1;

    public final int normalSlashFormat = 2;
    public final int defaultFormat = 3;

    public final int normalBarFormat = 3;

    public final int longSlashFormat = 4;

    public final int longBarFormat = 5;

    /**
     * 返回指定时间格式的时间字符串
     * [date, format_index]
     * @return java.lang.String
     * @throw
     */
    public String getFormatDate(Date date, int formatIndex){
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat(format[formatIndex]);
        return simpleDateFormat.format(date);
    }

    /**
     * @Function: 将字符串解析为时间
     * @Param:
     * @Return:
    */
    public Date getDateFromString(String source,int formatIndex) throws Exception{
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat(format[formatIndex]);
        return simpleDateFormat.parse(source);
    }
}

数据库相关自动代码

自动程序一

https://gitee.com/losHill/tools.git

自动程序二

初始化代码生成代码：读取指定格式的表格表述表单，生成java bean、数据库建表语句等代码（额外的工具代码，非项目代码）

import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

import java.io.File;
import java.io.FileInputStream;
import java.lang.reflect.Method;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 工具类：解析的表格默认第一个字段为主键，且是唯一主键，类型为int
 *
 * @author jiajian
 * @date 2023/4/7 11:54
 */
public class ParseExcelToDb {
    private static String dataDir = "D:\\loshill\\blog\\document\\code_create\\";
    private static String excelPath = dataDir + "table_info.xlsx";
    private static String createSqlPath = dataDir + "create_sql\\";
    private static String insertSqlPath = dataDir + "insert_sql\\";
    private static String entityPath = dataDir + "entity\\";

    private static String daoPath = dataDir + "dao\\";

    private static String selectSqlPath = dataDir + "select_sql\\";

    private static String updateSqlPath = dataDir + "update_sql\\";

    private static String deleteSqlPath = dataDir + "delete_sql\\";

    static {
        File file = new File(createSqlPath);
        if(!file.exists()){
            file.mkdirs();
        }
        file = new File(insertSqlPath);
        if(!file.exists()){
            file.mkdirs();
        }
        file = new File(entityPath);
        if(!file.exists()){
            file.mkdirs();
        }
        file = new File(daoPath);
        if(!file.exists()){
            file.mkdirs();
        }
        file = new File(selectSqlPath);
        if(!file.exists()){
            file.mkdirs();
        }file = new File(updateSqlPath);
        if(!file.exists()){
            file.mkdirs();
        }
        file = new File(deleteSqlPath);
        if(!file.exists()){
            file.mkdirs();
        }

    }

    // 解析表格获取到的信息
    private static Map<String,ArrayList<String[]>> info = getInformationFromForm();

    // 操作文件的工具
    private FileUtil fileUtil = new FileUtil();
    // 操作字符串的工具
    private StringUtil stringUtil = new StringUtil();

    /**
     * @Function: 使用jdbcTemplate的dao模板
     * @Param:
     * @Return:
     */
    public void getDao() throws Exception{
        // 循环表格
        for (Map.Entry entry : info.entrySet()){
            String result = "";
            // 需要用到的信息
            // 下划线格式的表名
            String tableName = (String)entry.getKey();
            ArrayList<String[]> table = (ArrayList<String[]>)entry.getValue();
            String[] bineArray = table.get(0);
            List<String> javaBineArray = Arrays.stream(bineArray).map(x->
                            String.format("%s.get%s()",stringUtil.getHumpFromUnderLineString(tableName,false),stringUtil.getHumpFromUnderLineString(x,true))).
                    collect(Collectors.toList());
            List<String> bineList = new ArrayList<>(Arrays.asList(bineArray));
            // 主键
            String primaryKey = bineArray[0];

            //包导入
            result += String.format("package com.jiajian.start.dao;\n" +
                    "\n" +
                    "import com.jiajian.start.bean.%s;\n" +
                    "import org.springframework.beans.factory.annotation.Autowired;\n" +
                    "import org.springframework.jdbc.core.BeanPropertyRowMapper;\n" +
                    "import org.springframework.jdbc.core.JdbcTemplate;\n" +
                    "import org.springframework.stereotype.Repository;\n" +
                    "import java.util.List;\n" +
                    "\n" +
                    "/**\n" +
                    " * TODO:\n" +
                    " *\n" +
                    " * @author jiajian\n" +
                    " */\n",stringUtil.getHumpFromUnderLineString(tableName,true));

            // 类声明
            result += String.format("@Repository\n" +
                            "public class %sDao{\n",
                    stringUtil.getHumpFromUnderLineString(tableName,true));
            // jdbc注入
            result += "@Autowired\n" +
                    "\tJdbcTemplate jdbcTemplate;\n\n";
            // 注释
            result += "\t/**\n" +
                    "\t * @Function: 插入一条数据\n" +
                    "\t * @Param:\n" +
                    "\t * @Return:\n" +
                    "\t*/\n";

            // 插入方法
            result += String.format("\tpublic int insert(%s %s){\n",
                    stringUtil.getHumpFromUnderLineString(tableName,true),
                    stringUtil.getHumpFromUnderLineString(tableName,false));
            String[] questionMarks = new String[bineArray.length-1];
            Arrays.fill(questionMarks,"?");
            result += String.format("\t\tString insertSql = \"INSERT INTO `%s`(`%s`) values (%s) \";\n",
                    entry.getKey(),
                    String.join("`,`",bineList.subList(1, bineList.size())),
                    String.join(",",questionMarks));
            result += String.format("\t\tint result = jdbcTemplate.update(insertSql,%s);\n",
                    String.join(",",javaBineArray.subList(1, javaBineArray.size())));
            result += "\t\treturn result;\n\t}\n\n";


            // 使用确定主键插入方法
            // 注释
            result += "\t/**\n" +
                    "\t * @Function: 使用确定主键插入数据\n" +
                    "\t * @Param:\n" +
                    "\t * @Return:\n" +
                    "\t*/\n";

            result += String.format("\tpublic int insertWithPrimaryKey(%s %s){\n",
                    stringUtil.getHumpFromUnderLineString(tableName,true),
                    stringUtil.getHumpFromUnderLineString(tableName,false));
            questionMarks = new String[bineArray.length];
            Arrays.fill(questionMarks,"?");
            result += String.format("\t\tString insertSql = \"INSERT INTO `%s`(`%s`) values (%s) \";\n",
                    entry.getKey(),
                    String.join("`,`",bineList),
                    String.join(",",questionMarks));
            result += String.format("\t\tint result = jdbcTemplate.update(insertSql,%s);\n",
                    String.join(",",javaBineArray));
            result += "\t\treturn result;\n\t}\n\n";



            // 查找最大主键方法
            // 注释+方法声明
            result += "\t/**\n" +
                    "\t * @Function: 查询最大主键值\n" +
                    "\t * @Param:\n" +
                    "\t * @Return:\n" +
                    "\t*/\n" +
                    "\tpublic int selectMaxPrimaryKey(){\n";
            // 方法体
            result += String.format(
                    "\t\tString selectSql = \"select `%s` from `%s` order by `%s` desc limit 1\";\n" +
                    "\t\tint result = jdbcTemplate.queryForObject(selectSql, Integer.class);\n" +
                    "\t\treturn result;\n" +
                    "\t}\n\n\n",
                    primaryKey,
                    tableName,
                    primaryKey);


            // 删除方法
            result += String.format("\t/**\n" +
                    "\t * @Function: 根据主键删除一条数据\n" +
                    "\t * @Param: %s\n" +
                    "\t * @Return:\n" +
                    "\t*/\n",primaryKey);
            result += String.format("\tpublic int deleteBy%s(int %s){\n",
                    stringUtil.getHumpFromUnderLineString(primaryKey,true),
                    stringUtil.getHumpFromUnderLineString(primaryKey,false));
            result += String.format("\t\tString deleteSql = \"delete from `%s` where `%s`=?\";\n",
                    tableName,
                    stringUtil.getHumpFromUnderLineString(primaryKey,false));
            result += String.format("\t\tint result = jdbcTemplate.update(deleteSql,%s);\nreturn result;\n\t}\n\n",
                    stringUtil.getHumpFromUnderLineString(primaryKey,false));


            // 更新方法
            result += "\t/**\n" +
                    "\t * @Function: 更新\n" +
                    "\t * @Param:\n" +
                    "\t * @Return:\n" +
                    "\t*/\n";
            result += String.format("\tpublic int update(%s %s){\n",
                    stringUtil.getHumpFromUnderLineString(tableName,true),
                    stringUtil.getHumpFromUnderLineString(tableName,false));
            result += String.format("\t\tString updateSql = \"update `%s` set `%s`=? where `%s`=? \";\n",
                    entry.getKey(),
                    String.join("`=?,`",bineArray),
                    primaryKey);
            result += String.format("\t\tint result = jdbcTemplate.update(updateSql,%s,%s.get%s());\n",
                    String.join(",",javaBineArray),
                    stringUtil.getHumpFromUnderLineString(tableName,false),
                    stringUtil.getHumpFromUnderLineString(primaryKey,true));
            result += "\t\treturn result;\n\t}\n\n";

            // 查询单个
            result += "\t/**\n" +
                    "\t * @Function: 单条信息查询\n" +
                    "\t * @Param:\n" +
                    "\t * @Return:\n" +
                    "\t*/\n";
            result += String.format("\tpublic %s selectBy%s(int %s){\n",
                    stringUtil.getHumpFromUnderLineString(tableName,true),
                    stringUtil.getHumpFromUnderLineString(primaryKey,true),
                    stringUtil.getHumpFromUnderLineString(primaryKey,false));
            result += String.format("\t\tString selectSql = \"select `%s` from `%s` where %s=?\";\n",
                    String.join("`,`",bineArray),
                    tableName,
                    primaryKey);
            result += String.format("\t\t%s %s = jdbcTemplate.queryForObject(selectSql,new BeanPropertyRowMapper<%s>(%s.class),%s);\n",
                    stringUtil.getHumpFromUnderLineString(tableName,true),
                    stringUtil.getHumpFromUnderLineString(tableName,false),
                    stringUtil.getHumpFromUnderLineString(tableName,true),
                    stringUtil.getHumpFromUnderLineString(tableName,true),
                    stringUtil.getHumpFromUnderLineString(primaryKey,false));
            result += String.format("\t\treturn %s;\n\t}\n\n",
                    stringUtil.getHumpFromUnderLineString(tableName,false));

            // 查询多个
            result += "\t/**\n" +
                    "\t * @Function: 多条信息查询\n" +
                    "\t * @Param:\n" +
                    "\t * @Return:\n" +
                    "\t*/\n";
            result += String.format("\tpublic List<%s> selectAll(){\n",
                    stringUtil.getHumpFromUnderLineString(tableName,true));
            result += String.format("\t\tString selectSql = \"select `%s` from `%s`\";\n",
                    String.join("`,`",bineArray),
                    tableName);
            result += String.format("\t\tList<%s> %sList = jdbcTemplate.query(selectSql,new BeanPropertyRowMapper<%s>(%s.class));\n",
                    stringUtil.getHumpFromUnderLineString(tableName,true),
                    stringUtil.getHumpFromUnderLineString(tableName,false),
                    stringUtil.getHumpFromUnderLineString(tableName,true),
                    stringUtil.getHumpFromUnderLineString(tableName,true));
            result += String.format("\t\treturn %sList;\n\t}\n\n",
                    stringUtil.getHumpFromUnderLineString(tableName,false));

            // 类模板收尾
            result += "}\n\n\n\n";
            fileUtil.writeIntoFile(result,daoPath+entry.getKey()+".txt");
        }
    }

    /**
     * 生成表格的对应实体
     * []
     * @return void
     * @throw
     */
    public void getEntity() throws Exception{

        for (Map.Entry entry : info.entrySet()){
            String result = "";
            // 需要用到如下几个信息，字段名，字段类型，字段备注
            ArrayList<String[]> table = (ArrayList<String[]>)entry.getValue();
            String[] bineArray = table.get(0);
            String[] typeArray = table.get(1);
            String[] commentArray = table.get(6);

            // 实体名
            String sqlTableName = (String) entry.getKey();
            String tableName = stringUtil.getHumpFromUnderLineString(sqlTableName,true);

            // 导包
            result += "package com.jiajian.start.bean;\n" +
                    "\n" +
                    "import lombok.Data;\n" +
                    "import javax.persistence.Entity;\n" +
                    "\n" +
                    "/**\n" +
                    " * TODO:\n" +
                    " *\n" +
                    " * @author jiajian\n" +
                    " */\n";

            // 组装字符串
            result += String.format("@Data\n@Entity\npublic class %s {\n",tableName);

            // 循环获取信息
            for (int i = 0; i < bineArray.length; i++) {
                // 字段名
                String sqlBine = bineArray[i];
                // 替换_命名为驼峰规则
                String bine = stringUtil.getHumpFromUnderLineString(sqlBine,false);
                // 字段类型
                String mysqlType = typeArray[i];
                String type = "String";
                switch (mysqlType){
                    case "int":
                        type = "int";
                        break;
                }
                // 注释
                String comment = commentArray[i];
                // 组装实体成员变量
                result += String.format("\t// %s\n\tprivate %s %s;\n\n",comment,type,bine);
            }

            // 组装字符串收尾
            result += "}\n\n\n\n";

            fileUtil.writeIntoFile(result,entityPath+entry.getKey()+".txt");
        }
    }

    /**
     * 根据信息列表生成插入sql语句
     * []
     * @return void
     * @throw
     */
    public void getInsertSql() throws Exception{
        // 生成指定格式的时间字符串
        DateUtil dateUtil = new DateUtil();
        // 随机数
        Random random = new Random();

        // 循环解析信息，组装sql
        for (Map.Entry entry : info.entrySet()){
            String result = "";
            // 存储插入的值
            ArrayList<String> insertValue1 = new ArrayList<>();
            ArrayList<String> insertValue2 = new ArrayList<>();
            ArrayList<String> insertValue3 = new ArrayList<>();
            ArrayList<String[]> table = (ArrayList<String[]>)entry.getValue();
            // 自增长列表
            String[] increment = table.get(4);
            // 字段类型列表
            String[] typeList = table.get(1);
            // 字段列表
            String[] bineArray = table.get(0);

            // 根据类型为每个字段生成三个随机值
            for (int i = 0; i < typeList.length; i++){
                if("y".equals(increment[i])){
                    // 如果是自增长则设值为null
                    insertValue1.add("null");
                    insertValue2.add("null");
                    insertValue3.add("null");
                    continue;
                }

                String type = typeList[i];
                // 如果是枚举类型则插入指定值
                if(type.contains("enum")){
                    String[] ss = type.replace("enum","").replace("(","").
                            replace(")","").split(",");
                    // 为字段生成三个随机值
                    insertValue1.add(ss[random.nextInt(ss.length)]);
                    insertValue2.add(ss[random.nextInt(ss.length)]);
                    insertValue3.add(ss[random.nextInt(ss.length)]);
                    continue;
                }
                // 为字段生成三个随机值
                switch (type){
                    case "int":
                        insertValue1.add(String.valueOf(new Random().nextInt()));
                        insertValue2.add(String.valueOf(new Random().nextInt()));
                        insertValue3.add(String.valueOf(new Random().nextInt()));
                        break;
                    case "datetime":
                        insertValue1.add("\'" + dateUtil.getFormatDate(new Date(),3) + "\'");
                        insertValue2.add("\'" + dateUtil.getFormatDate(new Date(),3) + "\'");
                        insertValue3.add("\'" + dateUtil.getFormatDate(new Date(),3) + "\'");
                        break;
                    default:
                        insertValue1.add("\'" + stringUtil.getRandomString(16) + "\'");
                        insertValue2.add("\'" + stringUtil.getRandomString(16) + "\'");
                        insertValue3.add("\'" + stringUtil.getRandomString(16) + "\'");
                        break;
                }
            }
            // 组装sql语句
            result += String.format("INSERT INTO `%s` values (%s),(%s),(%s);\n\n\n",
                    entry.getKey(),String.join(",",insertValue1)
                    ,String.join(",",insertValue2)
                    ,String.join(",",insertValue3));

            fileUtil.writeIntoFile(result,insertSqlPath+entry.getKey()+".txt");
        }
    }

    /**
     * @Function: 生成jdbcTemplate使用的参数形式的sql语句使用模板
     * @Param:
     * @Return:
     */
    public void getDeleteSql() throws Exception{
        // 表格循环
        for (Map.Entry entry : info.entrySet()){
            String result = "";
            ArrayList<String[]> table = (ArrayList<String[]>)entry.getValue();
            String tableName = (String)entry.getKey();
            result += String.format("String deleteSql = \"delete from %s where =?\";\n",
                    tableName);
            result += String.format("int result = jdbcTemplate.update(deleteSql,param);\nreturn result;\n\n\n");

            fileUtil.writeIntoFile(result,deleteSqlPath+entry.getKey()+".txt");
        }
    }

    /**
     * @Param:
     * @Function: 解析信息生成修改sql
     * @Return:
     */
    public void getUpdateSql() throws Exception{

        // 循环信息组装sql
        for (Map.Entry entry : info.entrySet()){

            // 返回结果
            String result = "";
            ArrayList<String[]> table = (ArrayList<String[]>)entry.getValue();
            // 需要使用到的信息为字段名
            String[] bineArray = table.get(0);
            // 作为sql参数部分
            String tableName = stringUtil.getHumpFromUnderLineString((String) entry.getKey(),false);
            String[] javaBineArray = Arrays.stream(bineArray).map(x->String.format("%s.get%s()",tableName,stringUtil.getHumpFromUnderLineString(x,true))).toArray(String[]::new);
            // 将字段组合为语句
            result += String.format("String updateSql = \"update `%s` set `%s=? where =? \";\n",
                    entry.getKey(),
                    String.join("`=?,`",bineArray));
            result += String.format("int result = jdbcTemplate.update(updateSql,%s,whereparam);\n",
                    String.join(",",javaBineArray));
            result += "return result;\n\n\n";

            fileUtil.writeIntoFile(result,updateSqlPath+entry.getKey()+".txt");
        }
    }

    /**
     * @Param:
     * @Function: 通过解析信息获取查询语句
     * @Return:
     */
    public void getSelectSql() throws Exception{
        // 循环所有表格
        for (Map.Entry entry : info.entrySet()){
            String result = "";

            // 需要使用到的信息为字段名
            ArrayList<String[]> table = (ArrayList<String[]>)entry.getValue();
            String[] bineArray = table.get(0);
            // 循环所有字段获取mysql语句
            result += String.format("select `%s` from `%s` \n\n\n",String.join("`,`",bineArray),entry.getKey());

            fileUtil.writeIntoFile(result,selectSqlPath+entry.getKey()+".txt");
        }
    }

    /**
     * 将getInformationFromForm方法解析出来的信息组装为sql语句，存储到sqlPath中
     * [infoMap, sqlPath]
     * @return void
     * @throw
     */
    public void getCreateSql() throws Exception{
        for (Map.Entry entry : info.entrySet()){

            // 循环获取信息，生成sql语句
            String results = "";
            // 组装sql语句
            String createSql = String.format("CREATE TABLE IF NOT EXISTS `%s` (\n", entry.getKey());
            // 表字段信息
            ArrayList<String[]> tableInfo = (ArrayList<String[]>)entry.getValue();
            String[] bineList = tableInfo.get(0);
            String[] typeList = tableInfo.get(1);
            String[] defaultList = tableInfo.get(2);
            String[] noneAbleList = tableInfo.get(3);
            String[] incrementList = tableInfo.get(4);
            String[] primaryKeyList = tableInfo.get(5);
            String[] commentList = tableInfo.get(6);
            String primaryKey = "";
            for (int i = 0; i < bineList.length; i++) {
                // 判断是否存在默认值
                String default_;
                if ("".equals(defaultList[i])){
                    default_ = "";
                }else {
                    if ("\"-\"".equals(defaultList[i])){
                        default_ = "default " + "\"-\"";
                    }else {
                        default_ = "default " + defaultList[i];
                    }
                }
                // 是否可空
                String noneAble;
                if ("y".equals(noneAbleList[i])){
                    noneAble = "NULL";
                }else {
                    noneAble = "NOT NULL";
                }
                // 判断是否是主键
                if ("y".equals(primaryKeyList[i])){
                    primaryKey = bineList[i];
                }
                // 是否是自增长
                String increment = "";
                if("y".equals(incrementList[i])){
                    increment = "AUTO_INCREMENT";
                }
                // 组装sql语句
                String temp = String.format("\t`%s` %s %s %s %s COMMENT \'%s\',\n",bineList[i],typeList[i],default_,noneAble,increment,commentList[i]);
                createSql += temp;
            }
            //建表语句的剩余部分，默认至少存在一个主键
            createSql += String.format("\tPRIMARY KEY (`%s`)\n" +
                    ")ENGINE=INNODB DEFAULT CHARSET=GBK;",primaryKey);

            // 组装写进文件的字符串
            results += String.format("%s\n\n", createSql);

            fileUtil.writeIntoFile(results,createSqlPath+entry.getKey()+".txt");
        }
    }

    /**
     * 读取的表格后缀只支持xlsx
     * 逐个读取表格内容后组合后返回，返回格式：{"表名":[[0字段],[1字段类型],[2默认值],[3可空属性],[4自增长],[5主键],[6注释]],"表名":[[],...]}
     * []
     * @return java.util.Map<java.lang.String,java.util.ArrayList<java.lang.String[]>>
     * @throw
     */
    private static Map<String,ArrayList<String[]>> getInformationFromForm() {
        // 返回结果
        Map<String,ArrayList<String[]>> results = new HashMap<>();
        // 获取表格文件
        try(FileInputStream fileInputStream = new FileInputStream(excelPath);
            XSSFWorkbook xssfWorkbook = new XSSFWorkbook(fileInputStream)
        ){
            // 循环读取表格
            for (int i = 0; i < xssfWorkbook.getNumberOfSheets(); i++) {
                Sheet sheet = xssfWorkbook.getSheetAt(i);
                // 获取表格内部的字段数，包含在sheet名称后面部分，通过-分割
                // 字段列表
                String[] nameAndNum = sheet.getSheetName().split("-");
                int rowNum = Integer.parseInt(nameAndNum[1]);
                System.out.println("读取：" + nameAndNum[0] + "  字段数：" + nameAndNum[1]);

                // 存储本表格包含的表的所有信息的列表
                ArrayList<String[]> tableList = new ArrayList<>();
                // 字段列表
                String[] bineList = new String[rowNum];
                tableList.add(bineList);
                // 字段类型列表
                String[] typeList = new String[rowNum];
                tableList.add(typeList);
                // 默认值列表
                String[] defaultList = new String[rowNum];
                tableList.add(defaultList);
                // 可空属性列表
                String[] noneAbleList = new String[rowNum];
                tableList.add(noneAbleList);
                // 自增长列表
                String[] incrementList = new String[rowNum];
                tableList.add(incrementList);
                // 主键字段列表
                String[] primaryKeyList = new String[rowNum];
                tableList.add(primaryKeyList);
                // 注释列表
                String[] commentList = new String[rowNum];
                tableList.add(commentList);

                // 第一行为标题行，从第二行开始读取
                for (int j = 1; j <= Integer.parseInt(nameAndNum[1]); j++) {
                    // 获取行
                    Row row = sheet.getRow(j);
                    // 第一列——字段
                    Cell cell0 = row.getCell(0);
                    String bine;
                    if (null == cell0){
                        bine = "";
                    }else {
                        bine = cell0.getStringCellValue();
                    }
                    bineList[j - 1] = bine;
                    // 第二列——字段类型
                    Cell cell1 = row.getCell(1);
                    String type;
                    if (null == cell1){
                        type = "";
                    }else {
                        type = cell1.getStringCellValue();
                    }
                    typeList[j-1] = type;
                    // 第三列——默认值
                    Cell cell2 = row.getCell(2);
                    String default_;
                    if (cell2 == null || cell2.getCellTypeEnum() == CellType._NONE || cell2.getCellTypeEnum() == CellType.BLANK){
                        default_ = "";
                    }else {
                        if("int".equals(type) || "decimal".equals(type)){
                            //如果是小数则读取数值，否则读取字符串
                            default_ = String.valueOf( (int) cell2.getNumericCellValue());
                        }else {
                            default_ = cell2.getStringCellValue().replace("'","");
                        }
                    }
                    defaultList[j-1] = default_;
                    // 第四列——是否可空
                    Cell cell3 = row.getCell(3);
                    String noneAble;
                    if (null == cell3){
                        noneAble = "";
                    }else {
                        noneAble = cell3.getStringCellValue();
                    }
                    noneAbleList[j-1] = noneAble;
                    // 第五列——自增长
                    Cell cell4 = row.getCell(4);
                    String increment;
                    if (null == cell4){
                        increment = "";
                    }else {
                        increment = cell4.getStringCellValue();
                    }
                    incrementList[j-1] = increment;
                    // 第六列——键类型
                    Cell cell5 = row.getCell(5);
                    String primaryKey;
                    if (null == cell5){
                        primaryKey = "";
                    }else {
                        primaryKey = cell5.getStringCellValue();
                    }
                    primaryKeyList[j-1] = primaryKey;
                    // 第七列——注释
                    Cell cell6 = row.getCell(6);
                    String comment;
                    if (null == cell6){
                        comment = "";
                    }else {
                        comment = cell6.getStringCellValue();
                    }
                    commentList[j-1] = comment;
                }

                // 将表格信息加入返回结果
                results.put(nameAndNum[0],tableList);
            }
        }catch (Exception e){
            e.printStackTrace();
        }


        return results;
    }

    /**
     * 将一个路径的文件名部分去除，返回目录和文件名
     * 通过//切割路径实现分离目录和文件名的目的
     * [path]
     * @return java.lang.String：目录
     * @throw
     */
    public String[] splitPath(String path){
        // 将路径按照//符号切割
        List<String> stringList = new ArrayList<>();
        stringList.addAll(Arrays.asList(path.split("\\\\")));
        // 去掉最后一项，即删除文件名
        String fileName = stringList.remove(stringList.size()-1);
        // 合并剩下的项作为目录返回
        String dir = String.join("\\\\",stringList)+"\\\\";
        return new String[]{dir,fileName};
    }

    public static void main(String[] args) throws Exception {
        ParseExcelToDb util = new ParseExcelToDb();
        util.getCreateSql();
        util.getInsertSql();
        util.getEntity();
        util.getSelectSql();
        util.getUpdateSql();
        util.getDeleteSql();
        util.getDao();
    }
}

USB

获取USB挂载路径

/**
     * 获取usb挂载路径
     * @return
     */
    private String usbMountedPath(){
        File file = new File("/proc/mounts");
        try(FileInputStream inputStream = new FileInputStream(file);
            InputStreamReader inputStreamReader = new InputStreamReader(inputStream, StandardCharsets.UTF_8);
            BufferedReader bufferedReader = new BufferedReader(inputStreamReader);){
            String line ;
            ArrayList<String > list = new ArrayList<>();
            while ((line = bufferedReader.readLine()) != null){
                if(line.contains("vfat")){
                    list.add(line);
                }
            }
            if(list.size() > 0){
                line = list.get(list.size() - 1);
                if(line.contains("vendor/factory")){
                    return null;
                }
                line = "/mnt" + line.split("/mnt")[1];
                line = line.split("vfat")[0];
                return line;
            }else {
                Log.i("yangyu","no ota mounted");
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        return null;
    }

 

usb状态广播接收

/**
     * usb状态监听广播接收器
     */
    private BroadcastReceiver usbReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            String action = intent.getAction();
            if("android.hardware.usb.action.USB_DEVICE_ATTACHED".equals(action) || "android.intent.action.MEDIA_MOUNTED".equals(action)){
                Log.i("yangyu","usb mounted");
            }else if("android.hardware.usb.action.USB_DEVICE_DETACHED".equals(action) || "android.intent.action.MEDIA_EJECT".equals(action)){
                Log.i("yangyu","usb unmounted");
            }
        }
    };

 

 图片

import android.content.res.Resources;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Matrix;
import android.graphics.PixelFormat;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;

public class BitmapUtils {

    public static Bitmap drawableToBitmap(Drawable drawable) {

        // 获取 drawable 长宽
        int width = drawable.getIntrinsicWidth();
        int heigh = drawable.getIntrinsicHeight();

        drawable.setBounds(0, 0, width, heigh);

        // 获取drawable的颜色格式
        Bitmap.Config config = drawable.getOpacity() != PixelFormat.OPAQUE ? Bitmap.Config.ARGB_8888
                : Bitmap.Config.RGB_565;
        // 创建bitmap
        Bitmap bitmap = Bitmap.createBitmap(width, heigh, config);
        // 创建bitmap画布
        Canvas canvas = new Canvas(bitmap);
        // 将drawable 内容画到画布中
        drawable.draw(canvas);
        return bitmap;
    }

    /**
     * 旋转
     * @param degree
     * @return
     */
    public static Bitmap rotateBitmap(int degree,Bitmap bitmap){
        Matrix matrix = new Matrix();
        matrix.postRotate(degree);
        bitmap = Bitmap.createBitmap(bitmap,0,0,bitmap.getWidth(),bitmap.getHeight(),matrix,true);
        return bitmap;
    }

    /**
     * 缩放bitmap
     * @param bitmap
     * @param width
     * @param height
     * @return
     */
    public static Bitmap zoomBitmap(Bitmap bitmap,int width,int height){
        int w = bitmap.getWidth();
        int h = bitmap.getHeight();

        //缩放比
        float ws = new Float(width)/w;
        float hs = new Float(height)/h;

        Matrix matrix = new Matrix();
        matrix.postScale(ws,hs);
        bitmap = Bitmap.createBitmap(bitmap,0,0,w,h,matrix,true);

        return bitmap;
    }
}

 

 

 

 

参考

Java - 格式化输出JSON字符串的两种方式

SpringBoot通过RSA实现用户名和密码的加密和解密