Spring整合邮件模板定时发送

最新推荐文章于 2024-07-07 17:00:00 发布

西门吹雪吹吹风

最新推荐文章于 2024-07-07 17:00:00 发布

阅读量6.9k

点赞数

分类专栏：项目整合文章标签：邮件发送 quartz spring整合邮件定时发送 mail 数据源

本文链接：https://blog.csdn.net/BobZhangfighting/article/details/81161757

版权

项目整合专栏收录该内容

2 篇文章 0 订阅

订阅专栏

前言

在企业级开发中，我们不可避免的使用到邮件发送，可能由于项目的需要，我们要定时定频率的给用户或者业务方发送邮件。那么我编写这个demo的由来呢，一个是整合一些常用的技术栈，此demo的业务流程：设置好相应时间定时发送邮件给业务方或者需求方，用到的技术：springMVC+mybatis+druid+mail+quartz+velocity等。总体来说配置简单，稍作更改即可部署成分布式结构工程。
概念介绍

发送邮件原理简介

电子邮件的发送与接收过程
过程解释说明

1、用户A的电子邮箱为：xx@qq.com，通过邮件客户端软件写好一封邮件，交到QQ的邮件服务器，这一步使用的协议是SMTP,对应图示的①；

2、QQ邮箱会根据用户A发送的邮件进行解析，也就是根据收件地址判断是否是自己管辖的账户，如果收件地址也是QQ邮箱，那么会直接存放到自己的存储空间。这里我们假设收件地址不是QQ邮箱，而是163邮箱，那么QQ邮箱就会将邮件转发到163邮箱服务器，转发使用的协议也是SMTP，对应图示的②；

3、163邮箱服务器接收到QQ邮箱转发过来的邮件，也会判断收件地址是否是自己，发现是自己的账户，那么就会将QQ邮箱转发过来的邮件存放到自己的内部存储空间，对应图示的③；

4、用户A将邮件发送了之后，就会通知用户B去指定的邮箱收取邮件。用户B会通过邮件客户端软件先向163邮箱服务器请求，要求收取自己的邮件，对应图示的④；

5、163邮箱服务器收到用户B的请求后，会从自己的存储空间中取出B未收取的邮件，对应图示⑤；

6、163邮箱服务器取出用户B未收取的邮件后，将邮件发给用户B，对应图示的⑥；最后三步用户B收取邮件的过程，使用的协议是POP3;

名词解释说明
邮件服务器：图示出现了两个邮件服务器，QQ和163邮件服务器。用户想要在网上收发邮件，必须要有专门的邮件服务器。邮件服务器我们可以假想为现实生活中的邮局。
如果按功能划分，邮件服务器可以划分为两种类型：
①、SMTP邮件服务器：用户替用户发送邮件和接收外面发送给本地用户的邮件，对应上图的第一、二步。它相当于现实生活中邮局的邮件接收部门（可接收普通用户要投出的邮件和其他邮局投递进来的邮件）。
　　②、POP3/IMAP邮件服务器：用户帮助用户读取SMTP邮件服务器接收进来的邮件，对应上图的第六步。它相当于专门为前来取包裹的用户提供服务的部门。
　　
电子邮箱：电子邮箱也称为E-mail地址，比如用户A的xx@qq.com，和用户B的xx@163.com用户能通过E-mail地址标识自己发送的电子邮件，同时也可以通过这个地址接收别人发来的电子邮件。电子邮箱需要到邮件服务器进行申请，也就是说，电子邮箱其实就是用户在邮件服务器上申请的账户。邮件服务器会把接收到的邮件保存到为该账户所分配的邮箱空间中，用户通过用户名密码登录到邮件服务器查收该地址已经收到的邮件。一般来讲，邮件服务器为用户分配的邮箱空间是有限的。
邮件客户端软件：我们可以直接在网站上进行邮件收发，也可以用邮件客户端软件。比如常见的FoxMail，Outlook Express。邮件客户端软件通常集邮件撰写，发送和收发功能于一体，主要用于帮助用户将邮件发送给SMTP邮件服务器和从POP3/IMAP邮件服务器读取用户的电子邮件我们可以直接在网站上进行邮件收发，也可以用邮件客户端软件。比如常见的FoxMail，Outlook Express。邮件客户端软件通常集邮件撰写，发送和收发功能于一体，主要用于帮助用户将邮件发送给SMTP邮件服务器和从POP3/IMAP邮件服务器读取用户的电子邮件。
邮件传输协议：电子邮件需要在邮件客户端和邮件服务器之间，以及两个邮件服务器之间进行邮件传递，那就必须要遵守一定的规则，这个规则就是邮件传输协议。下面我们分别简单介绍几种协议（后面会详细讲解）：
　　①、SMTP协议：全称为 Simple Mail Transfer Protocol，简单邮件传输协议。它定义了邮件客户端软件和SMTP邮件服务器之间，以及两台SMTP邮件服务器之间的通信规则。
　　②、POP3协议：全称为 Post Office Protocol，邮局协议。它定义了邮件客户端软件和POP3邮件服务器的通信规则。
　　③、IMAP协议：全称为 Internet Message Access Protocol,Internet消息访问协议，它是对POP3协议的一种扩展，也是定义了邮件客户端软件和IMAP邮件服务器的通信规则。

　　我们说所有的邮件服务器和邮件客户端软件程序都是基于上面的协议编写的
　　
定时任务
一般我们说到定时任务或者作业，可能第一感觉想到的就是Timer或者Quartz这种，但是这里来说一下Quartz的定时任务。
Quartz概述：Quartz是一个完全由Java编写的开源任务调度的框架，通过触发器设置作业定时运行规则，控制作业的运行时间。其中quartz集群通过故障切换和负载平衡的功能，能给调度器带来高可用性和伸缩性。主要用来执行定时任务，如：定时发送信息、定时生成报表等等。
核心概念：scheduler任务调度、Job任务、Trigger触发器、JobDetail任务细节等。
scheduler：需要把JobDetail和Trigger注册到scheduler中，才可以执行。
Job任务：其实Job是接口，其中只有一个execute方法，我们只需要implements此接口，重写execute(*)方法。
Trigger触发器：执行任务的规则；比如每天，每小时等。
一般情况使用SimpleTrigger，和CronTrigger，这些触发器实现了Trigger接口。或者 ScheduleBuilder 子类 SimpleScheduleBuilder和CronScheduleBuilder。
　　对于简单的时间来说，比如每天执行几次，使用SimpleTrigger。
　　对于复杂的时间表达式来说，比如每个月15日上午几点几分，使用CronTrigger以及CromExpression 类。
JobDetail：任务细节，Quartz执行Job时，需要新建个Job实例，但是不能直接操作Job类，所以通过JobDetail来获取Job的名称，描述信息。

Quartz的调用方式

 1. 创建调度工厂
 2. 根据工厂取得调度器实例
 3. Builder模式构建子组件<Job,Trigger>//builder模式、如JobBuilder
    TriggerBuilder、DateBuilder
 4. 通过调度器组装子组件，调度器，组装<子组件1，子组件2....>//工厂模式
 5. 调度器.start()//工厂模式

这里写图片描述
浅谈JobExecutionContext：当Scheduler调用一个Job，就会将JobExecutionContext传递给Job的execute()方法；Job能通过JobExecutionContext对象访问到Quartz运行时候的环境以及Job本身的明细数据。
JobDataMap是什么：在进行任务调度时JobDataMap存储在JobExecutionContext中，非常方便获取。
JobDataMap可以用来装载任何可序列化的数据对象，当Job实例对象被执行时这些参数对象会传递给它。
JobDataMap实现了JDK的Map接口，并且添加了一些非常方便的方法用来存取基本数据类型。
获取JobDataMap的两种方式：

从Map中直接获取
Job实现类中添加setter方法对应JobDataMap的键值(Quartz框架默认的JobFactory实现类在初始化job实例对象时会自动地调用这些setter方法)

Trigger是什么：Quartz中的触发器用来告诉调度程序作业什么时候触发，即Trigger对象是用来触发执行Job的。
这里写图片描述
触发器通用属性：

JobKey：表示job实例的标识，触发器被触发时，该指定的job实例会被执行。
StartTime：表示触发器的时间表首次被触发的时间。它的值的类型是java.util.Date.
EndTime：指定触发器的不再被触发的时间，它的值的类型是java.util.Date.

SimpleTrigger：在一个指定时间段内执行一次作业任务或是在指定的时间间隔内多次执行作业任务
需要注意的点：

重复次数可以为0，正整数或是SimpleTrigger.REPEAT_INDEFINITELY常量值。
重复执行间隔必须为0或长整数。
一旦被指定了endTime参数，那么它会覆盖重复次数参数的效果。

CronTrigger的作用：基于日历的作业调度器，而不是像SimpleTrigger那样精确指定间隔时间，比SimpleTrigger更常用。
Cron表达式：用于配置CronTrigger实例是由7个子表达式组成的字符串，描述了时间表的详细信息。
格式：[秒][分][小时][日][月][周][年]

Cron表达式特殊字符意义对应表
这里写图片描述
Cron表达式举例

通配符说明

Cron表达式小提示

‘L’和’W’可以组合使用
周字段英文字母不区分大小写即MON与mon相同
利用工具，在线生成

Scheduler-工厂模式：所有的Scheduler实例应该由SchedulerFactory来创建。
这里写图片描述

Velocity模板介绍

Velocity:是一个基于Java的模板引擎，可以让视图的设计者在web页面中引用java代码中定义的数据对象和命令。web designers只需要将精力用于视图外观设计上，而java程序员只需要关心如何写出高效简洁的java对象以实现业务逻辑。Velocity会将它们组装到一起，相比传统的jsp，velocity彻底的将避免在视图设计中出现java代码。

VTL(Velocity Template Language):使用引用（references）这种方式将动态内容（一般指java代码生成的数据对象）加入到你的web site中。VTL声明所有的语句都是以#开头，且包含一个指示符，Velocity将所有的变量以符号$开头，所附的值要用双引号括起来。

Velocity基本语法:
“#”：用来标识Velocity的关键字，包括#set，#if，#else，#foreach，#end，#include，#parse，#marco等；
“ $”：用于标识Velocity中的变量，如：$ i, $msg,$ TagUtil.options()等；
“{}”：用于明确标识Velocity的变量；
“！”：用于强制把不存在的变量显示为空白，例如：当找不到username时， $username返回的字符串为“$ username”，而$!username返回的是空字符串。

Velocity的总结：
模板引擎是为了使用户界面与业务数据内容分离而产生的的，它可以生成特定格式的文档。MVC中，M（model）包括后台的事务逻辑，真正处理事务的代码和商业逻辑等，它们是整个网站中最重要的工作部分；V（view）是网页的显示部分，这部分主要接受来自后台程序结果或数据，进行显示；C（controller）在视图和模型之间传递控制，并根据要求调用相应的视图显示模型返回的数据，主要负责调度工作。这样指责划分明确，简化了开发过程中相关人员工作，而平时的jsp页面，可以在jsp页面中写java相关逻辑，这样在V中混淆了逻辑代码，所以java模板引擎出现，模板引擎的出现，它严格的区分程序开发功能能和指责的划分。

Velocity与JSP的区别 ：
优点有：JSP：（1）功能强大，可以写java代码；
（2）支持JSP标签（Jsp tag）
（3）支持表达式语言（EL）
（4）官方标准，第三方jsp标签库，j2ee规范
而Velocity不能编写java代码，可以实现严格的MVC分离，比JSP性能好些。
缺点有：JSP中可以写java代码，当jsp中写过多的java业务逻辑，容易破坏mvc的结构；
Velocity中，不能编写java代码，用户群体和第三方标准库没有jsp多，对jsp标签支持的不够好。

重点来了

上面我们对概念熟悉一下、下面讲解一下Spring整合邮件模板定时发送项目：

配置文件：
pom.xml

<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/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.zt</groupId>
  <artifactId>mail</artifactId>
  <packaging>war</packaging>
  <version>0.0.1-SNAPSHOT</version>
  <name>mail Maven Webapp</name>
  <url>http://maven.apache.org</url>
  <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <springversion>4.3.6.RELEASE</springversion>
    </properties>

  <dependencies>
       <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>
        <!-- spring配置开始 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${springversion}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${springversion}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${springversion}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>4.3.6.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${springversion}</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.2</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.2</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.1</version>
        </dependency>
        <dependency>
            <groupId>org.glassfish.web</groupId>
            <artifactId>javax.servlet.jsp.jstl</artifactId>
            <version>1.2.1</version>
            <exclusions>
                <exclusion>
                    <artifactId>jstl-api</artifactId>
                    <groupId>javax.servlet.jsp.jstl</groupId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.apache.bval</groupId>
            <artifactId>bval-jsr303</artifactId>
            <version>0.5</version>
        </dependency>
    <dependency>  
        <groupId>taglibs</groupId>  
        <artifactId>standard</artifactId>  
        <version>1.1.2</version>  
    </dependency>  

    <!-- JSTL -->   
    <dependency>  
        <groupId>javax.servlet</groupId>  
        <artifactId>jstl</artifactId>  
        <version>1.1.2</version>  
    </dependency> 
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.11</version>
    </dependency>
    <dependency>
        <groupId>org.apache.httpcomponents</groupId>
        <artifactId>httpclient</artifactId>
        <version>4.3.6</version>
    </dependency>
    <dependency>
        <groupId>net.sf.json-lib</groupId>
        <artifactId>json-lib</artifactId>
        <version>2.2.3</version>
    </dependency>
    <dependency>
        <groupId>org.apache.velocity</groupId>
        <artifactId>velocity</artifactId>
        <version>1.7</version>
    </dependency>
    <dependency>
        <groupId>org.apache.velocity</groupId>
        <artifactId>velocity-tools</artifactId>
        <version>2.0</version>
    </dependency>
    <dependency>
        <groupId>com.sun.mail</groupId>
        <artifactId>javax.mail</artifactId>
        <version>1.5.5</version>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.0.19</version>
    </dependency>
       <!-- mybatis -->  
   <dependency>  
       <groupId>org.mybatis</groupId>  
       <artifactId>mybatis</artifactId>  
       <version>3.2.1</version>  
   </dependency>  
   <dependency>  
       <groupId>org.mybatis</groupId>  
       <artifactId>mybatis-spring</artifactId>  
       <version>1.2.0</version>  
   </dependency>  

   <!-- mysql -->
   <dependency>  
       <groupId>mysql</groupId>  
       <artifactId>mysql-connector-java</artifactId>  
       <version>5.1.26</version>  
   </dependency> 
    <dependency>
        <groupId>org.jodd</groupId>
        <artifactId>jodd-mail</artifactId>
        <version>3.6.5</version>
    </dependency>
        <!-- 新增jodd lib -->
    <dependency>
        <groupId>org.jodd</groupId>
        <artifactId>jodd-core</artifactId>
        <version>3.7</version>
    </dependency>

    <dependency>
        <groupId>org.jodd</groupId>
        <artifactId>jodd-bean</artifactId>
        <version>3.7</version>
    </dependency>

    <dependency>
        <groupId>org.jodd</groupId>
        <artifactId>jodd-props</artifactId>
        <version>3.7</version>
    </dependency>

    <dependency>
        <groupId>org.jodd</groupId>
        <artifactId>jodd-upload</artifactId>
        <version>3.7</version>
    </dependency>

    <dependency>
        <groupId>org.jodd</groupId>
        <artifactId>jodd-http</artifactId>
        <version>3.7</version>
    </dependency>
    <!-- quartz -->
    <dependency>
        <groupId>org.quartz-scheduler</groupId>
        <artifactId>quartz</artifactId>
        <version>2.2.3</version>
    </dependency>
  </dependencies>
  <build>
    <finalName>mail</finalName>
  </build>
</project>

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns="http://java.sun.com/xml/ns/javaee" 
xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" 
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" 
id="pay-service-merchant" version="3.0">
  <display-name>mail</display-name>
  <context-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:spring-context.xml</param-value>
    </context-param>
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>

  <!-- 字符处理开始 -->
  <filter>
        <filter-name>Encoding</filter-name>
        <filter-class>
            org.springframework.web.filter.CharacterEncodingFilter
        </filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>utf8</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>Encoding</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
   <!-- 字符处理结束 -->
  <!-- Spring MVC 配置开始 -->
  <servlet>
        <servlet-name>mails</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:spring-servlet.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>mails</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
   <!-- Spring MVC 配置结束 -->

</web-app>

spring-context.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans 
    xmlns="http://www.springframework.org/schema/beans"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xmlns:security="http://www.springframework.org/schema/security"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.1.xsd
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd
        http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security-3.1.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.1.xsd
        http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
   <mvc:annotation-driven />   
    <!-- 编码 -->
    <import resource="classpath:spring-encoding.xml"/>  

    <!-- mybatis -->  
    <import resource="classpath:spring-mybatis.xml"/> 

    <!-- velocity模板-->
    <import resource="classpath:spring-velocity.xml"/>

     <!-- 数据源 -->
    <import resource="classpath:spring-druid-mysql.xml"/>

    <!-- 定时器 -->
    <import resource="classpath:spring-quartz.xml"/>
        <!-- 加载properties-->
    <bean id="placeholder" 
        class="com.zt.common.MutilPropertyPlaceholderConfigurer">
        <property name="locations">
            <list>
                <value>classpath:env.porperties</value>
                <value>classpath:jdbc.properties</value>
                <value>classpath:log4j.properties</value>   
                <value>classpath:mail.properties</value>
                <value>classpath:common.porperties</value>      

            </list>
        </property>
    </bean>
    <!-- 配置要扫描的包 -->    
    <context:component-scan base-package="com.zt"/>
</beans>

spring-druid-mysql.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans 
    xmlns="http://www.springframework.org/schema/beans"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xmlns:security="http://www.springframework.org/schema/security"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.1.xsd
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd
        http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security-3.1.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.1.xsd
        http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">

    <!--配置数据源 使用的是Druid数据源 -->
    <bean name="mysqlDataSource" class="com.alibaba.druid.pool.DruidDataSource"
        init-method="init" destroy-method="close">
        <!-- 基本属性 url、user、password -->
        <!--  --><property name="url" value="${mysql_jdbc_url}" />
        <property name="username" value="${mysql_jdbc_username}" />
        <property name="password" value="${mysql_jdbc_password}" />
        <!-- <property name="defaultAutoCommit" value="false" /> -->
        <!-- 初始化连接大小 -->
        <property name="initialSize" value="5" />
        <!-- 连接池最大使用连接数量 -->
        <property name="maxActive" value="100" />
        <!-- 连接池最小空闲 -->
        <property name="minIdle" value="20" />

        <!-- 获取连接最大等待时间 -->
        <property name="maxWait" value="60000" />
        <!-- statement缓存大小
        <property name="poolPreparedStatements" value="true" />
        <property name="maxPoolPreparedStatementPerConnectionSize"
            value="33" />
             -->
        <!-- 用来检测有效sql -->
        <property name="validationQuery" value="SELECT 'x' x" />
        <property name="testOnBorrow" value="false" />
        <property name="testOnReturn" value="false" />
        <property name="testWhileIdle" value="true" />
        <!-- 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 -->
        <property name="timeBetweenEvictionRunsMillis" value="60000" />
        <!-- 配置一个连接在池中最小生存的时间，单位是毫秒 -->
        <property name="minEvictableIdleTimeMillis" value="300000" />
        <!-- 打开removeAbandoned功能 -->
        <property name="removeAbandoned" value="true" />
        <!-- 1800秒，也就是30分钟 -->
        <property name="removeAbandonedTimeout" value="1800" />
        <!-- 关闭abanded连接时输出错误日志 -->
        <property name="logAbandoned" value="true" />
        <!-- 监控数据库 -->
        <property name="filters" value="stat" />
    </bean>
</beans>

spring-encoding.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans 
    xmlns="http://www.springframework.org/schema/beans"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xmlns:security="http://www.springframework.org/schema/security"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.1.xsd
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd
        http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security-3.1.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.1.xsd
        http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">

    <!-- 设置spring编码 -->  
    <mvc:annotation-driven>
     <mvc:message-converters register-defaults="true">
        <bean class="org.springframework.http.converter.StringHttpMessageConverter">
          <property name="supportedMediaTypes" value = "text/plain;charset=UTF-8" />
        </bean>
       </mvc:message-converters>
     </mvc:annotation-driven>

</beans>

spring-mybatis.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans 
    xmlns="http://www.springframework.org/schema/beans"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xmlns:security="http://www.springframework.org/schema/security"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.1.xsd
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd建行卡转建行卡最快多久到账
        http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security-3.1.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.1.xsd
        http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">

    <!-- 多数据源配置 -->
    <bean id="multipleDataSource" class="com.zt.common.MultipleDataSource">
        <property name="defaultTargetDataSource" ref="mysqlDataSource"/>
        <property name="targetDataSources">
            <map>
                <entry key="mysql" value-ref="mysqlDataSource"/>
            </map>
        </property>
    </bean>

    <!-- myBatis文件 -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="multipleDataSource" />
        <property name="mapperLocations">
                  <list>
                   <value>classpath:mapper/*.xml</value>
                   </list>
         </property>
         <!-- 配置别名 -->
         <property name="typeAliasesPackage" value="com.zt.domain"></property>
    </bean>

    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
            <property name="basePackage" value="com.zt.dao" />
            <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" /> 
    </bean>
</beans>

spring-quartz.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-3.1.xsd">

    <!-- 执行类-->
    <bean id="pushEmailDataSchedule" class="com.zt.job.PushEmail" />
    <!-- ======================== 任务 ======================== -->
    <bean id="pushEmailDataJob"
        class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
        <property name="targetObject" ref="pushEmailDataSchedule"></property>
        <property name="targetMethod" value="pushEmail"></property>
    </bean>

    <!-- ======================== 触发器 ======================== -->
    <bean id="pushEmailTrigger"
        class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
        <property name="jobDetail" ref="pushEmailDataJob"></property>
        <property name="cronExpression" value="${quartz.pushemail.time}"></property>
    </bean>

    <!-- ======================== 调度器 ======================== -->
    <bean name="startSchedule"
        class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
        <property name="triggers">
            <list>
                <ref bean="pushEmailTrigger"/>
            </list>
        </property>
    </bean>

</beans>

spring-servlet.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans 
    xmlns="http://www.springframework.org/schema/beans"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xmlns:security="http://www.springframework.org/schema/security"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.1.xsd
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd
        http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security-3.1.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.1.xsd
        http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">


    <mvc:default-servlet-handler />

    <!-- ViewResolver -->       
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/" />
        <property name="suffix" value=".jsp" />
    </bean>      
</beans>

spring-velocity.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans 
    xmlns="http://www.springframework.org/schema/beans"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xmlns:security="http://www.springframework.org/schema/security"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.1.xsd
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd
        http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security-3.1.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.1.xsd
        http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">

    <bean id="velocityEngine" class="org.springframework.ui.velocity.VelocityEngineFactoryBean">
        <property name="velocityProperties">
            <props>
                <prop key="resource.loader">file</prop>
                <prop key="file.resource.loader.class">
                    org.apache.velocity.runtime.resource.loader.ClasspathResourceLoader
                </prop>
                <prop key="input.encoding">UTF-8</prop>
                <prop key="output.encoding">UTF-8</prop>
            </props>
        </property>
    </bean>

</beans>

common.porperties

#邮件定时推送配置每半分钟触发一次
quartz.pushemail.time<DEV>=30 * * * * ? 
quartz.pushemail.time<TEST>=30 * * * * ?
quartz.pushemail.time<PROD>=30 * * * * ?

env.porperties

#DEV TEST PROD
env=DEV

jdbc.porperties

#mysql\u9A71\u52A8
mysql_jdbc_dirver<DEV>=com.mysql.jdbc.Driver 
mysql_jdbc_dirver<TEST>=com.mysql.jdbc.Driver 
mysql_jdbc_dirver<PROD>=com.mysql.jdbc.Driver 
#\u6570\u636E\u5E93\u5730\u5740
mysql_jdbc_url<DEV>=jdbc:mysql://localhost:3306/test
mysql_jdbc_url<TEST>=
mysql_jdbc_url<PROD>=
#\u6570\u636E\u5E93\u7528\u6237\u540D
mysql_jdbc_username<DEV>=root
mysql_jdbc_username<TEST>=root
mysql_jdbc_username<PROD>=root
#\u6570\u636E\u5E93\u5BC6\u7801
mysql_jdbc_password<DEV>=root
mysql_jdbc_password<TEST>=root
mysql_jdbc_password<PROD>=root

log4j.properties

### è®¾ç½®###  
log4j.rootLogger = info,error,info,warn,stdout  

### è¾“å‡ºä¿¡æ¯åˆ°æŽ§åˆ¶æŠ¬ ###  
log4j.appender.stdout = org.apache.log4j.ConsoleAppender  
log4j.appender.stdout.Target = System.out  
log4j.appender.stdout.layout = org.apache.log4j.PatternLayout  
log4j.appender.stdout.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss}-[%p]-(%C:%L) %m%n 

### è¾“å‡ºDEBUG çº§åˆ«ä»¥ä¸Šçš„æ—¥å¿—###  
log4j.appender.warn = org.apache.log4j.DailyRollingFileAppender  
log4j.appender.warn.File = /data/syslogs/springmvc/warn.log  
log4j.appender.warn.Append = true  
log4j.appender.warn.Threshold = DEBUG  
log4j.appender.warn.layout = org.apache.log4j.PatternLayout  
log4j.appender.warn.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss}-[%p]-(%C:%L) %m%n  

### è¾“å‡ºERROR çº§åˆ«ä»¥ä¸Šçš„æ—¥å¿— ###  
log4j.appender.error = org.apache.log4j.DailyRollingFileAppender  
log4j.appender.error.File =/data/syslogs/springmvc/error.log  
log4j.appender.error.Append = true  
log4j.appender.error.Threshold = ERROR  
log4j.appender.error.layout = org.apache.log4j.PatternLayout  
log4j.appender.error.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss}-[%p]-(%C:%L) %m%n

### è¾“å‡ºINFO çº§åˆ«ä»¥ä¸Šçš„æ—¥å¿—###  
log4j.appender.info = org.apache.log4j.DailyRollingFileAppender  
log4j.appender.info.File =/data/syslogs/springmvc/info.log  
log4j.appender.info.Append = true  
log4j.appender.info.Threshold = INFO  
log4j.appender.info.layout = org.apache.log4j.PatternLayout  
log4j.appender.info.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss}-[%p]-(%C:%L) %m%n

mail.properties

####mail#####
#smtpserver
mail_smtpserver<DEV>=配你自己的开发邮件服务器地址
mail_smtpserver<TEST>=配你自己的测试邮件服务器地址
mail_smtpserver<PROD>=配你自己的生产邮件服务器地址
#port
mail_smtpport<DEV>=端口
mail_smtpport<TEST>=端口
mail_smtpport<PROD>=端口
mail_authuser<DEV>=发送者邮箱
mail_authuser<TEST>=发送者邮箱
mail_authuser<PROD>=发送者邮箱
mail_authpassword<DEV>=发送者邮箱密码
mail_authpassword<TEST>=发送者邮箱密码
mail_authpassword<PROD>=发送者邮箱密码

以上便是配置文件，上述配置文件是企业级开发框架整合，可配置切换多数据源，具体看你项目需要，也可以整合dubbo、zookeeper等配置文件。

接着来看看模板邮件的编写
test.vm如下：

<!DOCTYPE html>
<html>
<head lang="en">
    <meta charset="UTF-8">
    <title>模板文件</title>
</head>
<body>
<h2 style="text-align:center">${emailInfo.subject}</h2>
你好：${emailInfo.receiver},这是一封测试模板邮件，请注意查收！<br>
<p>来自：${emailInfo.sender},${emailInfo.date}</p>
<p>电话：${emailInfo.phone}</p>
<p>公司：${emailInfo.company}</p>
<p>地址：${emailInfo.address}</p>
</body>
</html>

公共代码
Log4jMyAppender.java

log4j配置文件的优先级

package com.zt.common;

import org.apache.log4j.DailyRollingFileAppender;
import org.apache.log4j.Priority;

//log4j配置文件
public class Log4jMyAppender extends DailyRollingFileAppender {

    @Override
    public boolean isAsSevereAsThreshold(Priority priority) {  
         //只判断是否相等，而不判断优先级   
        return this.getThreshold().equals(priority);  
    }  
}

MultipleDataSource.java

此段代码表示动态数据源的切换

package com.zt.common;

import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
/**
 * 动态数据源切换
 * @author zhangtao
 *
 */
public class MultipleDataSource extends AbstractRoutingDataSource {
    private static final ThreadLocal<String> dataSourceKey = new InheritableThreadLocal<String>();

    public static void setDataSourceKey(String dataSource) {
        dataSourceKey.set(dataSource);
    }

    @Override
    protected Object determineCurrentLookupKey() {
        return dataSourceKey.get();
    }
}

MutilPropertyPlaceholderConfigurer.java

这里是开发模式的调用

package com.zt.common;

import java.io.IOException;
import java.util.Map.Entry;
import java.util.Properties;
import java.util.Set;

import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.config.PropertyPlaceholderConfigurer;

/**
 * 环境模式切换调用
 * @author zhangtao
 *
 */
public class MutilPropertyPlaceholderConfigurer extends PropertyPlaceholderConfigurer implements InitializingBean{


     private static final String PRODUCTION_MODE = "env";  
       // 缓存所有的属性配置  
        private Properties properties;  
        /** 
         * @return the mode 
         */  
        public String getMode() {  
            return properties.getProperty(PRODUCTION_MODE);  
        }  
        @Override  
        protected Properties mergeProperties() throws IOException {  
            Properties mergeProperties = super.mergeProperties();  
            // 根据路由原则，提取最终生效的properties  
            this.properties = new Properties();  
           //获取路由规则,系统属性设置mode优先
            String mode = System.getProperty(PRODUCTION_MODE);  
            if (StringUtils.isEmpty(mode)) {  
                String str = mergeProperties.getProperty(PRODUCTION_MODE);  
                mode = str != null ? str : "PROD";  
            } 
            properties.put(PRODUCTION_MODE, mode);  
            String[] modes = mode.split(",");  
            Set<Entry<Object, Object>> es = mergeProperties.entrySet();  
            for (Entry<Object, Object> entry : es) {  
                String key = (String) entry.getKey();  
                int idx = key.lastIndexOf('<');  
                String realKey = idx == -1 ? key : key.substring(0, idx);  
                if (!properties.containsKey(realKey)) {  
                    Object value = null;  
                    for (String md : modes) {  
                        value = mergeProperties.get(realKey + "<" + md + ">");  
                        if (value != null) {  
                            properties.put(realKey, value);  
                            break;  
                        }  
                    }  
                    if (value == null) {  
                        value = mergeProperties.get(realKey);  
                        if (value != null) {  
                            properties.put(realKey, value);  
                        } else {  
                            throw new RuntimeException("impossible empty property for " + realKey);  
                        }  
                    }  
                }  
            }  
            return properties;  
        }  

        /** 
         * 开放此方法给需要的业务 
         *  
         * @param key 
         * @return 
         */  
        public String getProperty(String key) {  
            return resolvePlaceholder(key, properties);  
        }  

        public void afterPropertiesSet() throws Exception { 

         }  
}

功能业务代码：
EmailInfoVo.java

package com.zt.vo;

import java.io.Serializable;

/**
 * @author zhangtao
 * @since 2018年7月16日
 * 邮件内容公共信息
 **/
public class EmailInfoVo implements Serializable{

    private static final long serialVersionUID = 1L;
    private  String date;//时间
    private  String receiver;//收件人
    private  String sender;//发件人
    private String company;//公司
    private String phone;//电话
    private String address;//地址
    private String subject;//主题
    public String getSubject() {
        return subject;
    }
    public void setSubject(String subject) {
        this.subject = subject;
    }
    public String getDate() {
        return date;
    }
    public void setDate(String date) {
        this.date = date;
    }
    public String getReceiver() {
        return receiver;
    }
    public void setReceiver(String receiver) {
        this.receiver = receiver;
    }
    public String getSender() {
        return sender;
    }
    public void setSender(String sender) {
        this.sender = sender;
    }
    public String getCompany() {
        return company;
    }
    public void setCompany(String company) {
        this.company = company;
    }
    public String getPhone() {
        return phone;
    }
    public void setPhone(String phone) {
        this.phone = phone;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
}

EmailService.java

package com.zt.service;

import java.util.Map;

/**
 * @author zhangtao
 * @since 2018年7月13日
 **/
public interface EmailService {

    /**
     * receiver 接收人
     * topic 主题
     * msg 邮件内容
     * @return 是否发送成功，true成功，false失败
     */
    boolean sendMail(String receiver,String topic,String msg) ;

    /**
     * rcs 接收人列表，可多人
     * ccs 抄送人列表，可多人，可为空
     * bcc 密送人列表，可为空
     * topic 主题，可为空
     * msg 邮件内容
     * attachmentMap key文件名，value附件路径，可为空
     * @return 是否发送成功，true成功，false失败
     */
    boolean sendMailAtt(String[] rcs, String[] ccs ,String[] bccs, String topic, String msg, Map<String,String>  attachmentMap);

}

EmailServiceImpl.java

package com.zt.service.impl;

import java.io.File;
import java.util.Map;

import org.apache.commons.lang3.ObjectUtils;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

import com.zt.common.MutilPropertyPlaceholderConfigurer;
import com.zt.service.EmailService;

import jodd.mail.Email;
import jodd.mail.EmailAttachment;
import jodd.mail.SendMailSession;
import jodd.mail.SmtpServer;
import jodd.mail.att.FileAttachment;

/**
 * @author zhangtao
 * @since 2018年7月13日
 **/
@Service
public class EmailServiceImpl implements EmailService {
    private static final Logger logger = Logger.getLogger(EmailService.class);

    @Autowired
    private MutilPropertyPlaceholderConfigurer placeholder;

    /**
     * receiver 接收人
     * topic 主题
     * msg 邮件内容
     * @return 是否发送成功，true成功，false失败
     */
    public boolean sendMail(String receiver, String topic, String msg) {

        if(!StringUtils.hasText(receiver) || !StringUtils.hasText(msg)) {
            logger.info("receiver or message is empty");
            return false;
        }

        boolean sendFlag = true;
        SendMailSession session = null;
        try{

            String smtpServer = placeholder.getProperty("mail_smtpserver");
            int smtpPort = Integer.parseInt(ObjectUtils.toString(placeholder.getProperty("mail_smtpport")));
            String authUser = placeholder.getProperty("mail_authuser");
            String authPassword = placeholder.getProperty("mail_authpassword");

            SmtpServer<?> smtp = SmtpServer.create(smtpServer,smtpPort);
            smtp.authenticateWith(authUser, authPassword);
            smtp.property("mail.smtp.socketFactory.fallback", "false");
            session = smtp.createSession();

            Email email = Email.create().from(authUser)
                    .to(receiver).subject(topic)//设置了主题
                    .addHtml(msg);
            session.open();//打开连接
            session.sendMail(email);//发送邮件
            session.close();//关闭连接
            logger.info("send mail success:" + receiver + "," + msg);

        }
        catch(Exception e) {
            logger.error("send mail exception:"+e.getMessage(),e);
            //发送失败
            sendFlag = false;
        } 
        return sendFlag;        
    }


    /**
     * rcs 接收人列表，可多人
     * ccs 抄送人列表，可多人，可为空
     * bcc 密送人列表，可为空
     * topic 主题，可为空
     * msg 邮件内容
     * attachmentMap key文件名，value附件路径，可为空
     * @return 是否发送成功，true成功，false失败
     */
    public boolean sendMailAtt(String[] rcs, String[] ccs ,String[] bccs , String topic, String msg,Map<String,String>  attachmentMap) {

        if(null==rcs || rcs.length==0 || !StringUtils.hasText(msg)   ) {
            logger.info("rcs or  message is empty");
            return false;
        }

        boolean sendFlag = true;
        SendMailSession session = null;

        try{

            String smtpServer = placeholder.getProperty("mail_smtpserver");
            int smtpPort = Integer.parseInt(ObjectUtils.toString(placeholder.getProperty("mail_smtpport")));
            String authUser = placeholder.getProperty("mail_authuser");
            String authPassword = placeholder.getProperty("mail_authpassword");

            SmtpServer<?> smtp = SmtpServer.create(smtpServer,smtpPort);
            smtp.authenticateWith(authUser, authPassword);
            smtp.property("mail.smtp.socketFactory.fallback", "false");
            session = smtp.createSession();

            Email email = Email.create()
                    .from(authUser)
                    .to(rcs)
                    .subject(topic)//设置了主题
                    .addHtml(msg);
            //抄送人列表
            if(null!=ccs && ccs.length>0){
                email.cc(ccs);
            } 
            //密送人列表
            if(null!=bccs && bccs.length>0){
                email.bcc(bccs);
            }

            //附件 
            if(null != attachmentMap && attachmentMap.size()>0){
                logger.info("开始加载附件...");
                for (Map.Entry<String, String> entry : attachmentMap.entrySet()) {  

                    String attachmentName = entry.getKey();
                    String attachmentPath = entry.getValue();
                    logger.info("attachmentName->" + attachmentName + "####" + "attachmentPath->" + attachmentPath);
                    EmailAttachment emailAttachment = new FileAttachment(new File(attachmentPath), attachmentName, "");

                    email.attach(emailAttachment);
                }  
                logger.info("结束加载附件...");
            }

            session.open();//打开连接
            session.sendMail(email);//发送邮件
            session.close();
            logger.info("send mail success:" + rcs + "," + msg);
        }
        catch(Exception e) {
            logger.error("send mail exception:"+e.getMessage(),e);
            //发送失败
            sendFlag = false;
        }
        return sendFlag;
    }   
}

QuartzService.java

package com.zt.service;

import com.zt.domain.Email;

/**
 * @author zhangtao
 * @since 2018年7月16日
 **/
public interface QuartzService {

    //插入一条发送记录
    void add (Email email);

    //获取一条邮件记录
    Email getOne(String sender);

    //更新一条邮件记录
    void update(Email emails);
}

QuartzServiceImpl.java

package com.zt.service.impl;

import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.zt.dao.EmailDao;
import com.zt.domain.Email;
import com.zt.service.QuartzService;

/**
 * @author zhangtao
 * @since 2018年7月16日
 **/
@Service
public class QuartzServiceImpl implements QuartzService{
    private static final Logger logger = Logger.getLogger(QuartzService.class);

    @Autowired
    private EmailDao emailDao;

    //添加
    public void add(Email email) {

        logger.info("定时推送邮件中.......");  

        emailDao.add(email);
    }
    //查询一条
    public Email getOne(String sender) {

        return emailDao.getOne(sender);

    }
    //更新一条
    public void update(Email emails) {
        if(emails.getReceiver()!=null&&emails.getPushman()!=null) {
            emailDao.update(emails);
        }
    }
}

PushEmail.java:

这里的job既是定时发送邮件的执行类

package com.zt.job;

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

import org.apache.log4j.Logger;
import org.apache.velocity.app.VelocityEngine;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.io.ClassPathResource;
import org.springframework.ui.velocity.VelocityEngineUtils;

import com.zt.domain.Email;
import com.zt.service.EmailService;
import com.zt.service.QuartzService;
import com.zt.vo.EmailInfoVo;

/**
 * @author zhangtao
 * @since 2018年7月16日
 * 推送邮件
 **/
public class PushEmail {

    private static final Logger logger = Logger.getLogger(PushEmail.class);

    @Autowired
    private EmailService emailService;

    @Autowired
    private VelocityEngine velocityEngine;

    @Autowired
    private QuartzService quartzService;
    //推送邮件方法
    public boolean pushEmail() {
        Date date = new Date();
        logger.info("推送邮件中");
         EmailInfoVo emailInfoVo = new EmailInfoVo();
         emailInfoVo.setSubject("关于邮件测试");
         emailInfoVo.setCompany("某某有限公司");
         emailInfoVo.setAddress("广州市");
         String time = new SimpleDateFormat("yyyy年-MM月-dd日").format(new Date());
         emailInfoVo.setDate(time);
         emailInfoVo.setPhone("15200706014");
         emailInfoVo.setReceiver("TT");
         emailInfoVo.setSender("zhangtao@bluemoon.com.cn");
         Map<String,Object> model = new HashMap<String,Object>();
         model.put("emailInfo", emailInfoVo);
        //发送邮件
         String topic ="来自xxx网站的激活邮件";
         String path = "template/test.vm";
         ClassPathResource resource = new ClassPathResource(path);
         if (resource.exists()) {
             String msg = VelocityEngineUtils.mergeTemplateIntoString(velocityEngine,path, "UTF-8", model);
             boolean falg = emailService.sendMail(emailInfoVo.getSender(), topic,msg);
             if(falg) {
                //成功，查询数据库，如果存在则更新数据库，若不存在则插入
                Email emails =  quartzService.getOne(emailInfoVo.getSender());//查询数据库
                logger.info("查询："+emails);
                 if(emails!=null) {
                     int count = emails.getPushcount();
                     logger.info("从数据库中获取的推送次数为："+count);
                     emails.setPushcount(count+1);
                     logger.info("emails:"+emails.getPushcount()+"---"+emails.getId());
                     quartzService.update(emails);
                     logger.info("emails:"+emails.getPushcount()+"---"+emails.getId());
                     logger.info("存在更新数据库");
                 }else {//插入数据
                     Email email = new Email();
                     email.setReceiver(emailInfoVo.getSender());//收件人
                     email.setTime(new SimpleDateFormat("yyyy/MM/dd HH:ss").format(new Date()));//推送时间
                     email.setPushman(emailInfoVo.getSender());//推送者
                     email.setPushcount(0);//推送次数
                     quartzService.add(email);
                     logger.info("不存在，插入数据库");
                 }
                 return true;
             }
            }
        logger.info("推送耗时："+(new Date().getTime()-date.getTime())/1000+"秒");
        return false;
    }
}

Emial.java

这里是邮件实体封装类

package com.zt.domain;

import java.io.Serializable;

/**
 * @author zhangtao
 * @since 2018年7月16日
 **/
public class Email implements Serializable{

    private static final long serialVersionUID = 1L;

    private Integer id;
    private String time;//推送时间
    private String receiver;//收件人
    private Integer pushcount;//推送次数
    private String pushman;//推送人

    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getTime() {
        return time;
    }
    public void setTime(String time) {
        this.time = time;
    }
    public String getReceiver() {
        return receiver;
    }
    public void setReceiver(String receiver) {
        this.receiver = receiver;
    }
    public Integer getPushcount() {
        return pushcount;
    }
    public void setPushcount(Integer pushcount) {
        this.pushcount = pushcount;
    }
    public String getPushman() {
        return pushman;
    }
    public void setPushman(String pushman) {
        this.pushman = pushman;
    }
    public static long getSerialversionuid() {
        return serialVersionUID;
    }
}

EmailDao.java


package com.zt.dao;

import com.zt.domain.Email;

/**
 * @author zhangtao
 * @since 2018年7月16日
 **/
public interface EmailDao {

    void add(Email email);

    Email getOne(String pushman);

    void update(Email pushEmail);

}

mapper中的Email.xml

这里对应Dao层操作数据库的

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.zt.dao.EmailDao">

    <insert id="add" parameterType="Email">
    insert into pushemail(time,receiver,pushcount,pushman) values(#{time},#{receiver},#{pushcount},#{pushman})  
    </insert>   
    <update id="update" parameterType="Email">
    update  pushemail set pushcount=#{pushcount}
    where id = #{id}
    </update>
    <select id="getOne" parameterType="java.lang.String" resultType="Email">
    select * from pushemail where pushman =#{pushman}
    </select>
</mapper>

结果展示

在程序中我设置的是每半分钟推送一次成功即在数据库更新一次，记录推送的次数。
这里写图片描述

以上部分文字图片总结摘自：邮件发送的基本过程与概念，在此感谢博主的无私分享

西门吹雪吹吹风

关注

0
点赞
踩
6

收藏

觉得还不错? 一键收藏
打赏
0
评论
Spring整合邮件模板定时发送

前言在企业级开发中，我们不可避免的使用到邮件发送，可能由于项目的需要，我们要定时定频率的给用户或者业务方发送邮件。目录发送邮件原理简介电子邮件的发送与接收过程过程解释说明1、用户A的电子邮箱为：xx@qq.com，通过邮件客户端软件写好一封邮件，交到QQ的邮件服务器，这一步使用的协议是SMTP,对应图示的①；2、QQ邮箱会根据用户A发送的邮件进行解析，也就是根据收...
复制链接

扫一扫