Java修改文件MD5值-yellowcong

最新推荐文章于 2024-07-10 03:17:51 发布
最新推荐文章于 2024-07-10 03:17:51 发布
阅读量7.6k 收藏 9
点赞数 2
文章标签： java md5
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yelllowcong/article/details/75173605
版权

MD5是加密算法的一种，MD5对于每一个文件来说都是唯一的，在百度网盘、QQ的文件快传中，都是算文件的MD5在本地的服务器上有没有，如果有直接就可以上传。但是有一个场景，就是我的文件在百度上是 违规的，我可以通过修改MD5值，然后上传问文件。

修改文件MD5思路

一般MD5修改的办法，就是修改文件的内容，自然MD5就修改掉了，但是文件这么多，我们也不一定改得了，所以最核心的思路是，将一个文件分成多个文件，然后合并成一个文件，在合并的时候，添加一个空文件，就可以解决这个问题

/**
 * 给文件生成新的md5验证码
 * @param pathname 文件的全路径
 * @param newFileName  新文件的全路径
 */
private static void newMD5(String pathname,String newFileName){

    //分割文件
    String [] names = FileUtils.partitionFile(pathname);
    //创建一个空文件
    String newFile = pathname+".txt";
    FileUtils.copyStringToFile(UUID.randomUUID().toString(), newFile);

    //解决 md5 修改
    String [] newNames = new String[names.length+1];
    System.out.println(newNames.length);
    for(int i=0;i<names.length;i++){
        newNames[i] = names[i];
    }

    newNames[names.length] = newFile;
    //文件合并,多添加了一个空文件
    FileUtils.uniteFile(newNames, newFileName);

    //删除所有文件
    FileUtils.deletes(newNames);
}

文件分割

文件分割操作中，需要根据文件的大小来计算分割的份数，同时也要写计算分割的文件名，其中文件的大小可以自己根据文件的大小计算份数

/**
 * 文件分割
 * @param partSize
 * @param pathname
 * @return 
 * @throws Exception
 */
private static String[] partitionFile(int partSize,String pathname){
    DataInputStream in  = null;
    String [] names = null;
    try {
        //DataOutputStream
        //通过DataOutputStream 这个对象完成文件的分割
        //缓存
        File file = new File(pathname);
        //long size = file.length();
        //1024*1024 就是 1MB
        //System.out.println(size/1024/1024);
        //获取分割文件的名称
        names = getPartitionFileNames(pathname, partSize);
        in = new DataInputStream( new FileInputStream(file));
        byte [] buff = new byte[1024];
        DataOutputStream out = null;
        for(String name:names){
            System.out.println(name);
            out = new DataOutputStream(new FileOutputStream(new File(name)));
            long size = partSize;
            while(size >0){
                //当没有读取完的情况
                if(in.read(buff) != -1){
                    out.write(buff, 0, buff.length);
                }
                size = size-buff.length;
            }

            out.close();
        }
    } catch (Exception e) {
        throw new RuntimeException("分割失败");
    }finally{
        try {
            if(in!= null ){
                in.close();
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    return names;
}

计算文件名称

/**
 * 根据给定的每个文件的大小来获取文件的数目
 * @param pathname 文件名称
 * @param partSize 每个部分的大小
 * @return
 */
public static String [] getPartitionFileNames(String pathname,long partSize){
    File file = new File(pathname);
    long size = file.length();
    double num = (size/(double)partSize);
    //向上取整数,获取分割文件的数量
    num = Math.ceil(num);
    String [] names = new String [(int)num] ;
    for(int i=0;i<num;i++){
        names[i] = StringUtil.getFileSimpleName(pathname)+"_"+i+"."+StringUtil.getFileTypeByPath(pathname);
    }
    return names;
}

文件合并

文件拆分开后，我们需要将所有分开的文件合并，同时包含了空文件，然后删除空文件的操作

/**
 * 合并文件
 * @param files 多个子文件
 * @param newFile 新的文件
 * @throws Exception 异常
 */
public static void uniteFile(String[] files, String newFile) {
    DataOutputStream out = null;
    try {
        out = new DataOutputStream(new FileOutputStream(new File(newFile)));
        for(String name:files){
            FileInputStream in = new FileInputStream(new File(name));
            byte [] buff = new byte[1024];
            while((in.read(buff)) != -1){
                out.write(buff,0,buff.length);
            }
            in.close();
        }
    } catch (Exception e) {
        throw new RuntimeException(e.getMessage());
    }finally{
        try {
            if(out != null){
            out.close();
            }
        } catch (Exception e2) {
            // TODO: handle exception
        }

    }
}

完整代码

package com.yellowcong.utils;

import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.math.BigInteger;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.security.MessageDigest;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.Map.Entry;

import javax.servlet.http.HttpServletRequest;

import org.hibernate.mapping.Array;

import com.sun.xml.internal.messaging.saaj.util.ByteInputStream;

/**
 * 文件的 分割 合并
 * 文件的 md5
 * 获取文件的 md5
 * @author yellowcong
 * @date 2016年4月17日
 *
 */
public class FileUtils {
    //文件夹信息
    private static List<String> dirNames= null;
    //文件信息
    private static List<String> fileNames = null;

    //文件大小单位 ，我们可以通过添加SizeStr 来添加单位
    private static String [] sizeStr = {"B","KB","MB","GB","PB"}; 
    private static int count =0;
    private static long fileSize = 0;

    private FileUtils(){}

    /**
     * 获取类路径下文件的路径
     * @param fileName
     * @return
     */
    public static String getClassPathFilePath(String fileName){
        String path = FileUtils.class.getClassLoader().getResource(fileName).getPath().toString();
        if(path.contains("%20")){
            path = path.replace("%20", " ");
        }
        return path;
    }

    /**
     * 获取文件对象
     * @param fileName
     * @return
     */
    public static File getClassPathFile(String fileName){
        return new File(FileUtils.getClassPathFilePath(fileName));
    }

    /*在类路径创建我们的 文件夹*/
    /**
     * 创建类路径下面的文件夹
     * @param directory
     */
    public static String mkClassPathDir(String directory){
        String path = FileUtils.class.getClassLoader().getResource("").getPath();
        path += directory;
        File file = new File(path);
        if(!file.exists()){
            file.mkdir();
        }
        return path;
    }

    /**
     * 获取类文件的输入流
     * @param fileName
     * @return
     */
    public static InputStream getClassPathFileInputStream(String fileName){
        return FileUtils.class.getResourceAsStream(fileName);
    }


    /**
     * 将File 文件转化为 字符串
     * @param filePath
     * @return
     */
    public static String copyFileToString(String filePath){
        return FileUtils.getFileContent(filePath);
    }

    /**
     * 获取一个文本文件里面的内容
     * @param filePath
     * @return
     */
    public static String getFileContent(String filePath){
        FileReader in  = null;
        BufferedReader reader = null;
        try {
            in  = new FileReader(new File(filePath));
            reader = new BufferedReader(in);
            String line = null;
            StringBuffer str = new StringBuffer();
            while((line = reader.readLine())!= null){
                str.append(line);
                str.append("\r\n");
            }
            return str.toString();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            try {
                if(in != null){
                    in.close();
                }
                if(reader != null ){
                    reader.close();
                }
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        return null;
    }
    /**
     * 获取 web目录下的路径，便于上传
     * @param str
     * @param request
     * @return
     */
    public static String getWebFilePath(String str,HttpServletRequest request){
        //这个直接获取的方法已经过期了
//      return request.getRealPath(str);
        return request.getSession().getServletContext().getRealPath(str);
    }

    /**
     * 通过 路径来创建文件
     * @param path
     */
    public static void createDirectory(String path){
        File file = new File(path);
        if(!file.exists()){
            file.mkdirs();
        }
    }

    /**
     * 通过文件夹  获取文件夹 当前目录 和下面目录所有的文件 
     * @param path
     * @param isNowPath 目录级别  当前目录 数据 
     * @return
     */
    //获取所有文件
    public static List<String> getChildFiles(String path,boolean isNowPath){
        if(!new File(path).exists()){
            throw new RuntimeException(path+"，文件夹不存在");
        }
        if(!new File(path).isDirectory()){
            throw new RuntimeException(path+"，不是文件夹");
        }
        fileNames = new ArrayList<String>();
        listAllFile(path,isNowPath);
        return fileNames;
    }

    /**
     * 通过文件夹  获取文件夹 当前目录 和下面目录所有的文件 
     * @param path
     * @return
     */
    public static List<String> getChildFiles(String path){
        return getChildFiles(path, false);
    }



    /**
     * 通过文件夹 获取
     * 所有的文件夹
     * @param path 目录名称
     * @param isNowPath 是否是当前目录
     * @return
     */
    public static List<String> getChildDirs(String path,boolean isNowPath){
        if(!new File(path).exists()){
            throw new RuntimeException(path+"，文件夹不存在");
        }
        if(!new File(path).isDirectory()){
            throw new RuntimeException(path+"，不是文件夹");
        }
        dirNames = new ArrayList<String>();
        listAllDir(path,isNowPath);
        return dirNames;
    }
    /**
     * 通过文件夹 获取 我们的子 
     * 所有的文件夹  
     * @param path 目录名称
     * @return
     */
    public static List<String> getChildDirs(String path){
        return getChildDirs(path, false);
    }
    /**
     * 获取某个文件夹下面的文件
     * 其中文件夹包含了第一个文件夹就是自己 重复调用
     * 
     * @param path 文件夹路径名称
     */
    private static void listAllFile(String path,boolean isNowPath){
        File file = new File(path);
        if(file.isDirectory()){
                for(File f:file.listFiles()){
                    if(isNowPath){
                        if(f.isFile()){
                            fileNames.add(f.getPath());
                        }
                    }else{
                        listAllFile(f.getPath(),isNowPath);

                    }
                }
        }else{
            fileNames.add(path);
        }
    }
    /**
     * 获取某个文件夹下面的文件
     * 其中文件夹包含了第一个文件夹就是自己 重复调用
     * 
     * @param path 文件夹路径名称
     * @param isNowPath 是否是当前目录 ，包含子目录
     */
    private static void listAllDir(String path,boolean isNowPath){
        File file = new File(path);
        if(file.isDirectory()){
            dirNames.add(path);
            for(File f:file.listFiles()){
                if(isNowPath){
                    dirNames.add(f.getPath());
                }else{
                    listAllDir(f.getPath(),isNowPath);
                }

            }
        }
    }

    /**
     * 获取所有的文件，包括 文件夹的信息
     * @param path
     * @return
     */
    public static List<String> listAllFiles(String path){
         List<String> strs = FileUtils.getChildDirs(path);
         strs.addAll(FileUtils.getChildFiles(path));
         FileUtils.getChildFiles(path);
         return strs;
    }
    /**
     * 文件分类获取
     * @param isNowPath 是否 只是当前目录
     * 
     * String  文件类型  txt doc 等等
     * List<String> 存的路径
     * 
     * jpg xxx.xx
     *     xx.xx
     * 
     * 
     * @return
     */
    public static Map<String,List<String>> getFilesTypeMap(String path,boolean isNowPath){
        if(!new File(path).exists()){
            throw new RuntimeException(path+"，文件夹不存在");
        }
        List<String> str = FileUtils.getChildFiles(path,isNowPath);
        Map<String,List<String>> map = new HashMap<String, List<String>>();
        for(String val:str){
            String type = StringUtil.getFileTypeByPath(val);
            if(map.get(type) == null){
                List<String> names = new ArrayList<String>();
                names.add(val);
                map.put(type, names);
            }else{
                List<String> names =map.get(type);
                names.add(val);
                map.put(type, names);
            }
        }
        return map;
    }
    /**
     * 获取所有目录级别下面的数据
     * @param path
     * @return
     */
    public static Map<String,List<String>> getFilesTypeMap(String path){
        return getFilesTypeMap(path, false);
    }

    /**
     * 获取目录下文件下面 某个类型的数据
     * @param path
     * @param type 文件类型
     * @param isNowPath 是否是 当前目录 ， 不是所有 目录
     * @return
     */
    public static List<String> getFilesByType(String path,boolean isNowPath,String [] types){
        List<String> list = null;
        if(types != null && types.length >0){
            Map<String,List<String>> map = getFilesTypeMap(path,isNowPath);
            list = new ArrayList<String>();
            for(String type:types ){
                if(map.get(type)!= null){
                    list.addAll(map.get(type));
                }
            }
        }else{
            //如果没有说明 就是所有数据都要
             listAllFile(path, false);
             list = fileNames;
        }
        return list;
    }

    /**
     * 获取目录下文件下面 某个类型的数据
     * @param path
     * @param type 文件类型
     * @return
     */
    public static List<String> getFilesByType(String path,String [] types){
        return getFilesByType(path, false, types);
    }

    /**
     * 将InputStream  转化为输出数据
     * @param in 输入流
     * @param file 输出的文件对象
     */
    public static void copyInputStreamToFile(InputStream in ,File file){
        OutputStream out= null;
        try {
            out = new FileOutputStream(file);
            byte[] buff = new byte[1024];
            int len = 0;
            while ((len = in.read(buff)) > 0) {
                out.write(buff, 0, len);
            }
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            try {
                if(in != null){
                    in.close();
                }
            } catch (Exception e2) {
                // TODO: handle exception
            }finally{
                try {
                    if(out != null){
                        out.close();
                    }
                } catch (Exception e3) {
                    // TODO: handle exception
                }
            }
        }

    }


    /**
     * 将字符数据转化为我们的文件
     * @param data 字节数组
     * @param file 输出文件
     */
    public static void copyByte2File(byte [] data,File file){
        if ((data == null) || (data.length <= 0))
            return;

        OutputStream out = null;
        InputStream in = null;
        try {
            out = new FileOutputStream(file);
            in = new ByteInputStream(data,data.length );
            byte [] buff = new byte[1024];
            int len =  0;
            while((len = in.read(buff))>0){
                out.write(buff, 0, len);
            }
            out.flush();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            try {
                if(in != null){
                    in.close();
                }
            } catch (Exception e2) {
                // TODO: handle exception
            }finally{
                try {
                    if(out != null){
                        out.close();
                    }
                } catch (Exception e3) {
                    // TODO: handle exception
                }
            }
        }
    }

    /**
     * 将InputStream 转化为字节码文件
     * @return 
     */
    public static byte[] copyFileToByteArray(File file){
        InputStream  in = null;
        try {
            in = new FileInputStream(file);
            //获取字节码的数量，将字节码装
            int len = in.available();
            byte [] result = new byte[len];
            in.read(result);
            return result;
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            try {
                if(in != null){
                    in.close();
                }
            } catch (Exception e2) {
                // TODO: handle exception
            }
        }
        return null;

    }
    /**
     * 将InputStream 转化为字节码文件
     * @return 
     */
    public static byte[] copyInputStreamToByteArray(InputStream in){
        try {
            //获取字节码的数量，将字节码装
            int len = in.available();
            byte [] result = new byte[len];
            in.read(result);
            return result;
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            try {
                if(in != null){
                    in.close();
                }
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        return null;

    }
    /**
     * xx "B","KB","MB","GB","PB"
     * 
     * 计算文件大小
     * @param size
     */
    private static void getFileSize(long size){
        long result  = size/1024;
        if(result >=1 && count <(sizeStr.length-2)){
            fileSize = size/1024;
            count = count +1;
            getFileSize(fileSize);
        }else{
            fileSize = size;
        }
    }

    /**
     * 
     * xx "B","KB","MB","GB","PB"
     * 
     * 计算文件大小
     * 我们用的时候，对于 静态的数据，需要清空 或者重新初始化，解决多次使用，导致数据堆积问题
     * @param fileSize
     * @return
     */
    public static String getFileSizeStr(long filesize){
        if(filesize <0){
            throw new RuntimeException("文件大小有问题");
        }
        //多次使用的时候，这个 就会用问题了，一定要清空
        count = 0;
        fileSize= 0;
        getFileSize(filesize);
        return fileSize+sizeStr[count];
    }

    /**
     * 文件分割
     * String pathname = "E:\\迅雷下载\\疯狂动物城.Zootopia.2016.HDCAM.XVID.AC3.中文字幕[rarbt]\\疯狂动物城.Zootopia.2016.HDCAM.XVID.AC3.中文字幕[rarbt].mp4";
     * 给定文件进行分割，默认分割的大小是500MB
     * @return 切割的文件名称
     * @throws Exception
     */
    public static String[] partitionFile(String pathname){
        return partitionFile(1024*1024*500,pathname) ;
    }

    /**
     * 文件分割
     * @param partSize
     * @param pathname
     * @return 
     * @throws Exception
     */
    private static String[] partitionFile(int partSize,String pathname){
        DataInputStream in  = null;
        String [] names = null;
        try {
            //DataOutputStream
            //通过DataOutputStream 这个对象完成文件的分割
            //缓存
            File file = new File(pathname);
            //long size = file.length();
            //1024*1024 就是 1MB
            //System.out.println(size/1024/1024);
            //获取分割文件的名称
            names = getPartitionFileNames(pathname, partSize);
            in = new DataInputStream( new FileInputStream(file));
            byte [] buff = new byte[1024];
            DataOutputStream out = null;
            for(String name:names){
                System.out.println(name);
                out = new DataOutputStream(new FileOutputStream(new File(name)));
                long size = partSize;
                while(size >0){
                    //当没有读取完的情况
                    if(in.read(buff) != -1){
                        out.write(buff, 0, buff.length);
                    }
                    size = size-buff.length;
                }

                out.close();
            }
        } catch (Exception e) {
            throw new RuntimeException("分割失败");
        }finally{
            try {
                if(in!= null ){
                    in.close();
                }
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        return names;
    }

    /**
     * 新建md5文件
     * @param pathname 需要新建md5的文件名称
     * 
     * 创建的文件在那个目录中，然后文件的名称，添加了一个_md5
     */
    public static void newMD5(String pathname){
        String newFileName = StringUtil.getFileSimpleName(pathname)+"_yellowcong_md5."+StringUtil.getFileType(pathname);
        System.err.println("修改前MD5值\t"+FileUtils.getMd5(pathname));
        FileUtils.newMD5(pathname, newFileName);
        System.err.println("修改后MD5值\t"+FileUtils.getMd5(newFileName));
    }

    /**
     * 获取文件的MD5
     * @param filename 文件的名称，全路径的
     * @return
     */
    public static  String getMd5(String filename) {  
        String value = null;  
        FileInputStream in = null;  
        File file = new File(filename);
        try {  
            in = new FileInputStream(file);
            MappedByteBuffer byteBuffer = in.getChannel().map(FileChannel.MapMode.READ_ONLY, 0, file.length());  
            MessageDigest md5 = MessageDigest.getInstance("MD5");  
            md5.update(byteBuffer);  
            BigInteger bi = new BigInteger(1, md5.digest());  
            value = bi.toString(16);  
        } catch (Exception e) {  
            e.printStackTrace();  
        } finally {  
                if(null != in) {  
                    try {  
                    in.close();  
                } catch (IOException e) {  
                    e.printStackTrace();  
                }  
            }  
        }  
        return value;  
    }  
    /**
     * 给文件生成新的md5验证码
     * @param pathname 文件的全路径
     * @param newFileName  新文件的全路径
     */
    private static void newMD5(String pathname,String newFileName){
        //String pathname = "E:\\迅雷下载\\疯狂动物城.Zootopia.2016.HDCAM.XVID.AC3.中文字幕[rarbt]\\疯狂动物城.Zootopia.2016.HDCAM.XVID.AC3.中文字幕[rarbt].mp4";
        //分割文件
        String [] names = FileUtils.partitionFile(pathname);
        //创建一个空文件
        String newFile = pathname+".txt";
        FileUtils.copyStringToFile(UUID.randomUUID().toString(), newFile);

        //解决 md5 修改
        String [] newNames = new String[names.length+1];
        System.out.println(newNames.length);
        for(int i=0;i<names.length;i++){
            newNames[i] = names[i];
        }

        newNames[names.length] = newFile;
        //文件合并,多添加了一个空文件
        FileUtils.uniteFile(newNames, newFileName);

        //删除所有文件
        FileUtils.deletes(newNames);
    }
    /**
     * 删除多个文件
     * @param fileNames
     */
    public static void deletes(String [] fileNames){
        //删除文件
        for(String path:fileNames){
            new File(path).delete();
        }
    }
    /**
     * 合并文件
     * @param files 多个子文件
     * @param newFile 新的文件
     * @throws Exception 异常
     */
    public static void uniteFile(String[] files, String newFile) {
        DataOutputStream out = null;
        try {
            out = new DataOutputStream(new FileOutputStream(new File(newFile)));
            for(String name:files){
                FileInputStream in = new FileInputStream(new File(name));
                byte [] buff = new byte[1024];
                while((in.read(buff)) != -1){
                    out.write(buff,0,buff.length);
                }
                in.close();
            }
        } catch (Exception e) {
            throw new RuntimeException(e.getMessage());
        }finally{
            try {
                if(out != null){
                out.close();
                }
            } catch (Exception e2) {
                // TODO: handle exception
            }

        }
    }

    /**
     * 根据给定的每个文件的大小来获取文件的数目
     * @param pathname 文件名称
     * @param partSize 每个部分的大小
     * @return
     */
    public static String [] getPartitionFileNames(String pathname,long partSize){
        File file = new File(pathname);
        long size = file.length();
        double num = (size/(double)partSize);
        //向上取整数,获取分割文件的数量
        num = Math.ceil(num);
        String [] names = new String [(int)num] ;
        for(int i=0;i<num;i++){
            names[i] = StringUtil.getFileSimpleName(pathname)+"_"+i+"."+StringUtil.getFileTypeByPath(pathname);
        }
        return names;
    }

    /**
     * 将String类型的数据直接转化为文本数据
     * @param str
     * @param filename
     */
    public static void copyStringToFile(String str,String filename){
        FileWriter out = null;
        try {
            //将Str 转化为文件
             out= new FileWriter(new File(filename));
            char []  chars = str.toCharArray();
            out.write(chars,0,chars.length);
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                if(out != null){
                    out.close();
                }
            } catch (Exception e) {
                // TODO: handle exception
            }
        }
    }

    /**
     * 将InputStream 的数据转化为String类型的数据
     * @param in 输入数据
     * @param encoding  编码方式gb2312,utf-8 
     * @return String
     */
    public static String copyInput2String(InputStream in,String encoding){
        String str = null;
        try {
            //写数据
            String line = null;
            BufferedReader reader = new BufferedReader(new InputStreamReader(in,encoding));

            StringBuffer sb = new StringBuffer();
            while((line = reader.readLine())!= null){
                 sb.append(line);
            }
            str = sb.toString();
        } catch (Exception e) {
            // TODO: handle exception
        }finally{
            try {
                if(in != null){
                    in.close();
                }
            } catch (Exception e2) {
                // TODO: handle exception
            }
        }
        return str;
    }

    /**
     * 将InputStream 的数据转化为String类型的数据,设定默认的编码编码方式为UTF-8
     * @param in 输入数据
     * @return String
     */
    public static String copyInput2String(InputStream in){
        return FileUtils.copyInput2String(in,"UTF-8");
    }
}
狂飙的yellowcong
关注
专栏目录
CAS之5.2x版本自定义登录页面-yellowcong
02-02 1万+
我现在的需求是，我有两个子站点，yellowcong.com,yellowlu.com. 两个站点使用不同的样式。1、在services文件夹添加的json配置文件，2、配置application.properties，设置`cas.serviceRegistry.initFromJson=true`,让配置的json文件生效，3、在static 文件夹，添加静态样式，4、在templates文件夹添加模板
CAS之5.2x版本配置密码加密(MD5和SHA)-yellowcong
12-15 8692
在上一篇，俺说到了如何配置CAS如何通过访问数据库进行验证操作，这篇讲解如何通过MD5加密算法验证，和自定义密码的加密策略
java 修改文件MD5值
weixin_44604434的博客
11-14 790
批量修改文件MD5
使用Java计算文件的MD5值（含修改MD5值的方法）
qq_40734247的博客
02-09 7017
什么是 MD5 ？ MD5（Message Digest Algorithm，信息摘要算法），一种被广泛使用的密码散列函数，可以产生出一个128位（16字节）的散列值（hash value），用于确保信息传输完整一致。它后面这个数字 5 是因为它是为了取代 MD4 而发明的。简单的理解，它的作用就是给文件一个唯一标识。 如果我们修改了一个文件的扩展名，文件可能会打不开，但是对于 MD5 来说，并没...
JAVA计算文件 MD5
最新发布
weixin_41179520的博客
07-10 339
计算文件MD5的JAVA实现 在计算文件的MD5值时，通常使用MD5算法对文件进行哈希计算，得到一个128位的哈希值。MD5算法是广泛应用于加密和安全领域的一种哈希算法，能够生成一个唯一的哈希值来表示文件的内容。在JAVA中，我们可以通过使用MessageDigest类来计算文件的MD5值。 MD5算法原理 MD5（Mes...
java源码 java 获取文件md5值(用于检测文件完整性) 2018127
12-07
java源码 java 获取文件md5值(用于检测文件完整性) .
修改文件md5值的简单方法！
热门推荐
ycc2011的专栏
09-03 1万+
转载自：https://jingyan.baidu.com/article/e52e36150ccc3140c60c512e.html cmd命令行下： 同一目录下存在88.jpgabc.txt 两个文件。new.jpg为新生成的文件（md5码已经改变） copy /b 88.jpg+abc.txt new.jpg 单纯想上传一个文件，由于md5码相同所以上传失败；故改之 ...
java怎么连接activemq集群_ActiveMQ之集群（主从）搭建-yellowcong
weixin_39846186的博客
02-27 591
ActiveMq的集群是依赖于Zookeeper的，ActiveMq的集群是，主从集群的方式，主的挂掉，才会自动切换到从，从的才开始运行。安装准备系统架构 Zookeeper架构节点服务目录192.168.100.10:2182zookeeper1/usr/local/zookeeper/zookeeper1192.168.100.10:2183zookeeper2/usr/local/zooke...
CAS之5.2x版本自定义登录，多数据源登录-yellowcong
02-02 6222
通过自定义登录的策略，可以根据传递过来的参数，来确定使用那个数据库查询用户信息。这种方式，可以说是，爽歪歪啊。可以自己登录，设定数据源来访问。我后期加jdbctemplate的配置，将jdbc集成springboot里面,这样用的是springboot里面数据源。 学习要求需要对于cas和springboot环境搭建有所了解，不然看着，都不知道我说得啥玩意。项目地址https://gitee.com
史上最全的Cas学习整理-yellowcong
01-10 6854
本文介绍了，如何安装，开发cas,以及cas如何做二次开发，包含了自定义界面，证书，二次验证，邮箱找回密码，自定义返回消息等，以及与jenkins,gitlab,jumpserver ,gerrit,graylog,sonar，jira,confluence ,grafana等开发工具的集成， 若有新devops软件需要集成的，或新功能需要开发，尽管提，有求必应
java 获取文件MD5值
04-21
NULL 博文链接：https://hw1287789687.iteye.com/blog/1924190
md5视频修改工具，并去重
06-16
相信很多做视频剪辑的小伙伴都有遇过以下情况，就是辛辛苦苦剪辑了一个视频，上传到平台后却发现过不了审并显示该视频是搬运的情况，你知道为什么会出现这种情况吗？其实这是因为你的视频md5数值和平台已有的md5数据库重复了，每个视频都有专属的md5数值，当我们上传视频时，平台就会读取md5数值，如果数值重复，视频就会显示抄袭并被退回，想解决这个问题就只能用软件修改md5然后再重新上传，本工具就可以修改视频，文件，压缩包md5值，点击一键修改，然后需要等待一点时间。等它自动修改md5值之后，我们就可以保存好视频去平台进行上传了。
文件MD5修改，支持批量修改
10-20
程序直接修改文件，而不是新生成文件，如有需要记得先保存备份 修改原理：在文件最后添加了一串随机字符 想网盘保存小电影的可以试试 懒的弄界面了，就一个程序图标 将一个或者多个需要修改MD5的文件拖到程序图标就行了 修改完毕以后会弹窗，还有就是会写一个文本记录修改的文件 软件是用AU3写的，杀软可能报毒，自己斟酌是否使用
图片md5值修改工具！支持一键批量修改
03-07
很多小伙伴总是让我出个MD5修改工具，最近比较忙，然后抽了一些时间写了这个工具，可以实现一键批量修改图片的md5摘要值！易语言开发的，有兴趣的下载玩玩。
Java文件读取写入后 md5值不变的实现方法
08-28
下面小编就为大家分享一篇Java文件读取写入后 md5值不变的实现方法，具有很好的参考价值，希望对大家有所帮助
java 生成 文件 md5_JAVA版文件MD5生成器
weixin_36018119的博客
02-12 228
/**Main.java**Createdon2007年11月8日,上午9:15*/packagetest1;importjava.awt.datatransfer.DataFlavor;importjava.awt.datatransfer.Transferable;importjava.awt.datatransfer.UnsupportedFlavorException;impor...
修改文件MD5值
weixin_30477293的博客
04-19 2342
1.查看文件的MD5值 （1）下载MD5Checker http://getmd5checker.com/download.html 或者 链接: https://pan.baidu.com/s/1eawHWFkSwbdR9ch9w67Bfg 提取码: f77p （2）打开MD5Checker工具，直接将要查看的文件拖至工具列表中，或者点击添加 2.修改文件的MD5值 举个例子...
java对文件进行md5加密,对文件进行 MD5 加密
weixin_29231027的博客
03-22 1007
/** * 对文件进行 MD5 加密 * * @param file * 待加密的文件 * * @return 文件加密后的 MD5 值 * @throws IOException */ public static String md5(File file) throws IOException { FileInputStream is = new F...
文件合并（图片+视频），修改md5值，隐藏文件
qq_40734247的博客
01-01 1969
图片文件合并 前几天，写Java爬虫的时候，偶然间发现图像的数据重合起来了，然后图片就产生了问题。（可能也有的没有问题，那我也看不出来了，哈！） 可以参考这篇博客：简单Java爬虫 因为图片重合的原因，我就突发奇想，把很多张图片数据存入一个文件中，这样做的话，可以用于隐藏某些文件，然后需要的时候再将它们分隔开来 ，这样似乎很有趣，有想法就要付诸实践。所以，就写了一个demo程序，顺便写一个博客，来...
centos 流量统计
09-06
1. 首先，你需要修改nginx配置文件来启用流量统计模块。编辑nginx配置文件（一般是`/usr/local/nginx/conf/nginx.conf`），在server配置块中添加以下配置： ``` location ~/status { stub_status on; # 开启流量...
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

狂飙的yellowcong

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值