springboot 邮件接收发送 阿里云发送短信组件

最近公司用到一个收发邮件的功能，于是就开发了一个，代码贴出来，以减少大家的工作时间

首先，这个是个springboot项目，先贴出pom文件 用到的jar包

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion>

<groupId>com.guige</groupId>
<artifactId>rocky-message</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>

<name>rocky-message</name>
<description>消息(邮件短信)发送</description>

<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.4.7.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>

<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<java.version>1.8</java.version>
<pagehelper.version>4.1.6</pagehelper.version>
<druid.version>1.0.27</druid.version>
<!--  MyBatis Generator  -->
<!--  Java接口和实体类  -->
<!--  依赖版本  -->
<mapper.version>3.4.0</mapper.version>
<fastjson.version>1.2.13</fastjson.version>
<jackson.version>2.8.5</jackson.version>
</properties>

<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<!--<exclusions>
<exclusion>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-logging</artifactId>
</exclusion>
</exclusions>-->
</dependency>
<!-- https://mvnrepository.com/artifact/log4j/log4j -->
<!--    <dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>-->

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-configuration-processor</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-mail</artifactId>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-velocity -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-velocity</artifactId>
<version>1.4.7.RELEASE</version>
</dependency>

<!--        <!– https://mvnrepository.com/artifact/org.springframework.kafka/spring-kafka –>
<dependency>
<groupId>org.springframework.kafka</groupId>
<artifactId>spring-kafka</artifactId>
<version>1.2.0.RELEASE</version>
</dependency>
<!– https://mvnrepository.com/artifact/org.apache.kafka/kafka_2.11 –>
<dependency>
<groupId>org.apache.kafka</groupId>
<artifactId>kafka_2.11</artifactId>
<version>0.11.0.0</version>
</dependency>
<!– https://mvnrepository.com/artifact/org.apache.kafka/kafka-log4j-appender –>
<dependency>
<groupId>org.apache.kafka</groupId>
<artifactId>kafka-log4j-appender</artifactId>
<version>0.11.0.0</version>
</dependency>-->

<!-- cglib javassist -->
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>3.1</version>
</dependency>
<dependency>
<groupId>org.javassist</groupId>
<artifactId>javassist</artifactId>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>${fastjson.version}</version>
</dependency>
<!-- logger -->
<dependency>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
<version>1.1.1</version>
</dependency>

<!-- junit -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<scope>test</scope>
</dependency>

<!-- jackson -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-core</artifactId>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-annotations</artifactId>
</dependency>

<!-- general utils -->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.1</version>
</dependency>
<dependency>
<groupId>commons-io</groupId>
<artifactId>commons-io</artifactId>
<version>2.4</version>
</dependency>
<dependency>
<groupId>commons-codec</groupId>
<artifactId>commons-codec</artifactId>
</dependency>
<dependency>
<groupId>commons-fileupload</groupId>
<artifactId>commons-fileupload</artifactId>
<version>1.3</version>
</dependency>
<dependency>
<groupId>commons-beanutils</groupId>
<artifactId>commons-beanutils</artifactId>
<exclusions>
<exclusion>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-math3</artifactId>
<version>3.6</version>
</dependency>
<dependency>
<groupId>commons-collections</groupId>
<artifactId>commons-collections</artifactId>
</dependency>
<dependency>
<groupId>com.googlecode.gentyref</groupId>
<artifactId>gentyref</artifactId>
<version>1.2.0</version>
</dependency>

<!-- ftpclient -->
<dependency>
<groupId>commons-net</groupId>
<artifactId>commons-net</artifactId>
<version>3.6</version>
</dependency>

<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
<dependency>
<groupId>com.aliyun</groupId>
<artifactId>aliyun-java-sdk-core</artifactId>
<version>3.2.3</version>
<scope>system</scope>
<systemPath>${project.basedir}/lib/aliyun-java-sdk-core-3.2.3.jar</systemPath>
</dependency>

<dependency>
<groupId>com.aliyun</groupId>
<artifactId>aliyun-java-sdk-dybaseapi</artifactId>
<version>1.0.0-SNAPSHOT</version>
<scope>system</scope>
<systemPath>${project.basedir}/lib/aliyun-java-sdk-dysmsapi-1.0.0-SANPSHOT.jar</systemPath>
</dependency>
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>1.1.1</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.apache.httpcomponents/httpclient -->
<!--<dependency>
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpclient</artifactId>
<version>4.5.3</version>
</dependency>-->
<!-- https://mvnrepository.com/artifact/org.apache.httpcomponents/httpcore -->

<!-- https://mvnrepository.com/artifact/org.apache.httpcomponents/httpmime -->
<!--<dependency>
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpmime</artifactId>
<version>4.5.3</version>
</dependency>
-->
<!-- https://mvnrepository.com/artifact/org.webjars.npm/jsonwebtoken -->
<!-- https://mvnrepository.com/artifact/io.jsonwebtoken/jjwt -->
<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt</artifactId>
<version>0.9.0</version>
</dependency>

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-configuration-processor</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>com.github.pagehelper</groupId>
<artifactId>pagehelper</artifactId>
<version>${pagehelper.version}</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>${druid.version}</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
<groupId>tk.mybatis</groupId>
<artifactId>mapper</artifactId>
<version>${mapper.version}</version>
</dependency>
<dependency>
<groupId>tk.mybatis</groupId>
<artifactId>mapper-spring-boot-starter</artifactId>
<version>1.1.0</version>
<exclusions>
<exclusion>
<artifactId>mapper</artifactId>
<groupId>tk.mybatis</groupId>
</exclusion>
</exclusions>
</dependency>
<!-- ojdbc6 -->
<dependency>
<groupId>com.oracle</groupId>
<artifactId>ojdbc6</artifactId>
<version>11.2.0.3</version>
<scope>system</scope>
<systemPath>${project.basedir}/lib/ojdbc6-11.2.0.3.jar</systemPath>
</dependency>
</dependencies>
<repositories>
<repository>
<snapshots>
<enabled>true</enabled>
</snapshots>
<releases>
<enabled>true</enabled>
</releases>
<id>maven-public</id>
<name>maven-public</name>
<url>http://192.168.1.166:8081/nexus/content/groups/public/</url>
</repository>
</repositories>
<pluginRepositories>
<pluginRepository>
<id>maven-public</id>
<name>maven-public</name>
<url>http://192.168.1.166:8081/nexus/content/groups/public/</url>
<releases>
<enabled>true</enabled>
</releases>
<snapshots>
<enabled>true</enabled>
</snapshots>
</pluginRepository>
</pluginRepositories>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
<plugin>
<groupId>org.mybatis.generator</groupId>
<artifactId>mybatis-generator-maven-plugin</artifactId>
<version>1.3.2</version>
<configuration>
<configurationFile>src/main/resources/generator/generatorConfig.xml</configurationFile>
<overwrite>true</overwrite>
<verbose>true</verbose>
</configuration>

<dependencies>
<dependency>
<groupId>tk.mybatis</groupId>
<artifactId>mapper</artifactId>
<version>${mapper.version}</version>
</dependency>
</dependencies>
</plugin>

</plugins>
</build>

</project>

贴出application-dev的配置

server:
port: 9001

#################################
## DATASOURCE
#################################

spring:
mail:
host: smtp.mxhichina.com
username: service@***.com #songanwei@***.com
password: Guige102
nickName: '规格委外服务团队'
messages:
basename: message/message
datasource:
url: jdbc:oracle:thin:@dbServer254:1521:guigedb1
username: mis
password: ***
driverClassName: oracle.jdbc.OracleDriver
initialSize: 1
maxActive: 30
minIdle: 5
maxWaite: 600000
testOnBorrow: true
test-while-idle: true
# LOGGING
logging:
level:
root: info
com:
guige: debug
org: error
java:
sql: debug

saleAddressEmail: service@guigeinvest.com
basePath: 'D:/guige/emailUpload/'  #附件保存的目录
uploadrValuationUrl: 'http://localhost:8080/v2/analysis/combine/stock/stockpreference/fileUpload.do?SingleOrNot=0' #附件上传的目录

#kafka:
#  producer:
#    acks: 'all'
#    retries: 3
#    batch-size: 16384
#    buffer-memory: 33554432
#    linger: 0
#    servers: localhost:9092   # 指定kafka 代理地址，可以多个
#  consumer:
#    servers: localhost:9092
#    zookeeper:
#      connect: localhost:2181
#    group-id: message     #指定默认消费者group id
#    auto-offset-reset: earliest
#    enable-auto-commit: true
#    auto-commit-interval: 100
#    session-timeout: 6000
#    concurrency: 10
sms:
product: 'Dysmsapi' #产品名称:云通信短信API产品,开发者无需替换
domain: 'dysmsapi.aliyuncs.com' #产品域名,开发者无需替换
accessKeyId: 'LTAI3GjsF******' #此处需要替换成开发者自己的AK
accessKeySecret: 'mmYVMRb455w86zoAOb******'
defaultConnectTimeout: '10000' #超时时间
defaultReadTimeout: '10000' #超时时间
signName: '阿里云短信测试专用'
templateCode: 'SMS_8223****'

具体的实现，这里有一个通用的发邮件的接口 和一个 使用通用发邮件的接口 companyRegMail主要用来把定义的模板发送到邮箱中

sendSms 发短信的接口

package com.guige.message.service.impl;

import com.alibaba.fastjson.JSON;
import com.aliyuncs.dysmsapi.model.v20170525.SendSmsResponse;
import com.guige.base.exception.BadRequestException;
import com.guige.base.exception.BusinessException;

import com.guige.base.util.StringUtils;
import com.guige.message.enums.EmailType;
/*import com.guige.message.mq.Producer;*/
import com.guige.message.service.SmsService;
import com.guige.message.vo.CompanyRegVo;
import com.guige.message.vo.EmailVo;
import com.guige.message.enums.SendStatus;
import com.guige.message.service.MessageService;
import com.guige.message.vo.SmsVo;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections.map.HashedMap;
import org.apache.log4j.Logger;
import org.apache.velocity.app.VelocityEngine;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.mail.javamail.MimeMessageHelper;
import org.springframework.stereotype.Service;
import org.apache.velocity.app.VelocityEngine;
import org.springframework.ui.velocity.VelocityEngineUtils;

import javax.activation.DataSource;
import javax.activation.MimetypesFileTypeMap;
import javax.mail.internet.MimeMessage;
import javax.mail.util.ByteArrayDataSource;
import java.util.Map;
import java.util.Properties;

/**
* 消息发送实现  邮件短信
*
* @author songaw
* @date 2017/8/7 14:38
*/

@Service
public class MessageServiceImpl implements MessageService {
private static final Logger LOG = Logger.getLogger(MessageServiceImpl.class);
@Value("${spring.mail.username}")
private String username;
@Value("${saleAddressEmail}")
private String saleAddressEmail;
@Value("${spring.mail.nickName}")
private String nickName;
@Autowired
private JavaMailSender mailSender;
@Autowired
VelocityEngine velocityEngine;
@Autowired
SmsService smsService;
/*   private @Autowired
Producer producer;*/
@Override
public String sendEmail(EmailVo email) {
/*   producer.sendEmail(email);*/

//EmailVo email = JSON.parseObject(content, EmailVo.class);

if (email.getAddressees() == null || email.getAddressees().length == 0) {
LOG.error("");
}

try {
MimeMessage mimeMessage = mailSender.createMimeMessage();
MimeMessageHelper helper = new MimeMessageHelper(mimeMessage, true);
helper.setFrom(nickName + "<" + username + ">");
helper.setTo(email.getAddressees());
helper.setSubject(email.getSubject());
helper.setPriority(1);
helper.setText(email.getContent());
helper.setText(email.getContent(), true);

//附件
try {
setAffix(email, helper);
} catch (Exception e) {
LOG.error("附件发送错误");
return SendStatus.exception.getValue();
}
mailSender.send(mimeMessage);
} catch (Exception e) {
LOG.error(e.getMessage());
return SendStatus.exception.getValue();
}
return SendStatus.finish.getValue();
}
private void setAffix(EmailVo email, MimeMessageHelper message) throws Exception {
if (StringUtils.isNotBlank(email.getAffixContent())) {
String affixName = email.getAffixName();
byte[] affixContent = com.sun.org.apache.xerces.internal.impl.dv.util.Base64.decode(email.getAffixContent());
if (StringUtils.isNotBlank(affixName) && affixContent != null && affixContent.length > 0) {
MimetypesFileTypeMap typeMap = new MimetypesFileTypeMap();
DataSource source = new ByteArrayDataSource(email.getAffixContent(), typeMap.getContentType(email.getAffixName()));
message.addAttachment(email.getAffixName(), source);
}
}
}
@Override
public String companyRegMail(CompanyRegVo companyRegVo) {

String paramString = JSON.toJSONString(companyRegVo);
Map<String, Object> model = (Map)JSON.parse(paramString);
//        //初始化参数
//        Properties properties=new Properties();
//        //设置velocity资源加载方式为file
//        properties.setProperty("resource.loader", "templates");
//        //设置velocity资源加载方式为file时的处理类
//        properties.setProperty("file.resource.loader.class", "org.apache.velocity.runtime.resource.loader.FileResourceLoader");
//        //实例化一个VelocityEngine对象
//        VelocityEngine velocityEngine=new VelocityEngine(properties);
String text = VelocityEngineUtils.mergeTemplateIntoString(
velocityEngine, "companyRegSalesTemplate.vm", "UTF-8", model);
EmailVo emailVo = new EmailVo();
if(StringUtils.isNotBlank(saleAddressEmail)){
emailVo.setAddressees(saleAddressEmail.split(","));
}else {
emailVo.setAddressees(new String[]{username});
}
emailVo.setContent(text);
emailVo.setType(EmailType.HTML);
emailVo.setSubject("试用提醒");
return sendEmail(emailVo);
}

@Override
public String sendSms(SmsVo form) {
LOG.info(JSON.toJSONString(form));
try {
SendSmsResponse sendSmsResponse=  smsService.sendSms(form.getAddress(), form.getTemplateId(),form.getParams());
if(sendSmsResponse.getCode().equals("OK")) {
return SendStatus.finish.getValue();
}else{
throw new BusinessException(sendSmsResponse.getMessage());
}
}catch (Exception e){
e.printStackTrace();
throw new BusinessException(e);
}

}

}

发短信的service

package com.guige.message.service;

import com.alibaba.fastjson.JSON;
import com.aliyuncs.DefaultAcsClient;
import com.aliyuncs.IAcsClient;
import com.aliyuncs.dysmsapi.model.v20170525.QuerySendDetailsRequest;
import com.aliyuncs.dysmsapi.model.v20170525.QuerySendDetailsResponse;
import com.aliyuncs.dysmsapi.model.v20170525.SendSmsRequest;
import com.aliyuncs.dysmsapi.model.v20170525.SendSmsResponse;
import com.aliyuncs.exceptions.ClientException;
import com.aliyuncs.profile.DefaultProfile;
import com.aliyuncs.profile.IClientProfile;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

@Service
public class SmsService {

//产品名称
@Value("${sms.product}")
String product;
//产品域名
@Value("${sms.domain}")
String domain;
//KEY
@Value("${sms.accessKeyId}")
String accessKeyId;
@Value("${sms.accessKeySecret}")
String accessKeySecret;
@Value("${sms.defaultConnectTimeout}")
String defaultConnectTimeout;//超时时间
@Value("${sms.defaultReadTimeout}")
String defaultReadTimeout;//超时时间
@Value("${sms.signName}")
String signName;

private static Log logger = LogFactory.getLog(SmsService.class);

public SendSmsResponse sendSms(String phoneNumber, String templateCode, Map<String, String> params) throws ClientException {

//可自助调整超时时间
//   System.setProperty("sun.net.client.defaultConnectTimeout", defaultConnectTimeout);
//   System.setProperty("sun.net.client.defaultReadTimeout", defaultReadTimeout);
//初始化acsClient,暂不支持region化
IClientProfile profile = DefaultProfile.getProfile("cn-hangzhou", accessKeyId, accessKeySecret);
DefaultProfile.addEndpoint("cn-hangzhou", "cn-hangzhou", product, domain);
IAcsClient acsClient = new DefaultAcsClient(profile);

//组装请求对象-具体描述见控制台-文档部分内容
SendSmsRequest request = new SendSmsRequest();
//必填:待发送手机号
request.setPhoneNumbers(phoneNumber);
//必填:短信模板-可在短信控制台中找到
request.setSignName(signName);
//必填:短信模板-可在短信控制台中找到
request.setTemplateCode(templateCode);

request.setTemplateParam(JSON.toJSONString(params));
//选填-上行短信扩展码(无特殊需求用户请忽略此字段)
//request.setSmsUpExtendCode("90997");

//可选:outId为提供给业务方扩展字段,最终在短信回执消息中将此值带回给调用者
request.setOutId("yourOutId");

SendSmsResponse sendSmsResponse = null;
//hint 此处可能会抛出异常，注意catch
try {
sendSmsResponse = acsClient.getAcsResponse(request);
logger.info(JSON.toJSONString(sendSmsResponse));
} catch (Exception e) {
e.printStackTrace();
logger.error(e);
}

return sendSmsResponse;
}

public QuerySendDetailsResponse querySendDetails(String bizId, String phoneNumer, Date date, Long currentPage, Long pageSize) throws ClientException {

//可自助调整超时时间
//  System.setProperty("sun.net.client.defaultConnectTimeout", "10000");
//  System.setProperty("sun.net.client.defaultReadTimeout", "10000");

//初始化acsClient,暂不支持region化
IClientProfile profile = DefaultProfile.getProfile("cn-hangzhou", accessKeyId, accessKeySecret);
DefaultProfile.addEndpoint("cn-hangzhou", "cn-hangzhou", product, domain);
IAcsClient acsClient = new DefaultAcsClient(profile);

//组装请求对象
QuerySendDetailsRequest request = new QuerySendDetailsRequest();
//必填-号码
request.setPhoneNumber(phoneNumer);
//可选-流水号
request.setBizId(bizId);
//必填-发送日期 支持30天内记录查询，格式yyyyMMdd
SimpleDateFormat ft = new SimpleDateFormat("yyyyMMdd");
request.setSendDate(ft.format(date));
//必填-页大小
request.setPageSize(pageSize);
//必填-当前页码从1开始计数
request.setCurrentPage(currentPage);
QuerySendDetailsResponse querySendDetailsResponse = null;
//hint 此处可能会抛出异常，注意catch
try {
querySendDetailsResponse = acsClient.getAcsResponse(request);
} catch (Exception e) {
logger.error(e);
}

return querySendDetailsResponse;
}

}

解析邮件:

这个需求 主要是解析银行邮件中的报表信息 并上传到另一个服务器

package com.guige.message.service.impl;

import com.alibaba.fastjson.JSON;
import com.guige.base.jwt.SubjectModel;
import com.guige.base.jwt.TokenUtil;
import com.guige.base.util.DateUtil;
import com.guige.email.service.AuUserEmailInfoService;
import com.guige.email.vo.AuUserEmailInfoVo;
import com.guige.log.entity.DataWarningLog;
import com.guige.log.service.DataWarningService;
import com.guige.message.service.ParserValuationForEmailService;
import com.sun.mail.imap.IMAPFolder;
import com.sun.mail.imap.IMAPStore;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.core.io.FileSystemResource;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.client.RestTemplate;

import javax.mail.*;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;
import javax.mail.internet.MimeMultipart;
import javax.mail.internet.MimeUtility;
import java.io.*;
import java.util.List;
import java.util.Properties;

@Slf4j
@Service("parserValuationForEmailService")
public class ParserValuationForEmailServiceImpl implements ParserValuationForEmailService {
@Autowired
DataWarningService dataWarningService;
@Autowired
AuUserEmailInfoService auUserEmailInfoService;
@Value("${spring.mail.username}")
private String usernames;
@Value("${spring.mail.password}")
private String passwords;
@Value("${basePath}")
private String basePath;
@Value("${uploadrValuationUrl}")
private String uploadrValuationUrl;
@Autowired
RestTemplate restTemplate;
// @Scheduled(cron="0/20 * *  * * ? ")   //每20秒执行一次
@Override
public void readMail(){
List<AuUserEmailInfoVo> auUserEmailInfos= auUserEmailInfoService.findAllList();
if(!CollectionUtils.isEmpty(auUserEmailInfos)){
for(int i=0;i<auUserEmailInfos.size();i++){
scanEmail(auUserEmailInfos.get(i));
}
}
}

private void scanEmail(AuUserEmailInfoVo auUserEmailInfo) {
try {

Properties prop = System.getProperties();
prop.put("mail.store.protocol", auUserEmailInfo.getProtocol());
prop.put("mail.imap.host",auUserEmailInfo.getHost());

Session session = Session.getInstance(prop);
IMAPStore store = (IMAPStore) session.getStore( auUserEmailInfo.getProtocol()); // 使用imap会话机制，连接服务器
try {
store.connect(auUserEmailInfo.getEmail(), auUserEmailInfo.getPassword());
}catch (Exception e){
log.error("连接失败"+auUserEmailInfo.getEmail(),e);
}
IMAPFolder folder = (IMAPFolder) store.getFolder("INBOX"); // 收件箱
folder.open(Folder.READ_WRITE);
int messageCount = folder.getMessageCount();
//获取未读邮件
Message[] messages =folder.getMessages();    // folder.getMessages(folder.getMessageCount()-folder.getUnreadMessageCount()+1,folder.getMessageCount());
parseMessage(folder,auUserEmailInfo,messages); //解析邮件
//释放资源
if (folder != null) folder.close(true);
if (store != null) store.close();
System.out.println("读取成功。。。。。。。。。。。。");
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}
}

/**
* 解析邮件
* @param messages 要解析的邮件列表
*/
private void parseMessage(IMAPFolder folder,AuUserEmailInfoVo auUserEmailInfo,Message ...messages) throws  Exception {
if (messages == null || messages.length < 1) {
log.error(auUserEmailInfo.getUserId()+":"+auUserEmailInfo.getEmail()+":未找到要解析的邮件!");
return;
//throw new MessagingException("未找到要解析的邮件!");
}

// 解析所有邮件
for (int i = 0, count = messages.length; i < count; i++) {
MimeMessage msg = (MimeMessage) messages[i];
InternetAddress address = getFrom(msg);
String uid = folder.getUID(msg)+"";
//  msg.setFlag(Flags.Flag.SEEN, true);//设置成已读
/*  System.out.println(msg.getSubject());
System.out.println(msg.getMessageID());

System.out.println(address.getPersonal()+"<" + address.getAddress() + ">");//张三<zhangsan@163.com>
System.out.println(decodeText(msg.getSubject()));//转码后的标题
System.out.println(getReceiveAddress(msg, null));//收件人
System.out.println(msg.getSentDate());//收件日期*/
System.out.println(DateUtil.dateFormat(msg.getSentDate(),DateUtil.HOUR_PATTERN));//收件日期
System.out.println(msg.getSentDate().getTime());//收件日期
if(org.apache.commons.lang.StringUtils.isNotBlank(auUserEmailInfo.getAddressees())&&!auUserEmailInfo.getAddressees().contains(address.getAddress())){
continue;
}
if (isContainAttachment(msg)) {//保存附件

saveAttachment(msg, basePath+auUserEmailInfo.getEmail(),auUserEmailInfo,address.getAddress(),uid);
}
}
}

/**
* 获得邮件发件人
* @param msg 邮件内容
* @return 地址
* @throws MessagingException
* @throws UnsupportedEncodingException
*/
private InternetAddress getFrom(MimeMessage msg) throws MessagingException, UnsupportedEncodingException {
Address[] froms = msg.getFrom();
if (froms.length < 1)
throw new MessagingException("没有发件人!");

return (InternetAddress) froms[0];
}

/**
* 根据收件人类型，获取邮件收件人、抄送和密送地址。如果收件人类型为空，则获得所有的收件人
* <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
*/
private 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 part 邮件内容
* @return 邮件中存在附件返回true，不存在返回false
* @throws MessagingException
* @throws IOException
*/
private 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 part 邮件中多个组合体中的其中一个组合体
* @param destDir  附件保存目录
* @throws UnsupportedEncodingException
* @throws MessagingException
* @throws FileNotFoundException
* @throws IOException
*/
private void saveAttachment(Part part, String destDir,AuUserEmailInfoVo auUserEmailInfo,String sendEmail,String uid) 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();
this.saveAndSendFile(is, destDir, decodeText(bodyPart.getFileName()),auUserEmailInfo,sendEmail,uid);
} else if (bodyPart.isMimeType("multipart/*")) {
saveAttachment(bodyPart,destDir,auUserEmailInfo,sendEmail,uid);
} else {
String contentType = bodyPart.getContentType();
if (contentType.indexOf("name") != -1 || contentType.indexOf("application") != -1) {
this.saveAndSendFile(bodyPart.getInputStream(), destDir, decodeText(bodyPart.getFileName()),auUserEmailInfo,sendEmail,uid);
}
}
}
} else if (part.isMimeType("message/rfc822")) {
saveAttachment((Part) part.getContent(),destDir,auUserEmailInfo,sendEmail,uid);
}
}

/**
* 读取输入流中的数据保存至指定目录
* @param is 输入流
* @param fileName 文件名
* @param destDir 文件存储目录
* @throws FileNotFoundException
* @throws IOException
*/
private void saveAndSendFile(InputStream is, String destDir, String fileName, AuUserEmailInfoVo auUserEmailInfo, String sendEmail,String uid)
throws  IOException {
if(!fileName.endsWith("xls")&&!fileName.endsWith("xlsx")){
return;
}
List<DataWarningLog> dataWarningLogs=dataWarningService.queryDataWarningLogLog(auUserEmailInfo.getEmail(),sendEmail,sendEmail+uid);
if(CollectionUtils.isEmpty(dataWarningLogs)) {

saveFile(is, destDir, fileName);

try{
sendValuationHtml(destDir +File.separator+fileName,fileName,auUserEmailInfo);
dataWarningService.saveDataWarning(auUserEmailInfo.getEmail(), sendEmail, fileName,"1",sendEmail+uid);
}catch (Exception e){
log.error(e.getMessage(),e);
dataWarningService.saveDataWarning(auUserEmailInfo.getEmail(), sendEmail, fileName,"0",sendEmail+uid);
}
return;
}
DataWarningLog dataWarningLog= dataWarningLogs.get(0);
if("0".equals(dataWarningLog.getExt1())){
//扫描到未发送
File f = new File(destDir +File.separator+fileName);
if(!f.exists()){
saveFile(is, destDir, fileName);
}
sendValuationHtml(destDir +File.separator+fileName,fileName,auUserEmailInfo);
//判断文件是否存在  存在则不保存
dataWarningService.updateDataWarningStatus(dataWarningLog);
}

}

private void saveFile(InputStream is, String destDir, String fileName) throws IOException {
BufferedInputStream bis = new BufferedInputStream(is);
File fileDir = new File(destDir);
if(!(fileDir.exists() && fileDir.isDirectory())){
fileDir.mkdir();
}
BufferedOutputStream bos = new BufferedOutputStream(
new FileOutputStream(new File(destDir +File.separator+fileName/*+ uuidFilename*/)));

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
*/
private String decodeText(String encodeText) throws UnsupportedEncodingException {
if (encodeText == null || "".equals(encodeText)) {
return "";
} else {
return MimeUtility.decodeText(encodeText);
}
}
/**
* 获得邮件文本内容
* @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);
}
}
}

public void sendValuationHtml(String filePath,String fileName, AuUserEmailInfoVo userEmailInfo){

SubjectModel sub = new SubjectModel(userEmailInfo.getUserId(), userEmailInfo.getUserName());
String token = TokenUtil.createJWT(JSON.toJSONString(sub));

FileSystemResource resource = new FileSystemResource(new File(filePath));
MediaType type = MediaType.parseMediaType("multipart/form-data;charset=UTF-8");

MultiValueMap<String, Object> param = new LinkedMultiValueMap<>();
param.add("file", resource);
// param.set("name",fileName);
HttpHeaders headers = new HttpHeaders();
headers.setContentType(type);
headers.set("token", token);
HttpEntity<MultiValueMap<String, Object>> files = new HttpEntity<>(param, headers);
try {
String string = restTemplate.postForObject(uploadrValuationUrl+"&name="+fileName, files, String.class,param);
// JSONObject json=JSON.parseObject(string);

}catch (Exception e){
log.error(e.getMessage(),e);
}

}

}