Spring 1.2.x Integration with WebLogic Server

Pages: 1, 2, 3, 4


The WebLogic Server security system supports and extends J2EE security while providing a rich set of security providers that can be customized to deal with different security databases or security policies. Besides using standard J2EE security, application programmers can use a wide array of proprietary extensions that allow an application to tightly integrate with the security system. WebLogic Server comes with several security providers offering, for example, choices of authentication databases that include most of the popular LDAP servers, Active Directory, native Windows, and a built-in authentication solution. The built-in providers can be augmented with custom providers to integrate with nearly any authentication database, authorization mechanism, and credential mapping service. Since Spring applications deployed as webapps leverage J2EE security you can get the benefit of WebLogic Server security without any changes to your application.

Seasoned Spring users will also be aware of Acegi—Spring's own security framework. Currently, you can use either Acegi, WebLogic Server security, or both in your application since each is mutually independent of the other. More on this later.

Distributed transactions

Spring provides infrastructure for transaction management. Along with support for various database vendors, Spring also supports distributed transactions through a J2EE vendor's JTA implementation. Spring's JTA manager can be configured to work in conjunction with WebLogic Server’s JTA implementation through the WebLogicJtaTransactionManager.

WebLogicJtaTransactionManager delegates responsibilities directly to WebLogic Server’s Java Transaction API. WebLogic Server’s JTA TransactionManager interface is available to clients and bean providers through JNDI, and Spring manages this interaction. The transaction manager also enables scope of transactions; transactions can operate within and between clusters and domains.

The most powerful feature of WebLogicJtaTransactionManager is its ability to manage distributed transactions and the two-phase commit protocol for enterprise applications. By employing WebLogicJtaTransactionManager, applications can take advantage of transaction monitoring through the WebLogic Administration Console. The WebLogicJtaTransactionManager also allows for per-database isolation levels, which enable complex transaction configuration.

<!-- spring's transaction manager delegates to WebLogic

  Server's transaction manager -->

<bean id="transactionManager"   class="org.springframework.transaction.jta.WebLogicJtaTransactionManager">

   <property name="transactionManagerName"



<!-- base transaction proxy for which medrec spring beans inherit-->

<bean id="baseTransactionProxy"   class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"


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

   <property name="transactionAttributes">


         <prop key="activate*">


         <prop key="create*">


         <prop key="compose*">


         <prop key="deny*">


         <prop key="getRecord*">


         <prop key="getPatient*">


         <prop key="getLog*">


         <prop key="process*">


         <prop key="save*">


         <prop key="send*">




< /bean>

<!-- single point of service for all medrec clients -->

<bean id="medRecClientServiceFacade"


   <property name="target">



         <property name="adminService">

            <ref bean="adminService"/>


         <property name="patientService">

            <ref bean="patientService"/>


         <property name="recordService">

            <ref bean="recordService"/>


         <property name="recordXmlProcessorService">

            <ref bean="recordXmlProcessorService"/>





For more information, see Overview of Transactions in WebLogic Server Applications and Implementing Transaction Suspension in Spring.

Java Management Extensions

Java Management Extension (JMX) is a specification for monitoring and managing Java applications. It enables a generic management system to monitor an application, raise notifications when the application needs attention, and change the state of your application to remedy problems. Spring offers extensive JMX support, which includes the ability to expose WebLogic Server’s MBeanServer through Spring’s MBeanServerConnectionFactoryBean. The MBeanServerConnectionFactoryBean is a convenience factory whose byproduct is an MBeanServerConnection. During application deployment, the connection is established and cached to be later operated on by referencing beans.

The MBeanServerConnectionFactoryBean can be configured to return WebLogic Server’s Runtime MBean Server, which exposes monitoring, runtime control, and the active configuration of a specific WebLogic Server instance. This includes access to WebLogic Server’s Diagnostics Framework. Additionally, the Runtime MBean provides access to runtime MBeans and active configuration MBeans for the current server.

The MBeanServerConnectionFactoryBean can also be configured to obtain a connection to WebLogic Server’s Domain Runtime MBean Server. The Domain Runtime MBean Server provides admission to domain-wide services such as application deployment, JMS servers, and JDBC data sources. It is also a single point for accessing the hierarchies of all runtime MBeans and all active configuration MBeans for all servers in the domain. This MBean Server also acts as a single point of access for MBeans that reside on managed servers.

Additionally, the MBeanServerConnectionFactoryBean can be configured to obtain a connection to WebLogic Server’s Edit MBean Server. The Edit MBean Server provides the entry point for managing the configuration of the current WebLogic Server domain.

Note that WebLogic Server’s Domain Runtime MBean Server is not active during deployment. Because of this, the bean needs to be configured using Spring’s lazy initialization, which fetches the bean when it’s invoked.

Here is an example of configuring Spring’s MBeanServerConnectionFactoryBean with WebLogic’s MBean Servers:

<!-- expose WebLogic Server's runtime

  mbeanserver connection -->

<bean id="runtimeMbeanServerConnection"


   <property name="serviceUrl"      value="service:jmx:t3://${WS_HOST}:${WS_PORT}/jndi/weblogic.management.mbeanservers.runtime"/>

   <property name="environment">


         <prop key="java.naming.security.principal">


         <prop key="java.naming.security.credentials">


         <prop key="jmx.remote.protocol.provider.pkgs">





For more information, see Understanding WebLogic Server MBeans and Spring’s JMX Support.


Starting with WebLogic Server 9.0 and Spring 1.2.5, BEA is making available support and certification of the Spring Framework on WebLogic Server. This support is no mere sanity testing of the Spring libraries on WebLogic Server, but has involved intense effort and collaboration between BEA and Interface 21—the creators and maintainers of the Spring Framework. Not only have we tested all the features and configurations that we described above with Spring 1.2.5, but some of the new features were introduced in Spring 1.2.5 directly as a result of BEA and Interface 21 collaboration. Some features require fixes for WebLogic Server itself and will be available as a Spring combo-patch.


The Spring Open Source Framework Support 1.2.5 download includes Spring 1.2.5 - certified on WebLogic Server 9.0 - the Spring-JMX console extension and the WebLogic Medical Records sample application re-written using the Spring Framework.

Future Work

In the future we plan to provide deeper integration between WebLogic Server and the Spring Framework. Although we have several ideas, some of the most interesting are:

  • Spring Deployment Unit: Spring applications are normally deployed as webapps, but it would be possible to provide a dedicated deployment unit for Spring applications.

  • Acegi and WebLogic Server Security Integration: Acegi is Spring's security framework, and we plan to integrate this with WebLogic Server's enterprise class security framework.

  • Use of EJB 3.0 for persistence: Since Spring in general manipulates POJOs, you will likely need some kind of object-relational mapping technology in order to persist Spring beans. With the advent of EJB 3.0, WebLogic Server will provide a standardized mechanism for achieving this.


We have spent some time looking at Spring, WebLogic Server, and the integration of the two technologies. As we have shown, Spring enables enhanced developer productivity while WebLogic Server enables enhanced application quality of service. Both technologies are highly non-invasive, allowing you to concentrate on developing the business functionality of your application rather than the intricacies of technology specific APIs.

Andy Piper is a Senior Staff Engineer in the WebLogic Server advanced development group. Andy has worked on WebLogic Server for the past 6 years and is responsible for many features and innovations.

Rod Johnson is the founder of the Spring Framework and a well-known expert on Java and J2EE. Rod is CEO of Interface21, a consultancy devoted to providing expert J2EE and Spring Framework services.

Chris Wall Chris Wall is a Senior Software Engineer on the Blended Team at BEA. Chris has a background in consulting in many industries including communications, high tech, and international trade.

Nick Tran is a senior software engineer at BEA systems and the lead for the WebLogic Server samples team. He is involved in the development of core API examples and end-to-end applications such as Medical Records.