BlogJava-Sometimes Java-随笔分类-Tech Flow

Websphere MQ 6.0 Cluster指南

Sometimes Java — Fri, 16 Dec 2005 05:28:00 GMT

Websphere MQ 6.0 Cluster

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中，可以按照上述方法，让该节点与任意一个完整仓储库节点建立集群连接即可。

Sometimes Java 2005-12-16 13:28 发表评论

JSF开发实战(二)

Sometimes Java — Fri, 16 Dec 2005 05:02:00 GMT

JSF开发实战(二)

bromon原创　请尊重版权

    JSF开发实战的第一篇(http://www.blogjava.net/bromon/archive/2005/12/16/24189.html)演示了如何建立一个最简单的JSF应用，从那个例子中我们可以观察到JSF的页面组件是如何与后台的javabean绑定的，也看到了JSF标签的最基本使用。在本文中我们会演示一个更加复杂的应用，它包含了更丰富的JSF标签。

    要开发的例子是一个用户管理程序，管理员输入帐号与密码登陆，然后它可以看到所有用户的列表，并且可以修改或者删除其中的一些数据。利用myeclipse所带的jsf-config.xml设计器，页面流程如下：

    可以看出，这个应用设计到的业务逻辑有：

用户登陆、修改用户信息、增加新用户、删除用户

    我们在后台的数据库操作中使用hibernate框架来辅助开发，相关的技术细节请自行查阅文档。

    首先建立pojo文件：User.java，它包含几个基本属性：

private int id;
private String name;
private String password;
private int power;

请自行完成set/get方法，并且编写对应的hbm.xml文件。

我们的主要工作之一，是要建立好供jsf页面组件使用的javabean，把它命名为UMDelegater.java。它会调用UserManager来完成业务逻辑，这里是一个代理模式。UserManager的内容只是简单的增/删/查/改的操作，这里不再具体列出。UMDelegater的内容是：
package org.bromon.jsf.control;

import java.util.List;

import javax.faces.model.DataModel;
import javax.faces.model.ListDataModel;

import org.bromon.jsf.model.UserManager;//自行建立的工具类，负责所有的hibernate操作
import org.bromon.jsf.model.pojo.User;//pojo对象

public class UMDeletager {
    private UserManager um=new UserManager();//所有具体的方法都由它来实现
    private User user=new User();
        private DataModel allUsers=new ListDataModel();//JSF的内置对象，用来封装html中table的数据

        //----------set/get方法---------------------
    public DataModel getAllUsers() {
        return allUsers;
    }

    public void setAllUsers(List list) {
        allUsers.setWrappedData(list);
    }
    public UserManager getUm() {
        return um;
    }
    public void setUm(UserManager um) {
        this.um = um;
    }
    public User getUser() {
        return user;
    }
    public void setUser(User user) {
        this.user = user;
    }

    //-----功能方法---------
    public String login()
    {
        String s=um.login(this.getUser());
        if(s.equals("ok"))
        {
            this.setAllUsers(um.loadAll());//如果登陆成功，就取出所有的用户信息
            return "login:ok";
        }else
        {
            swapper.setLoginFailInfo(s);
            return "login:fail";
        }
    }

    public String edit()
    {
        this.user=(User)allUsers.getRowData();//页面中的table自动返回含有id的user对象
        this.user=um.loadById(user.getId());
        if(user!=null)
        {
            return "edit";
        }else
        {
            return "error";
        }
    }

    public String update()
    {
        um.update(this.getUser());
        this.setAllUsers(um.loadAll());//重新取一次数据，目的是更新缓存
        return "update:ok";
    }

    public String addNew()
    {
        this.setUser(new User());//生成一个新的user对象，不含任何数据，它会被自动映射成一个没有数据的form
        return "add";
    }

    public String add()
    {
        um.add(this.getUser());
        this.setAllUsers(um.loadAll());//重新取一次数据，目的是更新缓存
        return "add:ok";
    }
}

    在jsf-config.xml中声明这个bean：

＜managed-bean＞
        ＜managed-bean-name＞UMDelegater＜/managed-bean-name＞
＜managed-bean-class＞org.bromon.jsf.control.UMDeletager＜/managed-bean-class＞
        ＜managed-bean-scope＞session＜/managed-bean-scope＞
    ＜/managed-bean＞

业务逻辑就设计完成了，下面可以开始编写jsf文件，首先是index.jsp:

首先引入标签库，并且声明page属性：

<%@ taglib uri="http://java.sun.com/jsf/html" prefix="h" %>
<%@ taglib uri="http://java.sun.com/jsf/core" prefix="f" %>
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>

然后是构建页面：

＜body＞
    ＜f:view＞
        ＜h:form＞
            ＜h:panelGrid columns="3"＞
                 ＜h:outputLabel for="name" value="帐号:"/＞
                 ＜h:inputText id="name" value="# {UMDelegater.user.name}" required="true"/＞
                ＜h:message for="name"/＞

                 ＜h:outputLabel for="password" value="密码:"/＞
                 ＜h:inputSecret id="password" value="# {UMDelegater.user.password}" required="true" /＞
                ＜h:message for="password"/＞
            ＜/h:panelGrid＞
            ＜h:panelGroup＞
                 ＜h:commandButton value="登陆" action="# {UMDelegater.login}"/＞
            ＜/h:panelGroup＞
        ＜/h:form＞
    ＜/f:view＞
  ＜/body＞

页面中声明了两个文本框，分别映射UMDelegater对象中user对象的name属性，和UMDelegater对象中user对象的 password属性。一旦这个表单被提交，这两个文本框的值就会被自动赋给user对象，我们只需要从user中取数据就行了，不用再去执行麻烦的 request.getParameter(“”)，更改编码，转换数据类型等操作。

我们同时还声明了一个button，它与 UMDelegater对象的login方法绑定，点击该按钮，系统会执行UMDelegater.login方法，该方法从user对象中取出name 和password，和数据库中的记录进行比较。如果合法，那么就取出所有的数据，放到一个DataModel对象中，具体代码是：

List userList=UserManager.getAllUser();//取得所有用户数据，放到一个List中
DataModel allUser=new ListDataModel ();//DataModel是一个接口，ListDataModel是它的一个实现

allUsers.setWrappedData(userList);//将数据填充进去备用

使用DataModel意义何在呢？JSF中，我们可以把一个html页面上的table和一个DataModel绑定起来，这些数据会自动填充到 table中，我们不必再自己去写循环，生成若干的、来生成一个table。在list.jsp中我们会看到如何使用DataModel。

放好数据之后，登陆成功的操作就完成了，返回一个login:ok，就可以重定向到list.jsp。如果用户登陆失败，那么会返回login:fail，重定向到error.jsp，它的内容就不叙说了。下面我们看看list.jsp里面有什么，下面是它的代码：

＜body＞
    ＜f:view＞
        ＜h:form＞
             ＜h:dataTable id="users" value="#{UMDelegater.allUsers}" var ="u" border="1" width="80%" ＞
                ＜h:column＞
                     ＜f:facet name="header"＞
                         ＜h: outputText value="id"/＞
                     ＜/f:facet＞
                     ＜h:outputText value="# {u.id}"/＞
                ＜/h:column＞

                ＜h:column＞
                     ＜f:facet name="header"＞
                         ＜h: outputText value="帐号"/＞
                     ＜/f:facet＞
                     ＜h:commandLink action="# {UMDelegater.edit}"＞
                         ＜h: outputText value="#{u.name}"/＞
                     ＜/h:commandLink＞
                ＜/h:column＞

                ＜h:column＞
                     ＜f:facet name="header"＞
                         ＜h: outputText value="密码"/＞
                     ＜/f:facet＞
                     ＜h:outputText value="# {u.password}"/＞
                ＜/h:column＞

                ＜h:column＞
                     ＜f:facet name="header"＞
                         ＜h: outputText value="权限代码"/＞
                     ＜/f:facet＞
                     ＜h:outputText value="# {u.power}"/＞
                ＜/h:column＞
            ＜/h:dataTable＞
            ＜p＞
                 ＜h:commandLink action="#{UMDelegater.addNew} " value="增加用户" /＞
            ＜/p＞
        ＜/h:form＞
    ＜/f:view＞
  ＜/body＞

我们使用了一个h:dataTable标签，它是JSF独有的东西，它会被翻译为一个html的table，通过指定h:dataTable的value= "#{UMDelegater.allUsers}"属性，它就与我们刚才生成的DataModel对象关联起来，数据会被自动填充。我们只需要声明 dataTable中的每一列的表头，数据来自哪个字段就可以了，如下：
＜h:column＞
    ＜f:facet name="header"＞
        ＜h:outputText value="id"/＞
    ＜/f:facet＞
    ＜h:outputText value="#{u.id}"/＞
＜/h:column＞

表格最后还有一个“增加用户”的按钮，它与UMDelegater.addNew绑定，它会把我们重定向到add.jsp。
需要注意的是，每个用户名都是个超链接，点击之后可以重定向到edit.jsp，这个页面可以修改用户资料。这是通过如下代码实现的：

＜h:commandLink action="#{UMDelegater.edit}"＞
    ＜h:outputText value="#{u.name}"/＞
＜/h:commandLink＞

可以看出，实际上系统调用了UMDelegater.edit方法，该方法的功能是根据页面传过来的用户id查询数据库，找到相关记录后返回一个User对象，然后重定向到edit.jsp，由于我们后面编写edit.jsp的时候会把form元素与User对象绑定，所以该User对象所含有的数据会自动显示到各个form元素上。

list.jsp的显示效果如下：

看到这里你也许会问，那么我如何来美化这个表格？实际上这正式JSF这类框架面临的最大问题，它大量的使用了标签库，目前流行的网页制作工具(如 deamweaver)又没有提供足够的支持，所以只能依靠挖掘dataTable标签的各个属性，并且大量依赖css才能实现页面的美化。如果java 世界能有一个强大的JSF IDE，能够提供vs.net一样的能力，那么JSF也许会更容易流行。

下面我们来看看edit.jsp的内容，如下：

＜body＞
    ＜f:view＞
        ＜h:form＞
             ＜h:inputHidden id="id" value="#{UMDelegater.user.id}"/＞
            ＜h:panelGrid columns="3"＞
                 ＜h:outputLabel for="name" value="帐号"/＞
                 ＜h:inputText id="name" value="# {UMDelegater.user.name}" required="true"/＞
                ＜h:message for="name"/＞

                 ＜h:outputLabel for="power" value="权限"/＞
                 ＜h:inputText id="power" value="# {UMDelegater.user.power}" required="true"/＞
                ＜h:message for="power"/＞
            ＜/h:panelGrid＞
            ＜h:panelGroup＞
                 ＜h:commandButton value="保存" action="# {UMDelegater.update}"/＞
            ＜/h:panelGroup＞
        ＜/h:form＞
    ＜/f:view＞
  ＜/body＞

可以看出，edit.jsp并没有什么特别需要留意的，只是一个最简单的form与bean的绑定，“保存”按钮与UMDelegater.update方法绑定，它的功能是把修改后的form数据写入数据库，然后重新取一次数据，以免缓存做怪，看不到修改的效果。

Add.jsp也和edit.jsp很类似，它的内容如下：

＜body＞
    ＜f:view＞
          ＜h:form＞
              ＜h:panelGrid columns="3"＞
                   ＜h:outputLabel for="name" value= "帐号:" /＞
                   ＜h:inputText id="name" value="# {UMDelegater.user.name}" required="true"/＞
                   ＜h:message for="name"/＞

                   ＜h:outputLabel for="password" value="密码:"/＞
                   ＜h:inputText id="password" value ="#{UMDelegater.user.password}" required="true"/＞
                   ＜h:message for="password"/＞

                   ＜h:outputLabel for="power" value ="权限"/＞
                   ＜h:inputText id="power" value="# {UMDelegater.user.power}" required="true"/＞
                   ＜h:message for="power"/＞
              ＜/h:panelGrid＞
              ＜h:panelGroup＞
                   ＜h:commandButton value="保存" action="#{UMDelegater.add}"/＞
              ＜/h:panelGroup＞
          ＜/h:form＞
      ＜/f:view＞
  ＜/body＞

以上代码和edit.jsp几乎相同，请大家自行阅读理解，一口气写了8页，不想再?唆了。

由于最近时间很不充裕，所以JSF系列暂时打住，无限期搁置。我想这两篇文章已经能够说明很多问题，已经足够引导大家进入JSF的世界，自行研究解决其他细节。

Sometimes Java 2005-12-16 13:02 发表评论

JSF开发实战(一)

Sometimes Java — Fri, 16 Dec 2005 05:01:00 GMT

JSF开发实战(一)

bromon原创请尊重版权

    JSF将是J2EE5.0中所包含的web开发框架，这应该是第一个成为jcp标准，并且随j2eesdk一起发布的web框架，可以看出sun对它的期望很高。JSF最大的竞争对手是tapestry，是apache的产品，但是apache又弄出了个myfaces，是对jsf标准的一个实现。也许你也和我一样，在jsf和 tapestry之间犹豫很久，将来从apache的态度上应该可以看出二者的走向。在tss上有一篇比较jsf 1.0与tapestry 3.0的文章，内容很扎实到位：http://www.theserverside.com/articles/article.tss?l=JSFTapestry
JSF的竞争对手不是struts/webwork之流，它们基本上已经是不同阶段上的东西了，放在一起比较意义不大。

    JSF 的开发流程和asp.net中所倡导的code behind方式很相似，核心是事件驱动，组件和标签的封装程度非常高，很多典型应用已经不需要开发者去处理http。页面操作会被自动映射到对应的java bean中，后台逻辑只需要同java bean发生交互。整个过程是通过“依赖注入(DI)”来实现的，看来这是目前解偶合的最佳途径啊，spring的影响真是深远。不过正式因为jsf采用了这样的方式，导致开发工作和以前的jsp/struts 等都有非常大的不同，需要一定的时间去学习。学习之前建议先对依赖注入有比较清楚的认识，可以参考我的learn Spring in spring系列的第一篇。

    本系列将以两个例子来讲解jsf的基本开发，第一个例子当然是hello world。目前可用的jsf ide不多，ibm要到06年才能放出支持jsf的wtp版本。所以我们的例子基本以手写为主，这样也能让我们有更清楚的认识，同时推荐目前最好的jsf开发工具：myeclipse 4.0 GA。后面的例子将会有jsf和hibernate的内容，它都能给予很好的支持。由于myeclipse并不免费，所以我们除了讲解在ide中如何操作外，还会叙述手动操作的具体内容，以免过于依赖开发工具。用什么服务器都可以，这里采用了jboss 4.0.2。如果你的服务器是高版本的tomcat(5.5+)，那么必须要删除它自带的一些包才能很好的支持jsf，具体细节请查看它的文档。

    请自行下载jsf ri和JSTL 1.1。

废话少说，开始了。

    在myeclipse 4.0GA中新建一个web项目，命名为hello，为项目增加对JSTL的支持：

在JSTL的版本中选择1.1。
该操作实际上是把jstl.jar和standard.jar加到工程中。

采用类似的操作为项目添加对jsf的支持：myeclipse?add jsf capabilities
如图：

其中的jsf implementation是选择使用哪中JSF实现，我们采用的是sun的jsf ri
JSF config path是配置文件的位置，保持不变
URL pattern是jsf servlet的映射方式，有两种选择，具体细节后面说明。
以上操作上是为项目加入了jsf需要的jar和tld文件，并且创建了一个faces-config.xml的配置文件。涉及到的jar有：commons -beanutils.jar    commons-collections.jar        commons-digester.jar    commons-logging.jar    jsf-api.jar        jsf-impl.jar
涉及到了jsf中所有的tld文件。

当前的faces-config.xml文件的内容是：

环境已经建立好了，现在我们要建立一个程序，它的功能是让用户在表单中输入名字，提交后系统会返回一个问候。使用jsf的以后好处是，开发人员会很自然的把mvc各层分开，不会像使用strtus那样别扭，这一点在后面的开发中感觉得到。

首先开发model层，它是个很简单的bean：
package org.bromon.jsf.model.hello;

public class SayHello {
    public String say(String name)
    {
        return "你好,"+name;
    }
}

在model层中你可以随意的实现业务的数据逻辑，不需要与web层有任何的关系。

下面开发控制层，它负责存取web层的数据，并且调用model层的逻辑：
/**
* jsf的控制层方法
* @author bromon
*/
package org.bromon.jsf.control.hello;

import org.bromon.jsf.model.hello.*;

public class HelloDelegater {

    //------属性---------
    private String name;//表单中的文本框数据会传到这里
    private String result;//web页会从这里取得运行结果
    private SayHello sayHello;//model层的对象,并不事例化,由系统注入

    //-----set/get--------
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public SayHello getSayHello() {
        return sayHello;
    }
    public void setSayHello(SayHello sayHello) {
        this.sayHello = sayHello;
    }
    public String getResult() {
        return result;
    }
    public void setResult(String result) {
        this.result = result;
    }

    //-----逻辑方法---------
    public String say()
    {
        this.setResult(sayHello.say(this.getName()));
        return "ok";
    }
}

需要注意的是，属性的名字、set/get方法的名字必须严格按照java bean规范编写，因为它们要被注入依赖时使用。sayHello对象并没有被实例化，它会在运行时由系统注入。

这两个bean当然要在系统中申明，否则无法实现DI。在faces-config.xml文件中添加内容：

SayHello

org.bromon.jsf.model.hello.SayHello

request

HelloDelegater

org.bromon.jsf.control.hello.HelloDelegater

request

sayHello

#{SayHello}

    在后一个bean中，它的sayHello属性被指定要在运行时注入一个org.bromon.jsf.model.hello.SayHello的实例。

下面要编写表示层的页面，只有一个index.jsp：
需要引入两个标签库：

<%@ taglib uri="http://java.sun.com/jsf/html" prefix="h" %>
<%@ taglib uri="http://java.sun.com/jsf/core" prefix="f" %>
下面是构造jsf标签：

















页面中包含了一个文本框和一个label，他们分别被绑定到了HelloDelegater类的两个属性上，具体的绑定工作有系统通过翻转控制的方式调用对应的set/get方式实现。提交按钮被绑定到了HelloDelegater.say方法，该方法会把计算结果赋给result属性，它会在页面中显示出来。

因为我们在url pattern中选择了*.faces,所以我们应该访问如下地址来查看程序:
http://localhost:8080/hello/index.faces
相应的,如果你选择了/faces/*,那么就应该是:
http://localhost:8080/hello/faces/index.jsp

程序执行结果如下：

Sometimes Java 2005-12-16 13:01 发表评论

JBoss 4.0.2集群指南(二):建立JMS集群服务

Sometimes Java — Fri, 16 Dec 2005 04:57:00 GMT

JBoss 4.0.2集群指南(二)

建立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万左右的消息数量，无一丢失，应该说还算比较可靠。响应时间也还过的去，在简单的网络环境下，能够应付比较高的并发。

Sometimes Java 2005-12-16 12:57 发表评论

JBoss 4.0.2集群指南

Sometimes Java — Fri, 16 Dec 2005 04:56:00 GMT

JBoss 4.0.2集群指南

bromon原创请尊重版权

   本文主要讲解JBoss cluster的基本知识以及简单的配置方法，其间涉及了一些jboss的补充知识。

一、材料准备：

1、   JBoss 4.0.2

JBoss各个版本之间差异比较大，即使同为jboss 4.x的版本，内部组件的版本也不一致，所以请尽量使用同一版本的server。目前已经证明可以配置cluster的版本多为jboss 3.2.6和jboss 4.0.2。

2、   Apache 2.0.54

3、   Apache mod_jk-1-2-13-apache-2-0-54

二、安装：

1、   jboss4.0.2与apache 2.0.54的安装请自行搞定。假设jboss的安装目录为%jboss%，apache安装目录为%apache%。

2、   mod_jk的安装。

从apache.org获得文件mod_jk-1-2-13-apache-2-0-54.so，将该文件拷贝到%apache%\ modules。

三、jboss cluster入门

   Jboss 支持如下类型的cluster：EJB、web、JNDI、JMS，我们主要了解web cluster。
Web cluster实际上可以划分为两个话题：负载均衡 (load balance) 和状态同步。它们是互相独立的，单独配置。

负载均衡的概念比较简单，重要的是负载均衡的粒度。可以选择针对每个request的均衡，或者是针对每个用户的均衡。选择不同的粒度，需要不同的状态同步方式。

1、基于request的负载均衡

   该种方式下，负载均衡器 (load balancer)会根据各个node的状况，把每个http request进行分发。使用这样的均衡策略，就必须在多个node之间复制用户的session，实时保持整个cluster的用户状态同步，这种操作被称为session复制(session replication)。Jboss的实现原理是使用拦截器(interceptor)，根据用户的同步策略拦截request，做同步处理后再交给 server产生响应。

   该方法的优点是客户不会被绑定都具体的node，只要还有一个node存活，用户状态都不会丢失，cluster都能够继续工作。缺点是node之间通信频繁，响应速度有影响，多并发、高频操作的情况下性能下降比较厉害。

2、   基于用户的负载均衡

该种方式下，当用户发出第一个request后，负载均衡器动态的把该用户分配到某个节点，并记录该节点的jvm路由，以后该用户的所有request都会被绑定这个jvm路由，用户只会与该server发生交互，这种策略被称为粘性session(session sticky)。

该方法的优点是响应速度快，多个节点之间无须通信。缺点也很明显，某个node死掉以后，它负责的所有用户都会丢失session。

四、实战

1、负载均衡

   Jboss的负载均衡目前有两种方案，一是使用apache的mod_jk，二是使用jboss自带的负载均衡模块。下面分别讲解这两种配置。

mod_jk的配置

1、   请确认%apache%\modules下已经有mod_jk-1-2-13-apache-2-0-54.so文件。
2、   修改%apache%\conf\httpd.conf   在文件末尾添加:   Include conf/mod_jk2.conf
3、   在%apache%\conf下新建文件   mod_jk2.conf       文件内容如下：

# Load mod_jk module. Specify the filename
# of the mod_jk lib you’ve downloaded and
# installed in the previous section
LoadModule jk_module modules/mod_jk-1-2-13-apache-2-0-54.so
# Where to find workers.properties
JkWorkersFile conf/workers2.properties
# Where to put jk logs
JkLogFile logs/mod_jk.log
# Set the jk log level [debug/error/info]
JkLogLevel info
# Select the log format
JkLogStampFormat "[%a %b %d %H:%M:%S %Y] "
# JkOptions indicate to send SSL KEY SIZE,
JkOptions +ForwardKeySize +ForwardURICompat -ForwardDirectories
# JkRequestLogFormat set the request format
JkRequestLogFormat "%w %V %T"
JkMount /* loadbalancer

其中JkMount /* loadbalancer的意思是，把所有的请求都发给loadbalancer处理。可以通过修改url来控制发送某些request。
4、在%apache%\conf下新建文件   workers2.properties       其内容为：

worker.list=loadbalancer,server1,server2

# Define the first node...
worker.server1.port=8009
worker.server1.host=172.16.0.116
worker.server1.type=ajp13
worker.server1.lbfactor=1
worker.server1.local_worker=1
worker.server1.cachesize=10

# Define the first node...
worker.server2.port=8009
worker.server2.host=172.16.32.88
worker.server2.type=ajp13
worker.server2.lbfactor=1
worker.server2.local_worker=1
worker.server2.cachesize=10

# Now we define the load-balancing behaviour
worker.loadbalancer.type=lb
worker.loadbalancer.balanced_workers=server1,server2
worker.loadbalancer.sticky_session=1

其中对于node的命名规则是worker.节点名.xxxx。所以上述文件定义了两个节点：server1和server2。8009端口是jboss默认的ajp端口，另外需要注意的是worker.server2.lbfactor参数，它是节点的负载加权，它的值越大，获得负载的机会就越大。可以根据node的硬件性能进行调整。worker.loadbalancer.sticky_session参数是指定是否使用粘性session。

所有需要负载均衡的节点，都必须在worker.loadbalancer.balanced_workers参数中列举出来。

请记住所有node的名称和它对应着哪台机器，后面的配置中会使用。

尝试启动apache：%apache\bin\apache.exe，正常情况下没有任何提示。如果你使用的jk是2.0的，那么配置文件的写法完全不同，由于mod_jk2已经停止开发，所以apache并没有提供任何讲解，对于配置文件的编写也没有任何指导。

Jboss自带均衡器的配置

   将文件夹%jboss%\docs\examples\varia\loadbalancer\loadbalancer.sar拷贝到%jboss% \server\all\deploy下，并且修改loadbalancer.sar\loadbalancer.sar\META-INF\jboss -service.xml，在标签中类出所有节点，在标签中指定是否使用粘性 session。配置完成。

   该均衡器的缺点是负载能力相对不高，配置参数太少，比如无法指定不同节点的负载加权，所以后面都以mod_jk为例，不再讲解jboss自带的负载均衡器的内容。

   负载均衡的配置基本完成，启动jboss，其中过程中会列出DefaultPatition中所有的节点：
run.bat -c all

任何节点的关闭与启动都会在cluster中广播，比如加如一个新节点后，其他节点会得到提示

2、session sticky配置

   apache应该会以粘性session的方式分发请求。部署一个应用测试一下，你会发现粘性session没有起作用。因为我们还没有给jboss配置jvm路由( jvmRoute)，apache就无法知道究竟哪些session是属于哪个节点的。我们继续往下：

   修改server1机器上的jboss的配置文件：%jboss%\server\all\deploy\jbossweb-tomcat55.sar\ META-INF\ jboss-service.xml

   在110行有：false，将它改为true。值得注意的是在这行标签上面有一段注释，要求你在server.xml中必须有：
Engine name="jboss.web" jmvRoute="Node1" defaultHost="localhost"

   请注意这里有一个气死人不偿命的小bug，jboss的官方文档把 jvmRoute写成了jmvRoute，就是v和m两个字母的颠倒让我郁闷了三天，翻遍了jboss.com和theserverside.com。都是直接拷贝的错，吐血吐到脱水啊。

   下面需要修改server1上的%jboss%\server\all\deploy\jbossweb-tomcat55.sar\ server.xml，在32行左右有：

给它增加一个jvmRoute属性：

请注意，jvmRoute的值必须和mod_jk中的节点名字正确对应，否则无法正确路由。Cluster中的所有节点都应该做相应的配置。

Jboss的配置完成了，下面需要在你的web应用中修改配置文件，让它支持集群。

在WEB-INF\web.xml中加入属性：

Ok，基于用户的cluster完成了，每个用户会绑定都某个节点上进行交互。这种绑定是如何完成的呢？原来apache把客户分发到节点后，该节点会在用户的session id后面加上此节点的路由名称，变成这个样子：

Efdfxxd98daja87daj76da2dka**,server1

   有了这个标志，就能分辨该session属于哪个节点。

3、session replication配置

   下面要做的是基于request的cluster，也就让各个节点之间互相复制session状态。有两种复制模式，同步与异步。使用同步的方式， jboss会把session复制的操作和对request的响应放到一个应用事务(application transaction)，session复制完成后才去处理request。异步复制则发送session复制的消息后马上处理request， session复制则会稍有延迟。但是在多框架的web页面中，这样的集群方式会有问题。由于frame在同一时间发出多个request，会造成一些混乱，这也是采用基于用户的集群方式的原因之一。

   JBoss 4.0.2中采用了Jboss cache来实现session复制，实际上就是一个分布式缓存，由于session id中包含了jvm route，所以能够分辨session属于哪个节点。Session的更新类似于hibernate中的乐观锁，有了更新之后就让session的版本号增加，其他节点通过对比版本号来决定是否同步session状态。

   配置session replication首先需要编辑
%jboss% server\all\deploy\jbossweb-tomcat55.sar\META-INF\ jboss-service.xml，88行左右有：
instant
这就是刚才提到的复制模式，instant为立即复制，如果设为interval 那么系统会在延迟一段时间再进行复制，时间长度在2000中指定，单位是毫秒。

单独配置这一个地方还不够，在%jboss% server\all\deploy\ tc5-cluster-service.xml中有：

REPL_ASYNC

这里才真正决定复制是同步的还是异步的，可以指定为REPL_ASYNC(异步)或者REPL_SYNC(同步)。

在这个文件下面一点，还有一个config标签，里面指定了各个节点在进行session复制的时候如何通信，有udp和tcp两种可选，如果使用udp方式，那么应该将udp的lookback属性指定为true，因为windows上有一个叫做media sense的东西会影响udp multicast。注意如果你不了解multi address的ip规则，请不要随便修改mcast_addr的值。如果采用tcp方式的话，应该指定bind_addr的值为本机ip，并且在 TCPPING标签的initial_hosts属性中列出所有节点，格式是”机器名[端口号]”，比如在我们的例子中，就应该这样配置tcp(以其中一个节点为例)：

num_initial_members="3" up_thread="true" down_thread="true"/>

             retransmit_timeout="3000"/>

    print_local_addr="true" down_thread="true" up_thread="true"/>

   JBoss的clustering版主建议尽量使用udp。不过在Sobey内部，建议使用tcp方式，经测试可能有不明物体在影响udp通信，导致Timeout异常。

   在%jboss%\ server\all\deploy\ cluster-service.xml中也有关于udp和tcp的配置信息，在4.0以前版本的jboss中，会以这个文件为主配置，4.0以后都以 tc5-cluster-service.xml为主配置。

   Jboss的配置完成了，最后需要在web应用中增加配置信息，控制session复制的粒度。在WEB-INF\   jboss-web.xml中增加以下内容：

SET_AND_NON_PRIMITIVE_GET

SESSION

其中replication-trigger是指定哪些操作引发session的版本更新，它的取值有：

SET_AND_GET
SET_AND_NON_PRIMITIVE_GET
SET

replication-granularity是复制粒度，可以取session或attribute。如果取为attribute有可能导致复制失败，这是目前版本的jboss cache的一个bug，等待修正。

部署项目，测试，如果配置没有问题，可以在%jboss%\0server\all\log\server.log中发现类似于这样的信息：

DEBUG [org.jboss.web.tomcat.tc5.session.JBossCacheManager] check to see if needs to store and replicate session with id Im9-qpuaXppMS+xXwE3M+Q**.server1

DEBUG [org.jboss.web.tomcat.tc5.session.ClusteredSession] processSessionRepl(): session is dirty. Will increment version from: 20 and replicate.

   Session replication配置的成功率比较低，情况也很复杂，请仔细操作。

五、分布式热部署(distributable hot deploy)

   在一个节点很多的cluster中，如果部署应用的时候必须把程序文件拷贝到每个机器上的话，那实在太愚蠢了，幸好通过all启动的jboss自动支持分布式热部署。把支持cluster的应用（通常需要打包成war文件），放到%jboss%\server\all\farm下，那么处于同一 cluster中的其他节点会自动下载并且部署，jboss把这个称为Farm deploy。如下图：

End 2005-7-11 Released by bromon

Sometimes Java 2005-12-16 12:56 发表评论