精华内容
下载资源
问答
  • Java实现文件上传

    万次阅读 2017-05-19 13:47:07
    Java实现将本地文件上传到服务器并保存实现文件上传需要用的的jar包:commons-fileupload 和 commons-io1.将form表单的 enctype 设置为:multipart/form-data , method 设置为 post , 使用类型为 file 的input上传...

    Java实现将本地文件上传到服务器并保存

    实现文件上传需要用的的jar包:commons-fileupload 和 commons-io

    1.将form表单的 enctype 设置为:multipart/form-data , method 设置为 post , 使用类型为 file 的input上传文件。

    2.后台代码

    //创建文件工厂对象
      DiskFileItemFactory factory=new DiskFileItemFactory();
    //将文件保存在内存还是磁盘临时文件夹的临界值 
      factory.setSizeThreshold(1024*200);
      File tempDirectory=new File("d:\\tempDirectory");
      factory.setRepository(tempDirectory);
    //文件上传类
      ServletFileUpload upload=new ServletFileUpload(factory);
    
    //设置上传的文件大小临界值,超出会报错
      upload.setSizeMax(1024*1024*5);
      String fileName=null;
      String name=null;
      String pcDate=null;
    //接收用户上传信息
      try {
            List<FileItem> items=upload.parseRequest(request);
            //遍历items
             for (FileItem item:items) {
            //一般表单域
                if (item.isFormField()) {
                    name=item.getFieldName();
                    pcDate=item.getString();
                    }
                //若是文件域则把文件保存到d盘临时文件夹
                else {
                      String fieldName=item.getFieldName();
                    //上传的文件名
                      fileName=item.getName();
                    //上传的文件类型
                      String contentType=item.getContentType();
                    //上传的文件大小
                      long sizeInBytes=item.getSize();
    
            //可判断文件类型,若不符合类型要求则不保存,这里没有处理文件类型
                      InputStream in=item.getInputStream();
                      byte[] buffer=new byte[1024];
                      int len=0;
                File file=new File("d:\\tempDirectory\\"+fileName);
                    item.write(file);                               
                }
            }
        } catch (Exception e) {
                e.printStackTrace();
        }
    }

    以上就是文件上传的所有步骤,有需要的小伙伴可以参考一下。

    展开全文
  • java实现文件上传oss服务

    千次阅读 2019-02-27 11:42:59
    java实现文件上传oss服务 首先是pom.xml引入对应的jar包 &lt;!-- OSS文件上传 start --&gt; &lt;dependency&gt; &lt;groupId&gt;commons-httpclient&lt;/groupId&gt; &lt...

    java实现文件上传oss服务

    首先是pom.xml引入对应的jar包

    	<!-- OSS文件上传 start -->
    	<dependency>
    		<groupId>commons-httpclient</groupId>
    		<artifactId>commons-httpclient</artifactId>
    		<version>3.1</version>
    		<exclusions>
    			<exclusion>
    				<groupId>commons-codec</groupId>
    				<artifactId>commons-codec</artifactId>
    				<!--<version>1.2</version> -->
    			</exclusion>
    		</exclusions>
    	</dependency>
    	<dependency>
    		<groupId>commons-fileupload</groupId>
    		<artifactId>commons-fileupload</artifactId>
    		<version>1.3.1</version>
    	</dependency>
    	<dependency>
    		<groupId>commons-io</groupId>
    		<artifactId>commons-io</artifactId>
    		<version>2.5</version>
    	</dependency>
    	<dependency>
    		<groupId>com.alibaba</groupId>
    		<artifactId>druid</artifactId>
    		<version>1.1.6</version>
    	</dependency>
    	<!-- 支付宝授权认证 -->
    	<dependency>
    		<groupId>com.alipay.user.info.auth</groupId>
    		<artifactId>user-info-auth</artifactId>
    		<version>20161102120103</version>
    	</dependency>
    	<dependency>
    		<groupId>com.aliyun.oss</groupId>
    		<artifactId>oss</artifactId>
    		<version>2.2.1</version>
    	</dependency>
    	<dependency>
    		<groupId>commons-codec</groupId>
    		<artifactId>commons-codec</artifactId>
    		<version>1.9</version>
    	</dependency>
    	<dependency>
    		<groupId>commons-logging</groupId>
    		<artifactId>commons-logging</artifactId>
    		<version>1.2</version>
    	</dependency>
    	<dependency>
    		<groupId>org.hamcrest</groupId>
    		<artifactId>hamcrest-core</artifactId>
    		<version>1.1</version>
    	</dependency>
    	<dependency>
    		<groupId>org.jdom</groupId>
    		<artifactId>jdom</artifactId>
    		<version>1.1</version>
    	</dependency>
    	<dependency>
    		<groupId>org.apache.httpcomponents</groupId>
    		<artifactId>httpclient</artifactId>
    		<version>4.4.1</version>
    	</dependency>
    	<dependency>
    		<groupId>org.apache.httpcomponents</groupId>
    		<artifactId>httpcore</artifactId>
    		<version>4.4.1</version>
    	</dependency>
    	<!-- OSS文件上传 end -->
    

    文件上传工具类

    package com.asphalt.common.upload;
    
    import java.io.ByteArrayInputStream;
    import java.io.File;
    
    import org.slf4j.Logger;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.stereotype.Component;
    
    import com.alibaba.druid.util.StringUtils;
    import com.aliyun.oss.ClientException;
    import com.aliyun.oss.OSSClient;
    import com.aliyun.oss.OSSException;
    import com.aliyun.oss.model.GetObjectRequest;
    import com.asphalt.common.LoggerProxy;
    
    /**
     * 文件上传工具类
     * 
     * @author issuser
     * @date   2016-10-22
     */
    @Component
    public class FileUploadUtils {
    	
    	private static Logger logger=LoggerProxy.ProxyLogger(FileUploadUtils.class);
    	
    /*	private static String ossUrl = PropertiesUtil.GetValueByKey("application.properties", "asphalt.oss_url");
    	private static String bucketName = PropertiesUtil.GetValueByKey("application.properties", "asphalt.bucket_name");
    	private static String accessKeyId = PropertiesUtil.GetValueByKey("application.properties", "asphalt.access_key_id");
    	private static String accessKeySecret = PropertiesUtil.GetValueByKey("application.properties", "asphalt.access_key_secret");*/
    		
    	@Value("${asphalt.oss_url}")
    	private String ossUrl;
    	@Value("${asphalt.bucket_name}")
    	private String bucketName;
    	@Value("${asphalt.access_key_id}")
    	private String accessKeyId;
    	@Value("${asphalt.access_key_secret}")
    	private String accessKeySecret;
    	    
    
    	//Constructs a client instance with your account for accessing OSS
    	private static OSSClient client = null;
    	public OSSClient getInstance()
    	{
    		if(null == client)
    		{
    			client = new OSSClient(ossUrl, accessKeyId, accessKeySecret);
    		}
    		return client;
    	}
    	
    	/**
    	 * 文件上传
    	 * @param uploadFile
    	 * @return
    	 */
    	public boolean upload(File uploadFile) {
    		try {
    			if(uploadFile == null){
    				return false;
    			}
    			
    			getInstance().putObject(bucketName, uploadFile.getName(), uploadFile);
    			logger.info("FileUploadUtils#upload success: bucketName="+bucketName+", filename="+uploadFile.getName());
    			return true;
    		} catch (OSSException oe) {
    			logger.error("OSSException", oe);
    		} catch (ClientException ce) {
    			logger.error("ClientException", ce);
    		} 
    		return false;
    	}
    	
    	
    	/**
    	 * 文件上传
    	 * @param parentFolder 要上传的目录
    	 * @param filename	   文件名称
    	 * @param uploadFile
    	 * @return
    	 */
    	public boolean upload(String parentFolder, String filename, File uploadFile) {
    		try {
    			if(uploadFile == null || StringUtils.isEmpty(filename)){
    				return false;
    			}
    			
    			getInstance().putObject(bucketName, parentFolder + "/" +filename, uploadFile);
    			
    			logger.info("FileUploadUtils#upload success: bucketName="+bucketName+", parentFolder="+ parentFolder +", filename=" + filename);
    			
    			return true;
    		} catch (OSSException oe) {
    			logger.error("OSSException" ,oe);
    		} catch (ClientException ce) {
    			logger.error("ClientException" ,ce);
    		} 
    		return false;
    	}
    	
    	/**
    	 * 下載文件(oss文件下載)
    	 * @param file	下載文件的名字(文件名称或文件路径+名称)
    	 * @param path	下載文件的存放地址
    	 * @return
    	 */
    	public boolean download(String filename, String path){
    		boolean flag = false;
    		try{
    			getInstance().getObject(new GetObjectRequest(bucketName, filename), new File(path));
    		}catch(Exception e){
    			logger.error("FileUploadUtils#downloadFile occur error: filename="+filename+", path="+path, e);
    			return flag;
    		}
    		
    		logger.info("FileUploadUtils#downloadFile success: filename="+filename+", path="+path);
    		return true;
    	}
    	
    	
    	/**
    	 * 创建文件夹
    	 * @param folderName
    	 * @return
    	 */
    	public boolean createFolder(String folderName){
    		
    		try {
    			if(StringUtils.isEmpty(folderName)){
    				return false;
    			}
    			
    			if(!folderName.endsWith("/")){
    				folderName = folderName + "/";
    			}
    			
    			//Create an empty folder without request body, note that the key must be suffixed with a slash
    			getInstance().putObject(bucketName, folderName, new ByteArrayInputStream(new byte[0]));
    			logger.info("FileUploadUtils#createFolder success: folder name is " + folderName);
    			
    			return true;
    		} catch (OSSException oe) {
    			logger.error("OSSException" ,oe);
    		} catch (ClientException ce) {
    			logger.error("ClientException" ,ce);
    		} 
    		return false;
    	}
    	
    	
    	/**
    	 * 删除文件
    	 * 
    	 * @param filename   文件名字(全名-路径+文件名)
    	 * @return
    	 */
    	public boolean deleteFile(String filename){
    		
    		try {
    			if(StringUtils.isEmpty(filename)){
    				return false;
    			}
    			//OSSObject object = client.getObject(bucketName, filename);
    			
    			//client.deleteObject(bucketName, object.getKey());
    			getInstance().deleteObject(bucketName, filename);
    			
    			return true;
    		} catch (OSSException oe) {
    			logger.error("OSSException" ,oe);
    		} catch (ClientException ce) {
    			logger.error("ClientException" ,ce);
    		} 
    		return false;
    	}
    	
    	
    	/**
    	 * 删除文件
    	 * 
    	 * @param filename   文件夹名称
    	 * @return
    	 */
    	public boolean deleteFolder(String foldername){
    		
    		try {
    			if(StringUtils.isEmpty(foldername)){
    				return false;
    			}
    			
    			if(!foldername.endsWith("/")){
    				foldername = foldername + "/";
    			}
    			//OSSObject object = client.getObject(bucketName, filename);
    			
    			//client.deleteObject(bucketName, object.getKey());
    			getInstance().deleteObject(bucketName, foldername);
    			
    			return true;
    		} catch (OSSException oe) {
    			logger.error("OSSException" ,oe);
    		} catch (ClientException ce) {
    			logger.error("ClientException" ,ce);
    		} 
    		return false;
    	}
    
    	/**
    	 * 打印上
    	 * @param uploadId
    	 */
    	/*private static void listAllParts(String uploadId) {
    	    logger.info("Listing all parts......");
    	    ListPartsRequest listPartsRequest = new ListPartsRequest(bucketName, fileName, uploadId);
    	    PartListing partListing = client.listParts(listPartsRequest);
    	    
    	    int partCount = partListing.getParts().size();
    	    for (int i = 0; i < partCount; i++) {
    	        PartSummary partSummary = partListing.getParts().get(i);
    	        logger.info("\tPart#" + partSummary.getPartNumber() + ", ETag=" + partSummary.getETag());
    	    }
    	}*/
    }
    

    上传文件封装

    package com.asphalt.common.upload;
    
    import java.io.File;
    import java.text.DateFormat;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    import java.util.HashMap;
    import java.util.Map;
    import javax.servlet.http.HttpServletRequest;
    import org.slf4j.Logger;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.stereotype.Component;
    import org.springframework.util.FileCopyUtils;
    import org.springframework.web.multipart.MultipartFile;
    import org.springframework.web.multipart.MultipartHttpServletRequest;
    
    import com.asphalt.common.LoggerProxy;
    import com.asphalt.common.MD5;
    
    /**
     * 上传文件到oss服务器
     * @author as
     *
     */
    @Component
    public class FileUploadOSSUtil {
    	
    	private static Logger logger=LoggerProxy.ProxyLogger(FileUploadOSSUtil.class);
    	
    	@Autowired
    	private FileUploadUtils fileUploadUtils;
    	
    	
    /*	private static final String FILE_PATH = PropertiesUtil.GetValueByKey("application.properties", "asphalt.file_path");
    	private static final String OSS_URL = PropertiesUtil.GetValueByKey("application.properties", "asphalt.oss_url");//http://oss-cn-hangzhou.aliyuncs.com
    	private static final String BUCKET_NAME = PropertiesUtil.GetValueByKey("application.properties", "asphalt.bucket_name");//oss-dev-1
    */	
    	//上传到本地服务器的路径
    	@Value("${asphalt.file_path}")
    	private String FILE_PATH;
    	@Value("${asphalt.oss_url}")
    	private String OSS_URL;
    	@Value("${asphalt.bucket_name}")
    	private String BUCKET_NAME;
    	
    	/**
    	 * 上传文件到OSS服务器
    	 * @param request
    	 * @return Map<String, Object>
    	 */
    	public Map<String, Object> uploadFileToOSS(HttpServletRequest request ,String fileFieldName) {
    		Map<String, Object> map = new HashMap<String, Object>();
    		String destPath = null;
    		try {
    			MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
    	        // 获取上传的文件
    	        MultipartFile file = multipartRequest.getFile(fileFieldName); 
    	        //如果上传的文件不存在
    	        if (file.isEmpty()) {
    	            map.put("success", false);
    	            map.put("msg", "上传文件不存在");
    	        } else {
    	        	//上传的原始文件名
    //	        	String origFileName = new String(file.getOriginalFilename().getBytes("ISO-8859-1"), "UTF-8");
    	        	String origFileName = file.getOriginalFilename();
    	        	//文件类型
    	        	String changeFileName = origFileName.substring(origFileName.lastIndexOf("."), origFileName.length());
    	        	//自定义文件名称
    	            String fileName = getNowDate() + "-" + System.currentTimeMillis() + changeFileName;
    	            //上传到本地服务器的路径
    	            File file1 =new File(FILE_PATH);
    	            //如果文件夹不存在,则创建    
    	            if  (!file1.exists() && !file1.isDirectory()) {       
    	                file1.mkdir();    
    	            }
    	            //上传到本地服务器的文件名称(路径+名称)
    	            destPath = FILE_PATH + fileName;
    	            //将文件上传到本地服务器路径
                	FileCopyUtils.copy(file.getBytes(), new File(destPath));
                	
    		        //文件头编码,判断文件
    		        //校验上传文件的类型,根据后缀
    		        String fileByFile = changeFileName.substring(1);
    		        boolean checkType = CheckFileType.checkType(fileByFile, uploadFileTypeList());
    		        if (checkType) {
    		        	//上传到OSS服务器的文件夹
    		        	String parentFolder = getParentFolder();
    		        	//将本地服务器的文件上传
    		        	File upFile = new File(destPath);
    		        	//上传OSS是否成功
    		        	boolean isUploadSuccess = fileUploadUtils.upload(parentFolder, fileName, upFile);
    		        	map.put("success", isUploadSuccess);
    		        	//如果上传成功,则获取上传文件地址
    		        	if(isUploadSuccess) {
    		        		String ossFileUrl = getFileOSSUrl(parentFolder ,fileName);
    		        		map.put("origFileName", origFileName);
    		        		map.put("ossFileUrl", ossFileUrl);
    		        		map.put("msg", "文件上传成功");
    		        	} else {
    		        		map.put("msg", "文件上传文件服务器失败");
    		        	}
    		        } else {
    		        	map.put("sucess", false);
    					map.put("msg", "上传文件类型不正确");
    		        }
    		        //删除本地文件
    		        deleteFile(destPath);
    	        }
    		} catch(Exception e) {
    			logger.error("文件上传oss异常",e);
    			map.put("success",false);
    			map.put("msg","文件上传失败");
    			//删除本地文件
    			deleteFile(destPath);
            }
            return map;
    	}
    	
    	/**
    	 * 上传文件到OSS服务器
    	 * @param request
    	 * @return Map<String, Object>
    	 */
    	public Map<String, Object> uploadFileToOSS2(HttpServletRequest request ,String fileFieldName) {
    		Map<String, Object> map = new HashMap<String, Object>();
    		String destPath = null;
    		try {
    			MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
    	        // 获取上传的文件
    	        MultipartFile file = multipartRequest.getFile(fileFieldName); 
    	        //如果上传的文件不存在
    	        if (file.isEmpty()) {
    	            map.put("success", false);
    	            map.put("msg", "上传文件不存在");
    	        } else {
    	        	//上传的原始文件名
    //	        	String origFileName = new String(file.getOriginalFilename().getBytes("ISO-8859-1"), "UTF-8");
    	        	String origFileName = file.getOriginalFilename();
    	        	long fileSize = file.getSize();
    	        	//文件类型
    	        	String changeFileName = origFileName.substring(origFileName.lastIndexOf("."), origFileName.length());
    	        	//自定义文件名称
    	            String fileName = getNowDate() + "-" + System.currentTimeMillis() + changeFileName;
    	            //上传到本地服务器的路径
    	            File file1 =new File(FILE_PATH);
    	            //如果文件夹不存在,则创建    
    	            if  (!file1 .exists() && !file1 .isDirectory()) {       
    	                file1 .mkdir();    
    	            }
    	            //上传到本地服务器的文件名称(路径+名称)
    	            destPath = FILE_PATH + fileName;
    	            //将文件上传到本地服务器路径
                	FileCopyUtils.copy(file.getBytes(), new File(destPath));
                	String fileMD5 = MD5.getMD5(new File(destPath));
                	
    		        //文件头编码,判断文件,目前只能判断,xls,xlxs,zip,rar
    		        //校验上传文件的类型,根据后缀
    		        String fileByFile = changeFileName.substring(1);
    		        boolean checkType = CheckFileType.checkType(fileByFile, uploadFileTypeList());
    		        if (checkType) {
    		        	//上传到OSS服务器的文件夹
    		        	String parentFolder = getParentFolder();
    		        	//将本地服务器的文件上传
    		        	File upFile = new File(destPath);
    		        	//上传OSS是否成功
    		        	boolean isUploadSuccess = fileUploadUtils.upload(parentFolder, fileName, upFile);
    		        	map.put("success", isUploadSuccess);
    		        	//如果上传成功,则获取上传文件地址
    		        	if(isUploadSuccess) {
    		        		String ossFileUrl = getFileOSSUrl(parentFolder ,fileName);
    		        		map.put("origFileName", origFileName);
    		        		map.put("ossFileUrl", ossFileUrl);
    		        		map.put("filePath", destPath);
    		        		map.put("fileSize", fileSize);
    		        		map.put("fileMD5", fileMD5);
    		        		map.put("msg", "文件上传成功");
    		        	} else {
    		        		map.put("msg", "文件上传文件服务器失败");
    		        	}
    		        } else {
    		        	map.put("sucess", false);
    					map.put("msg", "上传文件类型不正确");
    					//删除本地文件
    					deleteFile(destPath);
    		        }
    	        }
    		} catch(Exception e) {
    			logger.error("文件上传oss异常",e);
    			map.put("success",false);
    			map.put("msg","文件上传失败");
    			//删除本地文件
    			deleteFile(destPath);
            }
            return map;
    	}
    	
    	
    	
    	/**
    	 * 根据规则,获取OSS文件路径
    	 * @param parentFolder 父目录
    	 * @param fileName 文件名称
    	 * @return String
    	 */
    	public  String getFileOSSUrl(String parentFolder , String fileName) {
    		String prefix = "http://";
    		String webSlash = "/";
    		String genUrl = null;
    		if(OSS_URL != null) {
    			String domainName = OSS_URL.substring(7);
    			genUrl = prefix + BUCKET_NAME + "." + domainName;
    		}
    		genUrl = (genUrl == null ? OSS_URL : genUrl);
    		return genUrl + webSlash + parentFolder + webSlash + fileName;
    	}
    	
    	/**
    	 * 当前时间
    	 * @return
    	 */
    	public String getParentFolder() {
    		String ossPath = "isoftportalsweb/" + new SimpleDateFormat("yyyyMMdd").format(new Date());
    		return ossPath;
    	}
    	
    	/**
    	 * 当前时间
    	 * @return
    	 */
    	public static String getNowDate() {
    		DateFormat df = new SimpleDateFormat("yyyyMMddHHmmss");
    		return df.format(new java.util.Date());
    	}
    	
    	/**
    	 * 删除本地服务器文件
    	 * @param filePath
    	 */
    	public static void deleteFile(String filePath) {
    		if (new File(filePath).exists()) {
            	new File(filePath).delete();
    		}
    	}
    	
    	/**
    	 * 允许上传文件类型列表 
    	 * @return String[] 上传文件类型列表
    	 */
    	private static String[] uploadFileTypeList() {
    		return new String[] {"JPG", "JPEG", "BMP", "PNG", "GIF" ,"XLS", "XLSX"};
    	}
    	
    }
    

    MD5类

    package com.asphalt.common;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.IOException;
    import java.io.UnsupportedEncodingException;
    import java.security.MessageDigest;
    import java.security.NoSuchAlgorithmException;
    
    public class MD5 {
    	
    	static char hexDigits[]={'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'};
    	
    	public static String getString(String s) throws Exception{
            char str[];
            byte strTemp[] = null;
    		try {
    			strTemp = s.getBytes("Utf-8");
    		} catch (UnsupportedEncodingException e1) {
    			e1.printStackTrace();
    		}
             if(strTemp==null) {
            	 throw new Exception("编码出错");
             }
            MessageDigest mdTemp;
            try {
                mdTemp = MessageDigest.getInstance("MD5");
                mdTemp.update(strTemp);
                byte md[]=mdTemp.digest();
                int j=md.length;
                str=new char[j*2];
                int k=0;
                for(int i=0;i<j;i++){
                    byte byte0=md[i];
                    str[k++]=hexDigits[byte0>>>4&0xf];
                    str[k++]=hexDigits[byte0&0xf];
                }
                return new String(str);
            } catch (NoSuchAlgorithmException e) {
                //throw e;
            	return "";
            }
        }
    	
        /** 
         * @funcion 对文件全文生成MD5摘要  
         * @param file:要加密的文件 
         * @return MD5摘要码 
         */  
        public static String getMD5(File file) {  
            FileInputStream fis = null;  
            try {  
                MessageDigest md = MessageDigest.getInstance("MD5");  
                fis = new FileInputStream(file);  
                byte[] buffer = new byte[2048];  
                int length = -1;  
                while ((length = fis.read(buffer)) != -1) {  
                    md.update(buffer, 0, length);  
                }  
                byte[] b = md.digest();  
                return byteToHexString(b);  
            } catch (Exception e) {  
                e.printStackTrace();  
                return null;  
            } finally {  
                try {  
                    fis.close();  
                } catch (IOException e) {  
                    e.printStackTrace();  
                }  
            }  
        }   
      
        /** 
         * @function 把byte[]数组转换成十六进制字符串表示形式 
         * @param tmp  要转换的byte[] 
         * @return 十六进制字符串表示形式 
         */  
        private static String byteToHexString(byte[] tmp) {  
            String s;  
            // 用字节表示就是 16 个字节  
            // 每个字节用 16 进制表示的话,使用两个字符,所以表示成 16 进制需要 32 个字符  
            // 比如一个字节为01011011,用十六进制字符来表示就是“5b”  
            char str[] = new char[16 * 2];  
            int k = 0; // 表示转换结果中对应的字符位置  
            for (int i = 0; i < 16; i++) { // 从第一个字节开始,对 MD5 的每一个字节转换成 16 进制字符的转换  
                byte byte0 = tmp[i]; // 取第 i 个字节  
                str[k++] = hexDigits[byte0 >>> 4 & 0xf]; // 取字节中高 4 位的数字转换, >>> 为逻辑右移,将符号位一起右移  
                str[k++] = hexDigits[byte0 & 0xf]; // 取字节中低 4 位的数字转换  
            }  
            s = new String(str); // 换后的结果转换为字符串  
            return s;  
        }  
      
    //    public static void main(String arg[]) throws Exception {  
    //    	String A = getString("12345asfkfk");
    //    	System.out.println(A);
    //    	long l1 = System.currentTimeMillis();
    //        String a = getMD5(new File("E:/data/内乡/贫困/贫困户信用信息(全).rar"));  
    //        long l2 = System.currentTimeMillis();
    //        System.out.println(l2-l1);
    //        String b = getMD5(new File("e:/2.txt"));  
    //        System.out.println("1.txt的摘要值为:" + a);  
    //        System.out.println("2.txt的摘要值为:" + b);  
    //        if(a.equals(b)) {  
    //            System.out.println("a.txt中的内容与b.txt中的内容一致");  
    //        } else {  
    //            System.out.println("a.txt中的内容与b.txt中的内容不一致");  
    //        }  
    //    }
        
    }
    
    展开全文
  • java实现文件上传与下载

    万次阅读 2015-08-08 13:59:19
    JAVA文件上传下载知识点整理, 东风化宇,文件上传 一、对于文件上传,浏览器在上传的过程中是将文件以流的形式提交到服务器端的,Servlet获取上传文件的输入流然后再解析里面的请求参数是比较麻烦。 JSP...

    欢迎大家访问我的博客:地址

     

    感谢:孤傲苍狼,JavaWeb学习总结(五十)——文件上传和下载

               JAVA中文件上传下载知识点整理

               东风化宇,文件上传

    一、对于文件上传,浏览器在上传的过程中是将文件以流的形式提交到服务器端的,Servlet获取上传文件的输入流然后再解析里面的请求参数是比较麻烦。

     

    JSP代码,POST请求,表单必须设置为enctype="multipart/form-data"

    <span style="font-size:14px;"><form action="upload3" method="post" enctype="multipart/form-data">
                File to upload:<input type="file" name="upfile"><br><br> 
                <input type="submit" value="Press"> to upload the file!
    </form></span>

    Servlet代码:

     

    <span style="font-size:14px;"><span style="white-space:pre">	</span>protected void doGet(HttpServletRequest request,
    			HttpServletResponse response) throws ServletException, IOException {
    		request.setCharacterEncoding("UTF-8");
    		System.out.println("请求正文长度为--->" + request.getContentLength());
    		System.out.println("请求类型及表单域分割符--->" + request.getContentType());
    		//保存文件目录
    		String savePath = "d:/temptemp";
    		File file = new File(savePath);
    		//判断上传文件目录是否存在
    		if(!file.exists() && !file.isDirectory()){
    			//此目录不存在
    			file.mkdir();
    		}
    		
    		String message = "";
    		try {
    			InputStream is = request.getInputStream();
    			OutputStream os = new FileOutputStream(savePath + "/test.txt");
    			
    			byte[] buffer = new byte[1024];
    			int len = 0;
    			
    			while((len=is.read(buffer))>0){
    				os.write(buffer,0,len);
    			}
    			is.close();
    			os.close();
    			message = "文件上传成功";
    		} catch (Exception e) {
    			message = "文件上传失败";
    			e.printStackTrace();
    		}
    		request.setAttribute("message", message);
    		request.getRequestDispatcher("/WEB-INF/message.jsp").forward(request, response);
    	}</span>


    对于fireFox浏览器:

     

    上传表单为空时,request.getContentLength()为198

    上传文件时,请求头信息为:

     

    后台输出:

     

    生成的上传文件:

    注意:上传的文本的字符编码,否则filename或正文就会出现乱码的可能。

    对于chrome浏览器:

    上传表单为空时:request.getContentLength()为190

    上传文件时,请求头信息为:

    后台输出:

    生成的文件:

    以上是采用servlet接收客户端请求的方式来处理普通文本类型的文件的。虽然可以通过分隔符以及其余的一些固定的字符串如filename,通过字符串操作来获取请求正文中需要的数据,但是操作过程也仅限于文本类型,毕竟对于数据流的解析是比较麻烦的。

    二、采用Apache提供的用来处理文件上传的开源组件Commons-fileupload

    文件上传时,enctype属性必须设置为”multipart/data-form”。该属性指定了提交表单时请求正文的MIME类型,默认值为application/x-www-form-urlencoded。

    JSP代码:

     

    <span style="font-size:14px;"><form action="upload2" method="post" enctype="multipart/form-data">
                File to upload:<input type="file" name="upfile"><br><br> 
                Notes about the file:<input type="text" name="note"><br><br>
                <input type="submit" value="Press"> to upload the file!
    </form></span>

    servlet代码:

     

     

    <span style="font-size:14px;">public class FileUploadNew extends HttpServlet {
    	@Override
    	protected void doPost(HttpServletRequest request,
    			HttpServletResponse response) throws ServletException, IOException {
    		this.doGet(request, response);
    	}
    
    	@Override
    	protected void doGet(HttpServletRequest request,
    			HttpServletResponse response) throws ServletException, IOException {
    		// 得到上传文件的保存目录,将上传的文件存放于WEB-INF目录下,不允许外界直接访问,保证上传文件的安全
    		String savePath = this.getServletContext().getRealPath(
    				"/WEB-INF/upload");
    		// 上传时生成的临时文件保存目录
    		String tempPath = this.getServletContext().getRealPath("/WEB-INF/temp");
    		File tempFile = new File(tempPath);
    		if (!tempFile.exists() && !tempFile.isDirectory()) {
    			// 创建临时目录
    			tempFile.mkdir();
    		}
    
    		String message = "";
    		try {
    			// 1、创建一个DiskFileItemFactory工厂
    			DiskFileItemFactory factory = new DiskFileItemFactory();
    			// 设置工厂的缓冲区的大小,当上传的文件大小超过缓冲区的大小时,就会生成一个临时文件存放到指定的临时目录当中。
    			factory.setSizeThreshold(1024 * 100);// 设置缓冲区的大小为100KB,如果不指定,那么缓冲区的大小默认是10KB
    			// 设置上传时生成的临时文件的保存目录
    			factory.setRepository(tempFile);
    			// 2、创建一个文件上传解析器
    			ServletFileUpload upload = new ServletFileUpload(factory);
    			// 监听文件上传进度
    			upload.setProgressListener(new ProgressListener() {
    				public void update(long pBytesRead, long pContentLength,
    						int arg2) {
    					System.out.println("文件大小为:" + pContentLength + ",当前已处理:"
    							+ pBytesRead);
    				}
    			});
    			// 解决上传文件名的中文乱码
    			upload.setHeaderEncoding("UTF-8");
    			// 3、判断提交上来的数据是否是上传表单的数据
    			if (!ServletFileUpload.isMultipartContent(request)) {
    				// 按照传统方式获取数据
    				return;
    			}
    
    			// 设置上传单个文件的大小的最大值,目前是设置为1024*1024字节,也就是1MB
    			upload.setFileSizeMax(1024 * 1024);
    			// 设置上传文件总量的最大值,最大值=同时上传的多个文件的大小的最大值的和,目前设置为10MB
    			upload.setSizeMax(1024 * 1024 * 10);
    			// 4、使用ServletFileUpload解析器解析上传数据,解析结果返回的是一个List<FileItem>集合,每一个FileItem对应一个Form表单的输入项
    			List<FileItem> list = upload.parseRequest(request);
    			for (FileItem item : list) {
    				// 如果fileItem中封装的是普通输入项的数据
    				if (item.isFormField()) {
    					String name = item.getFieldName();
    					// 解决普通输入项的数据的中文乱码问题
    					String value = item.getString("UTF-8");
    					// value = new String(value.getBytes("iso8859-1"),"UTF-8");
    					System.out.println(name + "=" + value);
    				} else {// 如果fileItem中封装的是上传文件
    						// 得到上传的文件名称,
    					String filename = item.getName();
    					System.out.println(filename);
    					if (filename == null || filename.trim().equals("")) {
    						continue;
    					}
    					// 注意:不同的浏览器提交的文件名是不一样的,有些浏览器提交上来的文件名是带有路径的,如:
    					// c:\a\b\1.txt,而有些只是单纯的文件名,如:1.txt
    					// 处理获取到的上传文件的文件名的路径部分,只保留文件名部分
    					filename = filename
    							.substring(filename.lastIndexOf("\\") + 1);
    					// 得到上传文件的扩展名
    					String fileExtName = filename.substring(filename
    							.lastIndexOf(".") + 1);
    					// 如果需要限制上传的文件类型,那么可以通过文件的扩展名来判断上传的文件类型是否合法
    					System.out.println("上传的文件的扩展名是:" + fileExtName);
    					// 获取item中的上传文件的输入流
    					InputStream in = item.getInputStream();
    					// 得到文件保存的名称
    					String saveFilename = makeFileName(filename);
    					// 得到文件的保存目录
    					String realSavePath = makePath(saveFilename, savePath);
    					// 创建一个文件输出流
    					FileOutputStream out = new FileOutputStream(realSavePath
    							+ "\\" + saveFilename);
    					// 创建一个缓冲区
    					byte buffer[] = new byte[1024];
    					// 判断输入流中的数据是否已经读完的标识
    					int len = 0;
    					// 循环将输入流读入到缓冲区当中,(len=in.read(buffer))>0就表示in里面还有数据
    					while ((len = in.read(buffer)) > 0) {
    						// 使用FileOutputStream输出流将缓冲区的数据写入到指定的目录(savePath + "\\"
    						// + filename)当中
    						out.write(buffer, 0, len);
    					}
    					// 关闭输入流
    					in.close();
    					// 关闭输出流
    					out.close();
    					// 删除处理文件上传时生成的临时文件
    					// item.delete();
    					message = "文件上传成功!";
    				}
    			}
    		} catch (FileUploadBase.FileSizeLimitExceededException e) {
    			message = "单个文件超出最大限制";
    			e.printStackTrace();
    		} catch (FileUploadBase.SizeLimitExceededException e) {
    			message = "上传文件超出数量限制";
    			e.printStackTrace();
    		} catch (Exception e) {
    			message = "文件上传失败";
    			e.printStackTrace();
    		}
    		request.setAttribute("message", message);
    		request.getRequestDispatcher("/WEB-INF/message.jsp").forward(request,
    				response);
    	}
    
    	private String makeFileName(String filename) {
    		// 为防止文件覆盖的现象发生,要为上传文件产生一个唯一的文件名
    		return UUID.randomUUID().toString() + "_" + filename;
    	}
    
    	/**
    	 *多目录存储
    	 */
    	private String makePath(String filename, String savePath) {
    		// 得到文件名的hashCode的值,得到的就是filename这个字符串对象在内存中的地址
    		int hashcode = filename.hashCode();
    		int dir1 = hashcode & 0xf; // 0--15
    		int dir2 = (hashcode & 0xf0) >> 4; // 0-15
    		// 构造新的保存目录
    		String dir = savePath + "\\" + dir1 + "\\" + dir2; // upload\2\3
    															// upload\3\5
    		// File既可以代表文件也可以代表目录
    		File file = new File(dir);
    		// 如果目录不存在
    		if (!file.exists()) {
    			// 创建目录
    			file.mkdirs();
    		}
    		return dir;
    	}
    }</span>

    另:

     

    1)DiskFileItemFactory
    该工厂类用于创建FileItem的实例,对于较小的表单项,FileItem实例的内容保存在内存中,对于大的表单项,FileItem实例的内容会保存在硬盘中的一个临时文件中。大小的阈值和临时文件的路径都可以配置。构造方法如下:
    DiskFileItemFactory():文件阈值大小为10KB,默认临时文件的路径可以通过System.getProperty(“java.io.tmpdir”) 来获得。
    DiskFileItemFactory(int sizeThreshold, File repository)
    注:处理文件上传时,自己用IO流处理,一定要在流关闭后删除临时文件。
    因此建议使用:FileItem.write(File file),会自动删除临时文件。
    2)乱码问题
    ① 普通字段的乱码
    解决办法:FileItem.getString(String charset);编码要和客户端一致。
    ② 上传的中文文件名乱码
    解决办法:request.setCharacterEncoding(“UTF-8″);编码要和客户端一致。
    3)文件重名问题
    当上传的两个文件同名时,第二个文件会覆盖掉第一个文件。
    解决方法:a.txt –> UUID_a.txt,使得存入服务器的文件名唯一。
    String fileName = item.getName();
    fileName = UUID.randomUUID().toString() + "_" + fileName;
    4)文件夹中文件过多问题
    解决思路:分目录存储。下面提供两种解决方案:
    ① 按照日期分目录存储:
    //按日期分目录存储,程序中修改storePath,形如/files/2014/08/29
    DateFormat df = new SimpleDateFormat("/yyyy/MM/dd");
    String childDir = df.format(new Date());
    //文件存放路径:位于项目根目录下的files目录,不存在则创建
    String storePath = getServletContext().getRealPath("/files"+childDir);
    ② 按照文件名的hashCode计算存储目录(推荐)
    //按文件名的hashCode分目录存储
    String childDir = mkChildDir(fileName);
    //文件存放路径:位于项目根目录下的files目录,不存在则创建
    String storePath = getServletContext().getRealPath("/files"+childDir);

    <span style="font-size:14px;"><span style="font-family:Microsoft YaHei;font-size:12px;">private String mkChildDir(String fileName) {
        int hashCode = fileName.hashCode();
        int dir1 = hashCode & 0xf;//取hashCode低4位
        int dir2 = (hashCode & 0xf0) >> 4; //取hashCode的低5~8位
        return "/" + dir1 + "/" + dir2;
    }</span>

    5)限制上传文件的大小和类型
    有时候需要对用户上传的文件大小和类型作出限制,如上传头像、证件照时不会很大,且文件MIME类型均为image/*,此时需要在服务器端进行判断。
    ① 限制大小
    单文件大小:ServletFileUpload.setFileSizeMax(2*1024*1024); //限制单文件大小为2M
    总文件大小(多文件上传):ServletFileUpload.setSizeMax(6*1024*1024);
    ② 限制类型
    一般判断:根据文件扩展名进行判断,缺点是如果更改了扩展名,如a.txt –> a.jpg,这种方法是无法检测出来的。
    稍微高级点的:根据文件MIME类型进行判断,缺点是只对IE浏览器有效,对Chrome、FireFox无效,因为后者请求头中文件的MIME类型就是依据扩展名的。
    6)服务器安全问题
    假设用户知道你的上传目录,并上传了一个含有Runtime.getRuntime().exec(“xxx”);脚本的JSP文件,就会严重威胁服务器的安全。
    解决方法:把存放文件的目录,放到WEB-INF下面。
    三、文件下载

     

    1.列出所有文件

    java代码

     

    <span style="font-size:14px;">/**
     * 列出文件目录下的所有文件
     */
    public class ListAllFile extends HttpServlet{
    	private static final long serialVersionUID = 1L;
    	@Override
    	protected void doPost(HttpServletRequest request, HttpServletResponse response)
    			throws ServletException, IOException {
    		this.doGet(request, response);
    	}
    	@Override
    	protected void doGet(HttpServletRequest request, HttpServletResponse response)
    			throws ServletException, IOException {
    		//文件目录
    		String filePath = "d:/temp";
    		File file = new File(filePath);
    		
    		//存储要下载的文件
    		Map<String,String> fileMap = new HashMap<String,String>();
    		
    		//如果目录存在,并且目录是一个文件夹
    		if(file.exists() && file.isDirectory()){
    			//获取所有文件
    			this.getFiles(file,fileMap);
    		}else{
    			file.mkdir();
    		}
    		
    		//将fileMap集合发送到下载页面
    		request.setAttribute("fileMap", fileMap);
    		request.getRequestDispatcher("/WEB-INF/download.jsp").forward(request,response);
    	}
    	/**
    	 * 获取目录下的所有文件
    	 * @throws IOException 
    	 */
    	public void getFiles(File file,Map<String,String> fileMap) throws IOException{
    		//目录为文件夹
    		if(file.isDirectory()){
    			File[] files = file.listFiles();
    			//遍历数组
    			for(File f : files){
    				//递归
    				getFiles(f,fileMap);
    			}
    		}else{//文件
    			//file.getAbsolutePath()获取文件绝对路径,唯一值,如:d:\temp\aaa.txt,需要转为d:/temp/aaa.txt
    			//file.getName()获得文件名,如:aaa.txt
    			fileMap.put(file.getAbsolutePath().replace("\\","/"),file.getName());
    		}
    	}
    }
    
    </span>

    JSP代码

     

     

    <span style="font-size:14px;"><%@page import="java.net.URLEncoder"%>
    <%@ page language="java" contentType="text/html; charset=UTF-8"
    	pageEncoding="UTF-8"%>
    <%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
    <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
    <html>
    <head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title>download</title>
    <script>
    	function myDownload(Obj,file){
    		uri = encodeURI(file);
    		Obj.href = "fileDownload?fileName="+encodeURI(uri);	//两次编码
    		Obj.click();
    	}
    </script>
    </head>
    <body>
    	<!-- 遍历Map集合 -->
    	<c:forEach items="${fileMap }" var="file">
    		${file.value } <a href="javascript:void(0)" onclick="myDownload(this,'${file.key }')">download</a>
    		<br>
    	 </c:forEach>
    	 ----------文件下载,中文乱码 -----------<br>
    	<c:forEach items="${fileMap }" var="file">
    		<c:url value="fileDownload" var="downloadUrl">
    			<c:param name="fileName" value="${file.key }"></c:param>
    		</c:url>
    		${file.value } <a href="${downloadUrl }">download</a><!-- 中文乱码 -->
    		<br>
    	</c:forEach>
    	${message}
    </body>
    </html><</span>

    2.下载文件

     

    java代码

     

    <span style="font-size:14px;">protected void doGet(HttpServletRequest request, HttpServletResponse response)
    			throws ServletException, IOException {
    		//获取下载文件,绝对路径
    		String fileName = request.getParameter("fileName");
    		//解码
    		fileName = URLDecoder.decode(fileName, "UTF-8");
    		//文件名
    		String realName = fileName.substring(fileName.lastIndexOf("/")+1);
    		System.out.println(fileName+"--->"+realName);
    		File file = new File(fileName);
    		if(!file.exists()){
    			request.setAttribute("message", "资源已删除");
    			request.getRequestDispatcher("/WEB-INF/download.jsp").forward(request, response);
    			return;
    		}
    		//设置响应头,控制浏览器下载该文件
    		realName = new String(realName.getBytes("UTF-8"),"ISO-8859-1");
    		response.setHeader("content-disposition", "attachment;filename=" + realName);
            //response.setHeader("content-disposition", "attachment;filename=" + URLEncoder.encode(realName, "UTF-8"));	//编码
            //读取要下载的文件,保存到文件输入流
            FileInputStream in = new FileInputStream(fileName);
            //输出流
            OutputStream out = response.getOutputStream();
            //缓冲区
            byte buffer[] = new byte[4096];
            int len = 0;
            while((len=in.read(buffer))>0){
                out.write(buffer, 0, len);
            }
            in.close();
            out.close();
    		
    }</span>

     

     

     

     

     

     

     

     

     

     

     

    展开全文
  • Java实现文件上传服务器和客户端

    千次阅读 2018-01-16 14:16:40
    本文实例为大家分享了Java实现文件上传服务器和客户端的具体代码,供大家参考,具体内容如下 文件上传服务器端: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 ...

    本文实例为大家分享了Java实现文件上传服务器和客户端的具体代码,供大家参考,具体内容如下

    文件上传服务器端:


    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    /** 
     * 使用TCP协议实现上传功能的服务器端 
     * 思路: 
     * 新建ServerSocket 
     * 等待客户端连接 
     * 连接上后开启子线程,把连接获取的Socket传给子线程 
     * 循环进行 
     * @author yajun 
     
     */ 
    public class UploadServer { 
        
     public static void main(String[] args) { 
      UploadServer server=new UploadServer(); 
      UploadThread command=new UploadThread(); 
      server.start(command); 
     
        
     /** 
      * 功能:接受连接,开启子线程,循环 
      * @param command 用于下载的子线程对象,该对象实现了Runnable接口 
      */ 
     private void start(UploadThread command){ 
      //局部变量 
      ServerSocket serverSocket = null
      Socket transSocket; 
      //业务逻辑 
      try
       serverSocket=new ServerSocket(55555); 
       while(true){ 
        System.out.println("等待连接……"); 
        transSocket=serverSocket.accept(); 
        int i=0
        i++; 
        System.out.println("第"+i+"个连接"); 
        //用不用在下载完后关闭线程呢??? 
        command.setSocket(transSocket); 
        Executors.newFixedThreadPool(5).execute(command); 
       
      //异常捕获 
      } catch (IOException e) { 
       e.printStackTrace(); 
      //关闭资源 
      } finally
       try
        serverSocket.close(); 
       } catch (IOException e) { 
        e.printStackTrace(); 
       
      }//End of try 
     }//End of connect 
     @Test 
     public void testConnect() { 
      //测试任务:先运行服务器端,然后多次运行客户端,服务器段可以不断创建子线程,则测试成功 
      //测试准备:构造一个线程,用于模拟下载线程 
      UploadThread command=new UploadThread(); 
      start(command); 
         
     
       
     @Test 
     public void testDown() throws IOException { 
      byte[] buf; 
      ByteArrayInputStream bis; 
      String str="canglaoshi.avi\ncontent,content,content"
      buf=str.getBytes(); 
      bis=new ByteArrayInputStream(buf); 
      UploadThread ut=new UploadThread(); 
      ut.down(bis); 
     
    //完成各个传输任务的子线程 
    class UploadThread implements Runnable{ 
        
     Socket socket; 
     public UploadThread(){} 
     public UploadThread(Socket socket){ 
      this.socket=socket; 
     
     @Override 
     public void run() { 
      InputStream in; 
      try
          
       in = socket.getInputStream(); 
       down(in); 
          
      //异常处理 
      } catch (IOException e) { 
       e.printStackTrace(); 
      } finally
       try
        socket.close(); 
       } catch (IOException e) { 
        e.printStackTrace(); 
       
      
      //测试代码 
      /*try { 
       Thread.sleep(5000); 
       System.out.println(Thread.currentThread().getName()+",复制完毕"); 
      } catch (InterruptedException e) { 
       e.printStackTrace(); 
      }*/ 
     }//End of run 
     public void setSocket(Socket socket){ 
      this.socket=socket; 
     
     //下载方法 
     /** 
      * 目标:把InputStream中的数据写入到本地 
      * 思路: 
      * 1.获取输入流,最好传入输入流,而不是直接从Socket获取,传入有利用单元测试 
      * 2.从输入流中读到文件名 
      * 3.新建文件和文件输出流 
      * 4.从输入流中读到文件内容到文件输出流 
      * 5. 
      * @throws IOException 
      */ 
     public void down(InputStream in) throws IOException{ 
      //局部变量 
      char ch; 
      char[] nameArr=new char[256]; 
      byte[] buf=new byte[1024]; 
      String name=""
      OutputStream out = null
      //业务逻辑 
      try
       //第一步:获取文件名,构造文件输出流 
       int i=0
       while((ch=(char) in.read())!='\n'){ 
        nameArr[i++]= ch; 
       
       //name=nameArr.toString();//这句话无法将字符数组转换为字符串,需用下面的语句 
       name=new String(nameArr); 
       System.out.println("要下载的文件为:"+name); 
       out=new FileOutputStream("src\\down\\"+name); 
       //第二步:将输入流中的其他内容写入到文件 
       int len; 
       while((len=in.read(buf))!=-1){ 
        out.write(buf,0,len); 
       
       out.flush(); 
      //异常捕获 
      } catch (IOException e) { 
       e.printStackTrace(); 
      //关闭资源 
      }finally
       //疑问:两个捕获可不可以放到一块呢,怎样处理关闭流时的异常最好呢? 
       in.close(); 
       out.close(); 
      
      //调试 
      System.out.println(name); 
     
        
    }//End of UploadThread

    文件上传客户端:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    /** 
     * 使用TCP协议实现上传功能的客户端 
     * @author yajun 
     */ 
    public class UploadClient { 
        
     public static void main(String[] args) { 
      UploadClient client=new UploadClient(); 
      client.upload("src\\thursday\\AsListTest.java"); 
     
       
     /** 
      * 作用:上传文件到服务器 
      * 1.建立到服务器的连接 
      * 2.获取输出流 
      * 3.将文件内容写入到输出流 
      * 4.获取服务器的响应 
      */ 
     private void upload(String name){ 
      Socket socket=null
      OutputStream out; 
      try
       socket=new Socket("127.0.0.1", 55555); 
       out=socket.getOutputStream(); 
       write2OutputStream(name, out); 
      //异常捕获 
      } catch (UnknownHostException e) { 
       e.printStackTrace(); 
      } catch (IOException e) { 
       e.printStackTrace(); 
      
     
     @Test 
     public void testUpload() { 
      upload("src\\status.xml"); 
     
     /** 
      * 作用:传入文件名和输出流,将文件写入到输出流 
      * @param path 
      * @throws IOException 
      */ 
     private void write2OutputStream(String path,OutputStream out) throws IOException{ 
         
      FileInputStream fis = null
      byte[] buf=new byte[1024]; 
      String fileName=""
      //业务逻辑 
      try
          
       //1.写入文件名 
       fileName=path.substring(path.lastIndexOf('\\')+1); 
       System.out.println("您要上传的文件名为:"+fileName); 
       out.write(fileName.getBytes()); 
       out.write('\n'); 
       //2.写入文件内容 
       fis=new FileInputStream(path); 
       int len; 
       while((len=fis.read(buf))!=-1){ 
        out.write(buf, 0, len); 
       
       out.flush(); 
      //异常处理 
      } catch (IOException e) { 
       e.printStackTrace(); 
      //关闭资源 
      } finally
       fis.close(); 
       out.close(); 
      
     }//End of upload 
     @Test 
     public void testWrite2OutputStream() throws IOException { 
      ByteArrayOutputStream out = null
      try
       out=new ByteArrayOutputStream(); 
       write2OutputStream("src\\status.xml", out); 
       System.out.println(out.toString("utf-8")); 
      } catch (IOException e) { 
       e.printStackTrace(); 
      } finally
       out.close(); 
      
         
     
        
    }
    展开全文
  • 一,实现文件上传(图片,文件,音视频) 普通的上传 @Override public Object uploadImage(MultipartFile file) { //获取文件名 String originalFilename = file.getOriginalFilename(); //获取文件后缀名 ...
  • java实现文件上传并预览效果

    千次阅读 2015-07-02 14:25:32
    java实现文件上传并预览效果 先简单了解下该实现的原理:该项目实现 office文件在线预览,如doc,docx,ppt,pptx,xls,xlxs
  • Java实现文件上传下载工具类

    千次阅读 2017-10-10 08:52:54
    本篇文章在Eclipse环境下采用Java语言实现文件上传下载工具类。上传时,为避免文件名在服务器中重复,采用“服务器时间(定义到毫秒)+文件名+文件后缀“的方式作为服务器上的文件名;下载过程中利用 spring mvc ...
  • Java实现文件上传功能

    万次阅读 2019-03-25 22:17:14
    在这里就简单实现一个上传的功能。 1. 上传页面的代码 一开始是这样写的,form表单后面没有enctype参数。 这里查看浏览器的请求参数,发现上传的图片只是图片的名字,根本不是图片的内容。 后面查看资料,发现在...
  • 有时候我们会有一些需求需要上传一些图片或者一些文件,我们写一个小例子来实现这个功能. 我这次是针对上传图片来做的,其实就是后缀名限制,返回自己定义 import java.io.File; import java.io.IOException; import ...
  • 1、首先将文件上传到服务器, 2、将文件传到数据库 3、上传完成后,删除文件
  • Java实现文件上传至本地服务器

    千次阅读 2019-09-09 20:37:24
    前提要求 前端页面要求 method=“post” enctype=“multipart/form-data” 上传文件的input的type=“file” 每个上传的组件必须有name属性,这样后台才能获取到数据 ...form action="/...上传文件所要用到...
  • java实现文件上传ftp服务器功能

    千次阅读 2017-03-09 16:55:34
    文件上传至服务器源码,我个人搭建的是ftp服务器。
  • java实现文件上传到指定目录

    千次阅读 2020-08-19 11:03:06
    最近有用到文件上传,所以了解了一下Spring中的MultipartFile,然后进行一个简单的记录 首先要在yml文件中进行配置 我们根据业务的不同,有可能是需要上传到项目路径下,也有可能是上传到系统磁盘中,我这边是利用...
  • Java实现文件上传下载功能

    千次阅读 2017-03-12 22:14:53
    1.文件上传原理 在TCP/IP中,最早出现的文件上传机制是FTP。它是将文件由客户端发送到服务器的标准机制。但是在JSP编程过程中不能使用FTP方法来上传文件,这是由JSP的运行机制所决定的。 在JSP中通过为表单元素...
  • java实现文件上传及要考虑的问题

    千次阅读 2017-05-06 20:20:51
    java文件上传 文件上传三个条件, 1,表单的提交方式是POST 2,enctype类型是multipart/form-data 3,提供文件上传域 常见的文件上传问题: 1,保证服务器的安全,意思是上传的文件的路径不能直接被用户访问到 --...
  • java实现文件上传到Linux服务器中

    千次阅读 2020-06-11 16:11:31
    * 上传文件到linux中 * @param multipartfile * @param path */ @Override public void uploadFile(MultipartFile multipartfile,String path) { // 获取文件名 String fileName = multipartfile....
  • Flex+java实现文件上传

    千次阅读 热门讨论 2010-04-14 14:47:00
    用了两天时间学习了下Flex和java配合实现文件上传,找了个小例子。前端当然是flex,后台使用servlet,把代码贴上来,备忘吧: FileUpload.java:import java.io.File;import java.io.IOException;import java.io....
  • java实现文件上传到数据库

    万次阅读 2015-03-30 21:09:15
    欢迎使用Markdown编辑器写博客本Markdown编辑器使用StackEdit...图片链接和图片上传 LaTex数学公式 UML序列图和流程图 离线写博客 导入导出Markdown文件 丰富的快捷键 快捷键 加粗 Ctrl + B 斜体 Ctrl + I 引用 Ctrl
  • java实现文件上传下载至ftp服务器

    千次阅读 2017-05-06 23:03:30
    以前做的一个项目,用到了文件上传下载至ftp服务器,现在对其进行一下复习,比较简单,一下就能看明白。 环境:首先,先安装ftp服务器,我是在win8本地用IIS配置的,比较简单,百度一下就可以找到安装文档。 1.在...
  • 1、文件上传 package com.myproject.aiplatform.core.utils; import java.io.BufferedInputStream; import java.io.File; import java.io.FileNotFoundException; import java.io.FileOutputStream; import j...
  • HTTP POST请求报文格式分析与Java实现文件上传

    万次阅读 多人点赞 2014-12-11 12:41:43
    其中GET用于从服务器获取数据,POST主要用于向服务器提交一些表单数据,例如文件上传等。而我们在使用HTTP请求时中遇到的比较麻烦的事情...今天我们就一起来学习HTTP POST的报文格式以及通过Java来模拟文件上传的请求。
  • java实现文件上传的三种方式

    千次阅读 2018-03-25 22:41:17
    JSP+Servlet一、文件上传下载原理在TCP/IP中,最早出现的文件上传机制是FTP。它是将文件由客户端发送到服务器的标准机制。但是在jsp编程中不能使用FTP方法来上传文件,这是由jsp的运行机制所决定的。()通过为表单...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 220,581
精华内容 88,232
关键字:

java实现文件上传

java 订阅