手写一个高并发批量定时邮件发送服务器《二》

最新推荐文章于 2022-04-02 16:20:14 发布
最新推荐文章于 2022-04-02 16:20:14 发布
阅读量733 收藏 4
点赞数
分类专栏： 高并发发送邮件 文章标签： java quartz 高并发 javamail 定时任务
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37045848/article/details/117118150
版权

一、设计思路

参考quartz任务调度框架，设计高并发邮件服务器。
1、将邮件发送封装成任务task线程。
2、创建任务调度中心，根据触发器来推送任务到任务执行线程池。
3、创建心跳触发器，来激活和触发任务调度。

二、代码

1、EmailTask （邮件发送任务类）

package com.zcb.monitor.business.utils;


import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.activation.DataHandler;
import javax.activation.FileDataSource;
import javax.mail.MessagingException;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.*;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.util.Date;

/**
 * @description:邮件发送任务类
 * @author: Administrator
 * @date: 2021/4/22
 */
public class EmailTask implements Runnable{
    private Logger logger = LoggerFactory.getLogger(this.getClass());

	/**发件人账户名*/
    String  senderAccount;
    /**密码或者授权码*/
    String  senderPassword;
    /**发生时间*/
    Date sendDate;
    /**邮件发送连接session*/
    Session session;
    /**发件人地址必须和发件人账户名这里是一致，因为一般邮箱登录账户和地址是一致的*/
    String senderAddress;
    /**收件人地址 多个以英文逗号分割*/
    String receiverTo;
    /**抄送人 多个以英文逗号分割*/
    String receiverCc;
    /**内容*/
    String content;
    /**标题*/
    String title ;
    /**同类型日志，用来日志信息累计*/
    String key;

    public EmailTask( Session session,
                      String senderAddress,
                      String receiverTo,
                      String receiverCc,
                      String content, String title, String key, String senderAccount,String  senderPassword,Date sendDate) {
        this.session=session;
        this.senderAddress=senderAddress;
        this.receiverTo=receiverTo;
        this.receiverCc=receiverCc;
        this.content=content;
        this.title=title;
        this.senderAccount=senderAccount;
        this.senderPassword=senderPassword;
        this.sendDate=sendDate;
        this.key=key;
    }

    public String getKey() {
        return key;
    }

    public void setKey(String key) {
        this.key = key;
    }

    public String getSenderAccount() {
        return senderAccount;
    }

    public void setSenderAccount(String senderAccount) {
        this.senderAccount = senderAccount;
    }

    public String getSenderPassword() {
        return senderPassword;
    }

    public void setSenderPassword(String senderPassword) {
        this.senderPassword = senderPassword;
    }

    public Date getSendDate() {
        return sendDate;
    }

    public void setSendDate(Date sendDate) {
        this.sendDate = sendDate;
    }

    public Session getSession() {
        return session;
    }

    public void setSession(Session session) {
        this.session = session;
    }

    public String getSenderAddress() {
        return senderAddress;
    }

    public void setSenderAddress(String senderAddress) {
        this.senderAddress = senderAddress;
    }

    public String getReceiverTo() {
        return receiverTo;
    }

    public void setReceiverTo(String receiverTo) {
        this.receiverTo = receiverTo;
    }

    public String getReceiverCc() {
        return receiverCc;
    }

    public void setReceiverCc(String receiverCc) {
        this.receiverCc = receiverCc;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }
    @Override
    public String toString() {
        return "EmailTask{" +
                "senderAccount='" + senderAccount + '\'' +
                ", senderPassword='" + senderPassword + '\'' +
                ", sendDate=" + sendDate +
                ", session=" + session +
                ", senderAddress='" + senderAddress + '\'' +
                ", receiverTo='" + receiverTo + '\'' +
                ", receiverCc='" + receiverCc + '\'' +
                ", content='" + content + '\'' +
                ", title='" + title + '\'' +
                ", key='" + key + '\'' +
                '}';
    }
    public void send() {
        Transport transport =null;
        try {
              transport = session.getTransport();
            //设置发件人的账户名和密码
            transport.connect(senderAccount, senderPassword);
            //设置发送信息
            MimeMessage mimeMessage = crateEmailMessage();
            if(mimeMessage!=null){
                transport.sendMessage(mimeMessage, mimeMessage.getAllRecipients());
                logger.info(senderAccount+"给"+receiverTo+"发送邮件标题为："+title+"内容为："+content);
            }
            
        } catch (MessagingException mex) {

            logger.error(new Date() + " send failed, exception: " + mex);

        }finally {
            if(transport!=null){
                try {
                transport.close();//关闭通道
                } catch (MessagingException mex) {
                    logger.error(new Date() + " send failed, exception: " + mex);
                }
            }
        }

    }
    @Override
    public void run() {
        logger.debug("进入邮箱发送");
        send();
    }
    public MimeMessage crateEmailMessage(){
        try{

            if(session!=null&& StringUtils.isNotBlank(senderAddress)&&StringUtils.isNotBlank(receiverTo)&&StringUtils.isNotBlank(content)&&StringUtils.isNotBlank(title)){

                //创建一封邮件的实例对象
                MimeMessage msg = new MimeMessage(session);
                //设置发件人地址
                msg.setFrom(new InternetAddress(senderAddress));
                /**
                 * 设置收件人地址（可以增加多个收件人、抄送、密送），即下面这一行代码书写多行
                 * MimeMessage.RecipientType.TO:发送
                 * MimeMessage.RecipientType.CC：抄送
                 * MimeMessage.RecipientType.BCC：密送
                 */
                if(receiverTo!=null&&receiverTo.contains(",")){
                    InternetAddress[] receiverToS = InternetAddress.parse(receiverTo);//以逗号分隔
                    msg.setRecipients(MimeMessage.RecipientType.TO,receiverToS);
                }else{
                    msg.setRecipient(MimeMessage.RecipientType.TO,new InternetAddress(receiverTo));
                }
                if(receiverCc!=null){


                if(receiverCc.contains(",")){
                    InternetAddress[] receiverCcS = InternetAddress.parse(receiverCc);//以逗号分隔

                    msg.setRecipients(MimeMessage.RecipientType.CC,receiverCcS);
                }else{

                    msg.setRecipient(MimeMessage.RecipientType.CC,new InternetAddress(receiverCc));
                }
                }
                //设置邮件主题
                msg.setSubject(title,"UTF-8");
                //设置邮件正文
               /* if(content.length()>5120){*/
                    // 设置优先级(1:紧急   3:普通    5:低)
                    msg.setHeader("X-Priority", "1");

                    //一个Multipart对象包含一个或多个bodypart对象，组成邮件正文
                    MimeMultipart multipart = new MimeMultipart();

                    //创建文本节点
                    MimeBodyPart text = new MimeBodyPart();
                    text.setContent("<p>"+title+"</p><p>详情请查看附件：</p>","text/html;charset=UTF-8");


                    //创建附件节点  读取本地文件,并读取附件名称
                    MimeBodyPart file1 = new MimeBodyPart();
                    //创建临时文件
                    File temp = File.createTempFile("temp", ".txt");

                    temp.deleteOnExit();
                    BufferedWriter out = new BufferedWriter(new FileWriter(temp));
                    out.write(content);
                    //System.out.println("临时文件已创建:");
                    out.close();
                    DataHandler dataHandler2 = new DataHandler(new FileDataSource(temp));
                    file1.setDataHandler(dataHandler2);
                    file1.setFileName(MimeUtility.encodeText(dataHandler2.getName()));


                    multipart.addBodyPart(text);
                    multipart.addBodyPart(file1);
                    multipart.setSubType("mixed");//混合关系

                    msg.setContent(multipart);
               /* }else{
                    msg.setContent(content, "text/html;charset=UTF-8");
                }*/

                //设置邮件的发送时间,默认立即发送

                msg.setSentDate(new Date());
// 保//保存设置
                msg.saveChanges();
                return msg;
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        return null;
    }

}

2、EmailManage （邮件调度和心跳触发器）

package com.zcb.monitor.business.utils;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.concurrent.*;

/**
 * 邮件任务执行调度类
 *
 * @description:
 * @author: Administrator
 * @date: 2021/4/22
 */

public class EmailManage {
    private static Logger logger = LoggerFactory.getLogger(EmailManage.class);


    private static HashMap<String, EmailTask> map = new HashMap<String, EmailTask>();
    private static BlockingQueue<Runnable> workQueue;//任务队列

    private static ExecutorService es;//线程池的接口
    private static EmailManage emailManage =new EmailManage();
    private static Thread thread;

    private EmailManage() {

        workQueue = new LinkedBlockingQueue<Runnable>();//构造无界的任务队列，资源足够，理论可以支持无线个任务

        es = new ThreadPoolExecutor(2, 4, //2 core； 4 max

                30, TimeUnit.SECONDS, workQueue, //30s keep alive

                new ThreadPoolExecutor.CallerRunsPolicy()); //任务失败重试

        thread = startBeating();//启动任务触发线程
    }


    /* * 发送邮件
     *
     */
    public static boolean send(String key, EmailTask task) {
        try {
            if (emailManage == null || es == null || workQueue == null) {
                emailManage = new EmailManage();

            }

            if (thread == null || !thread.isAlive()) {
                thread = emailManage.startBeating(); //心跳线程死亡 从新开启
                logger.debug("心跳线程死亡 从新开启心跳线程");
            }
            if (map == null) {
                map = new HashMap<String, EmailTask>();
                // return false;//发送邮件失败
            }
            if (key == null || task == null) {
                return false;//发送邮件失败
            }
            if (map.containsKey(key)) {
                EmailTask emailTask = map.get(key);
                task.setContent(emailTask.getContent() + "\n\n\n" + task.getContent());

            }
            map.put(key, task);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return true;
    }

    public static HashMap<String, EmailTask> getEmailTaskMap() {
        return map;
    }


    public void close() {// 关闭
        es.shutdown();

    }

    public Thread startBeating() {

        Runnable r = new Runnable() {
            @Override
            public void run() {
                while (true) {
                    try {
                        if (map != null && map.size() > 0) {
                            for (Iterator<String> iterator = map.keySet().iterator(); iterator.hasNext(); ) {
                                String key = iterator.next();
                                EmailTask emailTask = map.get(key);
                                if (emailTask != null) {
                                    //if (true) {
                                    if (new Date().getTime() > emailTask.getSendDate().getTime()) {
                                        logger.info(emailTask.toString() + new Date().toString() + "任务放入线程池");
                                        es.execute(emailTask);//将任务放入线程池
                                        iterator.remove();
                                        break;
                                    }
                                }


                            }


                        }


                        Thread.sleep(1000 * 30);//30秒循环一次
                    } catch (Exception e) {
                        e.printStackTrace();//打印异常信息，循环继续执行
                    }
                }
            }
        };
        Thread emailTrigger = new Thread(r);

        emailTrigger.start();
        return emailTrigger;
    }


}

3、EmailMessageProduct （emailMessage消息构建器）

package com.zcb.monitor.business.utils;


import com.zcb.monitor.business.data.EmailLogVo;
import com.zcb.monitor.data.entity.EmailMessageRule;
import com.zcb.monitor.data.entity.EmailReceiver;
import com.zcb.monitor.data.entity.EmailSender;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.mail.Session;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;

@Component
public class EmailMessageProduct {
    private Logger logger = LoggerFactory.getLogger(this.getClass());
    @Autowired
    EmailCache emailCache;

    public boolean sendEmail(EmailLogVo baseLog) {
/** 1、加载数据库配置信息
 *  2、验证是否是有效消息
 *  3、封装消息类EmailTask
 *  4、发送
 *
 */
        try {
            if (baseLog != null) {
                List<EmailReceiver> emailMessageRule = emailCache.getEmailMessageRule();
                EmailSender emailSender = emailCache.getEmailSender();
                Session emailSession = emailCache.getEmailSession();
                if (emailMessageRule != null && emailMessageRule.size() > 0) {
                    //   emailMessageRule.stream().forEach((emailReceiver)->{
                    for (EmailReceiver emailReceiver : emailMessageRule) {

                        if (emailReceiver != null && StringUtils.isNotBlank(emailReceiver.getCusNumber())
                                && StringUtils.isNotBlank(emailReceiver.getSystemName()) && StringUtils.isNotBlank(emailReceiver.getSystemType())) {
                            if (emailReceiver.getCusNumber().equals(baseLog.getCusNum())
                                    && emailReceiver.getSystemName().equals(baseLog.getSysName()) //系统名称
                                    && emailReceiver.getSystemType().equals(baseLog.getEnvDef())) {//套别

                                List<EmailMessageRule> list = emailReceiver.getList();
                                if (list != null && list.size() > 0) {
                                    // list.stream().forEach((temp)->{
                                    for (EmailMessageRule temp : list) {


                                        if (temp != null && StringUtils.isNotBlank(temp.getLogKey())) {

                                            if (temp.getLogKey().equals(baseLog.getMessagetype())) {
                                                if ("1".equals(temp.getIsHoliday()) && emailCache.getIsHoliday() == 1) {//节假日发送
                                                    Date aloudTime = getAloudTime(temp.getTimeSection());
                                                    if (aloudTime != null) {

                                                        EmailTask emailTask = crateEmailTask(
                                                                emailSession,
                                                                emailSender.getSenderAddress(),
                                                                emailReceiver.getReceiverTo(),
                                                                emailReceiver.getReceiverCc(),
                                                                baseLog.getMessage(),
                                                                "套别为：" + emailReceiver.getSystemType() + ",机构号为：" + emailReceiver.getCusNumber()
                                                                        + ",系统名称为：" + emailReceiver.getSystemName() +
                                                                        ",日志码为：" + temp.getLogKey() + ",日志信息为：" + temp.getLogValue(),
                                                                emailReceiver.getKey() + temp.getLogKey(),
                                                                emailSender.getSenderAccount(),
                                                                emailSender.getSenderPassword(),
                                                                aloudTime);
                                                        if (emailTask != null) {

                                                            return EmailManage.send(emailReceiver.getKey() + temp.getLogKey(), emailTask);

                                                        }


                                                    }

                                                } else if ("2".equals(temp.getIsHoliday()) && emailCache.getIsHoliday() == 0) {//工作发送
                                                    Date aloudTime = getAloudTime(temp.getTimeSection());
                                                    if (aloudTime != null) {

                                                        EmailTask emailTask = crateEmailTask(
                                                                emailSession,
                                                                emailSender.getSenderAddress(),
                                                                emailReceiver.getReceiverTo(),
                                                                emailReceiver.getReceiverCc(),
                                                                "<p>" + baseLog.getMessage() + "</p><p></p>",
                                                                "套别为：" + emailReceiver.getSystemType() + ",机构号为：" + emailReceiver.getCusNumber()
                                                                        + ",系统名称为：" + emailReceiver.getSystemName() +
                                                                        ",日志码为：" + temp.getLogKey() + ",日志信息为：" + temp.getLogValue(),
                                                                emailReceiver.getKey() + temp.getLogKey(),
                                                                emailSender.getSenderAccount(),
                                                                emailSender.getSenderPassword(),
                                                                aloudTime);
                                                        if (emailTask != null) {

                                                            return EmailManage.send(emailReceiver.getKey() + temp.getLogKey(), emailTask);

                                                        }


                                                    }
                                                } else if ("3".equals(temp.getIsHoliday())) {//all
                                                    Date aloudTime = getAloudTime(temp.getTimeSection());
                                                    if (aloudTime != null) {

                                                        EmailTask emailTask = crateEmailTask(
                                                                emailSession,
                                                                emailSender.getSenderAddress(),
                                                                emailReceiver.getReceiverTo(),
                                                                emailReceiver.getReceiverCc(),
                                                                baseLog.getMessage(),
                                                                "套别为：" + emailReceiver.getSystemType() + ",机构号为：" + emailReceiver.getCusNumber()
                                                                        + ",系统名称为：" + emailReceiver.getSystemName() +
                                                                        ",日志码为：" + temp.getLogKey() + ",日志信息为：" + temp.getLogValue(),
                                                                emailReceiver.getKey() + temp.getLogKey(),
                                                                emailSender.getSenderAccount(),
                                                                emailSender.getSenderPassword(),
                                                                aloudTime);
                                                        if (emailTask != null) {

                                                            return EmailManage.send(emailReceiver.getKey() + temp.getLogKey(), emailTask);

                                                        }


                                                    }
                                                }


                                            }

                                        }


                                    }


                                }


                            }


                        }


                    }

                }


            }

        } catch (Exception e) {
            e.printStackTrace();
        }

        return false;
    }

    public Date getAloudTime(String timeSection) {//eg:09:00:00-10:00:00;11:00:00-12:00:00
        try {
            if (StringUtils.isNotBlank(timeSection)) {
                if (timeSection.contains(";")) {
                    String[] split = timeSection.split(";");
                    if (split != null && split.length > 0) {
                        for (String split1 : split) {
                            if (split1 != null && split1.contains("-")) {
                                String[] splits = split1.split("-");
                                SimpleDateFormat sim1 = new SimpleDateFormat("yyyy-MM-dd");
                                SimpleDateFormat sim2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                                Date date = new Date();
                                String format1 = sim1.format(date);
                                if (splits != null && splits.length == 2) {
                                    String stardate = format1 + " " + splits[0];
                                    String enddate = format1 + " " + splits[1];

                                    Date date1 = sim2.parse(stardate);
                                    Date date2 = sim2.parse(enddate);

                                    if (date1.getTime() <= date.getTime() && date.getTime() <= date2.getTime()) {

                                        return date2;
                                    }


                                }

                            }

                        }


                    }
                } else {
                    if (timeSection != null && timeSection.contains("-")) {
                        String[] splits = timeSection.split("-");
                        SimpleDateFormat sim1 = new SimpleDateFormat("yyyy-MM-dd");
                        SimpleDateFormat sim2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                        Date date = new Date();
                        String format1 = sim1.format(date);
                        if (splits != null && splits.length == 2) {
                            String stardate = format1 + " " + splits[0];
                            String enddate = format1 + " " + splits[1];

                            Date date1 = sim2.parse(stardate);
                            Date date2 = sim2.parse(enddate);

                            if (date1.getTime() <= date.getTime() && date.getTime() <= date2.getTime()) {

                                System.out.println("通过" + stardate + "         " + enddate);
                                return date2;
                            }


                        }

                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    public EmailTask crateEmailTask(Session session,
                                    String senderAddress,
                                    String receiverTo,
                                    String receiverCc,
                                    String content, String title, String key, String senderAccount, String senderPassword, Date sendDate) {
        try {

            if (session != null && StringUtils.isNotBlank(senderAddress)
                    && StringUtils.isNotBlank(receiverTo) && StringUtils.isNotBlank(content) &&
                    StringUtils.isNotBlank(title) && StringUtils.isNotBlank(senderAccount) && StringUtils.isNotBlank(senderPassword) && sendDate != null) {
                return new EmailTask(session,
                        senderAddress,
                        receiverTo,
                        receiverCc,
                        content, title, key, senderAccount, senderPassword, sendDate);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;

    }

}

4、EmailCache （消息配置缓存）

package com.zcb.monitor.business.utils;

import com.zcb.monitor.data.entity.EmailMessageRule;
import com.zcb.monitor.data.entity.EmailReceiver;
import com.zcb.monitor.data.entity.EmailSender;
import com.zcb.monitor.data.mapper.EmailMessageRuleMapper;
import com.zcb.monitor.data.mapper.EmailReceiverMapper;
import com.zcb.monitor.data.mapper.EmailSenderMapper;
import com.sun.mail.util.MailSSLSocketFactory;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

import javax.mail.Session;
import java.util.Date;
import java.util.List;
import java.util.Properties;

@Service
public class EmailCache {
    private Logger logger = LoggerFactory.getLogger(this.getClass());
    @Autowired
    EmailMessageRuleMapper emailMessageRuleMapper;
    @Autowired
    EmailReceiverMapper emailReceiverMapper;
    @Autowired
    EmailSenderMapper emailSenderMapper;
    @Cacheable("isHoliday")
    public  int getIsHoliday(){
        return emailSenderMapper.getIsHoliday(new Date());
    }
    @Cacheable("emailSender")
    public EmailSender getEmailSender(){
        logger.info("-------------------------修改emailSender------------");
        return emailSenderMapper.getEmailConfig();
    }
    @Cacheable("emailMessageRule")
    public  List<EmailReceiver> getEmailMessageRule(){
        List<EmailReceiver> list = emailReceiverMapper.getList();
            if(list!=null&&list.size()>0){
                list.stream().forEach((emailReceiver) -> {
                    if(emailReceiver!=null&& StringUtils.isNotBlank(emailReceiver.getReceiverId())){
                        List<EmailMessageRule> list1 = emailMessageRuleMapper.getList(emailReceiver.getReceiverId());
                        if(list1!=null&&list1.size()>0){
                            emailReceiver.setList(list1);
                        }
                    }

                });


            }

        return list;
    }
    @Cacheable("emailSession")
    public Session getEmailSession(){
        Session session =null;
        EmailSender emailConfig = emailSenderMapper.getEmailConfig();
        if(emailConfig==null){
            logger.error("查询不到配置信息");
            return session;

        }
        if(StringUtils.isBlank(emailConfig.getSenderAccount())){
            logger.error("发送信息账户配置为空");
            return session;

        }
        if(StringUtils.isBlank(emailConfig.getSenderAddress())){
            logger.error("发送地址配置为空");
            return session;

        }
        if(StringUtils.isBlank(emailConfig.getSenderName())){
            logger.error("发送人名称配置为空");
            return session;

        }
        if(StringUtils.isBlank(emailConfig.getSenderPassword())){
            logger.error("邮箱密码配置为空");
            return session;
        }
        if(StringUtils.isBlank(emailConfig.getSmtpHost())){
            logger.error("SMTP服务器地址配置为空");
            return session;
        }
        if(StringUtils.isBlank(emailConfig.getSmtpPort())){
            logger.error("邮件服务器的端口号配置为空");
            return session;
        }
        MailSSLSocketFactory sf = null;// SSL加密
        try {
            //1、连接邮件服务器的参数配置
            Properties props = new Properties();

            sf = new MailSSLSocketFactory();

            sf.setTrustAllHosts(true); // 设置信任所有的主机

            props.put("mail.smtp.ssl.enable", "true");//设置开启ssl密

            props.put("mail.smtp.ssl.socketFactory", sf);//设置加密方式

            //设置用户的认证方式
            props.setProperty("mail.smtp.auth", "true");
            //设置传输协议
            props.setProperty("mail.transport.protocol", "smtp");
            //设置发件人的SMTP服务器地址
            props.setProperty("mail.smtp.host", emailConfig.getSmtpHost());
            //设置发送的端口号
            props.put("mail.smtp.port", emailConfig.getSmtpPort());
            //2、创建定义整个应用程序所需的环境信息的 Session 对象
             session = Session.getInstance(props);
            //设置调试信息在控制台打印出来
          //  session.setDebug(true);
        } catch (Exception e) {
            e.printStackTrace();

        }
        return  session;
    }
}

5、修改前端重新加载缓存

package com.zcb.monitor.service;



import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.cache.Cache;
import org.springframework.cache.CacheManager;

import java.util.Collection;

/**
 * @description:清除邮件信息缓存
 * @author: Administrator
 * @date: 2021/4/28
 */
@Slf4j
public class MonitorRefreshEmailCacheService extends EnvironmentalRequestResponseService implements IMonitorRefreshEmailCacheService {


    CacheManager cacheManager;

    @Override
    public boolean refreshAll() {
        if (cacheManager != null) {


            Collection<String> cacheNames = cacheManager.getCacheNames();
            if (cacheNames != null && cacheNames.size() > 0) {
                for (String key : cacheNames) {
                    if (StringUtils.isNotBlank(key)) {
                        Cache cache = cacheManager.getCache(key);
                        if (cache != null) {
                            cache.clear();

                        }
                    }

                }
                return true;
            }

        }

        return false;
    }

    @Override
    public boolean refreshByCacheKey(String key) {

        if (cacheManager != null) {
            if (StringUtils.isNotBlank(key)) {
                Cache cache = cacheManager.getCache(key);
                if (cache != null) {
                    cache.clear();
                    return true;
                }
            }


        }

        return false;
    }

    public CacheManager getCacheManager() {
        return cacheManager;
    }

    public void setCacheManager(CacheManager cacheManager) {
        this.cacheManager = cacheManager;
    }
}

6、邮件发送入口

	@Autowired
    protected EmailMessageProduct emailMessageProduct;
    
 			 boolean b = emailMessageProduct.sendEmail(emailLogVo);
            if (b) {
                log.info("邮件发送数据[{}]", JSON.toJSONString(emailLogVo));
            }
testZCB
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
js代码-利用promise 手写一个限制最大并发的类
07-14
js代码-利用promise 手写一个限制最大并发的类
php高并发推送系统设计,开放式高并发邮件推送系统的设计与实现
weixin_39860349的博客
03-19 131
摘要：随着互联网应用的高速发展,用户网上互动的需求越来越大,互动方式也越来越多.在众多网上互动方式中,电子邮件推送是到达率极高的用户互动手段,目前已成为各互联网应用必备的功能之一.对于应用提供商来说,自行搭建邮件系统,需要有熟悉邮件协议的开发人员,成本较高,应用效果也难以保证;使用传统电子邮件服务提供商提供的电子邮箱服务,虽然可以解决基本的邮件发送接收问题,但在推送邮件并发能力及推送管理等方面存在...
模拟多线程高并发邮件发送系统
qq_41030039的博客
08-30 1145
简单邮件发送流程： 服务器监听在8000端口，等待客户端连接。 接收到客户端的连接，得到目标邮件，用户名等邮件发送信息。 服务端连接邮件服务器，进行发送邮件。 返回发送结果给客户端。 继续监听端口，等待连接。 优化一：对每个请求开一个单独的线程来处理，这样服务端只需要监听端口，接受请求，开线程，由线程去处理业务操作（发送邮件），提高服务端的性能。可以同时接受多个请求，实现并发。 优化二：创建一...
java 多线程 发邮件_Java 多线程 BlockingQueue 实现 高并发邮件 代码 SystemEmailBlockingQueue...
weixin_42307478的博客
02-24 253
package com.pingan.emall.biz.util;import java.util.Map;import java.util.concurrent.ArrayBlockingQueue;import java.util.concurrent.BlockingQueue;import java.util.concurrent.ConcurrentHashMap;import jav...
手写一个高并发批量定时邮件发送服务器《一》
m0_37045848的博客
05-19 513
一、需求 为了方便场务和相关系统监控人员，在节假日获取ELK日志系统和一些关键系统定时操作信息，增加邮件发送功能。主要包含在日志配置和高并发邮件两部分。 二、设计流程图 三、邮件发送代码示例 1、在pom.xml添加javax.mail 依赖 <dependency> <groupId>javax.mail</groupId> <artifactId>mail</artifactId>
【javaMail】【3.多线程发邮件】java mail 多线程发送邮件
热门推荐
01-12 1万+
背景 多线程发送邮件 最近在做一个功能，需要批量或不定时散量发送邮件给不同的人。比方说注册功能，需要给注册人发送邮件，如果遇上系统新开放注册，有一定量的并发，如果一窝蜂地发，有可能造成smtp服务器拒绝421等状态
5分钟教你用nodeJS手写一个mock数据服务器的方法
10-16
主要介绍了5分钟教你用nodeJS手写一个mock数据服务器的方法，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
基于Java的MiniCat手写Http服务器设计源码
最新发布
04-15
基于Java的MiniCat手写Http服务器设计源码，该项目包含52个文件，主要文件类型有48个java源文件。...该项目是一个基于Java的MiniCat手写Http服务器设计源码，可能涉及用户界面设计、应用逻辑实现、数据存储等多个方面。
Java实战教程(多线程高并发邮件发送)
weixin_30267697的博客
10-22 1423
多线程高并发邮件发送 本章将带大家从零开始搭建一个多线程高并发邮件发送系统， 阅读本章的前提： 1.J2SE基本学完 2.JMeter学会基本使用 3.下载本章全部代码 下载地址：https://www.java123.vip/javaproc.php 代码下载完毕后，在vip.java123.mail包中将会有如下结构 接下来将对这7种程序逐一说明： 代码说明（sample...
详解阿里云CentOS Linux服务器上用postfix搭建邮件服务器
01-11
注：本文的邮件服务器只用于发送邮件，也就是STMP服务器。 一、准备工作 1. 为邮件服务器添加DNS解析 虽然不加DNS解析也能把邮件发出去，但会被大多数邮件服务器当作垃圾邮件。根据我们的实际经验，需要添加三条DNS解析记录：A记录、MX记录、TXT记录。比如域名cnblogs.info，对应的DNS记录如下： 2. 准备存放邮件的硬盘空间 如果用的是阿里云入门级Linux服务器，有一块20G的数据盘未挂载，需要格式化并挂载（假设这里挂载的目录是/data）。 二、配置postfix postfix是CentOS默认安装的邮件服务器软件。以下配置示例假设要配置的域名是cnblogs.inf
Java 多线程 BlockingQueue 实现 高并发邮件 代码 SystemEmailServiceImpl
lisu_suby的专栏
10-27 1802
package com.pingan.emall.biz.business.impl; import com.paic.pafa.app.biz.service.BaseService; import com.paic.pafa.app.lwc.core.util.DevLog; import com.pingan.emall.biz.business.SystemEmailServ
Django中使用多线程发送邮件
weixin_34418883的博客
05-15 137
1、settings.py 增加Email设置   #mail EMAIL_HOST = ‘smtp.gmail.com’                   #邮件smtp服务器 EMAIL_PORT = ’25′                                        #端口 EMAIL_HOST_USER = ‘code***@gmail.com’  #邮件账...
springboot利用线程池实现邮件发送
an-ping的博客
04-09 2706
最近实现一个邮件推送功能，整理如下: 1 编写线程类实现runnable接口:（其中JavaMailUtil为封装的发送邮件工具类） import lombok.Data; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Componen...
Java 多线程 BlockingQueue 实现 高并发邮件 概论
lisu_suby的专栏
10-27 2210
1、服务启动 初始化  1>/SystemEmailBlockingQueue
使用定时器完成每日发送多个邮件（发邮件，支持多人发送，可以直接粘贴使用）-----二
qq_43502688的博客
12-15 697
前几天利用HuTool写了一个发邮件的demo，我自己直接封装了一个发邮件的工具类，方便以后找不到直接粘贴使用，话不多说，直接上代码 package com.unicom.resinteractive.util; import cn.hutool.core.collection.CollUtil; import cn.hutool.core.io.FileUtil; import cn.hutool.extra.mail.MailUtil; import com.unicom.resinterac.
1.2. 并发控制
无心云
04-14 920
1.2. 并发控制任何时候只要有多个查询语句想要改变同一条数据时并发控制的问题就出现了。根据这一章的描述，MySQL在需要在两个层面来解决这个问题：服务器层面和存储引擎层面。并发控制是一个很大的课题，同时也有一大批关于并发控制的专著，但是本书的着眼点并不在于并发控制的理论或者MySQL的内部实现。因此我们只打算给读者一个关于如何处理并发读操作和并发写操作的概述，因此读者可以在本章的其余部分看到
Spring Boot 异步任务与定时任务，邮件发送
那就这样吧~
03-29 378
Spring Boot 异步任务 在项目开发中，绝大多数情况下都是通过同步方式处理业务逻辑的，但是比如批量处理数据，批量发送邮件，批量发送短信等操作容易造成阻塞的情况，之前大部分都是使用多线程来完成此类任务。 而在Spring 3+之后，就已经内置了@Async注解来完美解决这个问题，从而提高效率 使用的注解： @EnableAysnc 启动类上开启基于注解的异步任务 @Aysnc 标识的方法会...
springboot+多线程实现邮件发送（定时任务）
qq_51269815的博客
04-02 1316
一：实现一个简单的异步任务 1.不适用spring自带的异步注解 service层的AsyncService 类 package com.example.demo.service; import org.springframework.scheduling.annotation.Async; import org.springframework.stereotype.Service; @Service public class AsyncService { //多线程的简单列子
手写一个计算器
05-24
好的，我可以帮你手写一个简单的计算器。这个计算器可以进行加、减、乘、除的基本运算。 ``` #include <iostream> using namespace std; int main() { char op; // 运算符 double num1, num2; // 两个运算数 cout << "请输入一个算式，例如 1 + 2：" << endl; cin >> num1 >> op >> num2; // 输入算式 switch(op) { case '+': // 加法 cout << "结果为：" << num1 + num2 << endl; break; case '-': // 减法 cout << "结果为：" << num1 - num2 << endl; break; case '*': // 乘法 cout << "结果为：" << num1 * num2 << endl; break; case '/': // 除法 if(num2 != 0) { cout << "结果为：" << num1 / num2 << endl; } else { cout << "除数不能为0！" << endl; } break; default: // 非法运算符 cout << "输入的算式有误！" << endl; break; } return 0; } ``` 这个计算器只能进行一次运算，如果想要进行多次运算，可以将代码放在一个循环体中，每次循环结束后询问用户是否继续计算。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值