基于Weblogic+Integration+81的工作流管理系统研究 ...
扫扫二维码，随身浏览文档
手机或平板扫扫即可继续访问
基于Weblogic+Integration+81的工作流管理系统研究
举报该文档为侵权文档。
举报该文档含有违规或不良信息。
反馈该文档无法正常浏览。
举报该文档为重复文档。
推荐理由：
将文档分享至：
分享完整地址
文档地址：
粘贴到BBS或博客
flash地址：
支持嵌入FLASH地址的网站使用
html代码：
&embed src='/DocinViewer-4.swf' width='100%' height='600' type=application/x-shockwave-flash ALLOWFULLSCREEN='true' ALLOWSCRIPTACCESS='always'&&/embed&
450px*300px480px*400px650px*490px
支持嵌入HTML代码的网站使用
您的内容已经提交成功
您所提交的内容需要审核后才能发布，请您等待！
3秒自动关闭窗口linux消息队列通信-Linux-第七城市
linux消息队列通信
      进程间通信机制（Inter Process Communication，IPC），这些IPC机制的存在使UNIX在进程通信领域手段相当丰富，也使得程序员在开发一个由多个进程协作的任务组成的系统时，可以采用多种方法。这些高级IPC机制可分为以下三类：消息传递.信号量.共享存储。
       信息传递构造一个消息队列，进程间通过发送消息和接收信息进行通信。
       消息实质上就是一些字或字节的序列（未必以空字符结尾）。它通过消息队列的方法在进程间传递。。
      进程间通信通过IPC对象，每个IPC对象都有唯一的ID号,通信双方需要获取该ID，创建者通过创建函数可以得到该值，可是另外的进程不能随意访问创建者的空间，于是约定利用相同的KEY值对于相同的ID，
      系统为每一个IPC对象保存一个ipc_perm结构体，该结构说明了IPC对象的权限和所有者，每一个版本的内核各有不用的ipc_perm结构成员。若要查看详细的定义请参阅文件&sys/ipc.h&。
ipc_perm 结构定义于/usr/include/bits/ipc.h中，原型如下：
struct ipc_perm
     key_ //关键字
     uid_ /*共享内存所有者的有效用户ID */
     gid_ /* 共享内存所有者所属组的有效组ID*/
     uid_ /* 共享内存创建 者的有效用户ID*/
     gid_ /* 共享内存创建者所属组的有效组ID*/
     /* Permissions + SHM_DEST和SHM_LOCKED标志*/
      /* 序列号*/
Ftok函数：
     系统建立IPC通讯（如消息队列、共享内存时）必须指定一个ID值。通常情况下，该id值通过ftok函数得到。
ftok原型：ftok(char *pathname, int projid)
pathname：文件名（含路径）,通常设置为当前目录“.” 比如projid为'a',则为&./a&文件
projid：项目ID，必须为非0整数（0-255）.
其实它就是用来实现从文件名到关键值的映射。
（一）msgsnd函数：
功能： 进程利用它来向消息队列发送消息。
函数声明： int msgsnd ( int msqid, struct msgbuf *msgp, int msgsz, int msgflg )
返回值： 调用成功：返回0值；调用失败： -1
参数介绍：
第一个参数msqid： 是消息队列对象的标识符（由msgget()函数得到），
第二个参数msgp ： 指向要发送的消息所在的内存，
第三个参数msgsz： 是要发送信息的长度（字节数），可以用以下的公式计算：
(msgsz = sizeof(struct mymsgbuf) - sizeof(long);)
第四个参数：是控制函数行为的标志，可以取以下的值：
0，忽略标志位；
IPC_NOWAIT:如果消息队列已满，消息将不被写入队列，控制权返回调用函数的线
程。如果不指定这个参数，线程将被阻塞直到消息被可以被写入。
（二）msgget()函数：
功能： 用来创建新的消息队列或获取已有的消息队列。
函数声明： int msgget ( key_t key, int msgflg )
返回值： 调用成功：消息队列的标识符；调用失败： -1:
参数介绍：
第一个参数key： 消息队列对象的关键字(key)，函数将它与已有的消息队列对象的关键字进行比较来判断消息队列对象是否已经创建。
第二个参数msgflg：msgflg 控制函数具体操作。它可以取下面的几个值：
IPC_CREAT ：如果消息队列对象不存在，则创建之，否则则进行打开操作；
IPC_EXCL： 和IPC_CREAT 一起使用（用”|”连接），如果消息对象不存在则创建之，否则产生一个错误并返回-1。
除了以上的两个标志以外，在msgflg 标志中还可以有存取权限控制符。这种控制符的
意义和文件系统中的权限控制符是类似的。
（三）msgrcv()函数：
功能：用来从消息队列中取出消息。
函数声明： int msgrcv ( int msqid, struct msgbuf *msgp, int msgsz, long
mtype,int msgflg )
返回值： 调用成功：从消息队列里拷贝过来的字节数；调用失败：返回-1；
参数介绍：
函数的前三个参数和msgsnd()函数中对应的参数的含义是相同的。
第四个参数mtype：
      指定了函数从队列中所取的消息的类型。函数将从队列中搜索类型与之匹配的消息并将之返回。如果mtype 的值是零的话，函数将不做类型检查而自动返回队列中的最旧（优先级最小的）的消息。
第五个参数依然是是控制函数行为的标志，取值可以是：
    0,表示忽略；     MSG_NOERROR，如果函数取得的消息长度大于msgsz，将只返回msgsz 长度的信息，
剩下的部分被丢弃了。如果不指定这个参数，E2BIG 将被返回，而消息则留在队列中不被
取出。          IPC_NOWAIT，如果消息队列为空，则返回一个ENOMSG，并将控制权交回调用函数
的进程。如果不指定这个参数，那么进程将被阻塞直到函数可以从队列中得到符合条件的
消息为止。如果一个client 正在等待消息的时候队列被删除，EIDRM 就会被返回。如果进
程在阻塞等待过程中收到了系统的中断信号，EINTR 就会被返回。  
（注意：当消息从队列内取出后，相应的消息就从队列中删除了。）
msgctl()函数:
功能：直接控制消息队列的行为。
函数声明： int msgctl ( int msgqid, int cmd, struct msqid_ds *buf )
返回值：调用成功就返回0；失败就返回-1
参数介绍：
第一个参数msgqid ：是消息队列对象的标识符。
第二个参数是函数要对消息队列进行的操作，它可以是：
      IPC_STAT：取出系统保存的消息队列的msqid_ds 数据，并将其存入参数buf 指向的msqid_ds 结构
      IPC_SET：设定消息队列的msqid_ds 数据中的msg_perm 成员。设定的值由buf 指向的msqid_ds
结构给出。
      IPC_EMID：将队列从系统内核中删除。
     这三个命令的功能都是明显的，所以就不多解释了。唯一需要强调的是在IPC_STAT
命令中队列的msqid_ds 数据中唯一能被设定的只有msg_perm 成员，其是ipc_perm 类型的
数据。而ipc_perm 中能被修改的只有mode,pid 和uid 成员。其他的都是只能由系统来设定
实验代码：
(一)简单的test.c
#include&sys/msg.h&#include&sys/ipc.h&struct mymsg{
/* 消息类别 */
char mtext [<span style="color: #];
/* message text */ };int main(){
key_t key = ftok(&.&,<span style="color: #);
//以当前的路径为基础调用ftok函数返回一个关键值
printf(&当前文件夹的关键值是：%d/n&,key);
int mqid = msgget(key,<span style="color: #44|IPC_CREAT|IPC_EXCL);
//使用关键值来创建或打开一个消息，并返回它的标识符
printf(&消息队列的标识符是：%d/n&,mqid);
struct mymsg msg_snd={<span style="color: #,&qwerty&};
//定义放进消息队列里面的消息
int a = msgsnd(mqid,&msg_snd,<span style="color: #,<span style="color: #);
//调用msgsnd函数把消息写进消息队列里面
if(a==<span style="color: #)
//写入队列成功，a值为0，否则为-1
struct mymsg msg_
msg_rcv.mtype=<span style="color: #;
int b = msgrcv(mqid,&msg_rcv,<span style="color: #,msg_rcv.mtype,<span style="color: #);
//调用msgrcv函数把消息读出来
if(b!=-<span style="color: #)
{printf(&通过msgrcv从消息队列里面读取的消息:%s/n&,msg_rcv.mtext);}
return <span style="color: #;}实验前：实验后： 如果去除将消息取出的部分函数，则编译结果中将含有6个字节数，一个消息：实验分析：      了解好前面介绍的几个函数后，这个小实验就很好理解了。Ftok函数以当前路径为基础返回一个关键值，megget又根据关键值创建了消息队列（这段代码里是创建队列，而非打开）；而msgsnd函数和msgrcv函数都是根据消息队列标识符mqid（message queue id）来进行相应操作的，要注意的是，当消息被取走后，消息队列还在，但消息内容为空。 （二）具有优先级的队列       实现一个排队系统，使队列中的每个成员都被赋予一个优先级。一个服务进程从队列中取出成员并按照通常的方式处理。例如，排队的成员可以是文件名，此时服务进程就把文件复制到一个打印机上。 实验代码：头文件：
//用于消息传递实验的头文件/*q.h--header for message facility example */#include &sys/types.h&#include &sys/ipc.h&#include &sys/msg.h&#include &string.h&#include &error.h&#define QKEY
(key_t)0105
//给出消息队列的关键值#define QPERM
//#define MAXOBN
//maximum length of obj.name
给消息队列里面的消息加以限制#define MAXPRIOR
//最大优先级struct q_entry {
char mtext[MAXOBN+<span style="color: #];}; //注意不要漏掉此处的分号，否则会导致包含该q.h文件的C程序出现语法错误enter方法
#include&q.h&#include&stdio.h&int init_queue(void) {
int queue_
if ((queue_id=msgget(QKEY, IPC_CREAT|QPERM))==-<span style="color: #)
//使用msgget创建或打开一个消息队列，宏定义里面已经定义了关键值
perror(&获取队列的关键值失败！！！！！！！！！&);
return(queue_id);}int warn (char*s){
fprintf(stderr,&错误： %s/n&,s);}int enter(char *objname, int priority) {
//各种if检测判断，但主要是调用msgsnd
int len, s_
struct q_entry s_
//消息中转站，也是结构体类型
if ((len=strlen(objname))&MAXOBN) { //要先检查名称长度和队列的权限
warn(&队列名字太长拉，出错拉！&);
return(-<span style="color: #);
if (priority&MAXPRIOR||priority&<span style="color: #) {
//priority的最小值要为1
warn(&队列的权限超出了限制或则小于0&);
return(-<span style="color: #);
if ((s_qid=init_queue())==-<span style="color: #)
//调用init_queue打开消息队列
return(-<span style="color: #);
if(priority!=1)
warn(&不是消息对列的专用类型队/n&);
return(-1);
s_entry.mtype=(long)
//中转站的消息初始化
strncpy(s_entry.mtext, objname, MAXOBN);
if(s_entry.mtype==<span style="color: #)
{return <span style="color: #;}
if (msgsnd(s_qid, &s_entry, len, <span style="color: #)==-<span style="color: #) {
//把消息从中转站写进去消息队列里面
printf(&消息发送到队列里失败&);
return(-<span style="color: #);
else {return(<span style="color: #);}
}serve方法
#include&q.h& serve(void) {
//这个函数是用于处理消息队列中的服务程序，像是enter的翻版
int mlen, r_
struct q_entry r_
if ((r_qid=init_queue())==-<span style="color: #)
//通过标识符检查消息队列是否存在
return(-<span style="color: #);
if ((mlen=msgrcv(r_qid, &r_entry, MAXOBN,
(-<span style="color: #*MAXPRIOR), MSG_NOERROR))==-<span style="color: #)
perror(&从消息队列里面读取消息失败/n&);
return(-<span style="color: #);
r_entry.mtext[mlen]='/0';
//pro_obj完成实际的处理工作，就好比打印机系统把文件输出到打印设备上
proc_obj(&r_entry);
}}etest函数（向队列里面放入一个成员，而stest则就可以处理队列中的一个成员 ）
#include&stdio.h&#include&stdlib.h&#include&q.h&//etest向队列里面放入一个成员，而stest则就可以处理队列中的一个成员main(int argc, char **argv) {
int priority,n;
if (argc!=<span style="color: #) {
fprintf(stderr,&usage: %s 对象的优先权：/n&,argv[<span style="color: #]);
exit(<span style="color: #);
if ((priority=atol(argv[<span style="color: #]))&=<span style="color: #|priority&MAXPRIOR) {
warn(&队列优先顺序无效。&);
exit(<span style="color: #);
if (enter(argv[<span style="color: #], priority)&<span style="color: #) {
warn(&enter failure&);
exit(<span style="color: #);
exit(<span style="color: #);}stest函数(服务器进程函数，处理队列里面元素的函数)
#include &sys/types.h&#include &sys/msg.h&#include &unistd.h&#include &string.h&#include &stdio.h&truct msg_buf{
int//消息类型
char data[<span style="color: #5];//数据};int main(int argc,
char *argv[]){
struct msg_
//获取key值
key = ftok(&.&,
printf(&key = [%x]/n&,
//创建消息队列
msgid = msgget(key,
IPC_CREAT|<span style="color: #66);/*通过文件对应*/
if(msgid == -<span style="color: #)
printf(&creat error/n&);
return -<span style="color: #;
//以当前进程类型，非阻塞方式发送&test data&到消息队列
msgbuf.mtype = getpid();
strcpy(msgbuf.data,
&test data&);
ret = msgsnd(msgid,
sizeof(msgbuf.data),
IPC_NOWAIT);
if(ret == -<span style="color: #)
printf(&send message err/n&);
return -<span style="color: #;
//以非阻塞方式接收数据
memset(&msgbuf,
<span style="color: #,
sizeof(msgbuf));
ret = msgrcv(msgid,
sizeof(msgbuf.data), getpid(),
IPC_NOWAIT);
if(ret == -<span style="color: #)
printf(&receive message err/n&);
return -<span style="color: #;
printf(&receive msg = [%s]/n&,
msgbuf.data);
return <span style="color: #;} 实验结果：运行这两个简单程序。在服务器进程stest启动之前，etest向队列放入3条消息。注意，这些消息最终被输出的顺序。  删除消息队列：  相关思考1、 清空消息队列里面的全部消息方法：更改proc_obj函数：int proc_obj(struct q_entry *msg) {return 0;//printf(&优先权: %ld 对象名： %s /n&,msg-&mtype, msg-&mtext);}分析：被改后的函数不再把消息输出到界面，而是往缓存里面里返回0值，此前缓存里面是存放取出的消息内容，被替换成0值了。消息也就不存在了。结果如下： 2、消息队列成为某一特定优先级的专用队列：方法：只要在enter函数里面增加一个if判段就可以了，这里假定消息队列只给优先级为1的用，如下图： 结果如下：  3、过滤给定优先级的所有消息方法：可以再把所给定的优先级的消息过滤掉，方法是在enter函数加上一个优先级的判断语句，但暂时没有实现清空已有优先级的消息。添加的判断语句为： 结果如下： 实验扩展补充：linux下进程间通信的几种主要手段简介：
管道（Pipe）及有名管道（named pipe）：管道可用于具有亲缘关系进程间的通信，有名管道克服了管道没有名字的限制，因此，除具有管道所具有的功能外，它还允许无亲缘关系进程间的通信；
信号（Signal）：信号是比较复杂的通信方式，用于通知接受进程有某种事件发生，除了用于进程间通信外，进程还可以发送信号给进程本身；linux除了支持Unix早期信号语义函数sigal外，还支持语义符合Posix.1标准的信号函数sigaction（实际上，该函数是基于BSD的，BSD为了实现可靠信号机制，又能够统一对外接口，用sigaction函数重新实现了signal函数）；
报文（Message）队列（消息队列）：消息队列是消息的链接表，包括Posix消息队列system V消息队列。有足够权限的进程可以向队列中添加消息，被赋予读权限的进程则可以读走队列中的消息。消息队列克服了信号承载信息量少，管道只能承载无格式字节流以及缓冲区大小受限等缺点。
共享内存：使得多个进程可以访问同一块内存空间，是最快的可用IPC形式。是针对其他通信机制运行效率较低而设计的。往往与其它通信机制，如信号量结合使用，来达到进程间的同步及互斥。
信号量（semaphore）：主要作为进程间以及同一进程不同线程之间的同步手段。
套接口（Socket）：更为一般的进程间通信机制，可用于不同机器之间的进程间通信。起初是由Unix系统的BSD分支开发出来的，但现在一般可以移植到其它类Unix系统上：Linux和System V的变种都支持套接字。Weblogic中的load banlance问题
ZDNet软件频道 时间： 作者：李哲 | lizhe1985
本文关键词：
在一个复杂的企业应用环境中，往往一个application server无法承担所有的服务请求，所以很多企业都为此架起了多个服务器实例。而后者则是两种功能都提供，正常时作laod banlance，运行故障期间，fail over会起作用。
goid:梦想照进现实 - BlogJava 在一个复杂的企业应用环境中，往往一个application server无法承担所有的服务请求，所以很多企业都为此架起了多个服务器实例。这些服务器实例结合在一起，可以组织成一个强健的企业运行环境，它易于扩展、支持load banlance, 支持fail over, 可以做到backend server的failure对于客户是透明的。这样的一个企业环境就是我们常说的Cluster。 Cluster提供了多种load banlance的可能, 比如web application请求处理,可以通过proxy来实现(e.g. apache, HttpClusterServlet, IIS), 不同的J2EE Component在有不同的load banlance实现．下面我们来逐一看看， 1: Http请求通过proxy实现的load banlance 当客户端通过proxy访问Cluster中的业务页面时，proxy通过自身的算法(round-robin)来实现load banlance．当然这些请求要求是从不同的客户端(或者不带session的同一客户端的请求)发起的．对于同一客户端，如果页面中使用了session, 那么 通过session粘连来实现同一客户端的请求会被dispatch到primary server上．如果primary server无法提供服务，那么请求会被dispatch到其他server上。session粘连可以通过以下几种方式实现： 1.1：browser支持cookie的话，会把jsession id写入到cookie中，下次请求提交的时候jseeion id会被提交到proxy端，proxy通过jseeion id 来决定请求的dispatch。 1.2：browser不支持cookie，server端在处理返回页面时，调用response.encodeURL()来将session id附在url上。 1.3：post-data方式，直接将session作为数据，post到proxy端。 我们来看看提供的HttpClusterServlet是如何实现load banlance的， public synchronized Server next() { if (list.size() == 0) if (index == -1) index = (int)(java.lang.Math.random() * list.size()); else index = ++index % list.size(); Object[] servers = list.values().toArray(); return (Server) servers[index]; } HttpClusterServlet维护一个managed servlet list，每当一个请求被dispatch到某个managed server后，server list的index加1，这样在下次dispatch请求的时候，请求将会被dispatch到server list中的其他server上去。逻辑很简单，但基本也实现了load banlance功能。 2：InitialContext的load banlance 我们知道，每次我们需要获取jdbc connection， jms connection，ejb stub这类RMI Object的时候，我们都要初始化一个上下文，问题是我们初始化上下文的时候，连接的到底是哪个managed server? 初始化上下文的时候，我们需要提供一个provider url, 如下： PROVIDER_URL = "t3://localhost:7011"; 这种写法很简单，直接连接7001对应的server, 但如果写法如下呢？ CLUSTER_PROVIDER_URL="t3://localhost:7011,localhost:7021"; 这时候，load banlance就又来了。10个客户端( server或者thin client)new 10个InitialContext的话，这10个客户端将55分别连接到后端的两台server上去。实际上客户端在new InitialContext的时候，会创建一个T3连接到对应的managed server上(RJVMConnection)，注意这个RJVMConnection是个长连接，在同一个JVM中，连向同一managed server的连接只有一个。即如果一个客户端，连续new 10个 InitialContext, 这10个Context实际上是同一对象， server这时根本不会和后端的server通讯，因为对象已经在client JVM中有了。 new InitialContext的load banlance算法基本和proxy的算法一样，都是维护一个server list, 通过index递增的方法实现。不同的是：在连接某个managed server的connection遇到peer gone的时候， proxy可以recover server list, 而jndi context的load banlance算法则不能。也就是说如果后端有三个managed server， server1， server2相继出现故障的话，所有客户端的context将都会连接到server3, 即使server1, server2能够恢复过来，后续请求也不会连接到他们，除非server3后来出现问题。 值得一提的是：context所有的相关操作时server affinity的，而非load banlance。比如：2个客户端分别new了个context, 分别连接到server1和server2上，连接到server1的context，做了10次lookup，那么这10次操作，都在server1上完成，不会在server2上作任何操作。所以说jndi级别的load banlance不是绝对均衡的。 3: JMS Distributed Queue的load banlance Distributed Queue(简称DQ)，顾名思义，分布式队列。在不同的JMS Server上，我们会创建不同的物理Queue, 按照传统方式，我们在发送消息(或者创建JMSSession)的时候，需要指定一个物理Queue， 这样我们可以将消息发送到固定的Queue上。 由于在 server上， JMS Server是一个pin service， 即只能运行于单个managed server上的服务实例。 如果我们发送消息的时候，指定Queue对应的jms server出现了问题，这样消息无法发送出去。基于这个原因， 上提出了DQ，DQ是个逻辑Queue,并没有时间的物理Queue与其对应，它用于管理多个、分布于不同jms server上的物理Queue, 这样客户发送、接受消息的时候，需要指定的是DQ，而不是物理Queue。客户端知道的只是将消息发送到了DQ，而无法知道到底发送到哪个具体的物理Queue上了。那么是如何计算消息该发送到具体物理Queue呢？ JMS Connection Factroy的配置选项中load banlance参数：LoadBanlanceEnabled，ServerAffinityEnabled Distributed Queue的配置选项中load banlance参数：LoadBanlancePolicy，默认为Round-Robin， 可选值包括：Round-Robin, Random Load Balancing Enabled: Specifies whether non-anonymous producers created through a connection factory are load balanced within a distributed destination on a per-call basis. If enabled, the associated message producers are load balanced on every send() or publish() . If disabled, the associated message producers are load balanced on the first send() or publish(). ServerAffinityEnabled： Specifies whether a server instance that is load balancing consumers or producers across multiple members destinations of a distributed destination, will first attempt to load balance across any other physical destinations that are also running on the same server instance. Load Balancing Policy： Determines how messages are distributed to the members of this destination. Round-Robin - The system maintains an ordering of physical topic members within the set by distributing the messaging load across the topic members one at a time in the order that they are defined in the configuration file. Each
Server instance maintains an identical ordering, but may be at a different point within the ordering. If weights are assigned to any of the topic members in the set, then those members appear multiple times in the ordering. Random - The weight assigned to the topic members is used to compute a weighted distribution for the members of the set. The messaging load is distributed across the topic members by pseudo-randomly accessing the distribution. In the short run, the load will not be directly proportional to the weight. In the long run, the distribution will approach the limit of the distribution. A pure random distribution can be achieved by setting all the weights to the same value, which is typically set to 1. JMS Connection Factroy在创建JMSConnection的时候，这一层是load banlance的， 即JMSConnection会连接到不同的后端managed server上。这个load banlance是基于round_robin的。一旦connection创建完成，所有通过该JMSConnection创建的consumer, producer会stick到JMSConnection对应的managed server上， 即所有的message会被dispatch到该managed server的物理Queue上(因为sub-type的jms对象不是RMI对象，他们和后端managed server的通讯是基于dispatcher的，通过invocable id来识别对象)。如果producer send了很多条message, 那么这些消息如何分发？这就是Load Balancing ，ServerAffinity要做的事儿。 Load Balancing Enabled被check的时候，消息分发是基于send()方法的，即send一条message, message都会被分发到不同的Queue上。如果Load Balancing Enabled没有被check，那么同一producer send的所有message会被分发到同一物理Queue上。而ServerAffinity则说明loadbalance Queue的范围，如果serverAffinity为true，那么说明load banlance的范围为处理send request那台managed server上的Queues，如果为false，则说明在所有的queue间作load balance。 4：EJB的load banlance EJB的load banlance比较复杂，涉及到如下三个方面： 1：IntitialContext 关于InitialContext, 前面已经谈过，这里不再做讨论。 2：EJB Home 对于EJB Home，可以通过-ejb-jar.xml中的home-load-algorithm 配置，可选项包括：round-robin | random | weight-based | RoundRobinAffinity | RandomAffinity | WeightBasedAffinity, default依赖于.cluster.defaultLoadAlgorithm，如果没有对应的system property, 则为round-robin。 如果home-load-algorithm为round-robin，则说明客户端拿到initial context后，在做ejb home create的时候是round robin的(创建的的bean object位于不同的managed server上)。如果home-load-algorithm为RoundRobinAffinity ，则表明home create是round robin的，但后续的home的操作则是server affinity的，比如，home位于serverA上，则该home创建的所有bean object均位于serverA上。 其余算法基本类似，区别只是home create时候的算法不同而已。 3: EJB Object 对于Bean的load banlance，只有stateless session支持，可以通过stateless-bean-load-algorithm配置，可选项同EJB Home。因为stateful session bean及entity bean包含状态数据，所以无法作laod banlance，否则在数据同步方面，需要付出的开销要远大于laod banlance带来的收益。 如果stateless-bean-load-algorithm为round-robin，则说明bean操作是round-robin的。如果为RoundRobinAffinity ，则business method是affinity的，即所有的method都在object对应的server上被执行。 5：JDBC 对于JDBC,如果要使用load banlance的话，我们需要配置multi pool，multi pool和jms 的distribute destination类似，是一个逻辑pool，用于管理一组物理pool(通常位于不同的managed server上)。Multi pool的算法包括: HA(用于fail over), Load banlance。前者只是在某个物理pool出现故障的时候，用于fail over，而不提供load banlance。而后者则是两种功能都提供，正常时作laod banlance，运行故障期间，fail over会起作用。
上一篇:下一篇:
操作系统WebsphereWeblogic
? ? ? ? ? ? ? ? ? ?
? ? ? ? ? ? ? ? ? ?
? ? ? ? ? ? ? ? ? ?
最受关注的文章：
关键字： &&&&&& 关键字： &&&&&&&&&& 关键字： && 关键字： &&&&&&&& 关键字： &&&&&&&&&&
最新更新文章：
??????????
(没有帐户？)
使用第三方帐号登录:
??????????
Copyright& 1997- CNET Networks 版权所有。 ZDNet 是CNET Networks公司注册服务商标。中华人民共和国电信与信息服务业务经营许可证编号：京ICP证010391号 京ICP备号-159京公网安备：
