精华内容
下载资源
问答
  • 各位大侠好,求一份jsp或者java读取邮箱附件到数据库的代码。可以发到37825413@qq.com这个邮箱。谢谢

    各位大侠好,求一份jsp或者java读取邮箱附件到数据库的代码。可以发到37825413@qq.com这个邮箱。谢谢

    展开全文
  • java邮箱里面把附件拿出来 代码直接用 package com.kdmins.mail; import com.sun.mail.pop3.POP3Folder; import com.sun.mail.pop3.POP3Store; import com.sun.mail.util.MailSSLSocketFactory; import java....

    java 从邮箱里面把附件拿出来
    代码直接用
    springboot 项目

     <!--Emial-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-mail</artifactId>
            </dependency>
    
    package com.kdmins.mail;
    
    
    import com.sun.mail.pop3.POP3Folder;
    import com.sun.mail.pop3.POP3Store;
    import com.sun.mail.util.MailSSLSocketFactory;
    
    import java.io.BufferedInputStream;
    import java.io.BufferedOutputStream;
    import java.io.File;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.UnsupportedEncodingException;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    import java.util.Properties;
    import javax.mail.Address;
    import javax.mail.BodyPart;
    import javax.mail.Flags;
    import javax.mail.Folder;
    import javax.mail.Message;
    import javax.mail.MessagingException;
    import javax.mail.Multipart;
    import javax.mail.Part;
    import javax.mail.Session;
    import javax.mail.internet.InternetAddress;
    import javax.mail.internet.MimeMessage;
    import javax.mail.internet.MimeMultipart;
    import javax.mail.internet.MimeUtility;
    
    
    /**
     * 邮件接受测试
     */
    
    /**
     * 使用POP3协议接收邮件
     */
    public class POP3ReceiveMailTest {
    
        public static void main(String[] args) throws Exception {
            resceive();
        }
    
        /**
         * 接收邮件   使用之前请先开启邮箱中的协议
         */
        public static void resceive() throws Exception {
    
            Properties props = new Properties();
            props.setProperty("mail.popStore.protocol", "pop3");       // 使用pop3协议
            props.setProperty("mail.pop3.port", "995");           // 端口 每个邮箱端口号都不一样  网易163 是110
    
            MailSSLSocketFactory sf = new MailSSLSocketFactory();
            sf.setTrustAllHosts(true);
            props.put("mail.pop3.ssl.enable",true);
            props.put("mail.pop3.ssl.socketFactory",sf);
    
            //props.setProperty("mail.debug", "true");
            props.setProperty("mail.pop3.host", "pop.qq.com");
    
            Session session = Session.getInstance(props);
            POP3Store store = (POP3Store) session.getStore("pop3");
            //这里的密码 是令牌 而不是 真正的邮箱密码,具体请百度
            store.connect("pop.qq.com", 995, "123456@qq.com", "qqqqqqqqqqqqqq");
            POP3Folder folder = (POP3Folder) store.getFolder("INBOX");
    
    
            // 获得收件箱
            //Folder folder = store.getFolder("INBOX");
            /* Folder.READ_ONLY:只读权限
             * Folder.READ_WRITE:可读可写(可以修改邮件的状态)
             */
            folder.open(Folder.READ_WRITE); //打开收件箱
    
            // 由于POP3协议无法获知邮件的状态,所以getUnreadMessageCount得到的是收件箱的邮件总数
            System.out.println("未读邮件数: " + folder.getUnreadMessageCount());
    
            // 由于POP3协议无法获知邮件的状态,所以下面得到的结果始终都是为0
            System.out.println("删除邮件数: " + folder.getDeletedMessageCount());
            System.out.println("新邮件: " + folder.getNewMessageCount());
    
            // 获得收件箱中的邮件总数
            System.out.println("邮件总数: " + folder.getMessageCount());
    
            // 得到收件箱中的所有邮件,并解析
            Message[] messages = folder.getMessages();
            parseMessage(messages);
    
            //得到收件箱中的所有邮件并且删除邮件
            //deleteMessage(messages);
    
            //释放资源
            folder.close(true);
            store.close();
        }
    
        /**
         * 解析邮件
         *
         * @param messages 要解析的邮件列表
         */
        public static void parseMessage(Message... messages) throws MessagingException, IOException {
            if (messages == null || messages.length < 1)
                throw new MessagingException("未找到要解析的邮件!");
    
            // 解析所有邮件
            for (int i = 0, count = messages.length; i < count; i++) {
                MimeMessage msg = (MimeMessage) messages[i];
                System.out.println("------------------解析第" + msg.getMessageNumber() + "封邮件-------------------- ");
                System.out.println("主题: " + getSubject(msg));
                System.out.println("发件人: " + getFrom(msg));
                System.out.println("收件人:" + getReceiveAddress(msg, null));
                System.out.println("发送时间:" + getSentDate(msg, null));
                System.out.println("是否已读:" + isSeen(msg));
                System.out.println("邮件优先级:" + getPriority(msg));
                System.out.println("是否需要回执:" + isReplySign(msg));
                System.out.println("邮件大小:" + msg.getSize() * 1024 + "kb");
                boolean isContainerAttachment = isContainAttachment(msg);
                System.out.println("是否包含附件:" + isContainerAttachment);
                if (isContainerAttachment) {
                    //saveAttachment(msg, "d:\\mailTest\\" + msg.getSubject() + "_" + i + "_"); //保存附件
                    saveAttachment(msg, "d:\\mailTest\\"); //保存附件路径
                }
                StringBuffer content = new StringBuffer(30);
                getMailTextContent(msg, content);
                System.out.println("邮件正文:" + (content.length() > 100 ? content.substring(0, 100) + "..." : content));
                System.out.println("------------------第" + msg.getMessageNumber() + "封邮件解析结束-------------------- ");
                System.out.println();
    
            }
        }
    
    
        /**
         * 解析邮件
         *
         * @param messages 要解析的邮件列表
         */
        public static void deleteMessage(Message... messages) throws MessagingException, IOException {
            if (messages == null || messages.length < 1)
                throw new MessagingException("未找到要解析的邮件!");
    
            // 解析所有邮件
            for (int i = 0, count = messages.length; i < count; i++) {
    
                /**
                 *   邮件删除
                 */
                Message message = messages[i];
                String subject = message.getSubject();
                // set the DELETE flag to true
                message.setFlag(Flags.Flag.DELETED, true);
                System.out.println("Marked DELETE for message: " + subject);
    
    
            }
        }
    
        /**
         * 获得邮件主题
         *
         * @param msg 邮件内容
         * @return 解码后的邮件主题
         */
        public static String getSubject(MimeMessage msg) throws UnsupportedEncodingException, MessagingException {
            return MimeUtility.decodeText(msg.getSubject());
        }
    
        /**
         * 获得邮件发件人
         *
         * @param msg 邮件内容
         * @return 姓名 <Email地址>
         * @throws MessagingException
         * @throws UnsupportedEncodingException
         */
        public static String getFrom(MimeMessage msg) throws MessagingException, UnsupportedEncodingException {
            String from = "";
            Address[] froms = msg.getFrom();
            if (froms.length < 1)
                throw new MessagingException("没有发件人!");
    
            InternetAddress address = (InternetAddress) froms[0];
            String person = address.getPersonal();
            if (person != null) {
                person = MimeUtility.decodeText(person) + " ";
            } else {
                person = "";
            }
            from = person + "<" + address.getAddress() + ">";
    
            return from;
        }
    
        /**
         * 根据收件人类型,获取邮件收件人、抄送和密送地址。如果收件人类型为空,则获得所有的收件人
         * <p>Message.RecipientType.TO  收件人</p>
         * <p>Message.RecipientType.CC  抄送</p>
         * <p>Message.RecipientType.BCC 密送</p>
         *
         * @param msg  邮件内容
         * @param type 收件人类型
         * @return 收件人1 <邮件地址1>, 收件人2 <邮件地址2>, ...
         * @throws MessagingException
         */
        public static String getReceiveAddress(MimeMessage msg, Message.RecipientType type) throws MessagingException {
            StringBuffer receiveAddress = new StringBuffer();
            Address[] addresss = null;
            if (type == null) {
                addresss = msg.getAllRecipients();
            } else {
                addresss = msg.getRecipients(type);
            }
    
            if (addresss == null || addresss.length < 1)
                throw new MessagingException("没有收件人!");
            for (Address address : addresss) {
                InternetAddress internetAddress = (InternetAddress) address;
                receiveAddress.append(internetAddress.toUnicodeString()).append(",");
            }
    
            receiveAddress.deleteCharAt(receiveAddress.length() - 1); //删除最后一个逗号
    
            return receiveAddress.toString();
        }
    
        /**
         * 获得邮件发送时间
         *
         * @param msg 邮件内容
         * @return yyyy年mm月dd日 星期X HH:mm
         * @throws MessagingException
         */
        public static String getSentDate(MimeMessage msg, String pattern) throws MessagingException {
            Date receivedDate = msg.getSentDate();
            if (receivedDate == null)
                return "";
    
            if (pattern == null || "".equals(pattern))
                pattern = "yyyy年MM月dd日 E HH:mm ";
    
            return new SimpleDateFormat(pattern).format(receivedDate);
        }
    
        /**
         * 判断邮件中是否包含附件
         * <p>
         * //* @param msg 邮件内容
         *
         * @return 邮件中存在附件返回true,不存在返回false
         * @throws MessagingException
         * @throws IOException
         */
        public static boolean isContainAttachment(Part part) throws MessagingException, IOException {
            boolean flag = false;
            if (part.isMimeType("multipart/*")) {
                MimeMultipart multipart = (MimeMultipart) part.getContent();
                int partCount = multipart.getCount();
                for (int i = 0; i < partCount; i++) {
                    BodyPart bodyPart = multipart.getBodyPart(i);
                    String disp = bodyPart.getDisposition();
                    if (disp != null && (disp.equalsIgnoreCase(Part.ATTACHMENT) || disp.equalsIgnoreCase(Part.INLINE))) {
                        flag = true;
                    } else if (bodyPart.isMimeType("multipart/*")) {
                        flag = isContainAttachment(bodyPart);
                    } else {
                        String contentType = bodyPart.getContentType();
                        if (contentType.indexOf("application") != -1) {
                            flag = true;
                        }
    
                        if (contentType.indexOf("name") != -1) {
                            flag = true;
                        }
                    }
    
                    if (flag) break;
                }
            } else if (part.isMimeType("message/rfc822")) {
                flag = isContainAttachment((Part) part.getContent());
            }
            return flag;
        }
    
        /**
         * 判断邮件是否已读
         *
         * @param msg 邮件内容
         * @return 如果邮件已读返回true, 否则返回false
         * @throws MessagingException
         */
        public static boolean isSeen(MimeMessage msg) throws MessagingException {
            return msg.getFlags().contains(Flags.Flag.SEEN);
        }
    
        /**
         * 判断邮件是否需要阅读回执
         *
         * @param msg 邮件内容
         * @return 需要回执返回true, 否则返回false
         * @throws MessagingException
         */
        public static boolean isReplySign(MimeMessage msg) throws MessagingException {
            boolean replySign = false;
            String[] headers = msg.getHeader("Disposition-Notification-To");
            if (headers != null)
                replySign = true;
            return replySign;
        }
    
        /**
         * 获得邮件的优先级
         *
         * @param msg 邮件内容
         * @return 1(High):紧急  3:普通(Normal)  5:低(Low)
         * @throws MessagingException
         */
        public static String getPriority(MimeMessage msg) throws MessagingException {
            String priority = "普通";
            String[] headers = msg.getHeader("X-Priority");
            if (headers != null) {
                String headerPriority = headers[0];
                if (headerPriority.indexOf("1") != -1 || headerPriority.indexOf("High") != -1)
                    priority = "紧急";
                else if (headerPriority.indexOf("5") != -1 || headerPriority.indexOf("Low") != -1)
                    priority = "低";
                else
                    priority = "普通";
            }
            return priority;
        }
    
        /**
         * 获得邮件文本内容
         *
         * @param part    邮件体
         * @param content 存储邮件文本内容的字符串
         * @throws MessagingException
         * @throws IOException
         */
        public static void getMailTextContent(Part part, StringBuffer content) throws MessagingException, IOException {
            //如果是文本类型的附件,通过getContent方法可以取到文本内容,但这不是我们需要的结果,所以在这里要做判断
            boolean isContainTextAttach = part.getContentType().indexOf("name") > 0;
            if (part.isMimeType("text/*") && !isContainTextAttach) {
                content.append(part.getContent().toString());
            } else if (part.isMimeType("message/rfc822")) {
                getMailTextContent((Part) part.getContent(), content);
            } else if (part.isMimeType("multipart/*")) {
                Multipart multipart = (Multipart) part.getContent();
                int partCount = multipart.getCount();
                for (int i = 0; i < partCount; i++) {
                    BodyPart bodyPart = multipart.getBodyPart(i);
                    getMailTextContent(bodyPart, content);
                }
            }
        }
    
        /**
         * 保存附件
         *
         * @param part    邮件中多个组合体中的其中一个组合体
         * @param destDir 附件保存目录
         * @throws UnsupportedEncodingException
         * @throws MessagingException
         * @throws FileNotFoundException
         * @throws IOException
         */
        public static void saveAttachment(Part part, String destDir) throws UnsupportedEncodingException, MessagingException,
                FileNotFoundException, IOException {
            if (part.isMimeType("multipart/*")) {
                Multipart multipart = (Multipart) part.getContent();    //复杂体邮件
                //复杂体邮件包含多个邮件体
                int partCount = multipart.getCount();
                for (int i = 0; i < partCount; i++) {
                    //获得复杂体邮件中其中一个邮件体
                    BodyPart bodyPart = multipart.getBodyPart(i);
                    //某一个邮件体也有可能是由多个邮件体组成的复杂体
                    String disp = bodyPart.getDisposition();
                    if (disp != null && (disp.equalsIgnoreCase(Part.ATTACHMENT) || disp.equalsIgnoreCase(Part.INLINE))) {
                        InputStream is = bodyPart.getInputStream();
                        saveFile(is, destDir, decodeText(bodyPart.getFileName()));
                    } else if (bodyPart.isMimeType("multipart/*")) {
                        saveAttachment(bodyPart, destDir);
                    } else {
                        String contentType = bodyPart.getContentType();
                        if (contentType.indexOf("name") != -1 || contentType.indexOf("application") != -1) {
                            saveFile(bodyPart.getInputStream(), destDir, decodeText(bodyPart.getFileName()));
                        }
                    }
                }
            } else if (part.isMimeType("message/rfc822")) {
                saveAttachment((Part) part.getContent(), destDir);
            }
        }
    
        /**
         * 读取输入流中的数据保存至指定目录
         *
         * @param is       输入流
         * @param fileName 文件名
         * @param destDir  文件存储目录
         * @throws FileNotFoundException
         * @throws IOException
         */
        private static void saveFile(InputStream is, String destDir, String fileName)
                throws FileNotFoundException, IOException {
            BufferedInputStream bis = new BufferedInputStream(is);
            BufferedOutputStream bos = new BufferedOutputStream(
                    new FileOutputStream(new File(destDir + fileName)));
            int len = -1;
            while ((len = bis.read()) != -1) {
                bos.write(len);
                bos.flush();
            }
            bos.close();
            bis.close();
        }
    
        /**
         * 文本解码
         *
         * @param encodeText 解码MimeUtility.encodeText(String text)方法编码后的文本
         * @return 解码后的文本
         * @throws UnsupportedEncodingException
         */
        public static String decodeText(String encodeText) throws UnsupportedEncodingException {
            if (encodeText == null || "".equals(encodeText)) {
                return "";
            } else {
                return MimeUtility.decodeText(encodeText);
            }
        }
    
    
    }
    
    
    展开全文
  • 当有需求,需要把当天的报表文件发送给指定邮箱又不小生成多余的报表文件在硬盘中,就可以使用代码了。 实现过程是先将数据库里的数据,导出excel文件输出流中(注:不是直接生成文件),发送邮件时附件内容直接从...
  • java实现读取邮件发送邮件

    千次阅读 2016-02-18 11:16:40
    有些邮箱pop服务器不支持查看是否邮件已经被查看多的功能,只能通过自己认为添加标识标记邮件是已读还是未读 public class MailUtil { /**   * 判断邮件中是否包含附件   * @param msg 邮件内容   ...

    有些邮箱pop服务器不支持查看是否邮件已经被查看多的功能,只能通过自己认为添加标识标记邮件是已读还是未读


    public class MailUtil {


    /** 
         * 判断邮件中是否包含附件 
         * @param msg 邮件内容 
         * @return 邮件中存在附件返回true,不存在返回false 
         * @throws MessagingException 
         * @throws IOException 
         */  
        public static boolean isContainAttachment(Part part) throws MessagingException, IOException {  
            boolean flag = false;  
            if (part.isMimeType("multipart/*")) {  
                MimeMultipart multipart = (MimeMultipart) part.getContent();  
                int partCount = multipart.getCount();  
                for (int i = 0; i < partCount; i++) {  
                    BodyPart bodyPart = multipart.getBodyPart(i);  
                    String disp = bodyPart.getDisposition();  
                    if (disp != null && (disp.equalsIgnoreCase(Part.ATTACHMENT) || disp.equalsIgnoreCase(Part.INLINE))) {  
                        flag = true;  
                    } else if (bodyPart.isMimeType("multipart/*")) {  
                        flag = isContainAttachment(bodyPart);  
                    } else {  
                        String contentType = bodyPart.getContentType();  
                        if (contentType.indexOf("application") != -1) {  
                            flag = true;  
                        }    
                        if (contentType.indexOf("name") != -1) {  
                            flag = true;  
                        }   
                    }
                      
                    if (flag) break;  
                }  
            } else if (part.isMimeType("message/rfc822")) {
                flag = isContainAttachment((Part)part.getContent());  
            }  
            return flag;  
        }
        
        /** 
         * 获得邮件发件人 
         * @param msg 邮件内容 
         * @return 姓名 <Email地址> 
         * @throws MessagingException 
         * @throws UnsupportedEncodingException  
         */  
        public static String getFrom(MimeMessage msg) throws MessagingException, UnsupportedEncodingException {  
            String from = "";  
            Address[] froms = msg.getFrom();  
            if (froms.length < 1)  
                throw new MessagingException("没有发件人!");
              
            InternetAddress address = (InternetAddress) froms[0];  
            String person = address.getPersonal();  
            if (person != null) {  
                person = MimeUtility.decodeText(person) + " ";  
            } else {  
                person = "";  
            }  
            from = person + "<" + address.getAddress() + ">";  
              
            return from;  
        }
        
        /** 
         * 获得邮件文本内容 
         * @param part 邮件体 
         * @param content 存储邮件文本内容的字符串 
         * @throws MessagingException 
         * @throws IOException 
         */  
        public static void getMailTextContent(Part part, StringBuffer content) throws MessagingException, IOException {  
            //如果是文本类型的附件,通过getContent方法可以取到文本内容,但这不是我们需要的结果,所以在这里要做判断  
            boolean isContainTextAttach = part.getContentType().indexOf("name") > 0;   
            if (part.isMimeType("text/*") && !isContainTextAttach) {  
                content.append(part.getContent().toString());  
            } else if (part.isMimeType("message/rfc822")) {   
                getMailTextContent((Part)part.getContent(),content);  
            } else if (part.isMimeType("multipart/*")) {  
                Multipart multipart = (Multipart) part.getContent();  
                int partCount = multipart.getCount();  
                for (int i = 0; i < partCount; i++) {  
                    BodyPart bodyPart = multipart.getBodyPart(i);  
                    getMailTextContent(bodyPart,content);  
                }  
            }
        }  
        
        /** 
         * 获得邮件主题 
         * @param msg 邮件内容 
         * @return 解码后的邮件主题 
         */  
        public static String getSubject(MimeMessage msg) throws UnsupportedEncodingException, MessagingException {  
            return MimeUtility.decodeText(msg.getSubject());  
        }
        
        /** 
         * 根据收件人类型,获取邮件收件人、抄送和密送地址。如果收件人类型为空,则获得所有的收件人 
         * <p>Message.RecipientType.TO  收件人</p> 
         * <p>Message.RecipientType.CC  抄送</p> 
         * <p>Message.RecipientType.BCC 密送</p> 
         * @param msg 邮件内容 
         * @param type 收件人类型 
         * @return 收件人1 <邮件地址1>, 收件人2 <邮件地址2>, ... 
         * @throws MessagingException 
         */  
        public static String getReceiveAddress(MimeMessage msg, Message.RecipientType type) throws MessagingException {  
            StringBuffer receiveAddress = new StringBuffer();  
            Address[] addresss = null;  
            if (type == null) {  
                addresss = msg.getAllRecipients();
            } else {  
                addresss = msg.getRecipients(type);  
            }  
              
            if (addresss == null || addresss.length < 1)  
                throw new MessagingException("没有收件人!");
            for (Address address : addresss) {  
                InternetAddress internetAddress = (InternetAddress)address;  
                receiveAddress.append(internetAddress.toUnicodeString()).append(",");  
            }  
              
            receiveAddress.deleteCharAt(receiveAddress.length()-1); //删除最后一个逗号  
              
            return receiveAddress.toString();
        } 
        
        /** 
         * 获得邮件发送时间 
         * @param msg 邮件内容 
         * @return yyyy年mm月dd日 星期X HH:mm 
         * @throws MessagingException 
         */  
        public static String getSentDate(MimeMessage msg, String pattern) throws MessagingException {  
            Date receivedDate = msg.getSentDate();  
            if (receivedDate == null)  
                return "";  
              
            if (pattern == null || "".equals(pattern))  
                pattern = "yyyy年MM月dd日 E HH:mm ";  
              
            return new SimpleDateFormat(pattern).format(receivedDate);  
        }
        
        /**  
         * 判断邮件是否已读  
         * @param msg 邮件内容  
         * @return 如果邮件已读返回true,否则返回false  
         * @throws MessagingException   
         */  
        public static boolean isSeen(MimeMessage msg){  
            try {
    return msg.getFlags().contains(Flags.Flag.SEEN);
    } catch (MessagingException e) {
    e.printStackTrace();
    }
    return true;
        }
        
        /** 
         * 获得邮件的优先级 
         * @param msg 邮件内容 
         * @return 1(High):紧急  3:普通(Normal)  5:低(Low) 
         * @throws MessagingException  
         */  
        public static String getPriority(MimeMessage msg) throws MessagingException {  
            String priority = "普通";  
            String[] headers = msg.getHeader("X-Priority");  
            if (headers != null) {
                String headerPriority = headers[0];
                if (headerPriority.indexOf("1") != -1 || headerPriority.indexOf("High") != -1)
                    priority = "紧急";  
                else if (headerPriority.indexOf("5") != -1 || headerPriority.indexOf("Low") != -1)
                    priority = "低";
                else  
                    priority = "普通";
            }  
            return priority;
        }
        
        /** 
         * 判断邮件是否需要阅读回执 
         * @param msg 邮件内容 
         * @return 需要回执返回true,否则返回false 
         * @throws MessagingException 
         */  
        public static boolean isReplySign(MimeMessage msg) throws MessagingException {  
            boolean replySign = false;  
            String[] headers = msg.getHeader("Disposition-Notification-To");  
            if (headers != null)  
                replySign = true;  
            return replySign;  
        }
        
        /**  
         * 保存附件  
         * @param part 邮件中多个组合体中的其中一个组合体  
         * @param destDir  附件保存目录  
         * @throws UnsupportedEncodingException  
         * @throws MessagingException  
         * @throws FileNotFoundException  
         * @throws IOException  
         */  
        public static void saveAttachment(Part part, String destDir,String fileName) throws UnsupportedEncodingException, MessagingException,  
                FileNotFoundException, IOException {
            if (part.isMimeType("multipart/*")) {  
                Multipart multipart = (Multipart) part.getContent();//复杂体邮件  
                //复杂体邮件包含多个邮件体  
                int partCount = multipart.getCount();  
                for (int i = 0; i < partCount; i++) {  
                    //获得复杂体邮件中其中一个邮件体  
                    BodyPart bodyPart = multipart.getBodyPart(i);  
                    //某一个邮件体也有可能是由多个邮件体组成的复杂体
                    String disp = bodyPart.getDisposition();  
                    if (disp != null && (disp.equalsIgnoreCase(Part.ATTACHMENT) || disp.equalsIgnoreCase(Part.INLINE))) {  
                        InputStream is = bodyPart.getInputStream();
    //                    saveFile(is, destDir, decodeText(bodyPart.getFileName()));  
                        saveFile(is, destDir, fileName);  
                    } else if (bodyPart.isMimeType("multipart/*")) {  
                        saveAttachment(bodyPart,destDir,fileName);  
                    } else {  
                        String contentType = bodyPart.getContentType();  
                        if (contentType.indexOf("name") != -1 || contentType.indexOf("application") != -1) {  
    //                        saveFile(bodyPart.getInputStream(), destDir, decodeText(bodyPart.getFileName()));  
                            saveFile(bodyPart.getInputStream(), destDir, fileName);  
                        }  
                    }  
                }  
            } else if (part.isMimeType("message/rfc822")) {  
                saveAttachment((Part) part.getContent(),destDir,fileName);  
            }  
        }
        
        /**  
         * 读取输入流中的数据保存至指定目录  
         * @param is 输入流  
         * @param fileName 文件名  
         * @param destDir 文件存储目录  
         * @throws FileNotFoundException  
         * @throws IOException  
         */  
        private static void saveFile(InputStream is, String destDir, String fileName)  
                throws FileNotFoundException, IOException {
            BufferedInputStream bis = new BufferedInputStream(is);
            File destFile = new File(destDir + fileName);
            if(!destFile.exists()){
            destFile.getParentFile().mkdirs();
            destFile.createNewFile();
            }
            BufferedOutputStream bos = new BufferedOutputStream(  
                    new FileOutputStream(destFile));
            int len = -1;  
            while ((len = bis.read()) != -1) {  
                bos.write(len);  
                bos.flush();  
            }
            bos.close();  
            bis.close();
        }
        
        /** 
         * 文本解码 
         * @param encodeText 解码MimeUtility.encodeText(String text)方法编码后的文本 
         * @return 解码后的文本 
         * @throws UnsupportedEncodingException 
         */  
        public static String decodeText(String encodeText) throws UnsupportedEncodingException {  
            if (encodeText == null || "".equals(encodeText)) {  
                return "";  
            } else {  
                return MimeUtility.decodeText(encodeText);  
            }  
        } 
        
        public static List readMail(){
        List list =  new ArrayList();
    String username = ReadConfig.getKeyValue("username");
    String password = ReadConfig.getKeyValue("password");
    Properties props = new Properties();
    props.put("mail.pop3.port", "110");
    props.put("mail.pop3.host", "pop.sina.com");
    Session session = Session.getInstance(props);  
    try {
    Store store = session.getStore("pop3");
    store.connect(username, password);  
    Folder folder = store.getFolder("INBOX");  
    folder.open(Folder.READ_WRITE); //打开收件箱 
    Message messages[] = folder.getMessages();
    int readnum = Integer.valueOf(ReadConfig.getKeyValue("readnum"));
    // 解析未读邮件
    for (int i = readnum ; i < messages.length; i++) {
       MimeMessage msg = (MimeMessage) messages[i];
       System.out.println("------------------解析第" + msg.getMessageNumber() + "封邮件-------------------- ");  
       System.out.println("主题: " + getSubject(msg));  
       System.out.println("发件人: " + getFrom(msg));  
       StringBuffer content = new StringBuffer(30);
       getMailTextContent(msg, content);
       String mailContent = content.toString().trim();
       
       HashMap<String, String> map = new HashMap();
       
       // 正文
       map.put("content", mailContent);
       System.out.println("邮件正文:" + mailContent);
       
        // 附件
        boolean isContainerAttachment = isContainAttachment(msg);
    System.out.println("是否包含附件:" + isContainerAttachment);
        if (isContainerAttachment) {
        String fileName = "D:\\" + msg.getSubject() + ".docx";
        saveAttachment(msg, "D:\\" , msg.getSubject()+".docx");//转成input流数据
        map.put("attachFile", fileName);
        File file = new File(fileName);
    map.put("inputStream", base64EnCode(file));
       }
        list.add(map);
    }
    // 读完邮件,设置已读邮件数
    // ReadConfig.writeProperties("readnum", messages.length+"");
    } catch (Exception e) {
    e.printStackTrace();
    }
        return list ;
        }
        
        /**
    * 将邮件附件进行base64编码 
    * 接收方需要先解码成byte数组,再写文件
    * @param file
    * @return 
    * @throws  
    */
        public static String base64EnCode(File file){
        byte[] by = new byte[(int) file.length()]; 
    try {
    InputStream is = new FileInputStream(file); 
    ByteArrayOutputStream bytestream = new ByteArrayOutputStream(); 
    byte[] bb = new byte[2048]; 
    int ch; 
    ch = is.read(bb); 
    while (ch != -1) {
    bytestream.write(bb, 0, ch); 
    ch = is.read(bb); 
    }
    by = bytestream.toByteArray(); 
    } catch (Exception ex) { 
    ex.printStackTrace(); 
    }
    Base64 base64 = new Base64();
    return base64.encodeBase64String(by);
        }
        /**
         * @param map  
    * 发送邮件 
    * @param 
    * @return 
    * @throws  
    */
        public static void sendMail(final HashMap<String, String> map){
        String username = ReadConfig.getKeyValue("username");
    String password = ReadConfig.getKeyValue("password");
    String post = ReadConfig.getKeyValue("mail.smtp.port");
    String host = ReadConfig.getKeyValue("mail.smtp.host");
    Properties props = new Properties();
    props.put("mail.smtp.port", post);
    props.put("mail.smtp.host", host);
    props.put("mail.smtp.auth", "true");
    Session session = Session.getInstance(props,
                    new javax.mail.Authenticator() {
                        protected PasswordAuthentication getPasswordAuthentication() {
                        String username = ReadConfig.getKeyValue("username");
                    String password = ReadConfig.getKeyValue("password");
                            return new PasswordAuthentication(username, password);
                        }
                    });
    MimeMessage message = new MimeMessage(session);
    // 设置发信人
       try {
    message.setFrom(new InternetAddress(username));
       // 设置收件人
       message.setRecipient(RecipientType.TO,new InternetAddress("1553025502@qq.com"));
       message.setRecipient(RecipientType.CC,new InternetAddress("tianql@zhong-ying.com"));
       // 设置主题
       message.setSubject(map.get("title"));
       // 设置邮件内容
       message.setContent(map.get("content"), "text/html;charset=utf-8");
       // 邮件的附件,邮件附件目前没有不知道怎么发送
       
       // 发送
       Transport transport = session.getTransport("smtp");
       transport.send(message);
       } catch (AddressException e) {
    e.printStackTrace();
    } catch (MessagingException e) {
    e.printStackTrace();
    }
        }
    展开全文
  • Java 从文档中读取聊天记录

    千次阅读 2018-11-30 00:37:09
    根据附件中的QQ群聊天文件,读取其中的聊天记录,实现如下的方法:1)List getMessagesById(String id, Date beginTime, Date endTime):根据参数的id返回id对应的qq号码或者邮箱地址标识的聊天者在指定时间段内...

    题目要求

    根据附件中的QQ群聊天文件,读取其中的聊天记录,实现如下的方法:1)List getMessagesById(String id, Date beginTime, Date endTime):根据参数的id返回id对应的qq号码或者邮箱地址标识的聊天者在指定时间段内(beginTime与Date endTime之间)的所有聊天记录;2)getChatter():打印除了教师外的话唠(发言最多的)同学的QQ号(或邮箱)、名字(QQ群中的名字)。

    解题思路:

    在这里插入图片描述

    下载要读取的文档:(山东科技大学Java学习交流群.txt)
    https://mooc1-1.chaoxing.com/ueditorupload/read?objectId=e5ab362c913b5a20a027f64022fa806d

    以下是我的代码

    Date类

    这个类,成员有年月日时分秒,记录聊头信息发出的时间,具体实现如下

    // An highlighted block
    //自定义的日期类,有年月日,时分秒六个属性,两个方法,一个用来计算年月日,一个用来计算时分秒
    //通过这两个方法可以实现日期前后的比较,另外重写toString方法
    public class Date {
    	public int year;
    	public int month;
    	public int day;
    	public int hour;
    	public int minute;
    	public int second;
    	public Date(int year, int month, int day, int hour, int minute, int second) {
    		this.year = year;
    		this.month = month;
    		this.day = day;
    		this.hour = hour;
    		this.minute = minute;
    		this.second = second;
    	}
    	public int calculteday() {
    		return year*365+month*30+day;
    	}
    	public int calculatehour() {
    		return hour*3600+minute*60+second;
    	}
    	public String toString() {
    		return year+"年"+month+"月"+day+"日"+hour+"时"+minute+"分"+second+"秒";
    	}
    }
    
    

    Message类

    Message类有两个属性,一个Date属性,一个String属性,互相对应,String属性是聊天消息的内容,而Date则是这个聊天消息发出的时间,Message可以排序,具体实现是按照Date的前后排序,具体实现如下

    // An highlighted block
    //Message类实现信息的存储,有两个属性,一个Date类型,记录信息发出的时间,String类型的message记录信息内容
    //Message类实现的Comparable接口,可以排序,compareTo()方法通过Date(日期)排序
    public class Message implements Comparable<Message>{
    	private Date time;
    	private String message;
    	public Message(Date time, String message) {
    		this.time = time;
    		this.message = message;
    	}
    	
    	public Message(Date time) {
    		this.time = time;
    	}
    
    	public Date getTime() {
    		return time;
    	}
    	public void setTime(Date time) {
    		this.time = time;
    	}
    	public String getMessage() {
    		return message;
    	}
    	public void setMessage(String message) {
    		this.message = message;
    	}
    	@Override
    	public int compareTo(Message o) {
    		if(this.time.calculteday()<o.getTime().calculteday())
    			return -1;
    		else if(this.time.calculteday()>o.getTime().calculteday())
    			return 1;
    		else {
    			if(this.time.calculatehour()<o.getTime().calculatehour())
    				return -1;
    			else if(this.time.calculatehour()>o.getTime().calculatehour())
    				return 1;
    			else
    				return 0;
    		}
    	}
    	public String toString() {
    		return message;
    	}
    }
    
    

    People类

    People类的每一个对象都对应一个群成员,记录该成员的ID(即QQ号或者QQ邮箱)、群昵称、以及这个群成员所有的聊天消息(Message链表),因为读取文件要每行每行的读取,所以每读取一行的聊天消息,那么就将消息插入到Message链表中,并实现一次排序,这样读取完成后,每个群成员的聊天记录就会按照时间的先后排好序,查找的时候直接比较每一个Message对象的Date属性即可,具体实现如下

    // An highlighted block
    //People类有三个成员,一个String表示id,一个String表示群内的名字,一个容器类则是这个人所有的聊头记录,
    //get、set方法无需多说,addChat(Message message)方法是向记录聊天记录的容器内添加新读取的聊头记录
    //而sortchat()方法则是将记录聊头记录的容器按照时间先后的顺序排好序
    import java.util.Collections;
    import java.util.LinkedList;
    
    public class People {
    	public String id;
    	public String name;
    	public LinkedList<Message> chat;
    	public People(String id, String name) {
    		this.id = id;
    		this.name = name;
    		this.chat = new LinkedList<Message>();
    	}
    	public String getId() {
    		return id;
    	}
    	public void setId(String id) {
    		this.id = id;
    	}
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public LinkedList<Message> getChat() {
    		return chat;
    	}
    	public void setChat(LinkedList<Message> chat) {
    		this.chat = chat;
    	}
    	public void addChat(Message message) {
    		this.chat.add(message);
    	}
    	public void sortchat() {
    		Collections.sort(chat);
    	}
    	public String toString() {
    		return id+" "+name;
    	}
    }
    

    ReadChat类

    这个类是这个程序的关键所在,它主要用来读取文件,把文件中的所有人以及这些人各自的聊天记录保存到哈希表中,哈希表的key值是每个人的ID,value值是People类的对象,这个对象中保存有每个人的ID,群昵称,和他所有的聊天信息。
    具体的读取算法是:每行每行读取,如果读取的这一行信息是时间、群成员信息,那么就将时间、群成员信息(ID、群昵称)提取出来,创建一个Date对象保存时间,两个String对象保存群成员信息,如果不是,那么这行信息就是聊天内容,那么就将聊天内容保存到一个String对象中,接着读取下一行,再次判断新读取的这一行信息是聊天内容还是时间、群成员信息,如果是聊天内容,那么就调用String的concat方法将聊天内容添加到保存聊天内容的String对象中,如果不是聊天内容,那就是时间、群成员信息,那么就创建一个Message对象,将本次循环的Date对象和聊天内容String对象作为形参,判定本次循环的群成员是否在哈希表中,如果在,直接在哈希表在找出该群成员,调用该群成员的addchat方法,将Message对象插入到该群成员的聊天记录链表;如果哈希表中不存在该成员,那么创建一个新的People对象,将群成员信息作为形参,并在创建完成以后,将Message对象插入
    如此往复循环,知道读取到的字符串信息为null。
    具体实现如下:

    // An highlighted block
    //这个类中的readchat()用来读取文档中的信息,并将信息存储到一个哈希表(allchater)中,返回这个哈希表
    
    import java.io.*;
    import java.util.HashMap;
    
    public class ReadChat {
    	public static HashMap<String,People> readchat(){
    		HashMap<String,People> allchater = new HashMap<String,People>();
    		BufferedReader br = null;
    		File f = new File("山科大Java学习交流群.txt");
    		InputStreamReader fr = null; 
    		try {
    			fr = new InputStreamReader(new FileInputStream(f),"UTF-8");
    			br = new BufferedReader(fr);
    			String s = br.readLine();
    			//for(int o=0;o<1014;o++) {
    			
    			while(true) {			 
    				 
    				while("".equals(s)) {
    					s=br.readLine();
    				}
    				if(s==null)
    					break;
    				//sapce1记录第一个空格出现的位置,以此读取年月日
    				int space1 = 0;
    				for(int i=0;i<s.length();i++) {
    					if(Character.isWhitespace(s.charAt(i))) {
    						space1 = i;
    						break;
    					}
    				}
    				//tmp0是记录年月日的字符串
    				String tmp0 = s.substring(0, space1);
    				//space2记录第二个空格出现的位置,以此读取时分秒
    				int space2 = 0;
    				for(int i=space1+1;i<s.length();i++) {
    					if(Character.isWhitespace(s.charAt(i))) {
    						space2 = i;
    						break;
    					}
    				}
    				//用String的substring()方法提取出年月日和时分秒的字符串,
    				//再用split()方法提取成int类型,创建日期对象
    				//tmp1是记录时分秒的字符串
    				String tmp1 = s.substring(space1+1, space2);
    				//tmp2是记录群昵称和QQ号的字符串
    				String tmp2 = s.substring(space2+1, s.length()-1);
    				//将年月日、时分秒提取出来
    				String[] tday = tmp0.split("-");
    				String[] thour = tmp1.split(":");
    				int year = Integer.parseInt(tday[0]);
    				int month = Integer.parseInt(tday[1]);
    				int day = Integer.parseInt(tday[2]);
    				int hour = Integer.parseInt(thour[0]);
    				int minute = Integer.parseInt(thour[1]);
    				int second = Integer.parseInt(thour[2]);
    				Date date = new Date(year,month,day,hour,minute,second);
    				//将QQ号和群昵称提取出来
    				int flag = 0;
    				for(int i = 0; i<tmp2.length();i++) {
    					if((tmp2.charAt(i)=='('||tmp2.charAt(i)=='<')&&flag == 0) {
    						flag=i;
    						break;
    					}
    				}
    				String name = tmp2.substring(0, flag);
    				String id = tmp2.substring(flag+1, tmp2.length());
    				//将消息提取出来
    				String message = br.readLine();
    				while(true) {
    					String newline = br.readLine();
    					if(newline == null)
    					{
    						s = null;
    						break;
    					}
    					if("".equals(newline))
    					{
    						message = message.concat(newline);
    					}
    					else {
    						if(Character.isDigit(newline.charAt(0))&&Character.isDigit(newline.charAt(1))&&Character.isDigit(newline.charAt(2))&&Character.isDigit(newline.charAt(3))&&newline.charAt(4)=='-'&&Character.isDigit(newline.charAt(5))&&Character.isDigit(newline.charAt(6))&&newline.charAt(7)=='-'&&Character.isDigit(newline.charAt(8))&&Character.isDigit(newline.charAt(9))) {
    						//判断是消息还是日期姓名id
    							s = newline;
    							break;
    						}
    						else
    							message = message.concat(newline);
    					}
    				}
    				Message m = new Message(date,message);
    				//如果发消息的人已经在哈希表中存在,那么直接将消息添加到这个人的记录消息的容
    				//器类中即可,如果发消息的人在哈希表中还不存在,那么创建一个新的People插入到哈希表
    				if(allchater.containsKey(id)) {
    					allchater.get(id).addChat(m);
    					if(!name.equals(""))
    						allchater.get(id).setName(name);
    					allchater.get(id).sortchat();
    				}
    				else {
    					People people = new People(id,name);
    					people.addChat(m);
    					allchater.put(id, people);
    				}
    			}
    		}catch(FileNotFoundException e) {
    			System.out.println("文件未找到");
    		}catch(IOException e) {
    			System.out.println("文件读取错误");
    		}
    		return allchater;
    	}
    }
    
    

    主函数Main类

    main函数主要就是对读取文件返回的哈希表进行操作,根据ID找这个人在某一时间段的聊天记录,因为哈希表中ID是key值,所以可以直接根据ID找出这个人所对应的People对象,这个人所对应的对象中包含一个聊天记录链表(Message)链表,在Message链表中找Date大于开始时间,小于结束时间的所有聊天记录,并插入到一个新的Message链表中返回,这样就实现了List<> getMessagesById(String id, Date beginTime, Date endTime)方法;另外,想找出说话最多的同学也就比较简单了,首先我们遍历哈希表(遍历每个同学),哪个同学对应的People对象的聊天记录链表(Message)链表size()方法(即链表长度)最大,那么该同学就是说话最多的同学,这样我们就实现了getChatter()函数
    具体实现如下

    // An highlighted block
    import java.util.Collections;
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.LinkedList;
    import java.util.List;
    import java.util.Scanner;
    import java.util.Set;
    
    public class Main {
    
    	public static void main(String[] args) {
    		Scanner input = new Scanner(System.in);
    		HashMap<String, People> allchater = ReadChat.readchat();
    
    		System.out.println("输入你要查的id");
    		String id = input.next();
    		System.out.println("输入你查找的聊头记录的开始时间“年 月 日 时 分 秒”");
    		int yearbegin = input.nextInt();
    		int monthbegin = input.nextInt();
    		int daybegin = input.nextInt();
    		int hourbegin = input.nextInt();
    		int minutebegin = input.nextInt();
    		int secondbegin = input.nextInt();
    		Date beginTime = new Date(yearbegin, monthbegin, daybegin, hourbegin, minutebegin, secondbegin);
    		System.out.println("输入你查找的聊头记录的结束时间“年 月 日 时 分 秒”");
    		int yearend = input.nextInt();
    		int monthend = input.nextInt();
    		int dayend = input.nextInt();
    		int hourend = input.nextInt();
    		int minutend = input.nextInt();
    		int secondend = input.nextInt();
    		Date endTime = new Date(yearend, monthend, dayend, hourend, minutend, secondend);
    		LinkedList<Message> lm = (LinkedList<Message>) Main.getMessagesById(id, beginTime, endTime);
    		if (lm == null)
    			System.out.println("该成员不存在");
    		else {
    			if (lm.size() == 0)
    				System.out.println("该成员在这段时间内没有说话");
    			else {
    				System.out.println(allchater.get(id) + "在" + beginTime + "到" + endTime + "时间内,说的话为:");
    				for (int i = 0; i < lm.size(); i++) {
    					System.out.println(lm.get(i));
    				}
    			}
    		}
    		System.out.println("----------------");
    		People maxofmessage = Main.getChatter();
    		System.out.println("话痨的个人信息是:" + maxofmessage);
    	}
    
    	// 根据参数的id返回id对应的qq号码或者邮箱地址标识的聊天者在指定
    	// 时间段内(beginTime与Date endTime之间)的所有聊天记录
    	public static List<Message> getMessagesById(String id, Date beginTime, Date endTime) {
    		LinkedList<Message> list = new LinkedList<Message>();
    		HashMap<String, People> allchat = ReadChat.readchat();
    		People people = allchat.get(id);
    		if (people == null)
    			return null;
    		Message beginsay = new Message(beginTime, "");
    		Message endsay = new Message(endTime, "");
    		for (int i = 0; i < people.getChat().size(); i++) {
    			if (people.getChat().get(i).compareTo(beginsay) > 0 && people.getChat().get(i).compareTo(endsay) < 0) {
    				list.add(people.getChat().get(i));
    			}
    		}
    		return list;
    	}
    
    	// 打印除了教师外的话唠(发言最多的)同学的QQ号(或邮箱)、名字(QQ群中的名字)
    	public static People getChatter() {
    		People maxofmessage = null;
    		HashMap<String, People> allchat = ReadChat.readchat();
    		int sumofmessage = 0;
    		Set<String> keyset = allchat.keySet();
    		Iterator it = keyset.iterator();
    		while (it.hasNext()) {
    			String id = (String) it.next();
    			if (allchat.get(id).getChat().size() > sumofmessage && !id.equals("43760439")) {
    				maxofmessage = allchat.get(id);
    				sumofmessage = maxofmessage.getChat().size();
    			}
    		}
    		return maxofmessage;
    	}
    
    }
    
    
    展开全文
  • 一共三个方法,主方法sendmail() 包含添加附件根据邮箱配置发送邮件 reader方法和createImageMimeBodyPart方法是读取模板以及把图片插入到模板里,其中读取模板用的dom4j包里的方法(把html模板转成xml文件,转换很...
  • 最近遇到个小问题,要把前台传过来的字符串包装成txt格式并作为邮件的附件发送到指定邮箱。平时的解决思路是把字符串写入到本地文件,再读取文件作为邮件附件发送,但是发现文件没有必要在本地进行存储,最终采用流...
  • 初学java javamail总结

    2017-10-14 10:19:33
    1.配置好邮箱pop3协议,imap协议等等,腾讯邮箱记得开启这些服务,在设置---账号里面 ...3.测试小例子(借鉴别人的例子,然后我自己加以改进,可以读取邮件,把附件下载到本地) package test; import java.io.Buffe
  • java开源包1

    千次下载 热门讨论 2013-06-28 09:14:34
    jaev 是一个用来验证电子邮箱地址是否有效的 Java 项目。 Java的FastCGI网关 jFastCGI jFastCGI 是一个可以让Tomcat 之类的Servlet容器支持运行PHP和其它fastcgi应用程序,将Servlet容器充当成一个FastCGI 的网关。...
  • java开源包12

    热门讨论 2013-06-28 10:14:45
    jaev 是一个用来验证电子邮箱地址是否有效的 Java 项目。 Java的FastCGI网关 jFastCGI jFastCGI 是一个可以让Tomcat 之类的Servlet容器支持运行PHP和其它fastcgi应用程序,将Servlet容器充当成一个FastCGI 的网关。...
  • Java资源包01

    2016-08-31 09:16:25
    jaev 是一个用来验证电子邮箱地址是否有效的 Java 项目。 Java的FastCGI网关 jFastCGI jFastCGI 是一个可以让Tomcat 之类的Servlet容器支持运行PHP和其它fastcgi应用程序,将Servlet容器充当成一个FastCGI 的网关。...
  • java开源包101

    2016-07-13 10:11:08
    jaev 是一个用来验证电子邮箱地址是否有效的 Java 项目。 Java的FastCGI网关 jFastCGI jFastCGI 是一个可以让Tomcat 之类的Servlet容器支持运行PHP和其它fastcgi应用程序,将Servlet容器充当成一个FastCGI 的网关。...
  • java开源包11

    热门讨论 2013-06-28 10:10:38
    jaev 是一个用来验证电子邮箱地址是否有效的 Java 项目。 Java的FastCGI网关 jFastCGI jFastCGI 是一个可以让Tomcat 之类的Servlet容器支持运行PHP和其它fastcgi应用程序,将Servlet容器充当成一个FastCGI 的网关。...
  • java开源包2

    热门讨论 2013-06-28 09:17:39
    jaev 是一个用来验证电子邮箱地址是否有效的 Java 项目。 Java的FastCGI网关 jFastCGI jFastCGI 是一个可以让Tomcat 之类的Servlet容器支持运行PHP和其它fastcgi应用程序,将Servlet容器充当成一个FastCGI 的网关。...
  • java开源包3

    热门讨论 2013-06-28 09:20:52
    jaev 是一个用来验证电子邮箱地址是否有效的 Java 项目。 Java的FastCGI网关 jFastCGI jFastCGI 是一个可以让Tomcat 之类的Servlet容器支持运行PHP和其它fastcgi应用程序,将Servlet容器充当成一个FastCGI 的网关。...
  • java开源包6

    热门讨论 2013-06-28 09:48:32
    jaev 是一个用来验证电子邮箱地址是否有效的 Java 项目。 Java的FastCGI网关 jFastCGI jFastCGI 是一个可以让Tomcat 之类的Servlet容器支持运行PHP和其它fastcgi应用程序,将Servlet容器充当成一个FastCGI 的网关。...
  • java开源包5

    热门讨论 2013-06-28 09:38:46
    jaev 是一个用来验证电子邮箱地址是否有效的 Java 项目。 Java的FastCGI网关 jFastCGI jFastCGI 是一个可以让Tomcat 之类的Servlet容器支持运行PHP和其它fastcgi应用程序,将Servlet容器充当成一个FastCGI 的网关。...
  • java开源包10

    热门讨论 2013-06-28 10:06:40
    jaev 是一个用来验证电子邮箱地址是否有效的 Java 项目。 Java的FastCGI网关 jFastCGI jFastCGI 是一个可以让Tomcat 之类的Servlet容器支持运行PHP和其它fastcgi应用程序,将Servlet容器充当成一个FastCGI 的网关。...
  • java开源包4

    热门讨论 2013-06-28 09:26:54
    jaev 是一个用来验证电子邮箱地址是否有效的 Java 项目。 Java的FastCGI网关 jFastCGI jFastCGI 是一个可以让Tomcat 之类的Servlet容器支持运行PHP和其它fastcgi应用程序,将Servlet容器充当成一个FastCGI 的网关。...
  • java开源包8

    热门讨论 2013-06-28 09:55:26
    jaev 是一个用来验证电子邮箱地址是否有效的 Java 项目。 Java的FastCGI网关 jFastCGI jFastCGI 是一个可以让Tomcat 之类的Servlet容器支持运行PHP和其它fastcgi应用程序,将Servlet容器充当成一个FastCGI 的网关。...
  • java开源包9

    热门讨论 2013-06-28 09:58:55
    jaev 是一个用来验证电子邮箱地址是否有效的 Java 项目。 Java的FastCGI网关 jFastCGI jFastCGI 是一个可以让Tomcat 之类的Servlet容器支持运行PHP和其它fastcgi应用程序,将Servlet容器充当成一个FastCGI 的网关。...
  • java开源包7

    热门讨论 2013-06-28 09:52:16
    jaev 是一个用来验证电子邮箱地址是否有效的 Java 项目。 Java的FastCGI网关 jFastCGI jFastCGI 是一个可以让Tomcat 之类的Servlet容器支持运行PHP和其它fastcgi应用程序,将Servlet容器充当成一个FastCGI 的网关。...
  • JAVA上百实例源码以及开源项目

    千次下载 热门讨论 2016-01-03 17:37:40
    Java存储与读取对象 1个目标文件 如题 Java调色板面板源代码 1个目标文件 摘要:Java源码,窗体界面,调色板  使用Java语言编写的一款用于反映颜色变化的面板,也就是大家熟悉的颜色调色板演示程序。原理是初始化颜色...
  • [Java] JavaMail 查询邮件

    2019-10-05 20:44:33
    本文再演示下,如何读取邮箱上的邮件。 邮件内容的数据格式种类比较多,用户直接阅读邮件比较常见,通过程序解读邮件比较少见,所以,本文的例子只演示读取邮件信封上的内容,例如邮件主题、发件人。若邮件内容是纯...
  • Java从网络取得文件 1个目标文件 简单 Java从压缩包中提取文件 1个目标文件 简单 Java存储与读取对象 1个目标文件 如题 Java调色板面板源代码 1个目标文件 摘要:Java源码,窗体界面,调色板 使用Java语言编写的一款...
  • Java实现邮件发送

    2021-03-01 13:22:59
    电子邮件把邮件发送到收件人使用的邮件服务器,并放在其中的收件人邮箱中,收件人可以在自己方便时上网到自己使用的邮件服务器进行读取。 发送邮件:SMTP(Simple Mail Tranfer Protocol:简单邮件传送协议)协议 接收...
  • 读取PDF文件中的信息 package com.zht; import java.io.File; import java.io.UnsupportedEncodingException; import java.sql.Connection; import java.sql.DriverManager; import java.sql....
  • Java开发实战1200例.第2卷.part3

    热门讨论 2013-05-08 22:46:34
    实例025 使用DOM组件从数据流中读取XML 42 实例026 使用JDOM组件从文件中读取XML 44 实例027 使用JDOM组件读取XML 45 实例028 使用SAX组件从文件中读取XML 48 实例029 使用SAX组件从数据流中读取XML 50 实例030 使用...

空空如也

空空如也

1 2 3
收藏数 46
精华内容 18
关键字:

java读取邮箱附件

java 订阅