双11狂欢大促

盲盒赢 定制羽绒服

开启惊喜盲盒，抽取你的专属好礼

— 惊喜奖品抢先看 —

超级年卡50元券

周边70元券

手机支架

一拖三数据线

雨伞

运动毛巾

电动牙刷

VIP月卡

机械键盘

定制羽绒服

超级年卡50元券

周边70元券

手机支架

一拖三数据线

雨伞

运动毛巾

电动牙刷

VIP月卡

机械键盘

定制羽绒服

什么是JCA container？

2006-05-05 11:28:44 337 阅读 AI 写同款 · GEO 优化AI 选题数据监测一键分发 ›

CaOding 墨衍会员 · AI 创作全网分发关注 + 加入社区

HashMap扩容原理本篇文章分别讲解JDK1.7和JDK1.8下的HashMap底层实现原理文章目录一、什么是HashMap？二、为什么要使用HashMap？三、HashMap扩容为什么总是2的次幂四、JDk1.7扩容死循环问题五、JDK1.8的新结构1.为什么非要使用红黑树呢？2.什么是红黑树？3.红黑树的特性一、什么是HashMap？ HashMap 数据结构为数组+链表（JDk1.7），JDK1.8中增加了红黑树，其中：链表的节点存储的是一个 Entry 对象，每个Entry 对象存储四个属性（hash，key，v 阅读详情

可否详细精炼地介绍一下？谢谢呀！！~

...全文

HashMap扩容机制 HashMap扩容的核心是“扩容触发→容量计算→元素迁移”，JDK1.7到1.8的升级，本质是扩容效率和并发安全性的优化：JDK1.7：先扩容后插入，逐个元素重算下标、头插法迁移，低效且有死循环风险，无红黑树适配；JDK1.8：先插入后扩容，高低位整体迁移（核心优化），尾插法避免倒置，支持红黑树拆分与退化，高效且无死循环；核心记忆点：JDK1.8扩容关键是拆分高低位，低位留原下标，高位加旧容量，结合源码理解更透彻。阅读详情

CaOding

Java EE 67,535 成员 225,843 内容

+ 关注 + 加入社区

切换为时间正序

YuLimin 2006-12-03

打赏
举报

JCA(Java Connector Architecture) 提供了一个应用服务器和企业信息系统连接的标准Java解决方案，以及把这些系统整合起来实现最好的工作效率的方法。

JCA(J2EE Connector Architecture)是J2EE体系架构的一部分，为开发人员提供了一套连接各种企业信息系统(EIS，包括ERP、SCM、CRM等)的体系架构，对于EIS开发商而言，它们只需要开发一套基于JCA的EIS连接适配器，开发人员就能够在任何的J2EE应用服务器中连接并使用它。基于JCA的连接适配器的实现，需要涉及J2EE中的事务管理、安全管理及连接管理等服务组件。

MuseIn 2006-05-06

打赏
举报

The JCA Java Connector Architecture provides the most efficient way of thread pooling, resource pooling, transaction handling and consumption on JMS and other Resource Adapters. For example if you are consuming JMS messages, the JCA container provides the most efficient way of pooling the JMS sessions and connections, pooling threads and processing messages in parallel as well as transaction and exception handling.

The following are the steps to configure a Message Driven POJO in Spring with Jencks. There is the complete XML here

Configure the JCA Container
Just add the following to your Spring configuration file

<bean id="jencks" class="org.jencks.JCAContainer">


<property name="bootstrapContext">
<bean class="org.jencks.factory.BootstrapContextFactoryBean">
<property name="threadPoolSize" value="25"/>
</bean>
</property>


<property name="resourceAdapter">
<bean id="activeMQResourceAdapter" class="org.apache.activemq.ra.ActiveMQResourceAdapter">
<property name="serverUrl" value="tcp://localhost:51616"/>
</bean>
</property>
</bean>
Which will create the JCA container.

Notice that the bootstrapContext property is used to create the JCA BootstrapContext which includes the WorkManager (which is the JCA ThreadPool). This allows you to configure the thread pool size, transaction manager and so forth.

Notice that there is a work manager you can configure to set the thread pooling limits.

Also you can associate whichever JCA Resource Adapter you wish, such as to use another JMS provider. If you have a modern JMS like ActiveMQ it will come with its own optimised Resource Adapter. If your JMS provider does not have its own RA then consider using the GenericRA

Consuming inbound JMS messages
The following shows an example:

<bean id="inboundConnectorA" class="org.jencks.JCAConnector">

<property name="jcaContainer" ref="jencks" />


<property name="activationSpec">
<bean class="org.apache.activemq.ra.ActiveMQActivationSpec">
<property name="destination" value="test.spring.inboundConnectorA"/>
<property name="destinationType" value="javax.jms.Topic"/>
</bean>
</property>

<property name="ref" value="echoBean"/>
</bean>

<bean id="echoBean" class="org.jencks.TestBean" singleton="true"/>
The activation specification is dependent on the JCA Resource Adapter being used. If you are using ActiveMQ as your resource adapter then here are all the various properties you can configure, giving you full control over every aspect of the JMS subscription, pooling and delivery mode.

The POJO which implements the JMS MessageListener interface is referenced via the ref property in the inbound connector. The echoBean in this example can be any POJO created by Spring. If you wish you can use a spring singleton, or can add your own Spring interceptors around it - though note that Jencks already takes care of security and transaction handling for you automatically.

If you are using XA transactions on inbound messages and want to support recovery (that is on start up any in-progress transactions are recovered) then you must specify an id or name in the Spring XML configuration for the inbound connector as shown above. Failing to do so with a transaction manager such as Geronimo's will result in an exception during recovery.

Configuring the concurrency of message processing
One of the main points of using JCA is to allow you to process inbound messages concurrently in a thread pool using a pool of JMS connections and sessions. There are 2 main configuration points you can use in Jencks

the thread pool size defines the maximum number of concurrent messages that can be processed in Jencks across any subscription in that JCAContainer.
for some ActivationSpec implementations you can further configure the subscription to define the concurrency model. For example in ActiveMQ you can specify the maxSessions and maxMessagesPerSessions properties to configure how many concurrent messages can be processed for that subscription.
Using both approaches you can define how many threads are used for all the subscriptions and also how many of those threads can be used up by each subscription. This means you can segment your subscriptions to ensure one subscription doesn't overload other subscriptions.

You can also create multiple JCAContainer instances to allow you to have completely separate thread pools for different kinds of subscriptions if you wish.

Avoiding coupling your code to the JMS API
If you would rather avoid using the JMS MessageListener interface altogether you could use Spring Remoting with Jencks using the Lingo library.

Lingo is an implementation of Spring Remoting which adds remoting onto any POJO model. Lingo then takes care of all of the JMS code on both the client side and server side for you; marshalling things into and out of JMS Messages for you.

See the Lingo JCA example

Using XA
To use XA for an inbound connection in the JCA container you'll need to specify a transaction manager to the inbound connector. Here's an example

<bean id="inboundConnectorA" class="org.jencks.JCAConnector">

<property name="jcaContainer" ref="jencks" />


<property name="activationSpec">
<bean class="org.apache.activemq.ra.ActiveMQActivationSpec">
<property name="destination" value="test.spring.inboundConnectorA"/>
<property name="destinationType" value="javax.jms.Topic"/>
</bean>
</property>


<property name="transactionManager" ref="userTransaction"/>

<property name="ref" value="echoBean"/>
</bean>
You also need to provide a transaction manager implementation to use. Here this exampe uses Geronimo.

<bean id="transactionContextManager" class="org.jencks.factory.TransactionContextManagerFactoryBean"/>
<bean id="userTransaction" class="org.jencks.factory.GeronimoTransactionManagerFactoryBean"/>
<bean id="jtaTransactionManager" class="org.springframework.transaction.jta.JtaTransactionManager">
<property name="userTransaction" ref="userTransaction" />
</bean>
Sending outbound JMS messages
Jencks also supports JCA pooling and transaction support for Outbound JMS

✦双11狂欢大促✦

什么是JCA container？

相关推荐

双11狂欢大促