第9章Spring集成的其他功能
邮件服务，任务调试和Java消息服务.
邮件服务的附件是Spring书中光盘的09/Mail工程
一 普通邮件 SimpleMailMessage(JavaMail有两个包，mail.jar,activation.jar, 这里是使用spring的mail,
import org.springframework.mail.*; 用spring.jar包就可以了
)
Spring提供了非常方便的Mail抽象层，1它通过一个MailSend接口封装了邮件发送Bean;2而SimpleMailMessage封装了纯文本的简单邮件.
eg.
1 applicationContext.xml（spring配置文件）
<?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.xsd"
>
<!-- 配置MailSender -->
<bean id="mailSender" class="org.springframework.mail.javamail.JavaMailSenderImpl">
<property name="host" value="smtp.gmail.com" />
<property name="port" value="465" />
<property name="username" value="livebookstore" /> <!--这是测试的邮箱，用户名密码正确，可以使用--我的邮箱facepp911@gmail.com>
<property name="password" value="LiVe-BoOkStOrE" />
<property name="javaMailProperties">
<props>
<prop key="mail.smtp.auth">true</prop>
<prop key="mail.smtp.starttls.enable">true</prop>
<prop key="mail.smtp.socketFactory.class">javax.net.ssl.SSLSocketFactory</prop>
</props>
</property>
</bean>
</beans>
2 // 使用Spring提供的MailSender:
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
JavaMailSender mailSender = (JavaMailSender)context.getBean("mailSender");
// 创建一个纯文本邮件:
SimpleMailMessage mail = new SimpleMailMessage();
mail.setFrom("livebookstore@gmail.com");
mail.setTo("35482212@qq.com");
mail.setSubject("Another test mail");
mail.setText("测试使用Spring MailSender发送邮件");
// 发送:
mailSender.send(mail);
二带附件的邮件MimeMessage(发送带有附件的MimeMessage很麻烦，而Spring提供了一个助手来MimeMessageHelper
来MimeMessage很方便)
eg.1.applicationContext.xml(同上)
2. // 使用Spring提供的MailSender
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
JavaMailSender mailSender = (JavaMailSender)context.getBean("mailSender");
// 发送Mime邮件:
MimeMessage mime = mailSender.createMimeMessage();
MimeMessageHelper helper = new MimeMessageHelper(mime, true, "UTF-8");
helper.setFrom("livebookstore@gmail.com");
helper.setTo("livebookstore2@gmail.com");
helper.setSubject("Test mime mail");
// 设定为HTML格式:
helper.setText("<html><body>访问Live在线书店：<br>"
+ "<a href='http://www.livebookstore.net' target='_blank'>"
+ "<img src='cid:logo'></a></body></html>", //附件要嵌入到HTML中显示，则在IMG标签中用"cid:XXX"标记。对应的附件通过addInline()方法添加.
true);
helper.addInline("logo", new ClassPathResource("logo.gif"));//添加一个嵌入的图片,图片放在classes文件夹中
helper.addAttachment("freebsd.gif", new ClassPathResource("freebsd.gif"));//添加一个普通的附件,图片放在classes文件夹中
// 发送:
mailSender.send(mime);
三。任务调度（设置自动调度的任务）eg.需要定时分析每天日志记录,然后自动发报告给系统管理员。
Spring提供了一个非常实用的调度器，可以方便地配置任务并定期执行;Spring框架提供了一个抽象层，
封装了JDK的Timer类和开源的Quartz调度器。
使用Timer调度任务（见后面的附）
使用Quartz调度(关键词：Job,Trigger,scheduleJob(Job,Trigger))
Spring提供了两种方式来封装Quartz的Job,一种是直接派生QuartzJobBean.另一种是完全用最简单的POJO实现.
eg.方式一
package example.chapter9;
import java.util.Date;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.scheduling.quartz.QuartzJobBean;
public class Report extends QuartzJobBean {
private String name;
public void setName(String name) {
this.name = name;
}
@Override
protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
System.out.println("Send report to " + name + " at " + new Date());
try {
Thread.sleep(1000);
}
catch(InterruptedException e) {
e.printStackTrace();
}
}
}
config.xml
<!-- Job -->
<bean name="reportJob" class="org.springframework.scheduling.quartz.JobDetailBean">
<property name="jobClass" value="example.chapter9.Report" />
<property name="jobDataAsMap">
<map>
<entry key="name" value="Micheal" />
</map>
</property>
</bean>
<!-- Trigger -->
<!-- 定时运行reportJob -->
<bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean">
<property name="jobDetail" ref="reportJob" />
<!-- 每周周一至周五中午12:00执行 -->
<property name="cronExpression" value="0 0 12 ? * MON-FRI" /> //cronExpression的写法见附
</bean>
<!-- 启动调度器 -->
<bean id="scheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
<property name="triggers">
<list>
<ref bean="cronTrigger" />
</list>
</property>
</bean>
使用
package example.chapter9;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Main {
public static void main(String[] args) {
new ClassPathXmlApplicationContext("config.xml");
}
}
方式二
package example.chapter9;
import java.util.Date;
public class CheckDiskFreeSpace {
public void check() {
// get disk free space:
long freeSpace = Math.random() > 0.5 ? 100000000 : 200000000;
System.out.println("Check disk free space at " + new Date());
if(freeSpace<100*1024*1024) { // <100MB
System.out.println("Warning! Low disk free space...");
}
}
}
<!-- Job -->
<bean name="checkDiskFreeSpace" class="example.chapter9.CheckDiskFreeSpace" />
<bean name="checkDiskJob" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
<property name="targetObject" ref="checkDiskFreeSpace" />
<property name="targetMethod" value="check" />
<property name="concurrent" value="false" />
</bean>
<!-- Trigger -->
<!-- 周期性运行checkDiskJob -->
<bean id="repeatTrigger" class="org.springframework.scheduling.quartz.SimpleTriggerBean">
<property name="jobDetail" ref="checkDiskJob" />
<!-- 1分钟后启动 -->
<property name="startDelay" value="60000" />
<!-- 5分钟检查一次 -->
<property name="repeatInterval" value="300000" />
</bean>
<!-- 启动调度器 -->
<bean id="scheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
<property name="triggers">
<list>
<ref bean="repeatTrigger" />
</list>
</property>
</bean>
使用同上
四 java消息服务（即JMS）异步发送和接收事件通知
JMS是JavaEE标准中为企业应用服务程序提供消息传递服务的API标准.JMS使用异步发送和接收事件通知的应用程序变得容易。
Spring2.0中对JMS发送和接收消息做了非常方便的封装。
有两种模式：点对点模式，发布-订阅模式。
点对点模式和发布-订阅模式的主要接口，以及在JMS1.1中统一的接口。
点对点模式------------------发布-订阅模式------------------JMS1.1的统一接口
QueueConectionFactory TopicConnectionFactory ConnectionFactory
QueueConnection TopicConnection Connection
Queue Topic Destination
QueueSession TopicSession Session
QueueSender TopicPublisher MessageProducer
QueueReceiver TopicSubscriber MessageConsumer
eg.JMS
需要5个包: commons-logging,jms,jmxri,jmxtools,mon4j.(详细见附)
eg2.JMS_Spring 需要5个包: commons-logging,jms,jmxri,jmxtools,mon4j,spring
config.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.xsd"
>
<bean id="jmsConnectionFactory" class="org.springframework.jndi.JndiObjectFactoryBean">
<property name="jndiName" value="QueueConnectionFactory" />
</bean>
<bean id="jmsQueue" class="org.springframework.jndi.JndiObjectFactoryBean">
<property name="jndiName" value="jms/queue" />
</bean>
<bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
<property name="connectionFactory" ref="jmsConnectionFactory" />
<property name="defaultDestination" ref="jmsQueue" />
</bean>
<bean id="sender" class="example.chapter9.Sender"> *
<property name="jmsTemplate" ref="jmsTemplate" />
</bean>
<bean id="receiver" class="example.chapter9.Receiver" /> *
<bean id="listenerContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
<property name="connectionFactory" ref="jmsConnectionFactory" />
<property name="destination" ref="jmsQueue" />
<property name="messageListener" ref="receiver" />
</bean>
</beans>
-------------------------------------
package example.chapter9;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.Session;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.core.MessageCreator;
public class Sender {
private JmsTemplate jmsTemplate;
public void setJmsTemplate(JmsTemplate jmsTemplate) {
this.jmsTemplate = jmsTemplate;
}
public void send(final String text) { //发邮件的话，这里改成 send(SimpleMailMessage mess)
System.out.println(" Send: " + text);
jmsTemplate.send(new MessageCreator() {
public Message createMessage(Session session) throws JMSException {
return session.createTextMessage(text); //发邮件的时候，这里的textMessage需要改吗？
}
});
}
}
--------------------------------
package example.chapter9;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.TextMessage;
public class Receiver implements MessageListener {
public void onMessage(Message message) {
if(message instanceof TextMessage) {
TextMessage text = (TextMessage) message;
try {
System.out.println("Receive: " + text.getText());
}
catch(JMSException e) {}
}
}
}
----------------------------------
Mom4jUtil.java 启动服务，同附中例子的JMS中的Mom4jUtil.java
----------------------------------
Main.java(比起JMS例子，有点不同，不用写Receive;结果是接收到发送方传来的Message)
package example.chapter9;
import java.util.Date;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Main {
public static void main(String[] args) throws Exception {
Mom4jUtil.startJmsServer();
ApplicationContext context = new ClassPathXmlApplicationContext("config.xml");
Sender sender = (Sender) context.getBean("sender");
for(int i=0; i<10; i++) {
sender.send("Hello, it is " + new Date());
Thread.sleep(1000);
}
System.exit(0);
}
}
------------------完
eg3.JMS_servlet(通过页面发送消息)
两个包:common-logging,spring
index.html(发送消息的文本框)
<html><head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>发送JMS</title></head>
<body>
<form name="form1" method="post" action="sendMessage.jms">
输入消息：
<input name="text" type="text" id="text" maxlength="255">
<input type="submit" name="Submit" value="发送">
</form>
</body></html>
-------------------------------
SendMessageController
package example.chapter9;
import java.io.PrintWriter;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.Session;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.core.MessageCreator;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;
public class SendMessageController implements Controller {
private JmsTemplate jmsTemplate;
public void setJmsTemplate(JmsTemplate jmsTemplate) {
this.jmsTemplate = jmsTemplate;
}
public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
final String text = request.getParameter("text");
response.setContentType("text/html;charset=UTF-8");
response.setCharacterEncoding("UTF-8");
PrintWriter writer = response.getWriter();
if(text!=null && !text.equals("")) {
jmsTemplate.send(new MessageCreator() {
public Message createMessage(Session session) throws JMSException {
return session.createTextMessage(text);
}
});
writer.write("发送成功！<a href='index.html'>返回</a>");
writer.flush();
}
else {
writer.write("发送失败！<a href='index.html'>返回</a>");
writer.flush();
}
return null;
}
}
--------------------------------------
Receiver
package example.chapter9;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.TextMessage;
public class Receiver implements MessageListener {
public void onMessage(Message message) {
if(message instanceof TextMessage) {
TextMessage text = (TextMessage) message;
try {
System.out.println("Receive: " + text.getText());
}
catch(JMSException e) {}
}
}
}
---------------
dispatcher-servlet.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.xsd"
>
<bean id="jmsConnectionFactory" class="org.springframework.jndi.JndiObjectFactoryBean">
<property name="jndiName" value="java:comp/env/jms/factory" />
</bean>
<bean id="jmsQueue" class="org.springframework.jndi.JndiObjectFactoryBean">
<property name="jndiName" value="java:comp/env/jms/queue" />
</bean>
<bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
<property name="connectionFactory" ref="jmsConnectionFactory" />
<property name="defaultDestination" ref="jmsQueue" />
</bean>
<bean id="receiver" class="example.chapter9.Receiver" />*
<bean id="listenerContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
<property name="connectionFactory" ref="jmsConnectionFactory" />
<property name="destination" ref="jmsQueue" />
<property name="messageListener" ref="receiver" />
</bean>
<bean name="/sendMessage.jms" class="example.chapter9.SendMessageController">*//跳转到//http://localhost:8080/sendMessage.jms页
<property name="jmsTemplate" ref="jmsTemplate" />
</bean>
</beans>
--------------------------------------------
web.xml
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN" "http://java.sun.com/dtd/web-app_2_3.dtd">
<web-app>
<servlet>
<servlet-name>dispatcher</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>dispatcher</servlet-name>
<url-pattern>*.jms</url-pattern>
</servlet-mapping>
<welcome-file-list>
<welcome-file>index.html</welcome-file>
</welcome-file-list>
</web-app>
------------------------------完
练习题：使用JMS发送E-mail通知
在Web应用程序中，常常需要给用户发送邮件通知，例如，注册成功的欢迎邮件，订单确认邮件
，由于发送邮件是非常耗时的任务，对于需要实时发送的邮件，以同步的方式在一个HTTP请求中完成将
影响用户浏览，在新的线程中发送则需要自己管理纯种池等。这时，利用JMS提供的异步编程模型，借助Spring框架就可以在一个简单的POJO非常方便地处理邮件发送的任务。
读者可以试着将前面讲述的邮件发送程序集成到Recieve(send?)类中，在Sender和Receive中使用ObjectMessage(有简单邮件，和带附件的邮件)来传递信息。
*Spring框架中访问EJB组件。。。
*Spring框架对动态语言的支持，包括JRuby,Groovy和BeanShell.
如何使用SSL来保证电子邮件的传输安全。
附：
1.不用Spring发邮件的方法。过去的方法.
JavaMail
package example.chapter9;
import java.util.*;
import javax.mail.*;
import javax.mail.internet.*;
public class Main {
public static void main(String[] args) throws Exception {
// 直接使用JavaMail API:
Properties props = new Properties();
// 设置SMTP服务器:
props.put("mail.smtp.host", "smtp.gmail.com");
props.put("mail.smtp.port", "465");
props.put("mail.smtp.auth", "true");
// 使用SSL安全连接:
props.put("mail.smtp.starttls.enable", "true");
props.put("mail.smtp.socketFactory.class", "javax.net.ssl.SSLSocketFactory");
send(
props,
"livebookstore", // Username
"LiVe-BoOkStOrE", // Password
"livebookstore@gmail.com", // From
new String[] {"livebookstore2@gmail.com"}, // To
"A test mail", // Subject
"测试使用JavaMail API发送邮件" // Text
);
}
public static void send(Properties props, final String username, final String password, String from, String[] to, String subject, String text) throws MessagingException {
Session session = Session.getInstance(props, new Authenticator() {
public PasswordAuthentication getPasswordAuthentication() {
return new PasswordAuthentication(username, password);
}
});
session.setDebug(true);
Message message = new MimeMessage(session);
message.setFrom(new InternetAddress(from));
message.setSubject(subject);
message.setText(text);
message.setSentDate(new Date());
Address[] addressTo = new Address[to.length];
for(int i=0; i<to.length; i++) {
addressTo[i] = new InternetAddress(to[i]);
}
message.setRecipients(Message.RecipientType.TO, addressTo);
message.saveChanges();
Transport.send(message, addressTo);
}
}
}
2.使用Timer调度任务
（任务）package example.chapter9;
import java.util.Date;
import java.util.TimerTask;
public class ReportTimerTask extends TimerTask {
public void run() {
String log = "read from log file at " + new Date();
System.out.println(log);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
(配置config.xml)
<!-- 单一任务 -->
<bean id="reportTask" class="example.chapter9.ReportTimerTask" /> //关联任务类
<!-- 周期性任务 -->
<bean id="scheduledTask" class="org.springframework.scheduling.timer.ScheduledTimerTask">
<!-- 启动后等待10秒，然后开始执行 -->
<property name="delay" value="10000" />
<!-- 每60秒执行一次 -->
<property name="period" value="60000" />
<property name="timerTask" ref="reportTask" /> //周期性关联任务
</bean>
<!-- 启动任务的工厂 -->
<bean id="timerFactory" class="org.springframework.scheduling.timer.TimerFactoryBean">
<property name="scheduledTimerTasks">
<list>
<ref bean="scheduledTask" />
</list>
</property>
</bean>
(调用周期性任务)
package example.chapter9;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Main {
public static void main(String[] args) {
new ClassPathXmlApplicationContext("config.xml");
try {
Thread.sleep(300000);
}
catch(InterruptedException e) {}
System.exit(0);
}
}
(结果是第一分钟打印一行：read from log file at Thu Sep 04 17:15:11 CST 2008)
3.CronExpression的写法：
CronExpression用于定义触发Job的时间，由7个部份组成，分别代表：
秒，分，小时，一月中的某天，月份，星期，年份（可选）
eg."0 0 12 ? * MON"表示第周一 12:00:00执行，?表示忽略月份中的天数，因为通常
要么按照日期指定，要么按照星期指定，*表示全部，即每月都执行。
"," 指定一个列表....未完P327..
4.JMS
需要5个包: commons-logging,jms,jmxri,jmxtools,mon4j.
public class Main {
public static void main(String[] args) throws Exception {
Mom4jUtil.startJmsServer(); //启动
new Sender().start(); //发消息
new Receiver().start(); //收消息
Thread.sleep(30000);
System.exit(0);
}
}
------------------------------------------
import java.util.Date;
import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;
import javax.jms.Message;
import javax.jms.MessageProducer;
import javax.jms.Session;
import javax.naming.Context;
import javax.naming.InitialContext;
public class Sender extends Thread {
public void run() {
try {
Context ctx = new InitialContext();
ConnectionFactory factory = (ConnectionFactory) ctx.lookup("QueueConnectionFactory");
Destination destination = (Destination) ctx.lookup("jms/queue");
for(;;) {
Connection connection = null;
try {
connection = factory.createConnection();
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
MessageProducer producer = session.createProducer(destination);
String text = "Hello, it is " + new Date();
System.out.println(" Send: " + text);
Message message = session.createTextMessage(text);
producer.send(message);
producer.close();
session.close();
}
finally {
if(connection!=null)
connection.close();
}
Thread.sleep(1000 + (long)(Math.random() * 5000));
}
}
catch(Exception e) {
e.printStackTrace();
}
}
}
-------------------------
import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.MessageListener;
import javax.jms.Session;
import javax.jms.TextMessage;
import javax.naming.Context;
import javax.naming.InitialContext;
public class Receiver extends Thread implements MessageListener {
public void run() {
try {
Context ctx = new InitialContext();
ConnectionFactory factory = (ConnectionFactory) ctx.lookup("QueueConnectionFactory");
Destination destination = (Destination) ctx.lookup("jms/queue");
Connection connection = null;
try {
connection = factory.createConnection();
Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
MessageConsumer consumer = session.createConsumer(destination);
consumer.setMessageListener(this);
connection.start();
Thread.sleep(20000);
}
finally {
if(connection!=null)
connection.close();
}
}
catch(Exception e) {
e.printStackTrace();
}
}
public void onMessage(Message message) {
if(message instanceof TextMessage) {
TextMessage text = (TextMessage) message;
try {
System.out.println("Receive: " + text.getText());
}
catch(JMSException e) {
e.printStackTrace();
}
}
}
}
----------------------
import java.io.File;
import java.util.ArrayList;
import java.util.List;
import javax.naming.Context;
import org.mom4j.api.Mom4jConfig;
import org.mom4j.api.Mom4jDestination;
import org.mom4j.api.Mom4jFactory;
public final class Mom4jUtil {
public static void startJmsServer() throws Exception {
Mom4jFactory.start(new CustomConfig(), true);
System.setProperty(Context.INITIAL_CONTEXT_FACTORY, "org.mom4j.jndi.InitialCtxFactory");
System.setProperty(Context.PROVIDER_URL, "xcp://localhost:8001");
}
}
class CustomConfig implements Mom4jConfig {
public int getPort() { return 4444; }
public int getAdminPort() { return 8888; }
public int getJndiPort() { return 8001; }
public int getThreadCount() { return 3; }
public int getSyncInterval() { return 500; }
public int getAsyncInterval() { return 1000; }
public List getUsers() { return new ArrayList(); }
public List getContextHandlers() { return new ArrayList(); }
public File getMessageStore() {
File dir = new File("store/");
dir.mkdirs();
return dir;
}
public File getDurablesStore() {
return new File("durable.dat");
}
@SuppressWarnings("unchecked")
public List getDestinations() {
List list = new ArrayList(1);
list.add(new Mom4jDestination() {
public String getName() {
return "jms/queue";
}
public int getType() {
return Mom4jDestination.QUEUE;
}
});
return list;
}
}
-----------完
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
