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

　　Beehive只是提供了三种访问企业资源的系统控件，现实情况下我们需要访问更多类型的企业资源，所以我们需要自己来开发符合自己需要的控件。在这篇文章里，作者将介绍如何基于控件架构开发访问JavaMail资源的控件，简化对JavaMail资源的访问。

　　从前面的文章中，我们已经学习了Beehive中提供的三种访问企业资源的控件：JDBC控件、EJB控件和JMS控件，而这也是Beehive中目前已经提供的全部系统控件。然而J2EE标准中提供的企业资源类型远不止这三种，开发者选择等待Beehive开发组提供更多的控件显然是不明智的，我们必须自己动手来解决控件的开发。

　　本文中就将给大家介绍如何基于控件架构提供的API来开发自己的控件，我们选择开发者经常需要访问的企业资源——JavaMail作为目标资源，按照控件的命名规则，我们暂且叫做JavaMail控件吧。

　　要完成一个控件的设计，通常需要完成如下的工作：

　　确定控件要完成的功能。

　　分析要完成控件的功能，确定没有使用控件之前我们通常需要提供哪些参数，这些参数是否可能组合成集合使用，参数是否必须提供，参数的类型等。

　　根据分析结果，设计和实现对应于这些参数的注释，这些注释能够完整地体现第二步中分析的结果。

　　定义和实现控件公共类

　　根据控件的使用情况，确定控件公共接口类中需要对外提供的接口方法，要确定这些接口方法可能会比较困难，因为有些时候控件设计者可能难于确定是否为控件使用者提供低级接口以便使用者能够深入的控制控件的行为。

　　提供控件实现类

　　控件实现类通常被设计成可扩展（实现org.apache.beehive.controls.api.bean.Extensible接口）的，这样方便使用者扩展该实现类。控件实现类中最主要的方法是invoke(Method m,Object[] args)方法，这个方法的参数 m 代表控件使用者调用的业务方法，而 args 数组则对应着控件使用者调用该业务方法时提供的调用参数，控件实现类需要根据使用者提供的注释和调用业务时提供的参数完成控件主体功能的实现。

　　下面的章节中，我们将详细地讲解如果依照上面的步骤来完成JavaMail控件的设计和开发。本文中所有例子的源代码可以在通过资源下载区中的连接完成下载。

　　控件功能定义

　　JavaMail控件的开发目标是完成访问SMTP服务器发送邮件的封装，提供足够的注释满足开发者在发送邮件时需要设置的参数，同时提供邮件发送的实现方法使开发者在使用控件后无需编写访问SMTP服务器、设置邮件发送者/接收者等参数、发送邮件的代码，而只需要将精力集中到业务逻辑上。

　　需要提供的注释

　　在开发控件之前，我们需要确定向开发者提供哪些注释才能够满足他们定制控件的实际需求，因此我们首先要分析开发者使用这些控件时通常需要提供哪些参数。要访问SMTP服务器发送邮件，开发需要提供的参数分为两类：

　　1.目标SMTP服务器的参数

　　目标SMTP服务器的参数包括目标SMTP服务器的地址，访问SMTP服务器是否需要提供安全信息以及访问SMTP服务器所需要的用户名和密码，其中目标SMTP服务器的地址是必须的。我们需要提供的参数和相关要求如表1所示

　　表1 SMTP服务器参数表

　　参数名 参数类型 参数说明 是否必须提供 说明

　　serverAddress String SMTP服务器的地址 是 比如SMTP服务的地址是mail.vivianj.org

　　authorizationRequired boolean 使用SMTP服务器发送邮件时是否需要提供安全信息 否 如果需要提供安全信息，这个参数设为true，否则设为false

　　principal String 访问SMTP邮件服务器时使用的用户名 否

　　credentials String 访问SMTP邮件服务器时使用的密码 否

　　2.被发送邮件的参数

　　要发送一个邮件，我们需要提供的参数和相关要求如表2所示。

　　表2 邮件参数表

　　参数名 参数类型 参数说明 是否必须提供 例子

　　from String 邮件发送者 是

　　to String 邮件的接收者，可以使用xxx@xx.com,xxx1@xx.com,...的形式传递多个接收者 是 比如我们可以使用king@vivianj.org, guilaida@163.com 来设置邮件有两个接收者

　　cc String 邮件抄送的接收者，可以使用xxx@xx.com,xxx1@xx.com,...的形式传递多个抄送的接收者 否

　　bcc String 邮件暗送的接收者，可以使用xxx@xx.com,xxx1@xx.com,...的形式传递多个暗送的接收者 否

　　subject String 邮件的主题 否

　　contentType String 被发送邮件的格式，默认使用text/plain，另外一种可选的类型是text/html，你还可以在这个参数中加入字符集的设置 否 比如我们可以使用”text/html;charset= GB2312”来设置被发送的邮件使用html格式，编码使用GB2312

　　attachment String 邮件附件 否

　　Content Object 邮件内容 否

　　注释设计、实现

　　从以上两种参数常见的使用场景来看，由于同一个应用中SMTP服务器通常是比较固定的，所以SMTP服务器的参数也是比较固定的，而被发送邮件的参数则随着业务的变化而不断发生变化，充分考虑到这种不同点，我们需要为上面这两种种情况提供不同的注释以及注释的使用范围。

　　SMTPServer注释

　　SMTP服务器参数的注释名为SMTPServer，它可以设计成一个类级别的注释，用于为控件的继承类提供注释。根据前面表1 的分析，SMTPServer必须提供四个参数：serverAddress、authorizationRequired、principal、credentials。

　　由于和JavaMail控件结合非常紧密，SMTPServer注释被设计成控件接口的内部类，清单1 的第26到66行显示了SMTP注释的全部代码，代码中为关键的内容提供了相应的提示信息。

　　Message注释

　　被发送邮件的参数对应的注释名为Message。由于通常和业务方法密切相关，因此我们Message注释被定义成为控件继承类中的业务方法提供注释。

　　根据表2 的分析，Message对象必须提供8个参数，分别是：from,to,cc,bcc,subject,contentType,attachment,Content。其中Content(被发送邮件的参数中邮件内容)比较特殊，因为他会根据环境的不同而发生变化，所以我们将它看作Object类型的变量。在注释中定义Object这种类型没有必要，因此设计时我们不把Content当作的Message注释的属性，而是将它变成业务方法必须提供的参数。

　　Message注释被设计成JavaMail控件接口的内部类，Message注释的全部代码参见清单1 的第66~119行代码。

　　控件接口

　　由于邮件发送的功能比较简单，因此我们的控件接口类并不需要过多的提供接口方法，唯一设计提供的接口方法名为getMailException，它的功能是控件使用者调用时返回邮件发送过程中产生的最后一个违例。清单1 中提供了控件接口类的全部源代码。

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

　　JavaMailControl.java

　　

　　1. package org.vivianj.beehive.controls.examples.javamail;

　　2.

　　3. import java.lang.annotation.ElementType;

　　4. import java.lang.annotation.Inherited;

　　5. import java.lang.annotation.Retention;

　　6. import java.lang.annotation.RetentionPolicy;

　　7. import java.lang.annotation.Target;

　　8.

　　9. import org.apache.beehive.controls.api.bean.AnnotationConstraints;

　　10. import org.apache.beehive.controls.api.bean.AnnotationMemberTypes;

　　11. import org.apache.beehive.controls.api.bean.ControlInterface;

　　12. import org.apache.beehive.controls.api.properties.PropertySet;

　　13.

　　14. /**

　　15. * JavaMailControl 是JavaMail控件的公共接口类

　　16. */

　　17. @ControlInterface

　　18. public interface JavaMailControl {

　　19.

　　20. /**

　　21. * 获取邮件发送过程中产生的最后一个违例

　　22. * @return 返回邮件发送过程中产生的最后一个违例

　　23. */

　　24. public Throwable getMailException();

　　25.

　　26. /**

　　27. * 类级别的注释，用于注释JavaMail控件中目标SMTP服务器的

　　28. 相关信息

　　29. */

　　30. @PropertySet(prefix = “SMTPServer”)

　　31. /* 使用@ Inherited注释表示该注释可以被自动继承 */

　　32. @Inherited

　　33. /* 使用AllowExternalOverride表示定义的接口可以被覆盖 */

　　34. @AnnotationConstraints.AllowExternalOverride

　　35. @Retention(RetentionPolicy.RUNTIME)

　　36. /* 使用TYPE和FIRELD表示该注释能够作用于类、接口

　　37. 以及类成员变量 */

　　38. @Target( { ElementType.TYPE, ElementType.FIELD })

　　39. public @interface SMTPServer {

　　40.

　　41.

　　42. /**

　　43. * SMTP邮件发送服务器的地址，这个属性是必须设置的

　　44. */

　　45. String serverAddress();

　　46.

　　47. /**

　　48. * 使用该SMTP服务器发送邮件是否需要安全认证

　　

　　49. * true - 需要安全认证

　　

　　50. * false - 不需要安全认证

　　51. */

　　52. @AnnotationMemberTypes.Optional

　　53. boolean authorizationRequired() default false;

　　54.

　　55. /**

　　56. * 访问SMTP邮件服务器时使用的用户名

　　57. */

　　58. @AnnotationMemberTypes.Optional

　　59. String principal() default "";

　　60.

　　61. /**

　　62. * 访问SMTP邮件服务器时使用的密码

　　63. */

　　64. @AnnotationMemberTypes.Optional

　　65. String credentials() default "";

　　66. }

　　67.

　　68. /**

　　69. *

　　70. * Message 用于注释继承类中的业务方法，描述被发送邮件的信息

　　71. */

　　72. @PropertySet(prefix = "Message")

　　73. @Inherited

　　74. @AnnotationConstraints.AllowExternalOverride

　　75. @Retention(RetentionPolicy.RUNTIME)

　　76. @Target( { ElementType.METHOD })

　　77. public @interface Message {

　　78.

　　79. /**

　　80. * 邮件的发送者

　　81. */

　　82. String from();

　　83.

　　84. /**

　　85. * 邮件的接收者，可以使用xxx@xx.com,xxx1@xx.com,...的

　　86. 形式传递多个接收者

　　87. */

　　88. String to();

　　89.

　　90. /**

　　91. * 邮件抄送的接收者，可以使用 xxx@xx.com,

　　92. xxx1@xx.com,...的形式传递多个抄送的接收者

　　93. */

　　94. @AnnotationMemberTypes.Optional

　　95. String cc() default "";

　　96.

　　97. /**

　　98. * 邮件暗送的接收者，可以使用xxx@xx.com,

　　99. xxx1@xx.com,...的形式传递多个暗送的接收者

　　100. */

　　101. @AnnotationMemberTypes.Optional

　　102. String bcc() default "";

　　103.

　　104. /**

　　105. * 邮件的主题

　　106. */

　　107. @AnnotationMemberTypes.Optional

　　108. String subject() default "";

　　109.

　　110. /**

　　111. * 被发送邮件的类型，默认使用text/plain

　　112. */

　　113. @AnnotationMemberTypes.Optional

　　114. String contentType()

　　115. default "text/plain;charset=UTF-8";

　　116.

　　117.

　　118. /**

　　119. * 邮件附件

　　120. */

　　121. @AnnotationMemberTypes.Optional

　　122. String attachment() default "";

　　123. }

　　124. }

　　

　　从清单1中提供的源代码中我们注意到，SMTPServer接口的authorizationRequired、principal、credentials属性之前使用了@AnnotationMemberTypes.Optional注释。应用了@AnnotationMemberTypes.Optional注释属性表示用户使用过程中可以不为这些属性提供内容。没有提供@AnnotationMemberTypes.Optional注释的属性（比如serverAddress）被视为必须设置的属性，控件使用者使用该注释时必须提供对应的声明，否则将无法通过编译。

　　控件实现类

　　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资源访问。

　　使用JavaMail控件访问JavaMail资源

　　JavaMail控件本身并不能直接用于发送邮件，控件使用者必须继承该控件，提供对应的注释后才能够完成邮件发送的工作，本章节中将给大家讲解如何继承JavaMail控件来完成邮件发送的工作。

　　1.使用JavaMail控件连接到需要提供安全认证的SMTP服务器

　　网易(NEASE)公司是我个人比较喜欢的提供免费邮箱服务的网络公司。网易(NEASE)公司提供的免费邮箱对应的SMTP服务器(smtp.163.com)需要提供安全认证才能够发送邮件。

　　我们将编写一段代码，调用已经完成的JavaMail控件，访问需要提供安全信息的网易公司的SMTP服务器--smtp.163.com。为了简化例子，我们假设仅仅需要通过这段代码将邮件发送给唯一的一个接收者，不需要暗送或者抄送给其他人，要发送的邮件也没有附件。

　　清单3 中显示了符合要求的一个例子。

　　清单3 src\org\vivianj\beehive\controls\examples\

　　NeaseJavaMailControl.java

　　

　　1. package org.vivianj.beehive.controls.examples;

　　2.

　　3. import org.apache.beehive.controls.api.bean.ControlExtension;

　　4. import org.vivianj.beehive.controls.examples.javamail.JavaMailControl;

　　5.

　　6. /**

　　7. * NeaseJavaMailControl 用于继承JavaMail控件,完成邮件发送的

　　

　　8. * 功能,使用smtp.163.com邮件服务器

　　

　　9. * 使用该SMTP服务器需要提供安全信息

　　10. */

　　11. @ControlExtension

　　12. @JavaMailControl.SMTPServer(serverAddress = "smtp.163.com",

　　13. authorizationRequired = true, principal = "principal",

　　14. credentials = "credentials")

　　15. public interface NeaseJavaMailControl

　　16. extends JavaMailControl {

　　17.

　　18. /**

　　19. * 完成发送邮件的功能

　　

　　20. * 邮件发送者的邮箱是principal@163.com

　　

　　21. * 邮件接收者的邮箱是principal@163.com

　　

　　22. * 邮件主题是hello

　　

　　23. * 邮件的内容由控件使用者在调用时使用参数body传入

　　

　　24. *

　　25. * @param body

　　26. * 邮件的内容

　　27. */

　　28. @JavaMailControl.Message(from = "principal@163.com",

　　29. to = "principal@163.com", subject = "hello")

　　30. public void sendMail(String body);

　　31. }

　　2.使用Java控件连接到不需要提供安全认证的SMTP服务器

　　www.vivianj.org是我创建的唯J族组织负责维护的一个网站，它同时能够为唯J族组织的部分用户提供SMTP服务，它所使用的SMTP服务器(mail.vivianj.org)在发送邮件时不需要用户提供安全认证信息。

　　我们将编写一段代码，调用已经完成的JavaMail控件，连接到不需要提供安全信息的SMTP服务器—mail.vivianj.org后发送邮件。为了简化例子，我们假设仅仅需要通过这段代码将邮件发送给唯一的一个接收者，不需要暗送或者抄送给其他人，要发送的邮件也没有附件。

　　清单4 中显示了符合要求的一个例子。

　　清单4 src\org\vivianj\beehive\controls\examples\

　　VivianjJavaMailControl.java

　　

　　1. package org.vivianj.beehive.controls.examples;

　　2.

　　3. import org.apache.beehive.controls.api.bean.ControlExtension;

　　4. import org.vivianj.beehive.controls.examples.javamail.JavaMailControl;

　　5.

　　6. /**

　　7. * VivianjJavaMailControl 用于继承JavaMail控件

　　

　　8. * 实现通过mail.vivianj.org邮件服务器发送邮件的功能

　　

　　9. * 使用该SMTP服务器不需要提供安全信息

　　10. */

　　11. @ControlExtension

　　12. @JavaMailControl.SMTPServer(

　　13. serverAddress = "mail.vivianj.org",

　　14. authorizationRequired = false, principal = "username",

　　15. credentials = "password")

　　16. public interface VivianjJavaMailControl

　　17. extends JavaMailControl {

　　18.

　　19. /**

　　20. * 完成发送邮件的功能

　　

　　21. * 邮件发送者的邮箱是principal@vivianj.org

　　

　　22. * 邮件接收者的邮箱是principal@163.com

　　

　　23. * 邮件主题是hello

　　

　　24. * 邮件的内容由控件使用者在调用时使用参数body传入

　　

　　25. *

　　26. * @param body

　　27. * 邮件的内容

　　28. */

　　29. @JavaMailControl.Message(from = "principal@vivianj.org",

　　30. to = "principal@163.com", subject = "hello")

　　31. public void sendMail(String body);

　　}

　　

　　结束语

　　Beehive1.0发布的时候，只是提供了三种系统控件：JDBC控件、EJB控件和JMS控件，分别用于访问JDBC数据源、EJB和JMS。然而实际应用情况下，我们通常需要访问更多类型的企业资源，所以我们必须要根据实际情况编写符合实际要求的控件。

　　本文中，作者选择J2EE中常见的JavaMail资源作为例子，详细地介绍了如何基于控件架构分析、设计、实现和访问JavaMail控件的过程。读者可以根据上面的步骤，结合自己的实际需求，编写更多的控件，简化企业应用开发。