基于控件构架开发访问JavaMail的控件

控件实现类

　　 JavaMail控件要完成邮件发送的工作，必须要完成获取目标SMTP服务器参数、设置SMTP服务器参数、获取用户业务方法调用中提供的注释和参数、发送邮件等工作，其中获取目标SMTP服务器参数、设置SMTP服务器参数的动作通常只需要一次完成就行了，我们设计成在控件初始化的时候完成，反映到JavaMail控件的实现类中，我们可以将这部分工作在onCreate方法中完成。

　　在控件实现类中，最主要的方法就是invoke(Method m,Object[] args)，这个方法中的两个参数为我们提供了用于调用业务方法时提供的注释内容和调用参数，邮件发送的工作也被设计成在这个方法中完成。

　　JavaMail控件实现类继承了JavaMail控件的接口类，同时实现了org.apache.beehive.controls.api.bean.Extensible接口，这样JavaMail控件的使用者就可以直接继承该控件。清单2中显示了JavaMail实现类的完整源代码如下，源代码中在每一个关键点都提供了详细的说明，帮助大家理解JavaMail实现类的实现原理，请大家重点关注其中的onCreate和invoke两个方法。

　　清单2 src\org\vivianj\beehive\controls\examples\javamail\

　　JavaMailControlImpl.java

1.	package org.vivianj.beehive.controls.examples.javamail;
2.	
3.	import java.lang.reflect.Method;
4.	import java.util.Properties;
5.	
6.	import javax.activation.DataHandler;
7.	import javax.activation.FileDataSource;
8.	import javax.mail.Address;
9.	import javax.mail.BodyPart;
10.	import javax.mail.Multipart;
11.	import javax.mail.Session;
12.	import javax.mail.Transport;
13.	import javax.mail.internet.InternetAddress;
14.	import javax.mail.internet.MimeBodyPart;
15.	import javax.mail.internet.MimeMessage;
16.	import javax.mail.internet.MimeMultipart;
17.	
18.	import org.apache.beehive.controls.api.bean.ControlImplementation;
19.	import org.apache.beehive.controls.api.bean.Extensible;
20.	import org.apache.beehive.controls.api.context.Context;
21.	import org.apache.beehive.controls.api.context.ControlBeanContext;
22.	import org.apache.beehive.controls.api.context.ResourceContext;
23.	import org.apache.beehive.controls.api.context.ControlBeanContext.LifeCycle;
24.	import org.apache.beehive.controls.api.events.EventHandler;
25.	
26.	/**
27.	 * JavaMailControlImpl 用于封装访问SMTP邮件服务器发送邮件的操作
28.	 */
29.	@ControlImplementation
30.	public class JavaMailControlImpl implements JavaMailControl, Extensible,
31.			java.io.Serializable {
32.	
33.		static final long serialVersionUID = 1L;
34.	
35.		@Context
36.		ControlBeanContext context;
37.	
38.		@Context
39.		ResourceContext resourceContext;
40.	
41.		private Throwable lastException;
42.	
43.		private Session session;
44.	
45.		private Properties props;
46.	
47.		private String serverAddress;
48.	
49.		private boolean authorizationRequired;
50.	
51.		private String principal;
52.	
53.		private String credentials;
54.	
55.		private MimeMessage mimeMessage;
56.	
57.		private Multipart multipart;
58.	
59.		@EventHandler(field = “context”, 
60.	        eventSet = LifeCycle.class, eventName = “onCreate”)
61.		public void onCreate() {
62.			SMTPServer server = (SMTPServer) context
63.					.getControlPropertySet(SMTPServer.class);
64.			/* 获取SMTP服务器的地址 */
65.			serverAddress = server.serverAddress();
66.			/* 目标SMTP服务器发送邮件时是否需要安全认证 */
67.			authorizationRequired = 
68.	             server.authorizationRequired();
69.			/* 访问目标SMTP服务器时的用户名 */
70.			principal = server.principal();
71.			/* 访问目标SMTP服务器时的密码 */
72.			credentials = server.credentials();
73.	
74.			if (props == null)
75.				props = System.getProperties();
76.	
77.			/* 初始化SMTP服务器地址 */
78.			props.put(“mail.smtp.host”, serverAddress);
79.			/* 初始化访问目标SMTP服务器时是否需要提供安全信息 */
80.			setAuthorizationRequired(authorizationRequired);
81.		}
82.	
83.		/**
84.		 * 返回邮件发送过程中的最后一个违例对象
85.		 */
86.		public Throwable getMailException() {
87.	
88.			return lastException;
89.		}
90.	
91.		/**
92.		 * 根据用户提供的注释和调用方法时传入的参数完成邮件发送的
93.	       动作
94.		 * 
95.		 * @param m
96.		 *            被调用的业务方法
97.		 * @param args
98.		 *            调用业务方法时传递的参数
99.		 */
100.		public Object invoke(Method m, Object[] args) 
101.	        throws Throwable {
102.			Message message = (Message) context.
103.	             getMethodPropertySet(m,Message.class);
104.			/* 获取邮件的接收者 */
105.			String to = message.to();
106.			/* 获取邮件的发送者 */
107.			String from = message.from();
108.			/* 获取邮件抄送的接收者 */
109.			String cc = message.cc();
110.			/* 获取邮件暗送的接收者 */
111.			String bcc = message.bcc();
112.			/* 获取邮件格式 */
113.			String contentType = message.contentType();
114.			/* 获取邮件附件 */
115.			String attachment = message.attachment();
116.			/* 获取邮件主题 */
117.			String subject = message.subject();
118.			/* 获取邮件内容 */
119.			Object body = null;
120.			/* 如果业务方法没有提供发送方法，抛出违例信息 */
121.			if (args.length < 1) {
122.				body = ““;
123.				throw new IllegalArgumentException(
124.					“At most one parameter may be defined as the “
125.	                 + ”body of the Mail message”);
126.			} else
127.				body = args[0];
128.			/* 创建邮件对象 */
129.			createMimeMessage();
130.			/* 设置邮件对象的发送者 */
131.			setFrom(from);
132.			/* 设置邮件对象的接收者 */
133.			setTo(to);
134.			/* 设置邮件对象的抄送接收者 */
135.			setCC(cc);
136.			/* 设置邮件对象的暗送接收者 */
137.			setBCC(bcc);
138.			/* 设置邮件主题 */
139.			setSubject(subject);
140.			/* 设置邮件内容和格式 */
141.			setBody(body, contentType);
142.			/* 设置邮件附件 */
143.			setAttachment(attachment);
144.	
145.			/* 发送邮件 */
146.			sendMail();
147.			return null;
148.		}
149.	
150.		/**
151.		 * 设置访问SMTP服务器时是否需要提供
152.		 * 
153.		 * @param need
154.		 *            访问SMTP服务器时是否需要提供安全信息.
155.	                  true - 需要 ,false - 不需要
156.		 */
157.		private void setAuthorizationRequired(boolean need) {
158.			if (props == null)
159.				props = System.getProperties();
160.	
161.			if (need) {
162.				props.put(“mail.smtp.auth”, “true”);
163.			} else {
164.				props.put(“mail.smtp.auth”, “false”);
165.			}
166.		}
167.	
168.		/**
169.		 * 创建用于发送的邮件对象
170.		 */
171.		private void createMimeMessage() throws Exception {
172.			try {
173.				/* 获得邮件发送上下文 */
174.				session = Session.getDefaultInstance(props, null);
175.			} catch (Exception e) {
176.				e.printStackTrace();
177.				lastException = e;
178.				throw e;
179.			}
180.			try {
181.				/* 创建邮件发送消息对象 */
182.				mimeMessage = new MimeMessage(session);
183.				/* 创建邮件发送对象 */
184.				multipart = new MimeMultipart();
185.			} catch (Exception e) {
186.				e.printStackTrace();
187.				lastException = e;
188.				throw e;
189.			}
190.		}
191.	
192.		/**
193.		 * 设置被发送邮件的内容
194.		 * 
195.		 * @param body
196.		 *            被发送邮件的内容
197.		 * @param contentType
198.		 *            被发送邮件的类型
199.		 */
200.		public void setBody(Object body, String contentType) 
201.	        throws Exception {
202.			try {
203.				BodyPart bodyPart = new MimeBodyPart();
204.				bodyPart.setContent(body, contentType);
205.				multipart.addBodyPart(bodyPart);
206.	
207.			} catch (Exception e) {
208.				e.printStackTrace();
209.				lastException = e;
210.				throw e;
211.			}
212.		}
213.	
214.		/**
215.		 * 设置被发送邮件的主题
216.		 * 
217.		 * @param subject
218.		 *            被发送邮件的主题
219.		 */
220.		public void setSubject(String subject) throws Exception {
221.			try {
222.				mimeMessage.setSubject(subject);
223.	
224.			} catch (Exception e) {
225.				e.printStackTrace();
226.				lastException = e;
227.				throw e;
228.			}
229.		}
230.	
231.		/**
232.		 * 为被发送邮件增加附件
233.		 * 
234.		 * @param attachment
235.		 *            附件的文件路径
236.		 */
237.		public void setAttachment(String attachment) 
238.	        throws Exception {
239.	
240.			try {
241.				BodyPart bp = new MimeBodyPart();
242.				FileDataSource fileds = 
243.	                 new FileDataSource(attachment);
244.				bp.setDataHandler(new DataHandler(fileds));
245.				bp.setFileName(fileds.getName());
246.	
247.				multipart.addBodyPart(bp);
248.			} catch (Exception e) {
249.				e.printStackTrace();
250.				lastException = e;
251.				throw e;
252.			}
253.		}
254.	
255.		/**
256.		 * 设置邮件的发送者
257.		 * 
258.		 * @param from
259.		 *            邮件的发送者email地址
260.		 */
261.		public void setFrom(String from) throws Exception {
262.			try {
263.				mimeMessage.setFrom(new InternetAddress(from));
264.			} catch (Exception e) {
265.				e.printStackTrace();
266.				lastException = e;
267.				throw e;
268.			}
269.		}
270.	
271.		/**
272.		 * 设置邮件的接收者
273.		 * 
274.		 * @param to
275.		 *            邮件的接收者字符串
276.		 */
277.		public void setTo(String to) throws Exception {
278.			try {
279.				mimeMessage.setRecipients(
280.	                javax.mail.Message.RecipientType.TO,
281.					InternetAddress.parse(to));
282.			} catch (Exception e) {
283.				e.printStackTrace();
284.				lastException = e;
285.				throw e;
286.			}
287.	
288.		}
289.	
290.		/**
291.		 * 设置邮件抄送的接收者
292.		 * 
293.		 * @param cc
294.		 *            邮件抄送的接收者字符串
295.		 */
296.		public void setCC(String cc) throws Exception {
297.			try {
298.				mimeMessage.setRecipients(
299.	                javax.mail.Message.RecipientType.CC,
300.					(Address[]) InternetAddress.parse(cc));
301.			} catch (Exception e) {
302.				e.printStackTrace();
303.				lastException = e;
304.				throw e;
305.			}
306.		}
307.	
308.		/**
309.		 * 设置邮件暗送的接收者
310.		 * 
311.		 * @param bcc
312.		 *            邮件暗送接收者字符串
313.		 */
314.		public void setBCC(String bcc) throws Exception {
315.			try {
316.				mimeMessage.setRecipients(
317.	                javax.mail.Message.RecipientType.BCC,
318.					(Address[]) InternetAddress.parse(bcc));
319.			} catch (Exception e) {
320.				e.printStackTrace();
321.				lastException = e;
322.				throw e;
323.			}
324.		}
325.	
326.		/**
327.		 * 发送邮件
328.		 * 
329.		 */
330.		private void sendMail() throws Exception {
331.			try {
332.				/* 设置邮件发送消息对象 */
333.				mimeMessage.setContent(multipart);
334.				/* 保存邮件发送消息对象 */
335.				mimeMessage.saveChanges();
336.	
337.				/* 获取邮件发送上下文 */
338.				Session mailSession = 
339.	                Session.getInstance(props, null);
340.				
341.			/* 根据SMTP服务器对于安全的不同要求连接SMTP服务器 */
342.		      Transport transport = 
343.	              mailSession.getTransport(“smtp”);
344.				if (authorizationRequired)
345.					transport.connect((String) props.get(
346.	                 “mail.smtp.host”),principal, credentials);
347.				else
348.					transport.connect((String) props.get(
349.	                “mail.smtp.host”), ““, ““);
350.	
351.				
352.				/* 发送邮件给所有接收者 */
353.			Address[] tos = mimeMessage
354.		    .getRecipients(javax.mail.Message.RecipientType.TO);
355.			if (tos != null && tos.length > 0) {
356.					System.out.println(“tos.length = “ 
357.	               + tos.length);
358.					transport.sendMessage(mimeMessage, tos);
359.				}
360.				/* 发送邮件给所有抄收的接收者 */
361.				Address[] ccs = mimeMessage.getRecipients(
362.	                       javax.mail.Message.RecipientType.CC);
363.	
364.				if (ccs != null && ccs.length > 0) {
365.					transport.sendMessage(mimeMessage, ccs);
366.					System.out.println(“ccs.length = “ 
367.	                    + ccs.length);
368.				}
369.				/* 发送邮件给所有暗送的接收者 */
370.				Address[] bccs = mimeMessage.getRecipients(
371.	                   javax.mail.Message.RecipientType.BCC);
372.	
373.				if (bccs != null && bccs.length > 0) {
374.					transport.sendMessage(mimeMessage, bccs);
375.					System.out.println(“bccs.length = “ 
376.	                     + bccs.length);
377.				}
378.	
379.				/* 断开与SMTP服务器的连接 */
380.				transport.close();
381.	
382.			} catch (Exception e) {
383.				e.printStackTrace();
384.				lastException = e;
385.				throw e;
386.			}
387.		}
388.	}

　　经过上面的这些步骤以后，JavaMail控件的主体部分就已经全部完成了，我们可以将它编译、打包成jar文件，在另外的应用中使用它。下面的内容将介绍如何使用JavaMail控件完成JavaMail资源访问。

查看本文来源