精华内容
下载资源
问答
  • NULL 博文链接:https://davidhhs.iteye.com/blog/1662134
  • Java 组播组中发送和接受数据实例 3个目标文件。 Java读写文本文件的示例代码 1个目标文件。 java俄罗斯方块 一个目标文件。 Java非对称加密源码实例 1个目标文件 摘要:Java源码,算法相关,非对称加密 Java非对称...
  • 支持多文件上传、单个/批量附件下载,代码注释详细
  • JAVA附件上传之图片上传

    千次阅读 2017-07-18 19:15:57
     在Java的成长道路上,有很多的拦路虎.而它们中的每一个都可能曾经让你苦不堪言.对于我来说,图片上传就是我在从事Java工作以来,遇到的相当凶猛的一只.我曾经在写移动端接口的时候,需要写一个图片上传的接口.当然,...

    一 前言

       在Java的成长道路上,有很多的拦路虎.而它们中的每一个都可能曾经让你苦不堪言.对于我来说,图片上传就是我在从事Java工作以来,遇到的相当凶猛的一只.我曾经在写移动端接口的时候,需要写一个图片上传的接口.当然,只是简单的从PC端拷过来.(现在看来非常easy,但当时确实花了我整整两天的时间).在拷贝接口后,可能会遇到各种水土不服的问题,而我的同事也遇到了这个问题,我想应该也有很多其他童鞋和朋友会遇到类似的问题.所以我在这里记录一下PC端图片上传的大概过程,以及可能会遇到的问题.巩固自己,帮助他人.

    二 流程简述

      以添加商品为例,我们 在添加和发布商品的时候,通常会用到图片上传,也有可能是多张图片上传.但是道理都是一样的,在理清单张上传后,我相信对于从事java的朋友来说,这种管中窥豹,举一反三应该不难.

      这里一般会用两个表,产品表product和附件表attach.两者的关联外键为attachRootId.此ID为图片上传时生成的随机的唯一的图片标识.我们在操作商品的图片数据时,都是使用这个ID来实现关联的.



      在产品上传的页面,我们需要引入由美工设计好的图片上传页面.可以使用iframe标签包裹,以调整样式至理想的效果.这里大致的模块包含三部分:图片显示区域,功能按钮区域和上传提示区域(当然这些和我们Java无关,忍不住多说了一点),如下图:

       具体的效果如下图:

     上传页面显示细节:

      其实这里和我们一般的通过请求接口来获取页面的流程是一模一样的,主要想说的是在请求时的参数设置问题.我在这里把参数分为三种,分别是attachRootId,uploadType和fileType.

      在一个系统内,有多个地方会用到图片上传,为了防止数据过多导致混乱,也为了更好地去命名图片存放路径,我们在之前会规定好每个模块对应的图片类型如01对应企业,02对应商品.同时附件本身还有一个文件类型区分如01代表图片,02代表视频,03代表文档等这些都是我们在进行上传操作时需要用到的重要参数,也是请求接口时需要用的参数.

      另一个需要用到的参数就是我们上文提到的attachRootId,attachRootId不仅在上传的时候需要使用,在上传成功后显示图片也需要用到.那我们在添加商品时,可以直接生成一个attachRootId,具体的生成规则因人因公司而异,这里就不细说了.但是这个ID必须要保证它的唯一性.我们在修改商品信息时,数据库里已经有了这个商品图片的数据了,为了避免资源浪费,我们可以事先判断这个ID是否存在,如果存在就继续使用原有的attachRootId,不存在就生成一个新的.

     具体的后台上传操作:

     接收图片上传的数据:

     数据包括图片信息和参数信息.使用DefaultMultipartHttpServletRequest类来传递图片信息,使用CommonsMultipartFile类来接收图片信息,具体如下:


     数据接收成功后,我们需要对文件信息进行判断,确认用户上传的图片是否合法,主要包含文件是否上传判断,文件大小判断,文件类型判断以及图片数量判断.代码如下:


     数据判断通过后,生成图片的上传路径,这里就需要用到我们接收到的参数了.一般来说,我们上传的文件会存放在项目工作空间里的固定地址,主要就是通过if else实现的.具体的代码就不贴了.因为这部分其实并不重要的,而且难度并不高.

     在生成图片路径后,接下来要进行添加水印和保存图片存放信息到数据库.因此在这之前,要设置好操作数据库需要的参数信息.如attachRootId,文件类型,存放地址,文件名称等,代码如下:


    参数准备好就可以执行添加水印和上传操作了.

    三 部分问题解决方法

      图片上传总是提示失败:

      检查是否成功请求图片上传接口,如果已经请求到了,就走debugger,一步一步地检查,一定要耐心.通常这种错误都出现在数据验证和上传操作里

      图片上传成功后,图片显示区域显示404:

      不用多想,路径处理有问题.这里问题要么出在参数上,要么出现在根路径上

      图片上传成功,页面也显示,但是在详情页面无法显示:

      检查数据库保存的路径信息.对比取图片的sql,检查哪里不同


    关于图片上传就是这么多了,感觉自己表达能力有限.有些想要说的在写的过程中全部忘完了,不知道大家有没有遇到这种事情,反正我是经常遇到(笑cry).如果大家有问题,欢迎提问.在能力范围之内,一定解答!

    展开全文
  • JAVA上百实例源码以及开源项目

    千次下载 热门讨论 2016-01-03 17:37:40
    Java 组播组中发送和接受数据实例 3个目标文件。 Java读写文本文件的示例代码 1个目标文件。 java俄罗斯方块 一个目标文件。 Java非对称加密源码实例 1个目标文件 摘要:Java源码,算法相关,非对称加密  Java非...
  • java 收发邮件(带附件发送和附件解析) 1.java 发送邮件 收发邮件所需要的jar包。 <dependency> <groupId>javax.mail</groupId> <artifactId>javax.mail-api</artifactId> <...

    java 收发邮件(带附件发送和附件解析)

    1.java 发送邮件
    收发邮件所需要的jar包。

    	  <dependency>
                <groupId>javax.mail</groupId>
                <artifactId>javax.mail-api</artifactId>
                <version>1.6.2</version>
            </dependency>
            <dependency>
                <groupId>com.sun.mail</groupId>
                <artifactId>javax.mail</artifactId>
                <version>1.6.2</version>
            </dependency>
    

    1.1 发送不带附件的邮件

     /**
         * 发送邮件 不包含附件
         * @param toEmail 接受人邮箱
         * @param fromEmail 发送人邮箱
         * @param password 发送人密码
         */
        public static void sendEmaile(String toEmail,String fromEmail,String password) {
            try {
                Properties props = new Properties();
                //smtp保持不变,.后面改为邮箱后缀  eg:smtp.qq.com
                String host = "smtp.sea-level.com.cn";
                props.put("mail.smtp.host", host); // SMTP主机名
                props.put("mail.smtp.auth", "true"); // 是否需要用户认证
                props.put("mail.smtp.starttls.enable", "true"); // 启用TLS加密
                // 获取Session实例:
                Session session = Session.getInstance(props, new Authenticator() {
                    protected PasswordAuthentication getPasswordAuthentication() {
                        return new PasswordAuthentication(fromEmail, password);
                    }
                });
                MimeMessage message = new MimeMessage(session);
                // 设置发送方地址:
                message.setFrom(new InternetAddress(fromEmail));
                // 设置接收方地址:
                message.setRecipient(Message.RecipientType.TO, new InternetAddress(toEmail));
                // 设置邮件主题:
                message.setSubject("Hello", "UTF-8");
                // 设置邮件正文:这是普通邮件
                message.setText("Hi 这是一份来自javamail 邮件", "UTF-8");
                // 发送:
                Transport.send(message);
            } catch (MessagingException e) {
                e.printStackTrace();
            }
        }
    

    注:host 一定要根据自己的真实邮箱修改哦。
    1.2 发送带附件的邮件

    /**
         * 发送邮件 包含附件
         * @param toEmail
         * @param fromEmail
         * @param password
         */
        public static void sendEmailForFile(String toEmail,String fromEmail,String password){
            try {
                Properties props = new Properties();
                String host = "smtp.sea-level.com.cn";
                props.put("mail.smtp.host", host); // SMTP主机名
                props.put("mail.smtp.auth", "true"); // 是否需要用户认证
                //props.put("mail.smtp.port", "587"); // 主机端口号
                props.put("mail.smtp.starttls.enable", "true"); // 启用TLS加密
                // 获取Session实例:
                Session session = Session.getInstance(props, new Authenticator() {
                    protected PasswordAuthentication getPasswordAuthentication() {
                        return new PasswordAuthentication(fromEmail, password);
                    }
                });
                MimeMessage message = new MimeMessage(session);
                // 设置发送方地址:
                message.setFrom(new InternetAddress(fromEmail));
                // 设置接收方地址:
                message.setRecipient(Message.RecipientType.TO, new InternetAddress(toEmail));
                // 设置邮件主题:
                message.setSubject("Hello", "UTF-8");
                // 设置邮件正文:这是含有附件的邮件
                Multipart multipart = new MimeMultipart();
                // 添加text:
                BodyPart textpart = new MimeBodyPart();
                String body ="这是一个带有附件的邮件,请注意查收附件";
                textpart.setContent(body, "text/html;charset=utf-8");
                multipart.addBodyPart(textpart);
                // 添加附件: 直接发送内容
               /* BodyPart filepart = new MimeBodyPart();
                String fileName ="附件.txt";
                filepart.setFileName(fileName);
                //input 在附件中写入内容
                String input ="这里居然是文件的内容";
                try {
                    filepart.setDataHandler(new DataHandler(new ByteArrayDataSource(input, "application/octet-stream")));
                } catch (IOException e) {
                    e.printStackTrace();
                }
                multipart.addBodyPart(filepart);*/
               //发送邮件,发送本地文件
                BodyPart filepart = new MimeBodyPart();
                String fileName ="附件.txt";
                filepart.setFileName(fileName);
                //path 要发送的本地文件的路径
                String path ="d:\\file01.txt";
                FileDataSource fileDataSource = new FileDataSource(path);
                filepart.setDataHandler(new DataHandler(fileDataSource));
                multipart.addBodyPart(filepart);
                // 设置邮件内容为multipart:
                message.setContent(multipart);
                // 发送:
                Transport.send(message);
            } catch (MessagingException e) {
                e.printStackTrace();
            }
        }
    

    注:附件有两种方式,一种直接往附件里写内容,一种是发送本地存在的文件,按照提示进行放开相应的注释就可以了哦。
    在本地使用main() 方法就可以测试。
    2.接受邮件,并且读取附件内容

    package com.hzm;
    
    import com.sun.mail.imap.IMAPFolder;
    import com.sun.mail.imap.IMAPStore;
    
    import javax.mail.*;
    import javax.mail.internet.MimeMessage;
    import java.io.*;
    import java.util.Properties;
    
    /**
     * @Author:huangzhimin
     * @Date:2020/7/30
     * @描述:这里只处理未读邮件,并能够获取邮件中的附件
     **/
    public class ImapEmail {
        public static void main(String[] args) throws Exception{
            String user = "*******";// 邮箱的用户名
            String password = "****"; // 邮箱的密码
    
            Properties prop = System.getProperties();
            prop.put("mail.store.protocol", "imap");
            //此处也有修改为 内网邮箱后缀 eg: imap.qq.com
            prop.put("mail.imap.host", "imap.sea-level.com.cn");
    
            Session session = Session.getInstance(prop);
            // 使用imap会话机制,连接服务器
            IMAPStore store = (IMAPStore) session.getStore("imap");
            //链接邮箱
            store.connect(user, password);
            // 收件箱
            IMAPFolder folder = (IMAPFolder) store.getFolder("INBOX");
            //以只读的模式打开
            folder.open(Folder.READ_ONLY);
            // 获取总邮件数
            int  total = folder.getMessageCount();
            System.out.println("-----------------共有邮件:" + total + " 封--------------");
            System.out.println("未读邮件数:" + folder.getUnreadMessageCount());
            //获取收件箱中的所有邮件
            Message[] messages = folder.getMessages();
            for (Message message : messages) {
                //获取邮件的状态
                Flags flags = message.getFlags();
                //获取未读的邮件内容
                if (!flags.contains(Flags.Flag.SEEN)) {
                    System.out.println("发送时间:" + message.getSentDate());
                    System.out.println("主题:" + message.getSubject());
                    String subject =  message.getSubject();
                    System.out.println("内容: "+getBody((MimeMessage)message));
                    System.out.println("附件详细信息:");
                    getFileInputStream((MimeMessage)message);
                    //System.out.println("附件:"+getFileInputStream((MimeMessage)message));
                    //对指定的邮件进行解析 对指定主题的邮件设置已读
                    if(subject.equals("READ_ONLY")){
                        System.out.println("开始执行解析程序");
                        //将邮件设置为已读
                        message.setFlag(Flags.Flag.SEEN,true);
                    }
                }
    
            }
        }
    
        public static String getBody(Part part) throws MessagingException, IOException {
            if (part.isMimeType("text/*")) {
                return part.getContent().toString();
            }
            if (part.isMimeType("multipart/*")) {
                Multipart multipart = (Multipart) part.getContent();
                for (int i = 0; i < multipart.getCount(); i++) {
                    BodyPart bodyPart = multipart.getBodyPart(i);
                    String body = getBody(bodyPart);
                    if (!body.isEmpty()) {
                        return body;
                    }
                }
            }
            return "";
        }
    
        public static void getFileInputStream(Part part) throws Exception{
            if (part.isMimeType("multipart/*")) {
                Multipart multipart = (Multipart) part.getContent();
    
                for (int i = 0; i < multipart.getCount(); i++) {
                    BodyPart bodyPart = multipart.getBodyPart(i);
                    String disposition = bodyPart.getDisposition();
                    String fileName = null;
                    //说明有附件
                    if((disposition != null) && ((disposition.equals(Part.ATTACHMENT)) || (disposition
                            .equals(Part.INLINE)))){
                        fileName = bodyPart.getFileName();
                        System.out.println("附件名称"+fileName);
                        //获取附件的流
                        System.out.println("大小为:" + bodyPart.getSize());
    //                    InputStream inputStream = bodyPart.getInputStream();
    //                    //全量读出
    //                    int size = bodyPart.getSize();
    //                    byte[] buffer = new byte[size];
    //                    inputStream.read(buffer);
    //                    System.out.println("附件内容是:"+new String (buffer));
                        //按行读出
                        BufferedReader in = new BufferedReader(new InputStreamReader(bodyPart.getInputStream()));
                        String line = null;
                        while (( line = in.readLine())!= null ){
                            System.out.println("this line:"+ line);
                            line = null;
                        }
                        //inputStream.close();
                        in.close();
    
                    }
                }
            }
        }
    }
    
    

    本文只读取未读邮件的内容,和附件内容。如果想获取全部邮件的内容,修改if判断条件即可。
    同时对指定主题的邮件进行读取,和解析后将邮件设置为已读状态。
    注:邮件收取 有pop3 协议 和IMAP 协议,本文使用的是IMAP 协议。pop3协议无法区分邮件是否已读,同时无法将已读之类的操作提交到邮箱服务器,IMAP 使用更加便捷。

    展开全文
  • 请求方: /** * 文件上传 * @param url * @param content 上传参数 * @return */ ... String result = "";... CloseableHttpClient httpclient = HttpClients.createDefault();... //CloseableHttpClient ht

    请求方:

    /**
    	 * 文件上传
    	 * @param url
    	 * @param content  上传参数
    	 * @return
    	 */
    	public static String uploadFile(String url, HttpEntity content) {
    		String result = "";
    		CloseableHttpClient httpclient = HttpClients.createDefault();
    		//CloseableHttpClient httpclient = HttpClientBuilder.create().build();
    		try {
    			HttpPost httppost = new HttpPost(url);
    			httppost.setConfig(requestConfig);
    			httppost.setEntity(content);
    
    			logger.info("executing request " + httppost.getRequestLine());
    			CloseableHttpResponse response = httpclient.execute(httppost);
    			try {
    				logger.info(response.getStatusLine().toString());
    				HttpEntity resEntity = response.getEntity();
    				if (resEntity != null) {
    					result = EntityUtils.toString(response.getEntity());
    					logger.info(result);
    					logger.info("Response content length: " + resEntity.getContentLength());
    				}
    				EntityUtils.consume(resEntity);
    			} finally {
    				response.close();
    			}
    		} catch (ClientProtocolException e) {
    			logger.error("upload file ClientProtocolException",e);
    		} catch (IOException e) {
    			logger.error("upload file IOException",e);
    		} finally {
    			try {
    				httpclient.close();
    			} catch (IOException e) {
    				logger.error("upload file close httpClient IOException",e);
    			}
    		}
    		return result;
    	}

     

    HttpEntity content内容如下:
    //HttpMultipartMode.RFC6532参数的设定是为避免文件名为中文时乱码
    						HttpEntity reqEntity = MultipartEntityBuilder.create().setMode(HttpMultipartMode.RFC6532)
    								.addBinaryBody("file", new File(articleAttachment.getAttachmentPath()), ContentType.create("multipart/form-data", Consts.UTF_8), articleAttachment.getAttachmentName())
    								.addTextBody("name", articleAttachment.getAttachmentName(), ContentType.APPLICATION_JSON)
    								.addTextBody("type", "CJ", ContentType.APPLICATION_JSON)
    								.addTextBody("businessId", String.valueOf(articleAttachment.getArticleId()), ContentType.APPLICATION_JSON)
    								.addTextBody("knowledgeId", String.valueOf(kmKnowledgeId), ContentType.APPLICATION_JSON)
    								.build();

     

     

    服务方接口:

    /**
         * 
         * @return
         */
        @ResponseBody
        @PostMapping(value = "/saveAttachment", headers = "content-type=multipart/form-data")
        public SyncAttachmentRespDTO syncAttachment(MultipartFile file, SyncAttachmentReqDTO requestBody) {
            
            SyncAttachmentRespDTO result = syncKnowledgeService.saveAttachment(file, requestBody);
            return result;
        }
    SyncAttachmentReqDTO
    public class SyncAttachmentReqDTO {
    
        private String name;
        private AttachmentTypeEnum type;
        private Long businessId;
        private Long knowledgeId;
    }

     

    展开全文
  • java 邮件接受 实例

    2010-08-14 17:03:26
    这个小程序可以同时处理一般 邮件 的接受同时可以 处理含有 附件的 邮件的接受,代码含有注释 同时 这小程序 既可以接受 英文的邮件,可以处理中文,还可以 同时处理中英文 同时包含的邮件
  • 公司需求:根据业务需要定时发送邮件,并且邮件需要有excel附件附件内容为查询到的数据。 开发思路:由于服务器环境本身空间有限,而且不...查询了很多网上资料以及java邮件API,最终得以实现,分享下供大家参考...

    公司需求:根据业务需要定时发送邮件,并且邮件需要有excel附件,附件内容为查询到的数据。

    开发思路:由于服务器环境本身空间有限,而且不确定环境中读写权限,生成excel文件比较浪费资源,出现异常时可能导致删除临时文件失败。因此生成excel文件时不生成实际文件,直接获取到excel写入流,并且将流直接写入到邮件附件中。

    查询了很多网上资料以及java邮件API,最终得以实现,分享下供大家参考,互相学习!

    转载请标明出处:https://blog.csdn.net/yixin605691235/article/details/82429156

     

    详细代码:https://download.csdn.net/download/yixin605691235/10648074

    核心代码如下:

    配置邮箱服务器端口及发送人接收人

    mail.smtp.host=smtp.exmail.qq.com
    mail.smtp.port=465
    mail.send.address=xxx@xxx.xx
    mail.send.password=xxxxxx
    mail.accept.address=qqqqqq@qq.com
    mail.accept.address.other=qqqqqq@qq.com,qqqqqq@163.com

    生成excel工具类

    package com.yx.mail;
    
    import java.io.ByteArrayOutputStream;
    import java.io.IOException;
    import java.io.OutputStream;
    import java.io.UnsupportedEncodingException;
    import java.lang.reflect.Field;
    import java.math.BigDecimal;
    import java.net.URLEncoder;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    import java.util.LinkedHashMap;
    import java.util.LinkedList;
    import java.util.List;
    import java.util.Map;
    import java.util.Map.Entry;
    
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    import org.apache.commons.beanutils.PropertyUtils;
    import org.apache.commons.lang3.StringUtils;
    
    import jxl.Workbook;
    import jxl.common.Logger;
    import jxl.write.Label;
    import jxl.write.Number;
    import jxl.write.NumberFormat;
    import jxl.write.WritableCell;
    import jxl.write.WritableCellFormat;
    import jxl.write.WritableSheet;
    import jxl.write.WritableWorkbook;
    import jxl.write.WriteException;
    /**
     * java excel api(jxl) 导出excel工具类
     * @author Yanyanhui
     *
     */
    public class JxlUtil {
        
        private static Logger logger = Logger.getLogger(JxlUtil.class);
        
        private static int MAX_SHEET_SIZE = 65530;
        
        private static String DOUBLE_FORMAT = "#.00";
        private static String INTER_FORMAT = "#";
        
        private static WritableCellFormat INTER_CELL_FORMAT = new WritableCellFormat(new NumberFormat(INTER_FORMAT));
        private static WritableCellFormat DOUBLE_CELL_FORMAT = new WritableCellFormat(new NumberFormat(DOUBLE_FORMAT));
    
        /**
         * 列表转换成excel导出
         * @param list 要转换的列表
         * @param title 转换列表的标题
         * @param sheetName 工作表名称
         * @param request 请求
         * @param response 响应
         * @throws Exception
         */
        public static <T> void listToExcel(List<T> list,LinkedHashMap<String, String> title,String sheetName,HttpServletRequest request,HttpServletResponse response) throws Exception{
            listToExcel(list, title, sheetName, sheetName, 0, 0, request, response);
            
        }
        
        /**
         * 列表转换成excel导出
         * @param list 要转换的列表
         * @param title 转换列表的标题
         * @param sheetName 工作表名称
         * @param fileName excel文件名称
         * @param request 请求
         * @param response 响应
         * @throws Exception
         */
        public static <T> void listToExcel(List<T> list,LinkedHashMap<String, String> title,String sheetName, String fileName,HttpServletRequest request,HttpServletResponse response) throws Exception{
            listToExcel(list, title, sheetName, fileName, 0, 0, request, response);
            
        }
        
        /**
         * 列表转换成excel导出
         * @param list 要转换的列表
         * @param title 转换列表的标题
         * @param sheetName 工作表名称
         * @param fileName excel文件名称
         * @param startRow 从哪行开始输出
         * @param request 请求
         * @param response 响应
         * @throws Exception
         */
        public static <T> void listToExcel(List<T> list,LinkedHashMap<String, String> title,String sheetName, String fileName,int startRow,HttpServletRequest request,HttpServletResponse response) throws Exception{
            listToExcel(list, title, sheetName, fileName, 0, startRow, request, response);
        }
        
        /**
         * 列表转换成excel导出
         * @param list 要转换的列表
         * @param title 转换列表的标题
         * @param sheetName 工作表名称
         * @param fileName excel文件名称
         * @param sheetSize 工作表的大小
         * @param startRow 从哪行开始输出
         * @param request 请求
         * @param response 响应
         * @throws Exception
         */
        public static <T> void listToExcel(List<T> list,LinkedHashMap<String, String> title,String sheetName, String fileName,int sheetSize,int startRow,HttpServletRequest request,HttpServletResponse response) throws Exception{
    
            if (list == null || list.size() == 0) {
    //            throw new Exception("列表中没有任何数据");
            }
    
            if (sheetSize > MAX_SHEET_SIZE || sheetSize < 1) {
                sheetSize = MAX_SHEET_SIZE;
            }
    
            try {
                
                setResp(request, response, fileName);
    
                OutputStream outputStream = response.getOutputStream();
    
                WritableWorkbook wwb = Workbook.createWorkbook(outputStream);
                int size = 0;
                
                
                // 因为2003的Excel一个工作表最多可以有65536条记录,除去列头剩下65530条
                // 所以如果记录太多,需要放到多个工作表中,其实就是个分页的过程
                // 1.计算一共有多少个工作表
                double sheetNum = Math.ceil(size / new Integer(sheetSize).doubleValue());
                // 2.创建相应的工作表,并向其中填充数据
    
                WritableSheet sheet = wwb.createSheet(sheetName, 0);
                fillVeticalSheet(sheet, list, title, startRow, 0);
                
    //            setColumnAutoSize(sheet, 2);
                
                wwb.write();
                wwb.close();
    
            } catch (WriteException e) {
                e.printStackTrace();
                logger.error(e.getMessage());
            } catch (IOException e) {
                e.printStackTrace();
                logger.error(e.getMessage());
            } catch (Exception e) {
                e.printStackTrace();
                logger.error(e.getMessage());
            }
        }
        
        
        /**
         * 以流的形式导出excel
         * @param list 要转换的列表
         * @param title 转换列表的标题
         * @param sheetName 工作表名称
         * @param fileName excel文件名称
         * @param sheetSize 工作表的大小
         * @param startRow 从哪行开始输出
         * @param request 请求
         * @param response 响应
         * @return 
         * @throws Exception
         */
        public static <T> ByteArrayOutputStream listToExcelReturnOut(List<T> list,LinkedHashMap<String, String> title,String sheetName, String fileName,int sheetSize,int startRow,HttpServletRequest request,HttpServletResponse response) throws Exception{
    
            if (list == null || list.size() == 0) {
    //            throw new Exception("列表中没有任何数据");
            }
    
            if (sheetSize > MAX_SHEET_SIZE || sheetSize < 1) {
                sheetSize = MAX_SHEET_SIZE;
            }
    
    //        OutputStream outputStream = response.getOutputStream();
            ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
            setResp(request, response, fileName);
            try {
    
                WritableWorkbook wwb = Workbook.createWorkbook(outputStream);
                int size = 0;
                
                
                // 因为2003的Excel一个工作表最多可以有65536条记录,除去列头剩下65530条
                // 所以如果记录太多,需要放到多个工作表中,其实就是个分页的过程
                // 1.计算一共有多少个工作表
                double sheetNum = Math.ceil(size / new Integer(sheetSize).doubleValue());
                // 2.创建相应的工作表,并向其中填充数据
    
                WritableSheet sheet = wwb.createSheet(sheetName, 0);
                fillVeticalSheet(sheet, list, title, startRow, 0);
                
    //            setColumnAutoSize(sheet, 2);
                
                wwb.write();
                wwb.close();
                
                
            } catch (WriteException e) {
                e.printStackTrace();
                logger.error(e.getMessage());
            } catch (IOException e) {
                e.printStackTrace();
                logger.error(e.getMessage());
            } catch (Exception e) {
                e.printStackTrace();
                logger.error(e.getMessage());
            }
            return outputStream;
        }
        
    
    
        
        /**
         * 填充竖直方向的sheet
         * @param sheet
         * @param data
         * @param title
         * @param row
         * @param col
         * @throws Exception
         */
        public static <T> void fillVeticalSheet(WritableSheet sheet, List<T> data, LinkedHashMap<String, String> title, int row,
                int col) throws Exception {
            if (null == data || null == title) {
                return;
            }
    
            // 定义存放英文字段名和中文字段名的数组
            String[] enFields = new String[title.size()];
            String[] cnFields = new String[title.size()];
    
            // 填充数组
            int count = 0;
            for (Entry<String, String> entry : title.entrySet()) {
                enFields[count] = entry.getKey();
                cnFields[count] = entry.getValue();
                count++;
            }
    
            
            // 填充表头
            for (int i = 0; i < cnFields.length; i++) {
                String cnValue=cnFields[i];
                Label label = new Label(col + i, row,cnValue);
                sheet.addCell(label);
                sheet.setColumnView(col+i, cnValue.getBytes().length);//一个中文占2个字节,经过调试+4后效果比较理想 
        
            }
    
            // 填充内容
            int rowNo = row + 1;
            int colNo = col;
    
            for (int i = 0; i < data.size(); i++) {
                
                T item = data.get(i);
                for (int j = 0; j < enFields.length; j++) {
                    Object objValue = getFieldValueByNameSequence(enFields[j], item);
                    
                    WritableCell cell = getWritableCell(colNo+j, rowNo, objValue);
                    sheet.addCell(cell);
                    
                    
                }
    
                rowNo++;
            }
        }
        
        public static WritableCell getWritableCell(int column, int row, Object object){
            if (object == null) {
                return new Label(column, row, "");
            }
            
            String tempObj = object.toString();
            
            if (object instanceof Integer) {
                if (tempObj.equals("0")) {
                    return new Number(column, row, 0);
                }
    
                return new Number(column, row, Double.valueOf(tempObj),INTER_CELL_FORMAT);
            }
            
            
            if (object instanceof Double) {
                return new Number(column, row, Double.valueOf(tempObj),DOUBLE_CELL_FORMAT);
    
            }
            
            if (object instanceof BigDecimal) {
                if (tempObj.indexOf(".00") > 0) {
                    tempObj = tempObj.substring(0, tempObj.indexOf("."));
                    return tempObj.equals("0") ? new Number(column, row, 0)
                            : new Number(column, row, Double.valueOf(tempObj),INTER_CELL_FORMAT);
                }
    
                return new Number(column, row, Double.valueOf(tempObj),DOUBLE_CELL_FORMAT);
            }
            
            return new Label(column, row, tempObj);
            
        }
        
        
    
        /**
         * 根据带路径或不带路径的属性名获取属性值,即接受简单属性名,如userName等,又接受带路径的属性名,如student.department.
         * name等
         *
         * @param fieldNameSequence
         *            带路径的属性名或简单属性名
         * @param o
         *            对象
         * @return 属性值
         * @throws Exception
         *             异常
         */
        public static Object getFieldValueByNameSequence(String fieldNameSequence, Object o) throws Exception {
    
            Object value = null;
    
            // 将fieldNameSequence进行拆分
            String[] attributes = fieldNameSequence.split("\\.");
            if (attributes.length == 1) {
                value = PropertyUtils.getProperty(o, fieldNameSequence);
                
            } else {
                // 根据属性名获取属性对象
                Object fieldObj = PropertyUtils.getProperty(o, attributes[0]);
            
                
                String subFieldNameSequence = fieldNameSequence.substring(fieldNameSequence.indexOf(".") + 1);
                value = getFieldValueByNameSequence(subFieldNameSequence, fieldObj);
            }
            
            if (value instanceof Date) {
                value = new SimpleDateFormat("yyyy-MM-dd").format(
                        value).toString();    
                }
            
    //        if (value.toString().endsWith(".0000")) {
    //            String txt =value.toString();
    //            value = txt.substring(0, txt.lastIndexOf("."));
    //        }
            
            return value;
        }
    
        /**
         * 根据字段名获取字段
         *
         * @param fieldName
         *            字段名
         * @param clazz
         *            包含该字段的类
         * @return 字段
         */
        public static Field getFieldByName(String fieldName, Class<?> clazz) {
            // 拿到本类的所有字段
            Field[] selfFields = clazz.getDeclaredFields();
    
            // 如果本类中存在该字段,则返回
            for (Field field : selfFields) {
                if (field.getName().equals(fieldName)) {
                    return field;
                }
            }
    
            // 否则,查看父类中是否存在此字段,如果有则返回
            Class<?> superClazz = clazz.getSuperclass();
            if (superClazz != null && superClazz != Object.class) {
                return getFieldByName(fieldName, superClazz);
            }
    
            // 如果本类和父类都没有,则返回空
            return null;
        }
    
        
        public static <T> LinkedList<WritableCell> addCellInVertical(List<T> data, Map<String, String> dataTitle,
                Map<String, WritableCellFormat> cellFormatMap, int rowIndex, int colIndex) {
            Label label = new Label(1, 1, "中午");
    
            LinkedList<WritableCell> cells = new LinkedList<>();
            cells.add(label);
            return cells;
        }
    
        
    
        /**
         * 
         * @param fileName
         * @param request
         * @param response
         */
        private static void setResp(HttpServletRequest request, HttpServletResponse response, String fileName) {
            final String userAgent = request.getHeader("USER-AGENT");
    
            response.reset();
            // response.setContentType("application/vnd.ms-excel"); // 改成输出excel文件  
            response.setContentType("application/x-msdownload");
    
            try {
                String finalFileName = null;
    
                if (StringUtils.contains(userAgent, "MSIE")) {// IE浏览器
                    finalFileName = URLEncoder.encode(fileName, "UTF8");
                    }
    
                else if (StringUtils.contains(userAgent, "Mozilla")) {// google,火狐浏览器
                    finalFileName = new String(fileName.getBytes(), "ISO8859-1");
                    }
    
                else {
                    finalFileName = URLEncoder.encode(fileName, "UTF8");// 其他浏览器
                }
    
                String dataStr =  new SimpleDateFormat("yyyyMMddHHmmss").format(
                        new Date()).toString();
    
                // 这里设置一下让浏览器弹出下载提示框,而不是直接在浏览器中打开
                response.setHeader("Content-Disposition", "attachment; filename=" + finalFileName+"_"+dataStr + ".xls");
            } catch (UnsupportedEncodingException e) {
            }
    
        }
        
        /**
         * 设置工作表自动列宽和首行加粗
         *
         * @param ws
         *            要设置格式的工作表
         * @param extraWith
         *            额外的宽度
         */
        public static void setColumnAutoSize(WritableSheet ws, int extraWith) {
            // 获取本列的最宽单元格的宽度
            for (int i = 0; i < ws.getColumns(); i++) {
                int colWith = 0;
                for (int j = 0; j < ws.getRows(); j++) {
                    String content = ws.getCell(i, j).getContents().toString();
                    int cellWith = content.length();
                    if (colWith < cellWith) {
                        colWith = cellWith;
                    }
                }
                // 设置单元格的宽度为最宽宽度+额外宽度
                ws.setColumnView(i, colWith + extraWith);
            }
    
        }
        
    //    public static NumberFormat getNumFormate(Object object){
    //        NumberFormat numberFormat = new NumberFormat("");
    //        
    //    }
        
        public static void testExport(HttpServletRequest request,HttpServletResponse response) {
            try {
                setResp(request,response,"test");
    
                OutputStream outputStream = response.getOutputStream();
    
                WritableWorkbook wwb = Workbook.createWorkbook(outputStream);
                
                WritableSheet sheet = wwb.createSheet("test", 0);
    
                Label label = new Label(1, 1, "中午");
                sheet.addCell(label);
    
                wwb.write();
                wwb.close();
    
            } catch (WriteException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

     

    邮件工具类

     

    package com.yx.mail;
    
    
    import java.io.ByteArrayInputStream;
    import java.security.GeneralSecurityException;
    import java.util.Properties;
    import javax.activation.DataHandler;
    import javax.activation.DataSource;
    import javax.mail.Address;
    import javax.mail.Authenticator;
    import javax.mail.Message;
    import javax.mail.Part;
    import javax.mail.PasswordAuthentication;
    import javax.mail.Session;
    import javax.mail.Transport;
    import javax.mail.internet.AddressException;
    import javax.mail.internet.InternetAddress;
    import javax.mail.internet.MimeBodyPart;
    import javax.mail.internet.MimeMessage;
    import javax.mail.internet.MimeMultipart;
    import javax.mail.internet.MimeUtility;
    import javax.mail.internet.MimeMessage.RecipientType;
    import javax.mail.util.ByteArrayDataSource;
    import com.sun.mail.util.MailSSLSocketFactory;
    
    
    
    public class BaseMail {
    
    	/**
    	 * 发送邮件
    	 * 
    	 * @param to
    	 *            邮件收件人地址
    	 * @param copyEmail
    	 *            邮件抄送地址
    	 * @param title
    	 *            邮件标题
    	 * @param text
    	 *            内容
    	 * @param fileDs
    	 *            附件流
    	 */
    	public void sendMsgFileDs(String to, String copyEmail, String title, String text,ByteArrayInputStream inputstream) {
    		Session session = assembleSession();
    		Message msg=new MimeMessage(session);
    		try {
    			msg.setFrom(new InternetAddress(MailConfig.sendAddress));
    			msg.setSubject(title);
    			msg.setRecipients(RecipientType.TO, acceptAddressList(to,copyEmail));
    			MimeBodyPart contentPart=(MimeBodyPart) createContent(text,inputstream);//参数为正文内容和附件流
    //			MimeBodyPart stream = new MimeBodyPart();
    			
    //			MimeBodyPart part=(MimeBodyPart) createAttachment("D:/test/1.jpg");//可增加多个附件
    			MimeMultipart mime=new MimeMultipart("mixed");
    			mime.addBodyPart(contentPart);
    //			mime.addBodyPart(part);//可增加多个附件
    			msg.setContent(mime);
    			Transport.send(msg);
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    	}
    	
    	public Address[] acceptAddressList(String acceptAddress,String acceptAddressOther) {
    		// 创建邮件的接收者地址,并设置到邮件消息中
    		Address[] tos = null;
    		String [] copyEmail= acceptAddressOther.split(",");
    		try {
    			if (copyEmail != null) {
    				// 为每个邮件接收者创建一个地址
    				tos = new InternetAddress[copyEmail.length + 1];
    				tos[0] = new InternetAddress(acceptAddress);
    				for (int i = 0; i < copyEmail.length; i++) {
    					tos[i + 1] = new InternetAddress(copyEmail[i]);
    				}
    			} else {
    				tos = new InternetAddress[1];
    				tos[0] = new InternetAddress(acceptAddress);
    			}
    		} catch (AddressException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
            return tos;
    	}
    	
    	public Session assembleSession() {
    		Session session = null;
    		Properties props=new Properties();
    		props.setProperty("mail.smtp.auth", "true");
    		props.setProperty("mail.transport.protocol", "smtp");
    		props.setProperty("mail.smtp.port", MailConfig.mailSmtpPort);
    		props.setProperty("mail.smtp.host", MailConfig.mailSmtpHost);//邮件服务器
    		//开启安全协议
            MailSSLSocketFactory sf = null;
            try {
                sf = new MailSSLSocketFactory();
                sf.setTrustAllHosts(true);
            } catch (GeneralSecurityException e1) {
                e1.printStackTrace();
            }
    		props.put("mail.smtp.ssl.socketFactory", sf);
    		props.put("mail.smtp.ssl.enable", "true");
    		session = Session.getDefaultInstance(props, new MyAuthenricator(MailConfig.sendAddress,MailConfig.sendPassWord));
    		return session;
    	}
    	
    	static Part createContent(String content,ByteArrayInputStream inputstream){
    		MimeBodyPart contentPart=null;
    		try {
    			contentPart=new MimeBodyPart();
    			MimeMultipart contentMultipart=new MimeMultipart("related");
    			MimeBodyPart htmlPart=new MimeBodyPart();
    			htmlPart.setContent(content, "text/html;charset=gbk");
    			contentMultipart.addBodyPart(htmlPart);
    			//附件部分
    			MimeBodyPart excelBodyPart=new MimeBodyPart();
    			DataSource dataSource=new ByteArrayDataSource(inputstream, "application/excel");
                DataHandler dataHandler=new DataHandler(dataSource);
                excelBodyPart.setDataHandler(dataHandler);
                excelBodyPart.setFileName(MimeUtility.encodeText("通知.xls"));
    //			excelBodyPart.setDataHandler(new DataHandler(fileDs));
    //			excelBodyPart.setFileName(fileDs.getName());
    //			excelBodyPart.setContentID("excel");
    			contentMultipart.addBodyPart(excelBodyPart);
    			contentPart.setContent(contentMultipart);
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    		return contentPart;
    	}
    	
    	//用户名密码验证,需要实现抽象类Authenticator的抽象方法PasswordAuthentication
        static class MyAuthenricator extends Authenticator{  
            String u = null;  
            String p = null;  
            public MyAuthenricator(String u,String p){  
                this.u=u;  
                this.p=p;  
            }  
            @Override  
            protected PasswordAuthentication getPasswordAuthentication() {  
                return new PasswordAuthentication(u,p);  
            }  
        }
        
    }

     

    测试类:

    package com.yx.mail;
    
    import java.io.ByteArrayInputStream;
    import java.io.ByteArrayOutputStream;
    import java.util.ArrayList;
    import java.util.LinkedHashMap;
    import java.util.List;
    
    import org.apache.logging.log4j.LogManager;
    import org.apache.logging.log4j.Logger;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.context.annotation.Scope;
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestMethod;
    import org.springframework.web.bind.annotation.ResponseBody;
    
    
    @Controller
    @Scope(value = "prototype")
    public class TestMain extends BaseController{
    
    	private Logger logger = LogManager.getLogger(TestMain.class);
    	@Autowired 
    	private SendEmailService sendEmailService;
    	@RequestMapping(value = "/mail", method = RequestMethod.GET)
    	@ResponseBody
    	public String sendEmail() {
    		
    		List<Order> rechecklist = new ArrayList();
    		Order Order1 = new Order();
    		Order1.setOrderNo("1");
    		Order1.setProvinceId("黑龙江");
    		Order Order2 = new Order();
    		Order2.setOrderNo("2");
    		Order2.setProvinceId("吉林");
    		Order Order3 = new Order();
    		Order3.setOrderNo("3");
    		Order3.setProvinceId("辽宁");
    		Order Order4 = new Order();
    		Order4.setOrderNo("4");
    		Order4.setProvinceId("福建");
    		rechecklist.add(Order1);rechecklist.add(Order2);rechecklist.add(Order3);rechecklist.add(Order4);
    		
    		
    		
    		LinkedHashMap<String, String> recheckMap = new LinkedHashMap<>();
    		recheckMap.put("provinceId", "省份");
    		recheckMap.put("orderNo", "订单号");
    		
    		try {
    			ByteArrayOutputStream baos = JxlUtil.listToExcelReturnOut(rechecklist, recheckMap, "test", "testexport", 0, 0, request,
    					response);
    			ByteArrayInputStream InputStream = new ByteArrayInputStream(baos.toByteArray());
    			String email = MailConfig.acceptAddress;//接收人
    			String copyEmail = MailConfig.acceptAddressOther;//抄送多人以逗号分隔
    			String title = "XX通知";
    			String context = "当前系统存在"+rechecklist.size()+"条需要处理的订单。详情请留意附件。";
    			sendEmailService.sendMsgFileDs(email,copyEmail,title,context,InputStream);
    //			file.deleteOnExit();
    		} catch (Exception e) {
    			logger.info(e.getMessage());
    			logger.info("【MailNoticeController】sendEmail 异常");
    		}
    		
    		return null;
    	}
    }

     

    展开全文
  • Java以邮件附件的方式发送excel文件

    千次阅读 2019-05-16 14:40:51
    思路:Java创建Excel,返回一个... sendEmail()接受ByteArrayOutputStream 流以附件的形式发送出去 创建Excel表格: public class CreatExcel { public static ByteArrayOutputStream creatExcel(String[] t...
  • java 邮件开发 日益受到程序员们的喜欢
  • uniapp前端单文件上传JAVA后台接收实现(亲测),看了些文档,亲测了一天,后面还有多页面上传文档代码上传哦
  • 出现此类问题,多数是由于附件名称太长或附件名称有中文导致。 在发送邮件的方法类中加上静态代码块即可 /** * 后加的防止题目过长并且进行全局定义 */ static { System.setProperty("mail.mime....
  • 主要介绍了Java利用MultipartFile实现上传多份文件的代码,非常不错,具有一定的参考借鉴价值,需要的朋友可以参考下
  • java后台接受app上传图片

    千次阅读 2017-03-20 20:00:01
    package com.sujinabo.file; import java.io.File; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.util.List; import java.util.UUID; import javax.se
  • NULL 博文链接:https://little-bill.iteye.com/blog/1268491
  • Java调用C语言动态库(JNA方式):回调函数、结构体数组传参、结构体数组返回-附件资源
  • 问题引入 在一次做发邮件功能时发现,邮件附件为xlsx文件,在网页登录接收邮箱时,附件...参考Java发送邮件Excel附件名称变为.dat文件,虽然我的附件名没超过60个字符,但是有中文,也出现了这个问题 问题解决 参考...
  • java实现多文件异步上传
  •  String content = "集团人事老师,您好\r\n\r\n " + " 附件为"+DateUtil.getMonthStrByInteger(Integer.parseInt(beforeMonth.trim()))+"月度实体学校工资数据,如有疑问请随时沟通。\r\n" + "\r\n" + DateUtil....
  • 多文件上传以及java后台接受

    千次阅读 2017-04-05 17:30:11
    中的地址为我后台接受文件的地址, 因为上传文件,所以 enctype = "multipart/form-data" 是必须的 同时选择多个文件上传,不使用各种控件的话,把 multiple 设置为 "true" 即可。 另外,上传文件 input 中的 name ...
  • import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.File; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException;...
  • 怎么发送邮件,并且实现pdf作为附件的功能。
  • java邮件发送Demo(完整例子)

    热门讨论 2011-12-13 13:27:57
    java邮件发送Demo(完整例子):下面是我的测试方法: public static void demo(){ Mail mail=new Mail(); mail.setSmtpHost("smtp.163.com");/** 设置SMTP **/ String mailFrom="wangxin_admin@163.com"; ...
  • 下载邮箱附件的工具类: import java.io.File; import java.io.FileOutputStream; import java.io.InputStream; import java.util.Properties; import javax.mail.Flags; import javax.mail.Folder; ...
  • } 后端接收文件 以及接收多个参数 将文件定义成一个类的属性,将参数也定义成类的属性,如此 接收参数 和文件 实体类 entity FileSaveReqVO.java @ApiModelProperty(value = "上传的文件", required = true) @Not...
  • app传输图文文件到java后台

    千次阅读 2018-10-17 13:50:01
    @RequestMapping(params = "upload", method = RequestMethod.POST) @ResponseBody public void upload(HttpServletRequest request, HttpServletResponse response) throws ServletException, ...
  • 1 package TOOLS;... 3 import java.io.BufferedOutputStream; 4 import java.io.File; 5 import java.io.FileOutputStream; 6 import java.io.IOException; 7 import java.io.InputStream; 8 impo...
  • 直接后台代码,因为接受的base64字符前面data:image/jpeg;base64,不是照片内容,去掉即可,否则会文件不识别(损坏) /** * 新增保存附件 */ @PostMapping("/add") @ResponseBody public ResultBody addSave...
  • java_rtp 实现视频播放与保存

    热门讨论 2010-05-05 13:35:58
    java_rtp 实现视频播放与保存,实现视频,音频播放与保存,及回放

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 15,446
精华内容 6,178
关键字:

java接受附件

java 订阅