常用的工具方法

作者: acybDM | 来源:发表于2020-05-28 15:31 被阅读0次

常用的工具方法
一些常用的工具网
2020-06-27【日期类Date】
自定义NPM工具包（2）
JQ原理
iOS --- 常用的工具方法
python常用的工具方法
unity常用的工具方法
Apache common工具包之StringUtils的常用方
常用基础工具方法

日期类

    //获取过去的年月，格式如2020-01
    private String getPastMonth(int index) {
        Calendar c = Calendar.getInstance();
        c.add(Calendar.MONTH, index);
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM");
        String timeString = sdf.format(c.getTime());
        return timeString;
    }

附件类

import java.io.Closeable;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.HashMap;
import java.util.Properties;
import java.util.Vector;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang.StringUtils;

import com.jcraft.jsch.Channel;
import com.jcraft.jsch.ChannelSftp;
import com.jcraft.jsch.JSch;
import com.jcraft.jsch.JSchException;
import com.jcraft.jsch.Session;
import com.jcraft.jsch.SftpException;
import com.linkage.utils.Conver;

/**
 * sftp工具类：主要实现基于SFTP的文件上传、下载、删除功能
 * 基于jsch.jar实现
 */
public class SFTPUtil {

    //jsch对象
    private ChannelSftp sftp;
    //jsch对象
    private Session session;
    //用户名
    private String username;
    //密码
    private String password;
    //私钥
    private String privateKey;
    //服务器ip
    private String host;
    //服务器端口
    private int port;

    //构造基于密码认证的sftp对象
    public SFTPUtil(String username, String password, String host, int port) {
        this.username = username;
        this.password = password;
        this.host = host;
        this.port = port;
    }

    //构造基于秘钥认证的sftp对象
    public SFTPUtil(String username, String host, int port, String privateKey) {
        this.username = username;
        this.host = host;
        this.port = port;
        this.privateKey = privateKey;
    }

    //默认构造器
    public SFTPUtil() {
    }

    //连接sftp服务器
    public void login() {
        try {
            JSch jsch = new JSch();
            if (StringUtils.isNotBlank(privateKey)) {
                jsch.addIdentity(privateKey);//设置私钥
            }
            session = jsch.getSession(username, host, port);
            if (StringUtils.isNotBlank(password)) {
                session.setPassword(password);//设置密码
            }
            Properties config = new Properties();
            config.put("StrictHostKeyChecking", "no");//不进行公钥确认
            config.put("kex", "diffie-hellman-group1-sha1");//指定jsch使用的算法，不同jsch版本默认使用的算法不一样。服务器配置文件(/etc/ssh/sshd_config)根据openssh的版本决定是否需要配置支持此算法。
            session.setConfig(config);
            session.connect();
            Channel channel = session.openChannel("sftp");
            channel.connect();
            sftp = (ChannelSftp) channel;
        } catch (JSchException e) {
            Conver.printStackTrace(e);
        }
    }

    //关闭连接 server
    public void logout() {
        if (sftp != null) {
            if (sftp.isConnected()) {
                sftp.disconnect();
            }
        }
        if (session != null) {
            if (session.isConnected()) {
                session.disconnect();
            }
        }
    }
    
    //根据源文件路径上传附件
    public boolean upload(String srcFilePath, String remotePath, String remoteFileName){    
        return upload(new File(srcFilePath),remotePath,remoteFileName);     
    }
    
    //根据源文件File对象上传附件
    public boolean upload(File srcFile, String remotePath, String remoteFileName){  
        try {
            upload(remotePath,remoteFileName,new FileInputStream(srcFile));
        } catch (FileNotFoundException e) {
            Conver.printStackTrace(e);
            return false;
        } catch (SftpException e) {
            Conver.printStackTrace(e);
            return false;
        } finally {
            logout();
        }
        return true;
    }
    
    //通过流上传附件
    private void upload(String remotePath, String remoteFileName, InputStream input) throws SftpException {
        String[] dirs = remotePath.split("/");
        if(remotePath.startsWith("/")){
            dirs[0] = "/";
        }
        String basePath = dirs[0];
        try {
            sftp.cd(basePath);
        } catch (SftpException e) {
            sftp.mkdir(basePath);
            sftp.cd(basePath);
        }
        for(int i=1;i<dirs.length;i++){
            if(i==1 && remotePath.startsWith("/")){
                basePath += dirs[i];
            }else{              
                basePath += "/" + dirs[i];
            }
            try {
                sftp.cd(basePath);
            } catch (SftpException e) {
                sftp.mkdir(basePath);
                sftp.cd(basePath);
            }
        }           
        try{            
            sftp.put(input, remoteFileName); // 上传文件
        } finally{
            releaseIO(input);           
        }
    }
    
    
    /**
     * 
     * 下载文件
     * 
     * @param remotePath 下载目录
     * @param remoteFileName 下载的文件
     * @param localPath 存在本地的路径
     * @throws SftpException 
     * @throws FileNotFoundException 
     */
    public void download(String remoteFileName, String remotePath, String localPath) {
        FileOutputStream output = null;
        try{            
            output = new FileOutputStream(new File(localPath + File.separator + remoteFileName));
            if (StringUtils.isNotBlank(remotePath)) {
                sftp.cd(remotePath);
            }
            sftp.get(remoteFileName, output);
        } catch (FileNotFoundException e) {
        } catch (SftpException e) {
        } finally {
            releaseIO(output);
            logout();
        }
    }

    /**
     * 
     * 下载文件
     * 
     * @param directory 下载目录
     * @param downloadFile 下载的文件名
     * @return 字节数组
     */
    public byte[] download(String directory, String downloadFile) throws SftpException, IOException {
        if (directory != null && !"".equals(directory)) {
            sftp.cd(directory);
        }
        InputStream is = sftp.get(downloadFile);
        byte[] fileData = IOUtils.toByteArray(is);
        return fileData;
    }

    /**
     * 
     * 删除文件，并退出服务器
     * 
     * @param directory 要删除文件所在目录
     * @param deleteFile 要删除的文件
     */
    public void delete(String directory, String deleteFile) {
        try{
            sftp.cd(directory);
            sftp.rm(deleteFile);            
        }catch(SftpException e){
            Conver.printStackTrace(e);
        }finally{
            logout();
        }
    }
    
    /**
     * 
     * 删除文件
     * 
     * @param directory 要删除文件所在目录
     * @param deleteFile 要删除的文件
     */
    public void remove(String directory, String deleteFile) throws SftpException {
        sftp.cd(directory);
        sftp.rm(deleteFile);            
    }

    //基于sftp删除异地文件
    public static void delRemoteBySftp(String ip, String port, String user, String pwd, String remotePath, String remoteFileName) {
        SFTPUtil sftp = new SFTPUtil(user, pwd, ip, Integer.parseInt(port));
        sftp.login();
        try {
            sftp.remove(remotePath, remoteFileName);
        } catch (SftpException e) {
        }finally{           
            sftp.logout();
        }
    }
    
    /**
     * 
     * 列出目录下的文件
     * 
     * @param directory 要列出的目录
     */
    public Vector<?> listFiles(String directory) throws SftpException {
        return sftp.ls(directory);
    }
    
    //释放IO流
    public static void releaseIO(Closeable... closes){
        try{
            for(Closeable close : closes){
                if(close!=null){
                    close.close();
                }
            }
        }catch(IOException e){
        }
    }
}

//基于FTPClient可实现FTP服务器的文件上传下载

Json类

import java.util.Map;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;

/**
 * json工具类
 * 基于fastjson
 */
public class JsonUtil {

    //对象转换为json字符串
    public static String obj2Json(Object object) {
        return JSONObject.toJSONString(object);
    }

    //json字符串转换为指定类型的对象
    @SuppressWarnings("unchecked")
    public static Object json2Obj(String json, Class<?> clazz) {
        return JSONObject.parseObject(json, clazz);
    }

    //json字符串默认转换为Map类型的对象
    public static Object json2Obj(String json) {
        return json2Map(json);
    }

    //json字符串转换为Map类型的对象
    @SuppressWarnings("unchecked")
    public static Map<String, Object> json2Map(String json) {
        return JSONObject.parseObject(json, Map.class);
    }
    
    //json字符串转换为数组格式
    public static JSONArray str2JsonArray(String jsonStr){
        return JSONObject.parseArray(jsonStr);
    }
    //测试
    public static void main(String[] args) {
    }
}

加解密

Http调用

Xml转换

package utils;

import entity.Book;
import entity.Role;
import entity.Student;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;
import javax.xml.bind.Unmarshaller;
import java.io.StringReader;
import java.io.StringWriter;
import java.util.Date;

/**
 * xml转换工具类
 * java bean与xml相互转换
 * jdk自带，不需要依赖第三方jar
 */
public class JaxbUtil {

    private static final String DEFAULT_ENCODING = "UTF-8";

    public static String toXml(Object object) {
        return toXml(object, DEFAULT_ENCODING);
    }

    public static String toXml(Object object, String encoding) {
        try {
            JAXBContext jaxbContext = JAXBContext.newInstance(object.getClass());
            Marshaller marshaller = jaxbContext.createMarshaller();
            marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
            marshaller.setProperty(Marshaller.JAXB_ENCODING, encoding);
            StringWriter writer = new StringWriter();
            marshaller.marshal(object, writer);
            return writer.toString();
        } catch (JAXBException e) {
            e.printStackTrace();
        }
        return "";
    }

    @SuppressWarnings("unchecked")
    public static <T> T toObject(String xml, Class<T> clazz) {
        T object = null;
        try {
            JAXBContext context = JAXBContext.newInstance(clazz);
            Unmarshaller unmarshaller = context.createUnmarshaller();
            object = (T) unmarshaller.unmarshal(new StringReader(xml));
        } catch (JAXBException e) {
            e.printStackTrace();
        }
        return object;
    }

    //测试
    public static void main(String[] args) {
        //1.基础对象序列化测试
        Book book = new Book();
        book.setAuthor("张三");
        book.setDate(new Date());
//        book.setId(1);
        book.setPrice(79.1);
        book.setProp("你好");

        String s = toXml(book);
        System.out.println(s);

        //2.复杂对象序列化测试
        Role role = new Role();
        role.setDesc("role1");
        role.setName("角色1");
        role.setId("456");
        Student student = new Student();
        student.setId(123);
        student.setName("student");
        student.setRole(role);
        String s1 = toXml(student);
        System.out.println(s1);

        //3.反序列化测试
        String xml = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n" +
                "<student id=\"123\">\n" +
                "    <name>student</name>\n" +
                "    <role id=\"456\">\n" +
                "        <NAME>角色1</NAME>\n" +
                "        <DESC>role1</DESC>\n" +
                "    </role>\n" +
                "</student>";
        Student student1 = toObject(xml, Student.class);
        System.out.println(student1);

        //4.todo 集合对象测试
    }
}
package entity;

import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import java.util.Date;

//测试类Book 
//@XmlRootElement为必须的
@XmlRootElement
public class Book {

    @XmlAttribute(name = "activiti:id", required = true)
    private Integer id;

    @XmlElement
    private String author;

    //required = true时，取对应类型的默认值
    //double为0.0，Double为null
    //当对象类型的值为null时,不生成对应的标签
    //为""时，生成空标签
    //不能同时有get方法
    //既没有@XmlElement，也没有get方法时，不会生成对应标签
    @XmlElement(required = true)
    private Date date;

    @XmlElement
    private Double price;

    @XmlAttribute
    private String prop;

//    private

//    public int getId() {
//        return id;
//    }

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

//    public String getAuthor() {
//        return author;
//    }

    public void setAuthor(String author) {
        this.author = author;
    }

//    public Date getDate() {
//        return date;
//    }

    public void setDate(Date date) {
        this.date = date;
    }

//    public double getPrice() {
//        return price;
//    }

    public void setPrice(Double price) {
        this.price = price;
    }

    public void setProp(String prop) {
        this.prop = prop;
    }
}
package entity;

import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;

//测试类Student
@XmlRootElement
public class Student {

    @XmlAttribute
    private int id;

    @XmlElement
    private String name;

    @XmlElement
    private Role role;


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

    public void setName(String name) {
        this.name = name;
    }

    public void setRole(Role role) {
        this.role = role;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", role=" + role +
                '}';
    }
}
package entity;

import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;

//测试类Role
@XmlRootElement
public class Role {

    @XmlElement(name = "NAME")
    private String name;

    @XmlElement(name = "DESC")
    private String desc;

    @XmlAttribute
    private String id;

    public void setName(String name) {
        this.name = name;
    }

    public void setDesc(String desc) {
        this.desc = desc;
    }

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

    @Override
    public String toString() {
        return "Role{" +
                "name='" + name + '\'' +
                ", desc='" + desc + '\'' +
                ", id='" + id + '\'' +
                '}';
    }
}

常用的工具方法
日期类附件类 Json类加解密 Http调用 Xml转换
一些常用的工具网
查询Ip git常用使用方法 git常用工具和方法（2）模拟真实后台数据
2020-06-27【日期类Date】
Date常用方法 SimpleDateFormat 日期工具类日历类Calender
自定义NPM工具包（2）
添加常用工具包方法项目地址 1、修改package.json的配置 2、添加常用方法以数学方法为...
JQ原理
jq的基本结构 jq入口函数分析常用的jq方法 JQ 工具方法
iOS --- 常用的工具方法
在开发应用的过程中几乎所有的app都会用到的一些方法，现在记录下来，以便以后查看。等比缩放图片把url进行NS...
python常用的工具方法
一、json格式输出二、生成十位编号输出： 'traceId': '3RF9z0ExyP' 三、url转码，解...
unity常用的工具方法
1——获取时间相关 2——秒转年月日 3——Json保存和加载 4——文本的正则检测 5——256加密
Apache common工具包之StringUtils的常用方
StringUtils字符串工具类的常用方法一、StringUtils是什么 StringUtils 方法的操作...
常用基础工具方法
Charles 配置https ：http://www.jianshu.com/p/235bc6c3ca77