OAF_开发种类二5_完结OAF中Java类型并发程式开发oracle.apps.fnd.cp.request(概念)

by admin on 2019年4月13日
  1. Locale mLocale =
    CpContext.getLocale():取得地点区域新闻(见java.util.Locale)

按连接数限制速度

按连接数限速是指限制单个IP(可能其它的key)同时提倡的连接数,超出那个限制后,Nginx将直接拒绝越多的总是。那一个模块的布局比较好明白,详见ngx_http_limit_conn_module官方文书档案

PROG_APPL_ID、

按请求速率限制速度

按请求速率限制速度是指限制单个IP(可能其余的key)发送请求的速率,超出钦命速率后,Nginx将一向拒绝越多的伸手。接纳leaky
bucket
算法达成。为深切摸底那些模块,大家先从实验现象提及。开端在此以前我们先不难介绍一下该模块的铺排方式,以下边包车型地铁布局为例:

http {
    limit_req_zone $binary_remote_addr zone=mylimit:10m rate=2r/s;
    ...
    server {
        ...
        location /search/ {
            limit_req zone=mylimit burst=4 nodelay;
        }

使用limit_req_zone重点字,大家定义了2个名字为mylimit大小为拾MB的共享内部存款和储蓄器区域(zone),用来存放限制速度相关的总计音讯,限制速度的key值为贰进制的IP地址($binary_remote_addr),限速上限(rate)为二r/s;接着大家利用limit_req要害字将上述规则成效到/search/上。burstnodelay的职能稍后解释。

动用上述规则,对于/search/目录的拜访,单个IP的访问速度被限定在了二请求/秒,超过这几个范围的造访将一直被Nginx拒绝。

PROGRAM_ID、

着力算法

在探索Nginx限制速度模块在此以前,我们先来探视网络传输中常用多个的流量控制算法:漏桶算法令牌桶算法。那四只“桶”到底有啥样异同呢?

  1. ReqCompletion mReqCompletion =
    CpContext.getReqCompletion():取得请求截止消息ReqCompletion类

单个key相关的burst队列在哪儿

从不单个key相关的burst队列。下面代码中大家来看当到达最后一条规则时,只要excess<limit->burst限制速度模块就会重回NGX_OK,并不曾把结余请求放入队列的操作,那是因为Nginx是基于timer来治本请求的,当限制速度模块重回NGX_OK时,调度函数会总括三个延迟处理的时光,同时把那个请求放入到共享的timer队列中(1棵按等待时间从小到大排序的红黑树)。

ngx_http_limit_req_handler(ngx_http_request_t *r)
{
    ...
    for (n = 0; n < lrcf->limits.nelts; n++) {
        ...
        ngx_shmtx_lock(&ctx->shpool->mutex);// 获取锁
        rc = ngx_http_limit_req_lookup(limit, hash, &key, &excess, // 执行漏桶算法
                                       (n == lrcf->limits.nelts - 1));
        ngx_shmtx_unlock(&ctx->shpool->mutex);// 释放锁
        ...
        if (rc != NGX_AGAIN)
            break;
    }
    ...
    delay = ngx_http_limit_req_account(limits, n, &excess, &limit);// 计算当前请求需要的延迟时间
    if (!delay) {
        return NGX_DECLINED;// 不需要延迟,交给后续的handler进行处理
    }
    ...
    ngx_add_timer(r->connection->write, delay);// 否则将请求放到定时器队列里
    return NGX_AGAIN; // the request has been successfully processed, the request must be suspended until some event. http://www.nginxguts.com/2011/01/phases/
}

作者们见到ngx_http_limit_req_handler()调用了函数ngx_http_limit_req_lookup(),并依据其重回值决定怎样操作:或是拒绝,或是交给下三个handler处理,或是将请求放入定期器队列。当限制速度规则都经过后,该hanlder通过调用函数ngx_http_limit_req_account()搜查捕获当前央浼须要的延迟时间,固然不供给延期,就将呼吁提交后续的handler进行拍卖,不然将请求放到定时器队列里。注意这么些定时器队列是共享的,并不曾为独立的key(比如,每种IP地址)设置队列。关于handler模块背景知识的牵线,可参看Tengine团队撰写的Nginx开发从入门到精通

至于按请求速率限制速度的规律教学,可参看Rate Limiting with NGINX and NGINX
Plus
,关于源码更详实的分析可参看ngx_http_limit_req_module
源码分析
以及y123456yz的Nginx源码分析的git项目

 

实验一——皮秒级总计

咱俩有如下配置:

...
limit_req_zone $binary_remote_addr zone=mylimit:10m rate=2r/s;
server { 
    location / { 
        limit_req zone=mylimit;
    }
}
...

上述规则限制了每一种IP访问的快慢为贰r/s,并将该规则效能于跟目录。借使单个IP在尤其短的时光内并发发送七个请求,结果会怎样呢?

# 单个IP 10ms内并发发送6个请求
send 6 requests in parallel, time cost: 2 ms
HTTP/1.1 503 Service Temporarily Unavailable
HTTP/1.1 200 OK
HTTP/1.1 503 Service Temporarily Unavailable
HTTP/1.1 503 Service Temporarily Unavailable
HTTP/1.1 503 Service Temporarily Unavailable
HTTP/1.1 503 Service Temporarily Unavailable
end, total time cost: 461 ms

作者们利用单个IP在10ms内发并发送了伍个请求,唯有3个成功,剩下的五个都被拒绝。我们设置的进度是二r/s,为啥只有1个成功吗,是或不是Nginx限制错了?当然不是,是因为Nginx的限流计算是基于皮秒的,大家设置的速度是2r/s,转换一下便是500ms内单个IP只同意通过三个请求,从50一ms先导才允许通过第二个请求。

图片 1

(二).
mReqDetails.ReqGeneralInfo():取得并发请求的新闻类mReqGeneralInfo,那些类提供越来越深信不疑的有关并发请求的音信,如下所示:

试行三——nodelay下降排队时间

试验第22中学大家看看,通过设置burst参数,我们能够允许Nginx缓存处理肯定水平的发生,多余的呼吁可以先放到行列里,慢慢处理,那起到了平滑流量的服从。不过要是队列设置的可比大,请求排队的年月就会比较长,用户角度看来正是路虎极光T变长了,那对用户很不自身。有何化解办法呢?nodelay参数允许请求在排队的时候就立即被处理,也正是说只要请求能够进入burst队列,就会即时被后台worker处理,请小心,那代表burst设置了nodelay时,系统须臾间的QPS或许会抢先rate设置的阈值。nodelay参数要跟burst1起使用才有功力。

持续实验2的安排,大家投入nodelay选项:

...
limit_req_zone $binary_remote_addr zone=mylimit:10m rate=2r/s;
server { 
    location / { 
        limit_req zone=mylimit burst=4 nodelay;
    }
}
...

单个IP 十ms内并发发送伍个请求,结果如下:

# 单个IP 10ms内发送6个请求
   实验3, 设置burst和nodelay       |  实验2, 只设置burst
send 6 requests, time cost: 4 ms |  time cost: 2 ms
HTTP/1.1 200 OK                  |  HTTP/1.1 200 OK
HTTP/1.1 200 OK                  |  HTTP/1.1 503 ...
HTTP/1.1 200 OK                  |  HTTP/1.1 200 OK
HTTP/1.1 200 OK                  |  HTTP/1.1 200 OK
HTTP/1.1 503 ...                 |  HTTP/1.1 200 OK
HTTP/1.1 200 OK                  |  HTTP/1.1 200 OK
total time cost: 465 ms          |  total time cost: 2437 ms

跟实验二相对而言,请求成功率没变化,可是总体耗费时间变短了。那怎么解释啊?实验第22中学,有四个请求被置于burst队列其中,工作进程每隔500ms(rate=二r/s)取3个请求进行处理,最终二个请求要排队2s才会被拍卖;实验三中,请求放入队列跟实验贰是均等的,但不一样的是,队列中的请求同时全部了被拍卖的身价,所以实验3中的多少个请求能够说是同时开班被拍卖的,开销时间自然变短了。

不过请留意,就算设置burst和nodelay能够下落突发请求的拍卖时间,可是短时间来看并不会拉长吞吐量的上限,长时间吞吐量的上限是由rate决定的,因为nodelay只好保障burst的乞求被当下处理,但Nginx会限制队列成分释放的进度,就如限制了令牌桶中令牌发生的速度。

见状此间你或许会问,到场了nodelay参数之后的限快速计算法,到底算是哪三个“桶”,是漏桶算法还是令牌桶算法?当然还算是漏桶算法。记挂1种意况,令牌桶算法的token为耗尽时会如何是好吗?由于它有3个呼吁队列,所以会把接下去的呼吁缓存下来,缓存多少受限于队列大小。但那时缓存那几个请求还有意思呢?如若server已经过载,缓存队列更加长,PAJEROT越来越高,固然过了很久请求被处理了,对用户来说也没怎么价值了。所以当token不够用时,最明智的做法正是平昔拒绝用户的伸手,这就成了漏桶算法,哈哈~

  1. CpContext.setParameterList(String
    s):设置并发请求参数。格式(参数间用’冒号’分隔)如下:

    params=”P_IP_ADDS=”+host+”:P_PORT=”+sport+”:P_USER_NAME=”+user+”:P_PASSWORD=”+pass+”:P_START_PATH=”+filename+”:P_END_PATH=”+path+”:P_DIRECTION=”+”upload”;
    cpcontext.setParameterList(params);
    TransferCP transfer=new TransferCP();
    transfer.runProgram(cpcontext);

漏桶算法是怎么样促成的

漏桶算法的落实也比大家想象的简短,其主干是那一行公式excess = lr->excess - ctx->rate * ngx_abs(ms) / 1000 + 1000,那样代码的意趣是:excess表示近年来key上遗留的央浼数,此番遗留的伸手数
= 上次遗留的请求数 – 预设速率 X 过去的光阴 +
。那个一代表近年来那几个请求,由于Nginx内部表示将单位压缩了一千倍,所以叁个请求要转换到一千。

excess = lr->excess - ctx->rate * ngx_abs(ms) / 1000 + 1000; // 3. 执行漏桶算法
if (excess < 0) 
    excess = 0;
if ((ngx_uint_t) excess > limit->burst)
    return NGX_BUSY; // 超过了突发门限,拒绝
if (account) { // 是否是最后一条规则
    lr->excess = excess;    
    lr->last = now;    
    return NGX_OK; // 未超过限制,通过
}
...
return NGX_AGAIN; // 6. 执行下一条限流规则

上述代码受限算出当前key上遗留的请求数,如若跨越了burst,就径直拒绝;由于Nginx允许多条限制速度规则同时起功能,假如已是最后一条规则,则允许通过,否则执行下一条规则。

然后mReqDetails.getSessInfo()的getNlsLanguage()、getNlsTerritory()比较,假诺取出的值是一样的,则实施如下执行如下PL/SQL:

试行二——burst允许缓存处理突发请求

试验一大家见到,大家长期内发送了大气呼吁,Nginx根据阿秒级精度总结,超出限制的请求直接拒绝。那在实质上情况中未免过于严厉,真实互连网环境中呼吁到来不是匀速的,很只怕有请求“突发”的图景,约等于“一股子一股子”的。Nginx思虑到了这种意况,能够因而burst重大字开启对出人意料请求的缓存处理,而不是直接拒绝。

来看大家的布署:

...
limit_req_zone $binary_remote_addr zone=mylimit:10m rate=2r/s;
server { 
    location / { 
        limit_req zone=mylimit burst=4;
    }
}
...

大家进入了burst=4,意思是每种key(此处是各样IP)最多允许伍个突发请求的过来。假设单个IP在⑩ms内发送伍个请求,结果会怎样呢?

# 单个IP 10ms内发送6个请求,设置burst
send 6 requests in parallel, time cost: 2 ms
HTTP/1.1 200 OK
HTTP/1.1 503 Service Temporarily Unavailable
HTTP/1.1 200 OK
HTTP/1.1 200 OK
HTTP/1.1 200 OK
HTTP/1.1 200 OK
end, total time cost: 2437 ms

对待实验1成功数扩大了伍个,这几个大家设置的burst数目是一样的。具体处理流程是:三个请求被登时处理,5个请求被停放burst队列里,其余3个请求被拒绝。通过burst参数,大家使得Nginx限流具备了缓存处理突发流量的力量

可是请小心:burst的功用是让多余的央求能够先放到行列里,稳步处理。若是不加nodelay参数,队列里的呼吁不会应声处理,而是服从rate设置的速度,以飞秒级精确的速度逐年处理。

 

源码剖析

透过地点的言传身教,大家队请求限速模块有了迟早的认识,今后大家深深剖析代码完结。按请求速率限流模块ngx_http_limit_req_module代码位于src/http/modules/ngx_http_limit_req_module.c,900多好代码可谓短小精悍。相关代码有七个基本数据结构:

  1. 红黑树:通过红黑树记录每一个节点(依据证明时钦定的key)的总括音讯,方便寻找;
  2. LRU队列:将红黑树上的节点依据近来访问时间排序,时间近的放在队列底部,以便利用LRU队列淘汰旧的节点,幸免内部存储器溢出。

那三个至关心注重要目的存款和储蓄在ngx_http_limit_req_shctx_t中:

typedef struct {
    ngx_rbtree_t                  rbtree; /* red-black tree */
    ngx_rbtree_node_t             sentinel; /* the sentinel node of red-black tree */
    ngx_queue_t                   queue; /* used to expire info(LRU algorithm) */
} ngx_http_limit_req_shctx_t;

里面除了rbtree和queue之外,还有一个称呼sentinel的变量,那几个变量用作红黑树的NIL节点。

该模块的为主逻辑在函数ngx_http_limit_req_lookup()中,这一个函数主要流程是怎么着呢?对于每四个伸手:

  1. 从根节点起初查找红黑树,找到key对应的节点;
  2. 找到后修改该点在LRU队列中的位置,表示该点近年来被访问过;
  3. 实施漏桶算法;
  4. 没找到时根据LRU淘汰,腾出空间;
  5. 变化并插入新的红黑树节点;
  6. 实施下一条限流规则。

流程很显明,可是代码中牵涉到红黑树、LRU队列等高等数据结构,是或不是会写得很复杂?幸而Nginx作者功力深厚,代码写得简单易懂,哈哈~

// 漏桶算法核心流程
ngx_http_limit_req_lookup(...){
  while (node != sentinel) {
    // search rbtree
    if (hash < node->key) { node = node->left; continue;} // 1. 从根节点开始查找红黑树
    if (hash > node->key) { node = node->right; continue;}
    rc = ngx_memn2cmp(key->data, lr->data, key->len, (size_t) lr->len);
    if (rc == 0) {// found
      ngx_queue_remove(&lr->queue); // 2. 修改该点在LRU队列中的位置,表示该点最近被访问过
      ngx_queue_insert_head(&ctx->sh->queue, &lr->queue);// 2
      ms = (ngx_msec_int_t) (now - lr->last);
      excess = lr->excess - ctx->rate * ngx_abs(ms) / 1000 + 1000; // 3. 执行漏桶算法
      if (excess < 0) 
        excess = 0;
      if ((ngx_uint_t) excess > limit->burst)
        return NGX_BUSY; // 超过了突发门限,拒绝
      if (account) {// 是否是最后一条规则
        lr->excess = excess;    
        lr->last = now;    
        return NGX_OK; // 未超过限制,通过
      }
      ...
      return NGX_AGAIN; // 6. 执行下一条限流规则
    }
    node = (rc < 0) ? node->left : node->right; // 1
  } // while
  ...
  // not found
  ngx_http_limit_req_expire(ctx, 1); // 4. 根据LRU淘汰,腾出空间
  node = ngx_slab_alloc_locked(ctx->shpool, size); // 5. 生成新的红黑树节点
  ngx_rbtree_insert(&ctx->sh->rbtree, node);// 5. 插入该节点,重新平衡红黑树
  ngx_queue_insert_head(&ctx->sh->queue, &lr->queue);
  if (account) {    
    lr->last = now; 
    lr->count = 0;
    return NGX_OK;
  }
  ...
  return NGX_AGAIN; // 6. 执行下一条限流规则
}

代码有二种再次回到值,它们的趣味是:

  • NGX_BUSY 超过了产生门限,拒绝
  • NGX_OK 未超越限定,通过
  • NGX_AGAIN 未抢先限定,可是还有规则未履行,需进行下一条限流规则

上述代码简单通晓,但我们还有多少个难点:

  1. LRU是何等达成的?
  2. 漏桶算法是什么贯彻的?
  3. 每一种key相关的burst队列在哪儿?

CONC_PRIORITY_REQUEST、

令牌桶算法(token bucket)

令牌桶(token
bucket)
算法思想如图所示:

图片 2

算法思想是:

  • 令牌以固定速率产生,并缓存到令牌桶中;
  • 令牌桶放满时,多余的令牌被撇下;
  • 恳请要消耗等比例的令牌才能被拍卖;
  • 令牌不够时,请求被缓存。

对照漏桶算法,令牌桶算法不相同之处在于它不只有二只“桶”,还有个体系,那一个桶是用来存放在令牌的,队列才是用来存放请求的。

从功能上的话,漏桶和令牌桶算法最显眼的分别正是是或不是同意爆发流量(burst)的拍卖,漏桶算法能够粗犷限制数量的实时传输(处理)速率,对出乎预料流量不做额外处理;而令牌桶算法能够在范围数量的平分传输速率的还要同意某种程度的发生传输

Nginx按请求速率限制速度模块使用的是漏桶算法,即能够强行有限支撑请求的实时处理速度不会超越设置的阈值。

来设置Trace为启用

漏桶算法(leaky bucket)

漏桶算法(leaky
bucket)
算法思想如图所示:

图片 3

八个形象的阐述是:

  • 水(请求)从上面倒入水桶,从水桶下方流出(被处理);
  • 比不上流出的水存在水桶中(缓冲),以固定速率流出;
  • 水桶满后水溢出(扬弃)。

本条算法的大旨是:缓存请求、匀速处理、多余的请求直接丢掉。

一五.CpContext.initParameterList():起首化并发请求参数列表,查看代码如下:

结尾

正文首要讲解了Nginx按请求速率限制速度模块的用法和原理,个中burst和nodelay参数是不难引起误会的,就算可经过burst允许缓存处理突发请求,结合nodelay能够下落突发请求的拍卖时间,不过长时间来看他俩并不会增强吞吐量的上限,长时间吞吐量的上限是由rate决定的。需求尤其注意的是,burst设置了nodelay时,系统须臾间的QPS恐怕会超过rate设置的阈值。

正文只是对Nginx目光如豆,越来越多关于Nginx介绍的篇章,可参照Tengine团队撰文的Nginx开发从入门到明白

  1. LogFile LOG_FILE =
    CpContext.getLogFile():取得并发请求的日志类

Nginx限制速度模块分为哪二种?按请求速率限制速度的burst和nodelay参数是什么看头?漏桶算法和令牌桶算法究竟有何样不一样?本文将带您1探终究。大家会透过有个别归纳的演示展现Nginx限速模块是怎样行事的,然后结合代码讲解其背后的算法和公理。

  1. AppsEnvironmentStore =
    CpContext.createEnvironmentStore():创设EBS环境AppsEnvironmentStore类,它定义了Oracle获取dbc文件,建立连接环境的的操作

LRU是如何兑现的

LRU算法的落实极粗略,借使2个节点被访问了,那么就把它移到行列的头顶,当空间不足供给淘汰节点时,就选出队列尾巴部分的节点淘汰掉,主要显示在如下代码中:

ngx_queue_remove(&lr->queue); // 2. 修改该点在LRU队列中的位置,表示该点最近被访问过
ngx_queue_insert_head(&ctx->sh->queue, &lr->queue);// 2
...
ngx_http_limit_req_expire(ctx, 1); // 4. 根据LRU淘汰,腾出空间

透过这么些while循环就足以取出全体的面世请求参数,并将他们存到Hashtable
m_hashParametersList中,前面随时要运用并发请求参数的时候就足以通过m_hashParametersList.get(String)方法取出参数值来

Nginx限制速度模块

Nginx首要有三种限制速度措施:按连接数限制速度(ngx_http_limit_conn_module)、按请求速率限速(ngx_http_limit_req_module)。大家重点讲解按请求速率限制速度。

首先获得环境EnvironmentStore environmentstore =
getEnvStore();

其它还有相应的CpContext.setReqProfile(String s, String
s一)方法

  1. ReqDetails mReqDetails =
    CpContext.getReqDetails():取得并发请求细节消息

 


(1).
mReqDetails.getRequestId():获取RequestId信息

 

 

 

 

参考:http://blog.csdn.net/cunxiyuan108/article/details/7677758

  1. CpContext.modifyOutFileInDb(String
    s):更新FND_CONCURRENT_REQUESTS表的OUT_FILE

CpContext.setNLSLocale():获取本地音信寄存到CpContext.mLocale中

(3).
mReqDetails.getSessInfo():取得session相关消息ReqSessInfo类

CONC_PROGRAM_ID、

  1. Connection mJConn =
    CpContext.getJDBCConnection:取得Oracle
    JDBC驱动连接

 

(a) 0:
NORMAL

 

UPDATE
FND_CONCURRENT_REQUESTS  SET OUTFILE_NAME= ? WHERE REQUEST_ID=
?

  1. CpContext.rollback(Connection
    connection):rollback连接
  1. CpContext.loadProfiles():

APPL_SHRT_NAME、

 

(1).
将服务器上的文本通过FTP安全有效的导入到apps环境下

CONC_REQUEST_ID、

 

 

  1. CpContext.setSession():设置会话相关参数(语言和地面),查看代码如下:

RESP_ID、

UserId,RespId,RespAppId,LoginId,SecGrpId,UserName,RespName的setter和getter方法。

就此须要EBS系统中登记并运维Java并发程序,通过Java的强硬成效达成EBS的效能增加

它定义了3个空洞方法public abstract void runProgram(CpContext
cpcontext),其子类必须达成该方法。

图片 4

 

(二).
使用JDBC连接1个非Oracle的数据库,并拿走里面的数据,通过认证和转移导入到apps下的客制化表。对于上述假定,须求DBA建立透明网关,对于这么简约的急需将会做复杂的设置。

EnableTrace,NlsLanguage,NlsTerritory,NlsCodeSet,NlsNumChar的setter和getter方法。

RESP_APPL_ID、

  1. CpContext.initGlobal():初始化全局环境,能够查看到在这之中的代码如下:

    begin fnd_global.initialize(?,?,?,?,?,?,?,?,?,?,?,?); end;
    –那一个跟我们在PL/SQL里面起头化apps环境的代码一样效果
    begin
    FND_GLOBAL.APPS_INITIALIZE (USER_ID =>1110, RESP_ID=>50239, RESP_APPL_ID=>200);
    end;

 

CONC_PROGRAM_NAME、

  1. CpContext.initConcurrent():初叶化并发,查看代码下:

    begin fnd_concurrent.init_request; end;
    –只是调用了PL/SQL标准包,具体的底细能够去看package fnd

 

  1. 程序接口

实则那些细节是透过一条SQL从Oracle表中取出,看其getDetails(Connection
connection)方法就足以清楚了。


CONC_PROGRAM_APPLICATION_ID、

参考:http://www.cnblogs.com/echochen/archive/2011/11/17/2253148.html

将SECURITY_GROUP_ID、

  1. CpContext.setUserContext():设置了用户环境(将用户音信添加到SessionManager)

 

oracle.apps.fnd.utl.*

 

AFLOG_LEVEL音讯加载到出现请求的Profiles中(这一个参数都能够由此mReqDetails来博取)。

USER_ID、

  1. CpContext.loadEnvironment(Connection
    connection):加载环境上下文,调用如下PL/SQL

    select
    variable_name,
    value
    from fnd_concurrent_requests cr ,
    fnd_env_context ec
    where cr.controlling_manager = ec.concurrent_process_id
    and cr.request_id = ?

  1. ParameterList parameterlist =
    CpContext.getParameterList():取得并发请求的参数

    while(parameterlist.hasMoreElements()){
    NameValueType namevaluetype = parameterlist.nextParameter();
    m_hashParametersList.put(new String(namevaluetype.getName()), new String(namevaluetype.getValue()));
    }

 

 

除此以外还有setReqDetails(ReqDetails reqdetails, int
i)方法。

(五).
mReqDetails.getParaInfo():取得参数相关音讯ReqParameterInfo类

当蒙受如下贰种情形的时候,用PLSQL程序包来实现将Infiniti麻烦:

oracle.apps.fnd.cp.request.*

Begin
  FND_GLOBAL.set_nls_context(p_nls_language=>?,  -- environmentstore.setEnv("NLS_LANGUAGE", s);
                             p_nls_territory=>?); -- environmentstore.setEnv("NLS_TERRITORY", s1);
end;
  1. OutFile OUT_FILE = CpContext.
    getOutFile():取得并发请求的日志类
select column_seq_num num, 
       srw_param 
  from fnd_descr_flex_column_usages 
 where application_id = ?  -- mReqDetails.getGeneralInfo().getProgAppId();
   and descriptive_flexfield_name = ?  -- "$SRS$." + mReqDetails.getGeneralInfo().getProgName();
   and descriptive_flex_context_code = ?  -- "Global Data Elements"
   and enabled_flag = ?  -- "Y"
   order by 1
--可以看到可以从表fnd_descr_flex_column_usages里面获取并发请求参数。

反编写翻译LogFile类,能够看来它的构造函数:

OUT_FILE.writeln(String):往专业请求输出里面写内容

 

  1. CpContext.commit(Connection
    connection):commit连接

LOG_FILE.writeln(String
msg, 一):在此之前志里面写内容

public LogFile(CpContext cpcontext){
  mCtx = cpcontext;
  mFilePath = System.getProperty("request.logfile");
}

(d) 3:
PAUSED

 

CONC_PARENT_REQUEST、

(二). 四个主要的包

BEGIN
FND_CONC_STAT.COLLECT; END;

CpContext.setTrace():首先判断System.getProperty(“request.enabletrace”);是不是为’Y’;要是是,则运维                               

 

Thanks and Regards

(b) 1:
WARNING

public class BatchsCP implements JavaConcurrentProgram{
    public static final String RCS_ID = "$Header: BatchsCP.java 115.0 2008/09/07 14:36:23 pkm ship$";
    public void runProgram(CpContext cpcontext){
      //……coding here
    }
}

USERNAME、

(1). 全部的java并发可进行都必须兑现这几个接口(从那一个接口继承),

在Oracle EBS中的Java并发程序(Java
Concurrent
Program)是系统机能中的四个优点,它的产出使得用户能够在EBMWX五P系统中运作本身定义的Java程序。

CONC_LOGIN_ID、

(2).
ReqCompletion.setPaused(String s):暂停请求

  1. CpContext.initContext():初阶化上下文,里面定义了1些伊始化变量的措施和setter方法

图片 5二、CpContext类**

概念了对参数的操作:添,删等。

(c) 2:
ERROR

在是接纳Form/Report/SQL等并发程式时,集中在数码的操作和处理上,不过在事物处理与系统互相有非常大的局限性,未有Java程序方便,

图片 6一、摘要

 

(一).
ReqCompletion.setCompletion(int i, String s):s参数能够写入1些新闻,设置请求停止状态

参考:http://blog.csdn.net/cunxiyuan108/article/details/7677773

 

除此以外还有CpContext.setRollbackSegment(Connection
connection)设置回滚段

 20150719 Created By
BaoXinjian

应用Java并发程序的功利:

  1. CpContext.requestEnd():执行如下PL/SQL来收尾请求

AFLOG_ENABLED、

BEGIN
DBMS_SESSION.SET_SQL_TRACE(TRUE); END;

(四).
mReqDetails.getUserInfo():取得用户相关新闻ReqUserInfo类

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图