integrated_traffic/src/main/java/com/zcloud/util/FileUtil.java

package com.zcloud.util;

import com.zcloud.entity.PageData;
import org.bytedeco.javacv.FFmpegFrameGrabber;
import org.bytedeco.javacv.Frame;
import org.bytedeco.javacv.Java2DFrameConverter;
import org.springframework.web.multipart.MultipartFile;
import sun.misc.BASE64Encoder;

import javax.imageio.ImageIO;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.ByteBuffer;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.FileChannel.MapMode;
import java.util.ArrayList;
import java.util.Base64;
import java.util.List;

/**
 * 说明：文件处理
 * 作者：luoxiaobao
 * 官网：www.qdkjchina.com
 */
public class FileUtil {

	/**获取文件大小 返回 KB 保留3位小数  没有文件时返回0
	 * @param filepath 文件完整路径，包括文件名
	 * @return
	 */
	public static Double getFilesize(File backupath){
		return Double.valueOf(backupath.length())/1000.000;
	}


	/**获取文件大小 返回 KB 保留3位小数  没有文件时返回0
	 * @param filepath 文件完整路径，包括文件名
	 * @return
	 */
	public static Double getFilesize(String filepath){
		File backupath = new File(filepath);
		return Double.valueOf(backupath.length())/1000.000;
	}

	/**
	 * 创建目录
	 * @param destDirName目标目录名
	 * @return
	 */
	public static Boolean createDir(String destDirName) {
		File dir = new File(destDirName);
		if(!dir.getParentFile().exists()){				//判断有没有父路径，就是判断文件整个路径是否存在
			return dir.getParentFile().mkdirs();		//不存在就全部创建
		}
		return false;
	}

	/**
	 * 删除文件
	 * @param filePathAndName
	 *            String 文件路径及名称 如c:/fqf.txt
	 * @param fileContent
	 *            String
	 * @return boolean
	 */
	public static void delFile(String filePathAndName) {
		try {
			String filePath = filePathAndName;
			filePath = filePath.toString();
			File myDelFile = new File(filePath);
			myDelFile.delete();
		} catch (Exception e) {
			System.out.println("删除文件操作出错");
			e.printStackTrace();
		}
	}

	/**
	 * 读取到字节数组0
	 * @param filePath //路径
	 * @throws IOException
	 */
	public static byte[] getContent(String filePath) throws IOException {
		File file = new File(filePath);
		long fileSize = file.length();
		if (fileSize > Integer.MAX_VALUE) {
			System.out.println("file too big...");
			return null;
		}
		FileInputStream fi = new FileInputStream(file);
		byte[] buffer = new byte[(int) fileSize];
		int offset = 0;
		int numRead = 0;
		while (offset < buffer.length
				&& (numRead = fi.read(buffer, offset, buffer.length - offset)) >= 0) {
			offset += numRead;
		}
		// 确保所有数据均被读取
		if (offset != buffer.length) {
			throw new IOException("Could not completely read file " + file.getName());
		}
		fi.close();
		return buffer;
	}

	/**
	 * 读取到字节数组1
	 *
	 * @param filePath
	 * @return
	 * @throws IOException
	 */
	public static byte[] toByteArray(String filePath) throws IOException {

		File f = new File(filePath);
		if (!f.exists()) {
			throw new FileNotFoundException(filePath);
		}
		ByteArrayOutputStream bos = new ByteArrayOutputStream((int) f.length());
		BufferedInputStream in = null;
		try {
			in = new BufferedInputStream(new FileInputStream(f));
			int buf_size = 1024;
			byte[] buffer = new byte[buf_size];
			int len = 0;
			while (-1 != (len = in.read(buffer, 0, buf_size))) {
				bos.write(buffer, 0, len);
			}
			return bos.toByteArray();
		} catch (IOException e) {
			e.printStackTrace();
			throw e;
		} finally {
			try {
				in.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
			bos.close();
		}
	}

	/**
	 * 读取到字节数组2
	 *
	 * @param filePath
	 * @return
	 * @throws IOException
	 */
	public static byte[] toByteArray2(String filePath) throws IOException {
		File f = new File(filePath);
		if (!f.exists()) {
			throw new FileNotFoundException(filePath);
		}
		FileChannel channel = null;
		FileInputStream fs = null;
		try {
			fs = new FileInputStream(f);
			channel = fs.getChannel();
			ByteBuffer byteBuffer = ByteBuffer.allocate((int) channel.size());
			while ((channel.read(byteBuffer)) > 0) {
				// do nothing
				// System.out.println("reading");
			}
			return byteBuffer.array();
		} catch (IOException e) {
			e.printStackTrace();
			throw e;
		} finally {
			try {
				channel.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
			try {
				fs.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

	/**
	 * Mapped File way MappedByteBuffer 可以在处理大文件时，提升性能
	 *
	 * @param filename
	 * @return
	 * @throws IOException
	 */
	public static byte[] toByteArray3(String filePath) throws IOException {

		FileChannel fc = null;
		RandomAccessFile rf = null;
		try {
			rf = new RandomAccessFile(filePath, "r");
			fc = rf.getChannel();
			MappedByteBuffer byteBuffer = fc.map(MapMode.READ_ONLY, 0,
					fc.size()).load();
			//System.out.println(byteBuffer.isLoaded());
			byte[] result = new byte[(int) fc.size()];
			if (byteBuffer.remaining() > 0) {
				// System.out.println("remain");
				byteBuffer.get(result, 0, byteBuffer.remaining());
			}
			return result;
		} catch (IOException e) {
			e.printStackTrace();
			throw e;
		} finally {
			try {
				rf.close();
				fc.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

	public static byte[] toByteArray4(String filePath) throws IOException {

		URL url = new URL(filePath);
		InputStream inputStream=null;
		try {
			inputStream=url.openStream();
			ByteArrayOutputStream output = new ByteArrayOutputStream();
			byte[] buffer = new byte[1024*4];
			int n = 0;
			while (-1 != (n = inputStream.read(buffer))) {
				output.write(buffer, 0, n);
			}
			return output.toByteArray();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
			throw e;
		} catch (IOException e) {
			e.printStackTrace();
			throw e;
		} finally {
			try {
				inputStream.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

	/**
	 * 往文件里的内容
	 * @param filePath  文件路径
	 * @param content  写入的内容
	 */
	public static void writeFile(String fileP,String content){
		String filePath = String.valueOf(Thread.currentThread().getContextClassLoader().getResource(""))+"../../";	//项目路径
		filePath = filePath.replaceAll("file:/", "");
		filePath = filePath.replaceAll("%20", " ");
		filePath = filePath.trim() + fileP.trim();
		if(filePath.indexOf(":") != 1){
			filePath = File.separator + filePath;
		}
		try {
			OutputStreamWriter write = new OutputStreamWriter(new FileOutputStream(filePath),"utf-8");
			BufferedWriter writer=new BufferedWriter(write);
			writer.write(content);
			writer.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}


	/**读取文本里的全部内容
	 * @param filePath  文件路径
	 * @param encoding  编码
	 * @return
	 */
	public static String readTxtFileAll(String filePath, String encoding) {
		StringBuffer fileContent = new StringBuffer();
		try {
			filePath = filePath.replaceAll("file:/", "");
			filePath = filePath.replaceAll("%20", " ");
			filePath = filePath.trim();
			if(filePath.indexOf(":") != 1){
				filePath = File.separator + filePath;
			}
			File file = new File(filePath);
			if (file.isFile() && file.exists()) { 		// 判断文件是否存在
				InputStreamReader read = new InputStreamReader(
						new FileInputStream(file), encoding);	// 考虑到编码格式
				BufferedReader bufferedReader = new BufferedReader(read);
				String lineTxt = null;
				while ((lineTxt = bufferedReader.readLine()) != null) {
					fileContent.append(lineTxt);
					fileContent.append("\n");
				}
				read.close();
			}else{
				System.out.println("找不到指定的文件,查看此路径是否正确:"+filePath);
			}
		} catch (Exception e) {
			System.out.println("读取文件内容出错");
		}
		return fileContent.toString();
	}

	/**
	 * MultipartFile file转换成为File
	 * @param multiFile
	 * @return
	 */
	public static File MultipartFileToFile(MultipartFile multiFile) {
		// 获取文件名
		String fileName = multiFile.getOriginalFilename();
		// 获取文件后缀
		String prefix = fileName.substring(fileName.lastIndexOf("."));
		fileName = UuidUtil.get32UUID()+prefix;
		// 若需要防止生成的临时文件重复,可以在文件名后添加随机码

		try {
			File file = File.createTempFile(fileName, prefix);
			multiFile.transferTo(file);
			return file;
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}

	/**
	 * 在视频中截取N张照片，返回base64list.
	 * 如果  imgNum > 视频总帧数，  则视频多少帧。返回多少张图片
	 * 如 imgNum 为 10 , 视频总共有5帧 。则返回5张照片
	 *
	 * @param file   视频文件
	 * @param imgNum 截取图片数量
	 * @throws Exception
	 */
	public static List<PageData> fetchVideoToBase64List(File file, int imgNum) throws Exception {
		List<PageData> picBase64List = new ArrayList<PageData>();
		PageData picBase64 = new PageData();
		FFmpegFrameGrabber ff = new FFmpegFrameGrabber(file);
		ff.start();
		String rotate_old = ff.getVideoMetadata("rotate");//视频旋转角度，可能是null
		int lenght = ff.getLengthInFrames();
		int interval = lenght / imgNum;
		int i = 1;
		Frame f = null;
//        while (ff.getFrameNumber() == 0) {
//            f = ff.grabFrame();
//        }
		for (int s = 0; s < lenght; s++) {
			if (s >= i * interval) {
				f = ff.grabFrame();
				System.out.println("当前是第"+ff.getFrameNumber()+"帧----------");
				if (f != null && f.image != null) {
					picBase64.put("picBase64", getBase64FromFrame(f).replaceAll("\\s*", ""));
					picBase64.put("rotate_old", rotate_old);
					picBase64List.add(picBase64);
					Java2DFrameConverter converter = new Java2DFrameConverter();
					BufferedImage fecthedImage = converter.getBufferedImage(f);
					BufferedImage bi = new BufferedImage(f.imageWidth, f.imageHeight, BufferedImage.TYPE_3BYTE_BGR);


					bi.getGraphics().drawImage(fecthedImage.getScaledInstance(f.imageWidth, f.imageHeight, Image.SCALE_SMOOTH),
							0, 0, null);

					i++;
				}
			}


		}
		ff.stop();

		return picBase64List;
	}


	/**
	 * 图片旋转
	 *
	 * @param fullPath 图片路径
	 * @param angel    旋转角度
	 * @return
	 */
	public static String rotatePhonePhoto(String fullPath, int angel) {
		BufferedImage src;
		try {
			src = ImageIO.read(new File(fullPath));
			int src_width = src.getWidth(null);
			int src_height = src.getHeight(null);

			int swidth = src_width;
			int sheight = src_height;

			if (angel == 90 || angel == 270) {
				swidth = src_height;
				sheight = src_width;
			}
			Rectangle rect_des = new Rectangle(new Dimension(swidth, sheight));
			BufferedImage res = new BufferedImage(rect_des.width, rect_des.height, BufferedImage.TYPE_INT_RGB);
			Graphics2D g2 = res.createGraphics();
			g2.translate((rect_des.width - src_width) / 2, (rect_des.height - src_height) / 2);
			g2.rotate(Math.toRadians(angel), src_width / 2, src_height / 2);
			g2.drawImage(src, null, null);
			ImageIO.write(res, "jpg", new File(fullPath));
		} catch (Exception e) {
			e.printStackTrace();
		}
		return fullPath;

	}

	/**
	 * 将截取的帧生成文件或者生成base64 字符串
	 *
	 * @param frame
	 * @return
	 */
	public static String getBase64FromFrame(Frame frame) {
		String imgFormat = "jpg";
		Java2DFrameConverter converter = new Java2DFrameConverter();
		BufferedImage srcBi = converter.getBufferedImage(frame);
		// 可以选择对截取的帧进行等比例缩放
//        int owidth = srcBi.getWidth();
//        int oheight = srcBi.getHeight();
//        int width = 800;
//        int height = (int) (((double) width / owidth) * oheight);
//        BufferedImage bi = new BufferedImage(width, height, BufferedImage.TYPE_3BYTE_BGR);
//        bi.getGraphics().drawImage(srcBi.getScaledInstance(width, height, 800), 0, 0, null);
		try {
			ByteArrayOutputStream output = new ByteArrayOutputStream();
			// ImageIO工具类提供了将图片写成文件或者outputStream中
//            ImageIO.write(bi, imgFormat, targetFile);
			ImageIO.write(srcBi, imgFormat, output);
			// 这里需要获取图片的base64数据串，所以将图片写到流里面
			return new BASE64Encoder().encode(output.toByteArray());
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}
	/**
	 * 网路路径或本地路径转base64
	 *
	 * @throws Exception
	 */
	public static String encodeBase64File(String url) throws Exception {
		ByteArrayOutputStream outPut = new ByteArrayOutputStream();   //网络路径
		byte[] data = new byte[1024];
		try {
			// 创建URL
			URL path = new URL(url);
			// 创建链接
			HttpURLConnection conn = (HttpURLConnection) path.openConnection();
			conn.setRequestMethod("GET");
			conn.setConnectTimeout(10 * 1000);

			if (conn.getResponseCode() != 200) {
				return "fail";//连接失败/链接失效/图片不存在
			}
			InputStream inStream = conn.getInputStream();
			int len = -1;
			while ((len = inStream.read(data)) != -1) {
				outPut.write(data, 0, len);
			}
			inStream.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
		// 对字节数组Base64编码
		byte[] encode = Base64.getEncoder().encode(outPut.toByteArray());
		String res = new String(encode);
		return res;
//		File file = new File(url);    //本地路径
//		FileInputStream inputFile = new FileInputStream(file);
//		byte[] buffer = new byte[(int) file.length()];
//		inputFile.read(buffer);
//		inputFile.close();
//		return new BASE64Encoder().encode(buffer);
	}
}