bromon原创  请尊重版权

       本文主要讲解何搭建一个mq 6.0 cluster环境。

       Websphere MQ(简称mq)在多个节点之间的通信上，有两种方案，一是利用远程队列进行p2p的通信；一是利用cluster。

       远程队列构造网状的拓普结构：

       这种结构将导致频繁的节点间通信和大量的维护工作，所以很少采用。

       Cluster构造的拓普简单得多：

       位于同一个群集当中的若干队列管理器之间互相通讯时，不需要在每一个队列管理器上创建消息通道、远程队列管理器以及与通道相关的传输队列的定义，相反，我们只需要为每一个队列器上创建群集通道（MQ的通道分为三种类型，即服务器与服务器之间的消息通道，客户端与服务器之间的MQI通道，以及用于群集内部通讯的群集通道）。

       每个mq cluster都以一个仓储库(Repository)为中心，它包含了与该cluster有关的所有信息，这些信息存储在一个名为SYSTEM.CLUSTER.REPOSITORY.QUEUE的队列中。通常应该在一个cluster中选择两个节点来做仓储库，他们之间会互相备份。

       下面演示如何建立一个二节点的mq cluster，cluster的名称是sobey

●    节点一(tom)

       队列管理器名称              tom

       机器ip                       172.16.0.116

●    节点二(jerry)

       队列管理器名称              jerry

       机器ip                       172.16.32.11

步骤一 将tom和jerry指定为cluster的完整仓储库：

       在mq资源管理器中右击“tom”---属性---仓储库---集群的完整仓储库，填入集群名称”sobey”，如图：

以上操作可通过如下命令完成： runmqsc tom        alter  qmgr  repos(sobey)

 

在节点二上执行上述操作，将jerry指定为cluster的完整仓储库

步骤二 建立集群接收通道

       在tom上展开“高级”菜单---通道---新建---集群接收方通道，命名为“to.tom”

       在“连接名称”中输入本机ip或域名，本例为172.16.0.116

       在“集群”菜单中选择“在集群中共享”，并且填如集群名”sobey”。

       其中的“clwl”选项中可以填如0-9，以指定通道的优先级

以上操作可通过如下命令完成： runmqsc tom define  channel(to.tom)  chltype(clusrcvr)  trptype(tcp) conname(172.16.0.116)  cluster(sobey)

 

       在jerry节点上执行类似操作，将接收通道命名为“to.jerry”。

步骤三 建立集群发送通道

       在tom上展开“高级”菜单---通道---新建---集群发送方通道，命名为“to.jerry”，在通道的“连接名称”中输入目的地址的ip或者域名，本例为172.16.32.11

注：发送通道必须与目标地点的接收通道同名

	以上操作可通过如下命令完成： runmqsc define  channel(to.jerry)  chltype(clussdr)  trptype(tcp) conname(172.16.32.11)  cluster(sobey)

 

       在jerry上执行类似操作，建立名为”to.tom”的发送通道。

       分别在两个节点上右击发送通道，选择“启动”。如果建立成功，通道的状态会变为“正在运行”，否则为“正在重试”。

步骤四 建立集群队列

       在任一节点中选择“队列”---“新建”---“本地队列”，在队列的“集群”菜单中，选择“在集群中共享”，并填如集群名“sobey”。

       在“clwl”选项中可以填入0-9，指定队列在cluster中的优先级。

	以上操作可通过如下命令完成： runmqsc define  qlocal(队列名)  cluster(sobey)

 

集群创建完成。

如果要把一个新的节点加入到cluster中，可以按照上述方法，让该节点与任意一个完整仓储库节点建立集群连接即可。

建立JMS集群服务

bromon原创　请尊重版权

　　本问讲解如何在jboss 4.0.2中建立jms消息集群服务器，本文以《jboss 4.0.2集群指南》为基础，请参照阅读。（http://www.blogjava.net/bromon/archive/2005/12/16/24182.html）

　　Jms集群的意义在于提升系统在处理消息时的并发能力，建立这样的集群，有三个步骤：

1、 配置jms消息持久化所使用的数据库
2、 配置分布式的jndi环境
3、 配置分布式jms

　 　在jboss 4.0.2中，系统采用hibernate的方式来保存消息，所以能够兼容hibernate支持的所有数据库。Jboss默认采用hsql，在我们的例 子中，将使用oracle 9.2。首先需要配置连接到数据库的jndi数据源。方法是把doc\examples\jca下的oracle-ds.xml文件拷贝到server\ all\farm下，并且修改其中的参数，保证数据库能够正确连接。Cluster启动后，该文件能够通过jboss的farm服务，自动拷贝到其他集群 节点，并且自动部署。假设jndi数据源的名称为：GlobalDS将doc\examples\jms下的oracle-jdbc3- service.xml文件拷贝到server\all\deploy-hasingleton\jms目录下，并且删除该目录下的hsqldb- jdbc2-service.xml。修改oracle-jdbc3-service.xml，在56行左右指定name的值为数据源的名字： GlobalDS。这样系统会使用该数据源来保存jms消息。

使用如下命令启动boss: run –c all

启动完成后，正常情况下会发现oracle数据库中多出了三张表：
1、Jms_message_log  该表用于保存所有未处理的点对点消息，表结构是：
　　　 Messageid   消息id
　　　Destination  目的地
　　　Txid   事务id
　　　Txop   消息操作类型(a为新增，d为删除)
　　　Messageblob  消息内容

2、JMS_REFERENCE_LOG 用于保存所有未处理的topic消息，表结构是：
　　　Messageid
　　　Destination
　　　Txid
　　　Txop
　　　Messageblob
　　　Redelivered  消息是否被重发

3、JMS_TRANSACTION_LOG 用于保存处理消息过程中的一些重要的事务

　　需要注意的是，jboss 3.2之后就不在支持以文件形式保存消息，虽然这样最会比数据库操作快一倍以上。Jboss官方的解释是，使用文件会让系统不可靠。

　 　客户端在发送jms消息的时候，首先需要向app server查询jndi，在jboss cluster中，jndi是作为一个分布式的singleton出现的。每个节点除了有自己的jndi环境以外，整个cluster还具有一些全局的 jndi，客户端在进行jndi查询的时候，只需要向这个全局的jndi进行查询，cluster如果在全局jndi中找不到对应的jndi对象，就会按 次序向每个节点询问，看他们的本地jndi中是否有匹配的对象，如果有则返回给客户，如果所有的节点都没有，则抛出异常。所有以all方式启动的 jboss，都会打开1100端口，这个端口是全局jndi的入口，所有节点都是如此。

　　分布式的jndi有的节点有主次的区别，第一个 启动的jboss是主服务器，它会保存所有的全局jndi，其他的节点如果收到客户查询jndi的请求后，都会向主服务器请求数据。如果主服务器不幸 down掉，那么次节点会发现这个变化，然后启动自己的jndi环境，取代主服务器提供服务。

　　下面是配置jms的jndi，打开server\all\deploy-hasingleton\jms下的jbossmq-destinations-

service.xml文件，增加一个名为test的destination，如下：
  name="jboss.mq.destination:service=Queue,name=test">
   

name="DestinationManager">jboss.mq:service=DestinationManager
 

　　为了预防主服务器down了之后丢失该jndi，所以最好在每个节点都进行这个配置。

　　在jboss 4.0.2的默认配置下，是不支持消息bean的集群的，要达到这个目的，必须下载一个jar包才能实现，可以从这里获得: http://blog.yam.com/bromon/archives/489460.html

　　得到这个jar文件后，将它命名为cdot-jbossx.jar　文件放到server\all\deploy\jms下。下面编写消息bean，它的功能很简单，接收到来自test队列的消息后，打印消息id。

public class TestJmsBean
    implements MessageDrivenBean, MessageListener {
  MessageDrivenContext messageDrivenContext;
  public void ejbCreate() {
    System.out.println("消息bean创建");
  }

  public void ejbRemove() {
  }

  public void onMessage(Message msg) {
    try
    {
      System.out.println(msg.getJMSMessageID());
    }catch(Exception e)
    {
      e.printStackTrace();
    }
  }

  public void setMessageDrivenContext(MessageDrivenContext messageDrivenContext) {
    this.messageDrivenContext = messageDrivenContext;
  }
}

　　把这个消息bean部署到server\all\farm目录下，它会被自动拷贝到cluster的其它节点，并且被自动部署，你会

看到如下部署信息：

　　上面显示通过farm的方式，部署了一个名为GlobalDS的连接池，以及一个名为TestJms的消息bean。

下面写个客户端来测试一下：

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
      Properties p = new Properties();
      p.put(Context.INITIAL_CONTEXT_FACTORY,
            "org.jnp.interfaces.NamingContextFactory");
      p.put(Context.URL_PKG_PREFIXES, "jboss.naming:org.jnp.interfaces");
      p.put(Context.PROVIDER_URL, "172.16.0.116:1100"); // 全局jndi入口
      InitialContext ctx = new InitialContext(p);
      QueueConnectionFactory qcf = (QueueConnectionFactory) ctx.lookup(
          "ConnectionFactory");
      QueueConnection conn = qcf.createQueueConnection();

      Queue q = (Queue) ctx.lookup("queue/test");//查询名为test的destination
      QueueSession session = conn.createQueueSession(false,
          QueueSession.AUTO_ACKNOWLEDGE);
      conn.start();
      QueueSender sender = session.createSender(q);
      for (int i = 0; i < 10000; i++) {
        TextMessage tm = session.createTextMessage(sdf.format(new Date()));
        sender.send(tm, DeliveryMode.PERSISTENT, 4, 0);//发送持久化消息
        System.out.print("第" + i);
      }

      conn.stop();
      session.close();
      conn.close();

　　 执行一下，可以看到每个节点都创建了若干个消息bean，同时在处理消息，任意关闭一个次服务器，系统会自动fail over。查看Jms_message_log数据表，里面没有任何数据，表示所有的消息都已经被处理。
 Jboss 的jms cluster功能与websphere mq比较起来，是非常简陋的，可以配置的地方也很少，毕竟是免费的东西。Jboss的论坛上透露，在jboss 6.0中将会有全新的jboss messaging服务，不知要等到何年何月。针对这个cluster，我做过简单的测试，800万左右的消息数量，无一丢失，应该说还算比较可靠。响应 时间也还过的去，在简单的网络环境下，能够应付比较高的并发。

bromon原创 请尊重版权

       最近的工作都是在webligc 8.1 + hibernate的平台上做开发，涉及的数据库是oracle 9.2和db2 8.1。对于这两个数据库我的了解都远远不够，所以开发中遇到很多问题，还好问题都解决了，很感谢阿古。有的问题也许大家都会遇到，列出我的解决办法，供大家参考。

一、weblogic 8.1下的数据库连接池配置

weblogic 8.1下配置连接池是很容易的，通过console全鼠标操作。以前我做过很多次了，驾轻就熟，很快搞定。编写好pojo和hbm，test一下，结果抛出了一个SQLException，具体信息我没有记录，大概意思是说：“事务没有被提交，因为它处于一个分布式事务中，当分布式事务结束后它会被提交。”打开oracle，确实没有看到测试数据，整个环境中我没有使用JTA，也不存在分布式数据库。Google了一下，看见别人的建议有：

1、              选择jdbc驱动的时候，不要使用xa系列驱动。这个其实大家都知道，xa系列驱动是为JTA准备的，我在配置连接池的时候也确实没有选择这类驱动。排除。

2、              修改startWeblogic.cmd，不要启动pointbase。查看startWeblogic.cmd后没有发现有启动pointbase的迹象，在端口列表中也没有发现。排除。

后来找到的解决办法是，配置webloigc的data source时，有这么一个选项：

Honor Global Transactions

它的相关说明是：

Specifies whether this data source will participate in existing global (XA) transactions. Unchecking this option while creating the data source should be done rarely and with care. This option can not be changed once the data source is created.

       就是它了，把它去掉，try again，passed。 

       上述问题在oracle和db2中都存在。

二、时间字段的处理

开发过程中涉及到了时间的存储和查询，相关的处理要依靠oracle和db2自己的函数，有小小区别。

一个hibernate中对oracle进行时间查询的例子:

from scene.pojo.TaskInfo as ti where and ti.taskStartTime>=to_date('"+start+"','yyyy-MM-dd HH:mi:ss') and ti.taskEndTime<=to_date('"+end+"','yyyy-MM-dd HH:mi:ss')";

       其中的start和end变量为java.util.Date()。使用了oracle的to_date函数来做日期转换，很多java程序员也许会和我一样，直觉的采用”yyyy-MM-dd HH:mm:ss”的格式作为时间的正则表达式，但是在oracle中会引起错误：”ORA 01810 格式代码出现两次”。原因是sql中不区分大小写，MM和mm被认为是相同的格式代码，所以oracle的sql采用了mi代替分钟。

       DB2中的查询语句是：

from scene.pojo.TaskInfo as ti where and ti.taskStartTime>=timestamp('"+s+"')  and ti.taskEndTime<=timestamp('"+e+"')";

       DB2中的函数是timestamp，无须指定时间格式。

三、Hibernate的lazy loading

Lazy loading是进行集合映射时很有用处的优化选项，但是使用起来容易遇到问题。比如在我们的应用中，user->post形成一对多的映射，User中有一个包含post的List。同时系统采用了一个HibernateSession来管理session，它的逻辑是每进行一次数据库操作，就开新的session，操作完成后立即关闭该session。这样做的好处是可以严格关闭session，避免菜鸟级的错误，但是hibernate.org并不推荐这么做。因为这不适合lazy loading，也不适合跨方法的事务。

回到我们的例子，在User中，有多个属性：name，password，phone等，还有一个List类型的posts。当我们对posts使用lazy laoding的时候，hibernate会在获得User对象的时候，仅仅返回name,password,phone等基本属性，当你访问posts的时候，它才会从数据库中提取posts需要的数据，这就是所谓lazy laoding。但是在我们的系统中，session是被立即关闭的，也就是在读取了name,password,phone等基本属性后，session已经close了，再进行lazy loaiding就会有异常。

解决办法是在close session之前，调用Hibernate.initialize(user.getPosts())，告诉系统，user.getPosts()是需要lazy laoding的。但是这样做会破坏HibernateSession类的封装，郁闷。

后来采用所谓的OpenSessionInView模式，把session的周期交给servlet filter来管理，每当有request进来，就打开一个session，response结束之后再关闭它，这样可以让session存在于整个请求周期中。但是在实际操作过程中，发现一下问题：

Lazy laoding应该是两条select构成的，但是在使用了OpenSessionInView模式后，系统执行了一条select，session就被关闭了。相同的代码，放到普通环境中，就执行正常，目前这个问题已经在java eye挂了很久，无人解答。望高人指点。

Bromon原创 请尊重版权

　　任何需要交给spring管理的对象，都必须在配置文件中注册，这个过程被称为wiring，下面做一个最简单的Hello world演示，我们将要注册的类如下：

/**//*
 * 创建日期 2005-3-22
 */
package org.bromon.spring.test;

/**//**

 * @author Bromon

 */

public class HelloTalker 

{
    public String greeting()

    {

        return "hello world";

    }
}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
 <bean id=”helloTalker” class=” org.bromon.spring.test.HelloTalker”>
 </bean>
</beans>

　　通过使用bean标签，注册了一个HelloTalker对象，它的名字叫做helloTalker。然后我们编写一个测试类，它的工作是利用spring框架提供的接口，加载配置文件，通过指定对象的id，获得一个对象。它的代码如下：

/**//*
 * 创建日期 2005-3-17
 */

package org.bromon.spring.test.junit;

import java.io.FileInputStream;

import org.springframework.beans.factory.xml.XmlBeanFactory;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.bromon.spring.test;
/**//**
 * @author Bromon
 */

public class TestStudentManager extends TestCase {
    public void testHelloTalker() 
    {
        try
        {
            ApplicationContext context =new ClassPathXmlApplicationContext("springConfig.xml");

HelloTalker ht=(HelloTalker)context.getBean(“helloTalker”);

System.out.println(ht.greeting());

        }catch(Exception e)

        {

            e.printStackTrace();

        }

    }
}

　　第一步是修改HelloTalker，增加一个String name属性：

public String name;

　　为该属性编写set方法，该方法必须严格遵守javabean的命名规则：

　　修改greeting方法：

　　第二步，修改springConfig.xml中唯一的这个bean配置：

        <value>bromon</value>

    </property>

</bean>

　　修改完成。我们将一个名字”bromon”写死在springConfig.xml中，它会被动态的注入到HelloTalker的name属性中，greeting方法将会把它打印出来。重新运行刚才的junit类，可以看到结果。

　　我们只演示了如何注入一个最简单的String，实际上我们可以注入任何值类型，也可以注入任何类的实例，也可以注入List、Map、Properties。配置文件管理了所有的对象和对象间的关系，而对象则只负责执行自己的功能，他们的职责越少，藕合度越低，系统就越容易测试，管理维护也更容易。

　　<bean>标签还有很多属性，用于指定对象如何被实例化，它也有很多子标签用于配置对象的属性，请大家参考相关的DTD和文档，能够很快的掌握。本系列文章不是spring手册，spring的基础知识请参考spring in action，足够详细准确。后面的章节更多的讨论系统设计、开发的一些细节和高级特性。

下一篇：在spring中进行hibernate开发

Bromon原创 请尊重版权

　　当前的形势是，非常多的Java程序员言必称Spring，如此大面积的程序员集体叫”春”，体现了Spring框架的威力。春天正是叫春的好时候，你我一起来叫春吧。^_^

　　Spring的设计目的是简化J2EE开发，所以如果我们学习、使用它的时候还需要抓破头皮口吐白沫的话，岂不是个笑话？就我的经验来说，Spring在这方面做得很好，的确是一个很牛叉易用的框架。

　　之前我曾经设计过一个J2EE的考试系统，大量使用了EJB（详见http://blog.csdn.net/bromon/archive/2004/08/27/86291.aspx），我打算同样使用一个考试系统做例子，便于比较。两个系统的大致结构都差不多，不过新的版本采用了轻量级的方案，使用Hibernate作为ORM框架，所有的对象都交给spring来管理。

一、IoC与DI

　　首先想说说IoC（Inversion of Control，控制倒转）。这是spring的核心，贯穿始终。所谓IoC，对于spring框架来说，就是由spring来负责控制对象的生命周期和对象间的关系。这是什么意思呢，举个简单的例子，我们是如何找女朋友的？常见的情况是，我们到处去看哪里有长得漂亮身材又好的mm，然后打听她们的兴趣爱好、qq号、电话号、ip号、iq号………，想办法认识她们，投其所好送其所要，然后嘿嘿……这个过程是复杂深奥的，我们必须自己设计和面对每个环节。传统的程序开发也是如此，在一个对象中，如果要使用另外的对象，就必须得到它（自己new一个，或者从JNDI中查询一个），使用完之后还要将对象销毁（比如Connection等），对象始终会和其他的接口或类藕合起来。

　　那么IoC是如何做的呢？有点像通过婚介找女朋友，在我和女朋友之间引入了一个第三者：婚姻介绍所。婚介管理了很多男男女女的资料，我可以向婚介提出一个列表，告诉它我想找个什么样的女朋友，比如长得像李嘉欣，身材像林熙雷，唱歌像周杰伦，速度像卡洛斯，技术像齐达内之类的，然后婚介就会按照我们的要求，提供一个mm，我们只需要去和她谈恋爱、结婚就行了。简单明了，如果婚介给我们的人选不符合要求，我们就会抛出异常。整个过程不再由我自己控制，而是有婚介这样一个类似容器的机构来控制。Spring所倡导的开发方式就是如此，所有的类都会在spring容器中登记，告诉spring你是个什么东西，你需要什么东西，然后spring会在系统运行到适当的时候，把你要的东西主动给你，同时也把你交给其他需要你的东西。所有的类的创建、销毁都由spring来控制，也就是说控制对象生存周期的不再是引用它的对象，而是spring。对于某个具体的对象而言，以前是它控制其他对象，现在是所有对象都被spring控制，所以这叫控制反转。如果你还不明白的话，我决定放弃。

　　IoC的一个重点是在系统运行中，动态的向某个对象提供它所需要的其他对象。这一点是通过DI（Dependency Injection，依赖注入）来实现的。比如对象A需要操作数据库，以前我们总是要在A中自己编写代码来获得一个Connection对象，有了spring我们就只需要告诉spring，A中需要一个Connection，至于这个Connection怎么构造，何时构造，A不需要知道。在系统运行时，spring会在适当的时候制造一个Connection，然后像打针一样，注射到A当中，这样就完成了对各个对象之间关系的控制。A需要依赖Connection才能正常运行，而这个Connection是由spring注入到A中的，依赖注入的名字就这么来的。那么DI是如何实现的呢？Java 1.3之后一个重要特征是反射（reflection），它允许程序在运行的时候动态的生成对象、执行对象的方法、改变对象的属性，spring就是通过反射来实现注入的。关于反射的相关资料请查阅java doc。

　　理解了IoC和DI的概念后，一切都将变得简单明了，剩下的工作只是在spring的框架中堆积木而已。

下一篇：spring管理对象的简单例子

Bromon原创 请尊重版权

       有非常多的时候，我们希望自己的程序能够监视数据的变化，然后做出响应，这种情况非常多，比如探测数据库中数据的变化、检测用户状态的变化等等。通常我们都缺乏一种双工通信的机制，只能选择让程序做论询，隔一段时间检测一次数据变化，记录下来与上一次检测结果做对比，从而判断数据是否发生了变化。毫无疑问这样的方式很笨拙，不仅写起来痛苦，跑起来也耗资源，是典型的用80%的时间解决20%的问题。

       观察者(Observer)是一种模式，也是Java中的一个API，它让一个值对象(Value Object)具备自省的功能，当他发现自己的状态改变了，就向相关的对象发送消息，这样的监听方式当然比轮询好。我感冒了自己会去医院，用不着医生每个月来问一次。禽兽·宇枫曾经给了我一段麻将游戏的服务器端代码，本来是让我研究一下麻将的算法，但是却被其中Observer的使用所吸引，这样写出来的服务器执行效率很高。我曾经用线程池+反射+观察者写了一个即时消息的服务器，既有socket的方便也具备udp的高效，可惜后来因为大幅修改设计代码作废了，不过观察者还是值得研究。

       Java的Observer API是对观察者模式的一个实现。假设我们有一个对象容器，其中存放用户消息，我希望这个容器自省，当有新的消息进来就自动触发观察者作出响应。首先定义消息对象，是个很简单的值对象：

package com.gwnet.smsMessenger.mm.bromon; 

public class Message 
{ 
    private int id; 
    private String sender; 
    private String receiver; 
    private String content; 
    private String time; 
    //请自己实现set/get方法
} 

然后写一个存放Message的容器，容器使用ArrayList来存放对象是个很好的选择，也很简单：

/**//* 
* Created on 2004-8-11 
*/ 
package com.gwnet.smsMessenger.mm.bromon; 
import java.util.*; 
/**//** 
* @author Bromon 
*/ 
public class MessageList extends Observable 
{ 
    private List m=new ArrayList(); 
    private static MessageList ml=null; 

    public MessageList() 
    { 
    } 

    public static MessageList getInstance() 
    { 
        if(ml==null) 
       { 
           ml=new MessageList(); 
       } 
        return ml; 
    } 

    public void add(Message msg) 
    { 
        m.add(msg); 
        super.setChanged(); 
        super.notifyObservers(m); 
    } 

    public void del(Message msg) 
    { 
        m.remove(msg); 
    } 
} 

　　这个类继承了Observable类，并且对其中的add方法做了手脚，很明显，add方法的作用是向ArrayList容器中放入一个对象，这正是我们想监听的操作，所以有了:

uper.setChanged();

super.notifyObservers(m);

　　这意思是一旦调用add方法，这个类自己就会向所有注册过的观察者发送消息，消息内容是什么呢？内容就是m，是存放消息的容器，观察者可以收到这个改变了状态的容器，然后对它进行操作，从而实现了对容器的监听，当然，我们只实现了对add方法的监听，你也可以试试其他的。

　　需要特别注意的是这是一个不完整的单例类，写成单例是为了要保证整个jvm中只有这一个存放消息的容器，而不写成完整的单例，原因是将来可能要提供另外的实例化方法。所以理解起来可能稍微难一点，大家可以参考一下设计模式中的单例模式。

下面就是编写观察者并且注册它：

/**//* 
* Created on 2004-8-11 
*/ 
package com.gwnet.smsMessenger.bromon; 
import java.util.*; 
/**//** 
* @author Bromon 
*/ 
public class MessageObserver implements Observer 
{ 
    /**//* (non-Javadoc) 
     * @see java.util.Observer#update(java.util.Observable, java.lang.Object) 
     */ 
    public void update(Observable arg0, Object arg1) 
    { 
       List l=(List)arg1; 
        Message m=(Message)l.get(l.size()-1); 
        String receiver=m.getReceiver(); 
        System.out.println("给"+m.getReceiver()+”的新消息:”+m.getContent()); 
    } 
} 

　　这个类继承Oberver接口，update(Observable,Object)是必须提供的方法，在这个方法中我们接收被观察类传过来的数据（含有消息的容器），然后取出其中最后一个，读取它的内容。

　　Java里的观察者使用起来是非常简单的。我们的例子好处是所有的操作都在内存中进行，而且不需要轮询，效率非常高，缺点是一旦当机内存中的数据就丢失了，所以如果有一套比较完善的对象缓冲机制，就可以应付复杂的应用，写出高效简洁的多线程服务器。

　　异步通信是一个提升程序执行效率的很重要的手段，而性能问题又是EJB诞生以来一直都很受关注的话题。EJB执行效率不高的原因是客户端需要查询和调用远程接口，而本身在处理数据是很快的，毕竟EJB有比较完善的缓冲机制，几十万的app server也不是白吃内存的。客户端程序如果能够采用异步通信，只负责以消息的形式发送请求和需要处理的数据，不用等待系统查询、调用远程接口，可以节省大量时间，这也是EJB 2.0中引入消息驱动Bean的一个重要原因。J2EE的消息机制允许你以消息的形式传递对象，我们可以利用它实现很多应用。

　　在最近正在写的一个考试系统中，系统把学生对每一个题目的回答都实时记录到数据库，这样做会有比较频繁的数据库操作，对性能有比较大的影响，但是可以让学生的每一次答题都得到永久性保存，避免因为意外死机或异常退出造成学生提交的答案丢失。毫无疑问，数据的安全可靠是第一位的，但是上百个学生并发操作，这个负载也是很巨大的。为了在稳定和性能上谋求平衡，我们考虑这样一种模型：

　　◆在服务器端建立一个永久性的队列，该队列可以保证数据安全，即使服务器意外重启，里面的对象也不丢失。并且有一种机制保证队列中的对象只会被处理一次。

　　◆客户端把答案数据封装成javabean，然后提交到这个队列中，提交之后不必等待数据处理完成，直接进行以后的操作，产生新的数据后继续往队列里存放，不必去关心数据什么时候会被处理。

　　◆服务器以FIFO的顺序处理队列中的数据包。

结构大致如下图：

　　很明显，这里只提供一种单向通信，但是并非被迫，完全可以在建立另外一个队列，存放返回的消息，对应的消息通过消息ID进行关联。以消息bean为核心的java消息服务(JMS)实际上就是这样一个框架。

　　首先设计一个操作答案数据表的类：

　　它包含增加答案的方法和修改已有答案的方法，在实际的项目中，它由一个映射数据表的CMP Entity Bean和一个封装程序逻辑的SessionBean构成，是一个典型的session facade模式。实际的系统大致是这样：

　　在一个系统中同时使用CMP和Hibernate来做映射，是一个非常怪异的设计，这样做只是为了使系统更有研究和讨论的价值，实际应用中恐怕我自己也要仔细考虑是否采用BMP代替Hibernate。

　　编写消息bean之前，首先定义消息中要传递的是什么对象：

下面是消息Bean的代码：

/**//*
* 消息bean，处理针对Answer的操作
* Created on 2004-7-27
*/
package org.bromon.examer.message;

import javax.ejb.MessageDrivenBean;
import javax.jms.*;
import org.bromon.examer.base.*;
import org.bromon.examer.session.*;

public class AnswerMessageBean implements MessageDrivenBean, MessageListener
{
    private javax.ejb.MessageDrivenContext messageContext = null;
//定义上下文
public void setMessageDrivenContext(
javax.ejb.MessageDrivenContext messageContext)
throws javax.ejb.EJBException
{
this.messageContext = messageContext;
}

public void ejbRemove()
{
messageContext = null;
}

//收到消息后将执行这个方法
public void onMessage(javax.jms.Message message)
{
try
{
if(message instanceof ObjectMessage)
{
AnswerOperate ap=(AnswerOperate)((ObjectMessage)message).getObject();
//调用EJB对AnswerOperate对象进行处理
}
System.out.printn("消息处理完毕");
}catch(Exception e)
{
System.out.println(e);
}
}

}

　　消息如何保障安全呢？有两个手段，一是使用消息验证，客户必须提供匹配的帐号密码才能访问消息中的数据。二是对消息中的对象加密，客户必须持有对应的密钥才能获得对象。

package org.bromon.test;
public interface DB
{
java.sql.Connection openDB(String url,String user,String password);
void close();
}

　　这个接口只定义两个方法，没有任何有实际意义的代码，具体的代码由实作这个接口的类来给出，比如Mysql.java：

Package org.bromon.test;
import java.sql.*;
public class Mysql implements DB
{
private String url=”jdbc:mysql:localhost:3306/test”;
private String user=”root”;
private String password=””;
private Connection conn;
public Connection openDB(url,user,password)
{
//连接数据库的代码
}

public void close()
{
//关闭数据库
}
}

　　类似的当然还有Oracle.java等等，接口DB给这些类归了个类，在应用程序中我们这样定义对象：

org.bromon.test.DB myDB;

　　使用myDB来操作数据库，就可以不用管实际上我所使用的是哪个类，这就是所谓的“开-闭”原则。但是问题在于接口是不能实例化的，myDB=new DB()，这样的代码是绝对错误的，我们只能myDB=new Mysql()或者myDB=new Oracle()。麻烦了，我还是需要指定具体实例化的是哪个类，用了接口跟没用一样。所以我们需要一个工厂：

package org.bromon.test;
public class DBFactory
{
　　public static DB Connection getConn()
　　{
　　　　Return(new Mysql());
　　}
}

　　所以实例化的代码变成：myDB=DBFactory.getConn()；
　　这就是23种模式中最基础的普通工厂(Factory)，工厂类负责具体实例化哪个类，而其他的程序逻辑都是针对DB这个接口进行操作，这就是“针对接口编程”。责任都被推卸给工厂类了，当然你也可以继续定义工厂接口，继续把责任上抛，这就演变成抽象工厂(Abstract Factory)。

　　整个过程中接口不负责任何具体操作，其他的程序要连接数据库的话，只需要构造一个DB对象就OK，而不管工厂类如何变化。这就是接口的意义----抽象。

　　继承的概念不用多说，很好理解。为什么要继承呢？因为你想重用代码？这绝对不是理由，继承的意义也在于抽象，而不是代码重用。如果对象A有一个run()方法，对象B也想有这个方法，所以有人就Class B extends A。这是不经大脑的做法。如果在B中实例化一个A，调用A的Run()方法，是不是可以达到同样的目的？如下：

Class B
{
A  a=new A();
a.run();
}

　　这就是利用类的聚合来重用代码，是委派模式的雏形，是GoF一贯倡导的做法。

　　那么继承的意义何在？其实这是历史原因造成的，最开始的OO语言只有继承，没有接口，所以只能以继承来实现抽象，请一定注意，继承的本意在于抽象，而非代码重用（虽然继承也有这个作用），这是很多Java烂书最严重的错误之一，它们所造成的阴影，我至今还没有完全摆脱，坏书害人啊，尤其是入门类的，流毒太大。什么时候应该使用继承？只在抽象类中使用，其他情况下尽量不使用。抽象类也是不能实例化的，它仅仅提供一个模版而已，这就很能说明问题。

　　软件开发的万恶之源，一是重复代码而不是重用代码，二是烂用继承，尤以c++程序员为甚。Java中取缔多重继承，目的就是制止烂用继承，实是非常明智的做法，不过很多人都不理解。Java能够更好的体现设计，这是让我入迷的原因之一。

/**//*
*@Author bromon
*2004-6-12
*/
package org.bromon.test;

import javax.servlet.*;
import javax.servlet.http.*;

public class SessionCount implements HttpSessionListener
{
private static int count=0;

public void sessionCreated(HttpSessionEvent se)
{
count++;
System.out.println(“session创建：”+new java.util.Date());
}

public void sessionDestroyed(HttpSessionEvent se)
{
count--;
System.out.println(“session销毁:”+new java.util.Date());
}

public static int getCount()
{
return(count);
}
}

　　怎么样，是不是一目了然？count被定义为static，是因为要保证整个系统只有这一个count。如果你实在不放心，可以把它写成一个单例类。

然后在web.xml中声明这个监听器：
<listener>
<listener-class>
org.bromon.test.SessionCount
</listener-class>
</listener>

编写一个测试页面test.jsp，内容是获得count：
<%
int count=org.bromon.test.SessionCount.getCount();
out.println(count);
%>

　　需要注意的是，这里根本不涉及任何session的操作。重启动App server，试着连接test.jsp，可以看到监听器已经开始工作。

2、 Attribute监听
　　作为一个站内消息系统，肯定要获得所有登陆者的ID，才有可能互发消息。这就涉及Attribute监听。假设我们写了个用户登陆的模块，用户通过身份验证之后会产生一个session，保存它的相关信息，比如：
//check.jsp
<%
String name=request.getParameter(“name”);
Name=new String(name.getBytes(“ISO8859-1”));
session.setAttribute(“user”,name);
%>

　　做过jsp的兄弟应该对这段代码再熟悉不过了，下面写个监听器来监听用户登陆，把所有用户的ID保存到一个List当中，这个监听器实作HttpSessionAttributeListener接口：

/**//*
*@Author bromon
*2004-6-12
*/
package org.bromon.test;

import javax.servlet.*;
import javax.servlet.http.*;
import java.util.*;

public class OnlineList implements HttpSessionAttributeListener
{
private static List list=new ArrayList();

public void attributeAdded(HttpSessionBindingEvent se)
{
if(“user”.equals(se.getName()))
{
list.add(se.getValue());
}
}

public void attributeRemoved(HttpSessionBindingEvent se)
{
if(“user”.equals(se.getName()))
{
list.remove(se.getValue());
}
}

public void attributeReplaced(HttpSessionBindingEvent se){}

public static List getList()
{
return(list);
}
}

写个简单的jsp来得到用户列表：
<%
java.util.List list=org.bromon.test.OnlineList.getList();
out.println(“共有”+list.size()+”名用户已登陆：”);
for(int I=0;I<lise.size();i++)
{
out.println(list.get(i));
}
%>

也许你说，这有什么神奇呢，监听session而已，不着急，看看xmlhttp。

二、 XMLHTTP

　　XMLHTTP的用处很多，这里只说我们需要的，就是无刷新的与server通信，看这段代码：

<script language="javascript"> 
xml = new ActiveXObject("Microsoft.XMLHTTP"); 
var post=" ";//构造要携带的数据 
xml.open("POST","http://localhost:7001/TestWL/index.jsp",false);//使用POST方法打开一个到服务器的连接，以异步方式通信 
xml.setrequestheader("content-length",post.length); 
xml.setrequestheader("content-type","application/x-www-form-urlencoded"); 
xml.send(post);//发送数据 
var res = xml.responseText;//接收服务器返回的数据 
document.write(res); 
</script>

　　豁然开朗，这段代码就是打开一个HTTP连接，以标准的HTTP格式传递数据，如果你喜欢，可以用XML的格式来传递。更改一下xml对象的构造方式就可以兼容Mozilla和Netscape。下面来写一个轮询，每隔一段时间刷新一次用户列表，当然，是不需要刷新页面的：

<html>
<head><title>探测器</title>
<script language="javascript">
function detect()
{
xml = new ActiveXObject("Microsoft.XMLHTTP"); 
var post=" ";//构造要携带的数据 
xml.open("POST","http://localhost:7001/TestWL/index.jsp",false);//使用POST方法打开一个到服务器的连接，以异步方式通信
xml.setrequestheader("content-length",post.length); 
xml.setrequestheader("content-type","application/x-www-form-urlencoded"); 
xml.send(post);//发送数据 
var res = xml.responseText;//接收服务器返回的数据 
list.innerText=res;
setTimeout(“detect()”,5000);//每隔5秒钟轮询一次
} 
</script>
<body onload=”detect()”>
<a id=”list”></a>
</body>
</html>

　　这样的通信方式数据量很小，不用重新传递整个页面，5秒钟轮一次，普通PC也能承受较大的在线数。构造一个探测器来监听在线列表和消息，效果是很好的，即使你的客户坐在电脑前袖手旁观，键鼠都不碰一下，也能保证数据即时传递，页面也不会发生跳转和刷新。

Session监听加上XMLHTTP通信，开发一个较为完善的站内消息系统实在易如反掌。

 bromon原创 版权所有

　　MS的电子表格（Excel）是Office的重要成员，是保存统计数据的一种常用格式。作为办公文档，势必要涉及到的电子文档的交换，Excel是一种在企业中非常通用的文件格式，打印和管理也比较方便。在一个Java应用中，将一部分数据生成Excel格式，是与其他系统无缝连接的重要手段。

　　在开源世界中，有两套比较有影响的API可供使用，一个是POI，一个是jExcelAPI。其中jExcelAPI是一个韩国程序员的作品，虽然没有POI那样血统高贵，但是在笔者的使用过程中，感觉简单方便，对中文支持非常好，功能也比较强大。它的下载地址是：http://www.andykhan.com/jexcelapi/  当前的最高版本是2.4。作者的网站上对它的特征有如下描述：

 ● 支持Excel 95-2000的所有版本
 ● 生成Excel 2000标准格式
 ● 支持字体、数字、日期操作
 ● 能够修饰单元格属性
 ● 支持图像和图表

　　应该说以上功能已经能够大致满足我们的需要。最关键的是这套API是纯Java的，并不依赖Windows系统，即使运行在Linux下，它同样能够正确的处理Excel文件。另外需要说明的是，这套API对图形和图表的支持很有限，而且仅仅识别PNG格式。

 　　搭建环境

　　将下载后的文件解包，得到jxl.jar，放入classpath，安装就完成了。

　　基本操作

 一、创建文件

　　拟生成一个名为“测试数据.xls”的Excel文件，其中第一个工作表被命名为“第一页”，大致效果如下：

 代码（CreateXLS.java）：

//生成Excel的类
 import java.io.*;
 import jxl.*;
 import jxl.write.*;

 public class CreateXLS
 {
 public static void main(String args[])
 {
 try
 {
  //打开文件
  WritableWorkbook book=
 Workbook.createWorkbook(new File(“测试.xls”));
     
 //生成名为“第一页”的工作表，参数0表示这是第一页
   WritableSheet sheet=book.createSheet(“第一页”,0);
   
 //在Label对象的构造子中指名单元格位置是第一列第一行(0,0)
 //以及单元格内容为test
   Label label=new Label(0,0,”test”);

   //将定义好的单元格添加到工作表中
   sheet.addCell(label);

   /**//*生成一个保存数字的单元格
 必须使用Number的完整包路径，否则有语法歧义
 单元格位置是第二列，第一行，值为789.123*/
   jxl.write.Number number = new jxl.write.Number(1,0,789.123);
   sheet.addCell(number);

   //写入数据并关闭文件
   book.write();
   book.close();

  }catch(Exception e)
  {
   System.out.println(e);
  }
 }
 } 

 　　编译执行后，会在当前位置产生一个Excel文件。

 三、读取文件

 　　以刚才我们创建的Excel文件为例，做一个简单的读取操作，程序代码如下：

//读取Excel的类
 import java.io.*;
 import jxl.*;

 public class ReadXLS
 {
 public static void main(String args[])
 {
  try
  {
   Workbook book=
 Workbook.getWorkbook(new File(“测试.xls”));
   
   //获得第一个工作表对象
 Sheet sheet=book.getSheet(0);

 //得到第一列第一行的单元格
 Cell cell1=sheet.getCell(0,0);
 String result=cell1.getContents();
 System.out.println(result);

 book.close();

  }catch(Exception e)
  {
   System.out.println(e);
  }
 }
 }

 程序执行结果：test

 四、修改文件

 　　利用jExcelAPI可以修改已有的Excel文件，修改Excel文件的时候，除了打开文件的方式不同之外，其他操作和创建Excel是一样的。下面的例子是在我们已经生成的Excel文件中添加一个工作表：

//修改Excel的类，添加一个工作表
 import java.io.*;
 import jxl.*;
 import jxl.write.*;

 public class UpdateXLS
 {
 public static void main(String args[])
 {
  try
  {
   //Excel获得文件
   Workbook wb=Workbook.getWorkbook(new File(“测试.xls”));
   
   //打开一个文件的副本，并且指定数据写回到原文件
 WritableWorkbook book=
 Workbook.createWorkbook(new File(“测试.xls”),wb);
   
   //添加一个工作表
   WritableSheet sheet=book.createSheet(“第二页”,1);

   sheet.addCell(new Label(0,0,”第二页的测试数据”));
   
   book.write();
   book.close();
  }catch(Exception e)
  {
   System.out.println(e);
  }
 }
 } 

 执行结果如图：

 高级操作

 一、 数据格式化

 　　在Excel中不涉及复杂的数据类型，能够比较好的处理字串、数字和日期已经能够满足一般的应用。

 1、 字串格式化

 　　字符串的格式化涉及到的是字体、粗细、字号等元素，这些功能主要由WritableFont和WritableCellFormat类来负责。假设我们在生成一个含有字串的单元格时，使用如下语句，为方便叙述，我们为每一行命令加了编号：

WritableFont font1=
 new WritableFont(WritableFont.TIMES,16,WritableFont.BOLD); ①

 WritableCellFormat format1=new WritableCellFormat(font1); ②

 Label label=new Label(0,0,”data 4 test”,format1) ③

　　其中①指定了字串格式：字体为TIMES，字号16，加粗显示。WritableFont有非常丰富的构造子，供不同情况下使用，jExcelAPI的java-doc中有详细列表，这里不再列出。

　　②处代码使用了WritableCellFormat类，这个类非常重要，通过它可以指定单元格的各种属性，后面的单元格格式化中会有更多描述。

　　③处使用了Label类的构造子，指定了字串被赋予那种格式。

　　在WritableCellFormat类中，还有一个很重要的方法是指定数据的对齐方式，比如针对我们上面的实例，可以指定：

 //把水平对齐方式指定为居中
 format1.setAlignment(jxl.format.Alignment.CENTRE);

 //把垂直对齐方式指定为居中
 format1.setVerticalAlignment(jxl.format.VerticalAlignment.CENTRE);

 二、单元格操作

　　Excel中很重要的一部分是对单元格的操作，比如行高、列宽、单元格合并等，所幸jExcelAPI提供了这些支持。这些操作相对比较简单，下面只介绍一下相关的API。

 1、 合并单元格

 WritableSheet.mergeCells(int m,int n,int p,int q); 

 作用是从(m,n)到(p,q)的单元格全部合并，比如：
 WritableSheet sheet=book.createSheet(“第一页”,0);

 //合并第一列第一行到第六列第一行的所有单元格
 sheet.mergeCells(0,0,5,0);

 合并既可以是横向的，也可以是纵向的。合并后的单元格不能再次进行合并，否则会触发异常。

 2、 行高和列宽

 WritableSheet.setRowView(int i,int height);

 作用是指定第i+1行的高度，比如：

 //将第一行的高度设为200
 sheet.setRowView(0,200);

 WritableSheet.setColumnView(int i,int width);

 作用是指定第i+1列的宽度，比如：

 //将第一列的宽度设为30
 sheet.setColumnView(0,30);

 jExcelAPI还有其他的一些功能，比如插入图片等，这里就不再一一介绍，读者可以自己探索。

 四川绵阳
 原文发表于《开发高手》0405期

Bromon原创 请尊重版权

 　　通常情况下我们都使用pop3协议来收邮件，IMAP嘛现在就不涉及了。收邮件的功能虽然我用了很多时间才基本搞清楚，不过讲起来就so easy了，一个程序就可以基本包括。

 　　邮件大致可以分三种：纯文本邮件、含有其他数据的文本邮件、含有附件的邮件。

/**//*
 * Created on 2004-4-26
 */
 package org.bromon.mail;
 import javax.mail.*;
 import java.util.*;
 import java.io.*;

 /**//**
 * @author Bromon
 */
 public class Receiver
 {
 Folder inbox;
 Store store;

 //连接邮件服务器，获得所有邮件的列表
 public Message[] getMail(String host,String name,String password) throws Exception
 {
  Properties prop=new Properties();
  prop.put("mail.pop3.host",host);
  Session session=Session.getDefaultInstance(prop);
  store=session.getStore("pop3");
  store.connect(host,name,password);
  
  inbox=store.getDefaultFolder().getFolder("INBOX");
  inbox.open(Folder.READ_ONLY);
  
  Message[] msg=inbox.getMessages();
  
  FetchProfile profile=new FetchProfile();
  profile.add(FetchProfile.Item.ENVELOPE);
  inbox.fetch(msg,profile);
  
  return(msg);
 }

 //处理任何一种邮件都需要的方法
 private void handle(Message msg) throws Exception
 {
  System.out.println("邮件主题:"+msg.getSubject());
  System.out.println("邮件作者:"+msg.getFrom()[0].toString());
  System.out.println("发送日期:"+msg.getSentDate());
 }

 //处理文本邮件
 public void handleText(Message msg) throws Exception
 {
  this.handle(msg);
  System.out.println("邮件内容:"+msg.getContent());
 }

 //处理Multipart邮件，包括了保存附件的功能
 public void handleMultipart(Message msg) throws Exception
 {
  String disposition;
  BodyPart part;
  
  Multipart mp=(Multipart)msg.getContent();
  int mpCount=mp.getCount();//Miltipart的数量,用于除了多个part,比如多个附件
  for(int m=0;m<mpCount;m++)
  {
   this.handle(msg);
   
   part=mp.getBodyPart(m);
   disposition=part.getDisposition();
   if(disposition!=null && disposition.equals(Part.ATTACHMENT))//判断是否有附件
   {
    //this.saveAttach(part);//这个方法负责保存附件，注释掉是因为附件可能有病毒，请清理信箱之后再取掉注释
   }else{
    System.out.println(part.getContent());
   }
  }
 }

 private void saveAttach(BodyPart part) throws Exception
 {
  String temp=part.getFileName();//得到未经处理的附件名字
  String s=temp.substring(11,temp.indexOf("?=")-1);//去到header和footer
  
  //文件名一般都经过了base64编码,下面是解码
  String fileName=this.base64Decoder(s);
  System.out.println("有附件:"+fileName);
  
  InputStream in=part.getInputStream();
  FileOutputStream writer=new FileOutputStream(new File(fileName));
  byte[] content=new byte[255];
  int read=0;
  while((read=in.read(content))!=-1)
  {
   writer.write(content);
  }
  writer.close();
  in.close();
 }

 //base64解码
 private String base64Decoder(String s) throws Exception
 {
  sun.misc.BASE64Decoder decoder = new sun.misc.BASE64Decoder();
  byte[] b=decoder.decodeBuffer(s);
  
  return(new String(b));
 }

 //关闭连接
 public void close() throws Exception
 {
  if(inbox!=null)
  {
   inbox.close(false);
  }
  
  if(store!=null)
  {
   store.close();
  }
 }

 public static void main(String args[])
 {
  String host="pop.163.com";
  String name="bromon";
  String password="My password";
  
  Receiver receiver=new Receiver();
  
  try
  {   
   Message[] msg=receiver.getMail(host,name,password);
   
   for(int i=0;i<msg.length;i++)
   {
    if(msg[i].isMimeType("text/*"))//判断邮件类型
    {
     receiver.handleText(msg[i]);
    }else{
     receiver.handleMultipart(msg[i]);
    }
    System.out.println("****************************");
   }
   receiver.close();
  }catch(Exception e)
  {
   System.out.println(e);
  }
 }
 }

 　　没有习惯读java代码的兄弟可能会觉得麻烦了一点，其中有个小问题，下载的附件会再文件名后面加上一个”#”符号，不知道这是javamail的特别处理还是pop3的规范。通过程序更改文件名很简单，就不说了。对于email还有很多其他的操作，可以自己取查看一下javadoc，我就不影响大家探索的乐趣了。在Properties里配置代理服务器，可以让程序通过代理收发邮件，一般的HTTP、socks 4、socks 5都支持。

　　怎样才算比较完整的Javamail操作指南？我想应该包括绝大多数基本的email操作，能够应付一般的应用。在本指南中打算囊括以下内容：

 ● 发送email：包括文本邮件、HTML邮件、带附件的邮件、SMTP验证
 ● 接收email：pop3远程连接、收取不同MIME的邮件、处理附件

　　我想有了上述功能的介绍，应该可以应付很多email的相关应用了。所以请允许我给本文拟了一个比较狂妄的名字，这样才能保证收视率，。还是那句话，写这个post的原因就是没有在网上看到更全面的，你看过的话记得要告诉我。

　　下面的所有例子都经过实际测试，你可以说它写得不够OO，不够plugable，但是它的确是可以参考的。自从有了javamail，发垃圾邮件就方便多了。本文代码多说明少，这倒不是我偷懒，而是很多东西都涉及pop3等协议的规范，如果不了解这些规范的话，由的东西我实在不知道怎么跟你解释；如果了解的话，那我基本上就不用再解释。所以本着实用的原则就省略了，由兴趣的话自己去翻翻协议规范。

　　废话少说，首先需要配置环境。需要的包是mail.jar和activation.jar。高版本的J2SDK EE自带。地址嘛，再java.sun.com上搜索一下，很容易找到。放到classpath中就KO。

 一、 邮件的发送

 下面了弄个发邮件的Hello World，热热身：

/**//*************
 Name:TextMailSender.java
 Author:Bromon
 Version:1.0
 Date:2004-4-26
 Note:发送email到bromon@163.com,需要安装SMTP服务器
 *************/
 package org.bromon.mail;
 import javax.mail.*;
 import javax.mail.internet.*;
 import java.util.*;
 public class TextMailSender
 {
 public static void main(String args[])
 {
  try
  {
   Properties prop=new Properties();
   //指定要使用的SMTP服务器为bromon2k
   prop.put("mail.smtp.host","bromon2k");
   Session mailSession=Session.getDefaultInstance(prop);

   //发件人地址
   InternetAddress from=new InternetAddress("bromon@bromon2k");
   //收件人地址
   InternetAddress to=new InternetAddress("bromon@163.com");
   
   MimeMessage msg=new MimeMessage(mailSession);
   msg.setFrom(from);
   msg.addRecipient(javax.mail.Message.RecipientType.TO,to);
   //发信日期
   msg.setSentDate(new java.util.Date());
   //title
   msg.setSubject("你好");
   //邮件正文
   msg.setText("hello,bromon");
   Transport.send(msg);
  }catch(Exception e)
  {
   System.out.println(e);
  }
 }
 } 

　　程序很简单，但是它是不能运行的（倒）。除非你的机器上安装了一个SMTP服务器，而且你的机器还叫做bromon2k。写这么一段不能执行的程序不是为了找打，而是让各位对javamail有个基本印象，我就懒得改了。下面演示的是如何通过163、sohu等email服务商提供的免费邮箱来发邮件，基本操作和上面的一样，只是多一个SMTP验证而已：

/**//*
 * Created on 2004-4-26
 */
 package org.bromon.mail;
 import javax.mail.*;
 import java.util.*;
 import javax.mail.internet.*;

 /**//**
 * @author Bromon
 */
 public class SenderWithSMTPVer
 {
 String host="";
 String user="";
 String password="";

 public void setHost(String host)
 {
  this.host=host;
 }

 public void setAccount(String user,String password)
 {
  this.user=user;
  this.password=password;
 }

 public void send(String from,String to,String subject,String content)
 {
  Properties props = new Properties();
  props.put("mail.smtp.host", host);//指定SMTP服务器
  props.put("mail.smtp.auth", "true");//指定是否需要SMTP验证
  try
  {
   Session mailSession = Session.getDefaultInstance(props);
   
   mailSession.setDebug(true);//是否在控制台显示debug信息
   
   Message message=new MimeMessage(mailSession);
   message.setFrom(new InternetAddress(from));//发件人
   message.addRecipient(Message.RecipientType.TO,new InternetAddress(to));//收件人
   
   message.setSubject(subject);//邮件主题
   message.setText(content);//邮件内容
   message.saveChanges();
   
   Transport transport = mailSession.getTransport("smtp");
   transport.connect(host, user, password);
   transport.sendMessage(message, message.getAllRecipients());
   transport.close();
  }catch(Exception e)
  {
   System.out.println(e);
  }
  
 }

 public static void main(String args[])
 {
  SenderWithSMTPVer sm=new SenderWithSMTPVer();

  sm.setHost("smtp.163.com");//指定要使用的邮件服务器
  sm.setAccount("abc","123");//指定帐号和密码

  /**//*
 * @param String 发件人的地址
   * @param String 收件人地址
   * @param String 邮件标题
   * @param String 邮件正文
  */
  sm.send("abc@163.com","bromon@163.com","标题","内容");
 }

 }

 
　　这段程序好像也不需要解释了吧，把SMTP地址、帐号、密码等配置信息写到Properties里面，Java里面很多API都需要这么干，比如再程序中加入对代理服务器的支持等。

　　上面的程序修改一下服务器地址、帐号、密码就可以使用，非常简单。

　　如何发送一个HTML格式的Email呢？也很简单，再邮件正文中写入HTML代码，然后指定邮件的ContentType就OK，下面只给出关键代码：

 ………..
 MimeMessage msg=new MimeMessage(mailSession);
 msg.setContent(content,"text/html");
 msg.setText(“<html><body><h1>下面的，你们好吗?</body></html>”);
 ………

　　下面是发送带有附件的email，稍微复杂一点，而且和前面的程序有一些不同，请仔细一点，同时需要一点IO的知识。相同的代码就不在列出，只写关键部分，谁都想偷懒不是？

import javax.mail.*;
 import javax.mail.internet.*;
 import javax.activation.*;
 import java.util.*;
 ……….
 MimeMessage msg=new MimeMessage(mailSession);
 msg.setSentDate(new Date());
 msg.setSubject("hello");

 MimeBodyPart textBodyPart=new MimeBodyPart();
 textBodyPart.setText(“邮件正文”);

 MimeBodyPart fileBodyPart=new MimeBodyPart();
 FileDataSource fds=new FileDataSource("GIS.rar");//要发送的附件
 fileBodyPart.setDataHandler(new DataHandler(fds));
 fileBodyPart.setFileName(fds.getName());
 Multipart container=new MimeMultipart();
 container.addBodyPart(textBodyPart);
 container.addBodyPart(fileBodyPart);
 msg.setContent(container);
 Transport.send(msg);
 ………… 

　　这里的msg由两个MimeBodyPart构成，这个东西解释起来基本上比较难，如果不了解相关的规范就不太好解释，如果了解的话，我就不用解释了，这个这个………唉。

 bromon原创 版权所有

　　在一般的B/S程序中(最典型的是web服务)，工作的方式是客户端(brower)向服务器端(server)发送一个请求，服务器端响应这个请求并发回客户端所请求的数据。在这个过程中服务器端扮演的是一个被动响应的角色，一般的情况下，服务器端是不会主动向客户端写数据的。由于HTTP是一个无连接的协议，也就是说当服务器端完成对客户端的响应后，双方的连接就断开了，直到下一次客户端发出请求时再重新建立连接。这样的HTTP协议是节省网络资源的，但是也给我们带来了一些麻烦，比如客户端不能实时探查服务器端的数据变化，不能作出及时的响应。所以当我们在做一些需要客户端和服务器端互相响应的程序时（比如聊天室、web短信息），不得不在客户端不停的刷新页面，以求获得最新的数据，这样做增加的服务器的负担。如果服务器能在数据发生变化的时候主动向客户端写数据，那么问题就解决了，这就是所谓的“推”技术。

 　　在java中，客户端主动向服务器端申请数据，叫做“拉”；服务器主动向客户端写数据，叫做“推”。我们可以在服务器端打开某个端口，监听客户端的连接，就可以向客户端随意写数据，这是我们做C/S程序的原理，“推”技术采用相同的原理，只是客户端是浏览器而已，只要我们按照浏览器能够识别的格式向客户端写数据，客户端就可以通过HTTP与服务器建立连接，并获得数据。
 HTTP是一个很庞大的协议，但是我们只需要用到很小一部分。最重要的是要知道按照什么格式写数据，浏览器才认识。当我们浏览一个网站的某一页，比如www.sohu.com/page.htm的时候，我们是在向服务器发送这样一个信息：

 GET /page.htm HTTP/1.0

 From: someuser@somehost.com

 User-Agent: Mozilla/4.0 （compatible; MSIE 5.0; Windows NT 5.0; DigExt）

 空行

　　其中第一行是我们要关注的，它由空格分隔成三部分，一是请求的方法(get)，二是请求的页面，三是HTTP的版本。如果请求无误，服务器将返回如下信息：
 HTTP/1.0 200 OK

 Date: Thu, 8 Oct 2002 14:23:11 GMT

 Content-Type: text/html

 Content-Length: 1644

 ＜html＞
 ＜body＞
 ＜h1＞Hello world!＜/h1＞
 （其他内容）...
 ＜/body＞
 ＜/html＞

　　 第一行表示连接成果，然后是返回数据的属性，从<html>开始才是返回给浏览器返回的数据。在我们自己的程序中只需要按照上述格式写数据，就可以实现一个自己的简易web服务器。下面是一个hello,world的例子：

//myServer.java
 import java.io.*;
 import java.net.*;
 public class myServer
 {
 static ServerSocket server=null;
 static OutputStreamWriter ow=null;
 public static void main(String args[])
 {
  int port=800;
  try
  {
   server=new ServerSocket(port);
  }catch(Exception e)
  {
   System.out.println(e);
  }
  while(true)
  {
   try
   {
    Socket socket=server.accept();
    ow=new OutputStreamWriter(socket.getOutputStream());
    ow.write("HTTP/1.0 200 ok ");
    ow.write("Content-Type:text/html ");
    ow.write("<html><body>");
    ow.write("hello,world");
    ow.write("</body></html>");
    ow.flush();
    socket.close();
   }catch(Exception e)
   {
    System.out.println(e);
   }
  }
 }
 } 

 编译：javac myServer.java
 运行：java myServer
 然后打开浏览器，输入http://localhost:800，将会返回一个”hello,world”
 以上就是一个“推”技术的简单实现，将它扩展一下，比如加入多线程响应，就可以实现无刷新的聊天室，请读者自己考虑。

 原文发表于《程序春秋》0301期 

 1、创建XML文档：

import java.io.*;
 import org.jdom.*;
 import org.jdom.input.*;
 import org.jdom.output.*;

 public class CreateXML
 {
  public void Create()
  {
   try
   {
    Document doc = new Document();   
    ProcessingInstruction pi=new ProcessingInstruction("xml-stylesheet","type="text/xsl" href="test.xsl"");
    doc.addContent(pi);
    
    Namespace ns = Namespace.getNamespace("http://www.bromon.org" );
    Namespace ns2 = Namespace.getNamespace("other", "http://www.w3c.org" );

    Element root = new Element("根元素", ns);
    root.addNamespaceDeclaration(ns2);
    doc.setRootElement(root);
    Element el1 = new Element("元素一");
    el1.setAttribute("属性", "属性一");
    
    Text text1=new Text("元素值");
             Element em = new Element("元素二").addContent("第二个元素");

    el1.addContent(text1);
             el1.addContent(em);
             
             Element el2 = new Element("元素三").addContent("第三个元素");

             root.addContent(el1);
             root.addContent(el2);
             
             //缩进四个空格,自动换行,gb2312编码
             XMLOutputter outputter = new XMLOutputter("  ", true,"GB2312");
             outputter.output(doc, new FileWriter("test.xml"));
         }catch(Exception e)
         {
          System.out.println(e);
         }
     }
     
     public static void main(String args[])
     {
      new CreateXML().Create();
     }
     
 }