Introduction
Our goal with this IBM Redbooks publication is to provide the information necessary for you to understand and take advantage of IBM WebSphere Application Server V8.5.5 Liberty (Liberty) within IBM CICS Transaction Server (CICS TS) V5.3. You will find the use of Liberty advantageous whether you intend to extend existing enterprise services hosted in CICS, or intend to develop new services supporting new lines of business.
The following topics are covered in this chapter:
1.1 What to expect from this book
This book provides a technical introduction to many of the concepts surrounding Liberty, including Java Enterprise Edition (Java EE) and the web profile. It then describes the steps necessary to develop, configure, and deploy web applications into the Liberty server within IBM CICS.
1.1.1 Intended audiences
This book provides information for a wide variety of roles from architects to application developers and CICS system programmers, and assumes that you are familiar with the basics concepts of CICS:
•Architects should review this chapter and all of the chapters in the technology essentials section Part 1, “Technology essentials” on page 15.
•Application developers should refer to:
•System programmers should refer to Part 2, “Up and running” on page 67.
1.1.2 Scenarios
With this book, you can find example code to quickly get up and running with Java EE 6 web applications and Liberty. Our main scenarios are based on the CICS general insurance application (GENAPP) Support Pack (CB12), which you can download and try for yourself by following examples in this book. Download it from the following website:
1.2 What is Liberty?
Fundamentally, Liberty is a modular implementation (or profile) of WebSphere Application Server technology. It is intended to provide a lighter weight and more dynamic runtime than the classic WebSphere Application Server runtime. It provides support for most of the Java Platform, Enterprise Edition technology previously supported in WebSphere Application Server, but in a composable runtime using configurable components termed features. Liberty is provided with WebSphere Application Server V.8.5 onwards, and runs on various distributed platforms as well as on z/OS. It is also available for developers as a download from the wasdev.net website.
A Liberty server can be provisioned with as little as the WebSphere Application Server kernel, web container, and HTTP transport features for a servlet engine. If you require access to a database, Liberty can dynamically initialize the Java Database Connectivity (JDBC) feature, or if you require a RESTful interface, the JAX-RS feature could be initialized. The approach of being able to select the features you require allows Liberty to initialize quickly with a basic web application and have the smallest footprint as possible in the system. The initialization of features and applications is achieved dynamically, meaning you are not usually required to restart your Liberty server to add features. This can be particularly powerful in development environments where developers need code changes to be reflected easily and immediately.
Liberty is built by using Open Services Gateway initiative (OSGi) technology and concepts. The fit-for-purpose nature of the run time relies on the dynamic behavior inherent in the OSGi framework and service registry. As bundles are installed to or uninstalled from the framework, the services that each bundle provides are added or removed from the service registry. The addition and removal of services similarly cascades to other dependent services. The result is a dynamic, composable run time that can be provisioned with only what your application requires and responds dynamically to configuration changes as your application evolves.
The Liberty server in CICS is supplied with and licensed through the installation of CICS TS for z/OS. It supplies the same Liberty technology as supplied with the IBM WebSphere Application Server Liberty products, but with a set of CICS specific user extensions, which provide for the integration with the CICS runtime.
1.2.1 Java EE 6
With Java EE 6 came the delivery of the Java EE 6 Web Profile. Much like the story of WebSphere Application Server and Liberty, until the introduction of the profiles, the Java EE 6 Full Platform was a run time that implemented as many application use cases possible. This approach of providing a large set of APIs meant that Java Platform, Enterprise Edition application servers need to provide the full set of Java Platform, Enterprise Edition APIs, although most applications would use only a small subset.
The introduction of profiles in Java EE 6 alleviates this issue by defining smaller subsets of APIs that are focused on particular styles of application. The first such profile is the Java EE 6 Web Profile. The Java EE 6 Web Profile is a subset of Java EE 6 APIs that are targeted to the creation of web applications.
Liberty inside of CICS TS V5.3 supports the Java EE 6 Web Profile and provides partial support for Java EE 6 full platform. Table 1-1 shows the relationship between the supported features of Liberty inside CICS and the corresponding Java Specification Request (JSR) implemented in the profile. A JSR is a request to develop a new specification or the revision of an existing specification that is delivered as part of Java. A list of all proposed and final JSRs can be found at the Java Community Process website:
Table 1-1 Liberty-supported features and corresponding JSRs
|
|
Liberty feature
|
JSR
|
Description
|
|
Java EE 6 Web Profile
|
beanValidation-1.0
|
JSR 303
|
Bean Validation
|
|
|
cdi-1.0
|
JSR 299
|
Contexts and Dependency Injection
|
|
|
ejbLite-3.1
|
JSR 318
|
EJB Lite subset of the EJB 3.1 specification
|
|
|
jdbc-4.0
|
JSR 221
|
Java Database Connector API
|
|
|
jpa-2.0
|
JSR 317
|
Java Persistence 2.0
|
|
|
jndi-1.0
|
JSR 316
|
Java Naming and Directory Interface
|
|
|
jsf-2.0
|
JSR 314
|
JavaServer Faces 2.0
|
|
|
jsp-2.2
|
JSR 245
|
JavaServer Pages 2.2
|
|
|
servlet-3.0
|
JSR 315
|
Java Servlet 3.0
|
|
|
webProfile-6.0
|
JSR 342
|
Java EE 6 Web Profile
|
|
Java EE 6 full platform
|
jaxb-2.2
|
JSR 222
|
Java Architecture for XML Binding 2.0
|
|
|
jaxrs-1.1
|
JSR 311
|
Java API for RESTful Web Services 1.1
|
|
|
jaxws-2.2
|
JSR 224
|
Java API for XML-Based Web Services 2.2
|
|
|
jca-1.6
|
JSR 322
|
Java EE Connector Architecture 1.6
|
|
|
jms-1.1
|
JSR 914
|
Java Message Service API 1.1
|
1.2.2 Java EE 7
Java EE 7 is the new evolution of the Java Enterprise Edition standard that embraces the latest standards such as HTML5 and web sockets, as well as removing inconsistencies in the existing standard and providing updates for most of the components. It is being rapidly adopted by the Java Platform, Enterprise Edition application server marketplace and at the time of writing is supported by the WebSphere Application Server Liberty FixPack6, and has been announced for support in classic WebSphere Application Server. For more information, see the following announcement letter:
Building on this position, IBM announced the following statement covering upcoming Java EE 7 support for CICS TS V5.3: “IBM intends to deliver support for Java applications that exploit Java EE 7 Full Platform features when running in the WebSphere Liberty profile that is integrated with IBM CICS Transaction Server for z/OS (CICS TS).”
For more information, see the following announcement letter:
1.2.3 Additional resources
More resources are available to support development with Liberty. The following list provides developer-focused community resources:
•WebSphere Application Server Liberty V8.5.5 IBM Knowledge Center
•Java Platform, Enterprise Edition 6 (Java EE 6) Specification
•WASdev community
The WASdev community is a hub for information about developing applications for WebSphere Application Server, and using Liberty in particular. Articles, podcasts, videos, and samples are refreshed regularly.
•WASdev forum
The WASdev forum provides an opportunity for users of Liberty to interact with each other and with the IBM developers working on the product.
•Stack Overflow tags
Stack Overflow is a Q&A site that is no cost to use. It allows users to ask and answer questions with built-in incentives to reward high-quality answers. Use the websphere-liberty tags to ask or answers questions about Liberty.
1.3 Benefits of running web applications in CICS
So, what are the benefits of running web applications using Liberty in CICS? There are many ways of analyzing this issue but stepping back, there are four key benefits that running web applications in CICS provides: Skills, integration, performance, and cost reduction.
1.3.1 Skills
An important benefit of Liberty in CICS is that it opens to CICS a whole new world of application development. The direction of training and skills growth today is moving towards Java and Java EE web applications. With Liberty in CICS, you can develop Java EE web applications in an integrated development environment (IDE) and then deploy them to CICS. This allows Java web developers to participate in developing, extending, and updating business applications for CICS. For instance, they can use a familiar Java API like JAX-RS to build a new service interface for invoking existing business application programs. They can use JSP technology or servlets to update the presentation interface for CICS transactions, and they can use other features in the Java EE 6 framework to build new business logic applications.
1.3.2 Integration
Integrating Java applications with existing CICS applications has been recognized by many customers as a cost-effective way of modernizing business applications by exploiting the mixed language application serving environment offered by CICS. Java components can run alongside existing COBOL, PL/I, and assembler applications, with CICS providing the runtime integration, without having to provide a dedicated new application server for the Java components.
1.3.3 Performance
An inherent benefit of running your Java EE web applications in a Liberty Java virtual machine (JVM) Server in CICS is the simplicity and speed of accessing CICS resources. A request from a web client enters Liberty and runs on a Java thread just like on any Java EE web server. However, the Liberty server is running within a JVM server in CICS. This results in the Java thread being integrated with CICS in such a way that the request also runs as a CICS transaction.
This means that access to CICS resources, such as a database or file, are highly optimized. There is no need for requests to travel through an adapter and across a network because the transaction has already begun. Put simply, it is generally faster to run your web application as close as possible to your data.
1.3.4 Cost reduction
All Java applications on z/OS can benefit from the price advantages of IBM z Systems specialty processors (IBM System z® Application Assist Processor (zAAP) or IBM System z Integrated Information Processor (zIIP)). Specialty processors provide a way to lower overall z Systems costs both in terms of hardware capital and in terms of software-based charging. Put simply, any Java code executes on a speciality engine. For Liberty web applications, this includes most of the Liberty server runtime, and any servlet or web-based components. However, any calls to CICS either via JCICS, JDBC type 2 drivers, or JCA local ECI will only run on a zIIP during the initial Java phase, as once within CICS workload will not be zIIP eligible.
So Liberty in CICS offers the best of all worlds. It is Liberty, a Java EE application server capable of hosting web applications built using Java EE 6 features and it is CICS, a familiar and robust transaction processing server providing close integration with your data. This combination offers opportunities to modernize presentation logic, leverage growing Java development skills, integrate legacy business processes with new interfaces, simplify and speed access to your data, and gain financially from running Java applications on zAAP processors.
The following subsections introduce three scenarios that illustrate ways that you can benefit from running web applications in a Liberty JVM server in CICS. In later chapters, each scenario is detailed further.
•Porting a web application to Liberty in CICS
•Creating an integration logic interface for existing CICS business logic
•Writing new Java business logic applications
1.3.5 Porting a web application
Web applications written by using the features of the Java EE 6 Web Profile subset can be hosted in CICS TS V5.3. This includes all of the core web container APIs, such as JSP and servlets. It also includes many of the common Java EE API and capabilities such as JAX-RS and JAX-WS and JDBC.
You might consider deploying existing web applications to CICS TS V5.3 for reasons of convenience, consolidation, or flexibility. However, a particularly compelling reason to make that move is for those applications that use the JCA ECI resource adapter to invoke a program on CICS TS. Figure 1-1 on page 7 shows a web application hosted outside of CICS and using JCA with CICS Transaction Gateway (CICS TG) to invoke a program on CICS TS.
Figure 1-1 JCA-based web application using CICS TG
The JCA ECI call shown in Figure 1-1 involves leaving the Java EE application server and going out through the JCA resource adapter via a network to the CICS Transaction Gateway and then on to a connected CICS region. If there are many such calls to CICS applications within the web application, it might make more sense to move the entire web application to the Liberty JVM server on CICS TS.
Figure 1-2 summarizes how the application might look after the web application is ported to a Liberty JVM server in CICS TS V5.3.
Figure 1-2 JCA-based web application running in CICS
Figure 1-1 and Figure 1-2 show how you can consolidate the two halves of this type of web application. The front-end web application runs in a Liberty JVM server in the same CICS region as the program invoked through JCA. This “lift and shift” consolidation has the potential to improve the performance of the web application by eliminating the network latency. Improved performance is more likely to be realized in cases where the web application makes frequent calls to the CICS COBOL program, or large amounts of data are transferred.
In Figure 1-2, notice that JCA straddles the boundary between Liberty and the JVM server and CICS. This represents that the CICS implementation of the cicsts:JcaLocalEci-1.0 feature treats the JCA ECI call in much the same manner as a local JCICS Program.link(). This technique ensures that the call is highly optimized as well as provides the opportunity for the Liberty JVM server to become a front-end liberty-owning region (LOR). The target programs of the ECI calls could all be defined as dynamic and routed to a series of back-end application-owning regions (AORs) using CICSPlex SM dynamic routing.
In addition to JCA ECI resource adapter calls, there are other ways that a web application can invoke business logic applications in CICS TS. These include web requests via HTTP, web services calls using XML and SOAP, and Java Message Service (JMS) applications. In many cases, web applications that use these methods of communicating with CICS TS can also be ported to a Liberty JVM server in CICS TS with little or no modification.
1.3.6 Creating an integration logic interface
A big benefit of Liberty in CICS is being able to take advantage of the existing and growing pool of Java development skills. For example, those skills can be put to use developing a RESTful (JAX-RS) or web service (JAX-WS) Java application that provides a new service interface to an existing business logic program in CICS TS. Such an application can be deployed directly into a Liberty JVM server collocated with the business logic program in the same CICS region. Refer to Figure 1-3.
Figure 1-3 Integration with existing CICS business logic
Chapter 10, “Creating an integration logic application” on page 179 gives an example of exposing existing COBOL business logic as a RESTful web service though a Liberty web application.
1.3.7 Creating a Java business logic application
In the previous two sections, the web application was presented as a pass-through to the core business logic contained in the COBOL program. The natural progression to this is to develop new web applications that handle the business logic. With Liberty in CICS, Java EE developers can use Java EE frameworks and APIs such as Enterprise JavaBeans (EJB), Java Persistence API (JPA), Java Transaction API (JTA), and CDI Managed Beans to develop such applications. These new applications can use the JCA local ECI resource adapter to invoke CICS applications, the JCICS classes to access CICS resources such as VSAM files, and JDBC data sources to access relational databases such as IBM DB2® or Derby (Figure 1-4).
Figure 1-4 Java business logic applications in CICS
Chapter 11, “Creating a business logic application” on page 191 gives an example of creating new Java business logic in a Liberty JVM server to supplement an existing COBOL business application.
1.4 What’s new in Liberty for CICS TS V5.3
As with previous versions, CICS TS V5.3 delivers support for a new set of features in Liberty. This now includes the Java EE 6 Web Profile, as well as a growing subset of features from WebSphere Application Server Liberty V8.5.5.
1.4.1 Supported Liberty features
The following list describes the currently supported set of Liberty features supported in CICS TS V5.3 along with the CICS user features that provide for integration with the CICS runtime. This list is likely to be further extended during the lifetime of CICS TS V5.3. For the latest information, see the CICS TS V5.3 IBM Knowledge Center at this location:
appSecurity-2.0
The appSecurity-2.0 feature enables support for securing your server and applications. This feature includes a basic user registry and allows the implementation of basic user name and password authentication and Lightweight Third Party Authentication (LTPA) token authentication.
beanValidation-1.0
The beanValidation-1.0 feature provides an annotation-based model for validation JavaBeans. JavaBeans are classes that encapsulate many Java objects into a single object known as a bean. The beanValidation-1.0 feature can be used to assert and maintain the integrity of data as it travels through an application.
blueprint-1.0
The blueprint-1.0 feature enables support for deploying OSGi applications that use the OSGi blueprint container application. The Blueprint Container Specification defines a dependency injection framework for OSGi and provides a simple and easy programming model for creating dynamic applications in the OSGi environment without adding complexity to the Java code.
cdi-1.0 and managedBeans-1.0
The cdi-1.0 feature enables the context and dependency injection (CDI) platform for your applications. When activated, it provides these benefits:
•Context management
•Type-safe dependency injection
•Decorators
•Interceptor bindings
•Event model
•Integration into JSF and JSP files using Expression Languages.
The managedBeans-1.0 feature enables support for the Managed Beans 1.0 specification. Managed Beans provide a common foundation for different Java EE component types that are managed by a container. Common services provided to Managed Beans include resource injection, lifecycle management, and the use of interceptors.
ejbLite-3.1
Enterprise JavaBeans (EJB) technology is the component architecture for developing and deploying business logic applications in Java. EJB provides a set of features that allow developers to produce transactional, secure, and portable applications. Because most applications will not use the full set of features available with EJB, Ejblite was introduced to provide a subset of the most common features of EJB without any of the remote Internet Inter-ORB Protocol (IIOP) connectivity.
jaxb-2.2
The jaxb-2.2 feature enables support for the Java Architecture for XML Binding (JAXB) 2.2 specification. JAXB is a useful technology for developing Java web services and provides two main features, the ability to serialize Java objects into XML, and the inverse, parsing XML into Java objects.
jaxrs-1.1
The jaxrs-1.1 feature enables support for Java API for RESTful Web Services 1.1, and is the key API for developing RESTful-based Java applications. It supports the use of annotations to define web service clients and servers that utilize a Representational State Transfer (REST) architectural style. In 1.3.6, “Creating an integration logic interface” on page 8, we utilize the jaxrs-1.1 feature to expose an application as a JavaScript Object Notation (JSON) RESTful web service.
jaxws-2.2
The jaxws-2.2 feature enables support for the Java API for XML-Based Web Services 2.2, and is used together with JAXB to create Java web services. The feature allows annotation-based handling of XML web services requests into applications.
jca-1.6
The jca-1.6 feature enables the development and use of the Java EE Connector Architecture (JCA) resource adapters. JCA defines an architecture for connecting Java EE applications to enterprise information systems (EISs) applications outside of Java. The jca-1.6 feature is a requirement for the JCA local ECI resource adapter, which is provided by the cicsts:jcaLocalEci0.1-0 feature.
jdbc-4.0
The jdbc-4.0 feature enables the use of Java Database Connectivity (JDBC) technology. The feature enables the configuration of data sources to access databases. This is provided through a Java API that provides querying and manipulating data in a database. This can be used in CICS Liberty to access a remote data source using a type 4 JDBC driver. All access to a local DB2 must use the cicsts:jdbc-1.0 feature and the DB2 type 2 driver.
jms-1.1, wasJmsClient-1.1, wasJmsServer-1.1, wasJmsSecurity-1.0
The Java Message Service (JMS) API is for creating, sending, receiving, and reading messages between clients. The wasJmsClient-1.1 and wasJmsServer-1.1 features are available for Liberty in CICS and provide access to WebSphere Application Server embedded messaging clients running in Liberty or classic WebSphere Application Server. MQLink, which allows IBM MQ and WebSphere Application Server messaging to interact, is not supported within Liberty.
The wasJmsSecurity-1.0 feature enables the WebSphere Embedded Messaging Server to authenticate and authorize access from JMS clients.
jmsMdb-3.1, mdb-3.1
Message-driven beans (MDBs) provide a means for the asynchronous inbound processing of messages when using JMS.
jndi-1.-0
The jndi-1.0 feature enables the use of Java Naming and Directory Inventory (JNDI) to access server-configured resources. JNDI is a Java API for a directory service that allows applications to look up data and objects by using their name.
jpa-2.0, osgi-jpa-1.0
The Java persistence API specification is an API that provides a mechanism for managing persistence and object-relational mapping and functions. Persistence is important to enterprise applications because of the required access to relational databases. Until the EJB 3.0 specification, enterprise applications were required to manage persistence themselves or use third-party solutions to handle database manipulation.
JPA represents a simplification of the persistence programming model. The JPA specification explicitly defines the object-relational mapping, rather than relying on vendor-specific mapping implementations.
json-1.0
The json-1.0 feature provides access to the JavaScript Object Notation (JSON4J) library, and is used together with JAXRS to create RESTful services. The JSON4J library provides a Java model for constructing and manipulating data to be rendered as JSON data. In 1.3.6, “Creating an integration logic interface” on page 8, we utilize the json-1.0 feature to expose an application as a JSON RESTful web service.
ldapRegistry-1.0
The ldapRegistry-1.0 feature enables support for using a Lightweight Directory Access Protocol (LDAP) server as a user registry. LDAP is a lightweight application protocol used to connect, search, and modify information about users, systems, and services. This information can then be shared across all systems that are connected to the LDAP server. LDAP security registries are supported in CICS Liberty with the cicsts:distributedIdentity-1.0 feature.
mongodb-2.0
MongoDB is a popular no-SQL database. MongoDB trades the traditional table-based relational database structure with JSON-like documents. These JSON-like documents use dynamic schema that can make integration of applications easy. The mongodb-2.0 features enable the use of a MongoDB database on a remote system.
monitor-1.0, restConnector-1.0, and localConnector-1.0
The monitor-1.0, restConnector-1.0, and localConnector-1.0 features provide monitoring and analysis capabilities for Java applications and components using Java Management Extensions (JMX) Technology.
The monitor-1.0 features enable the monitoring support for the following user runtime components:
•JVM
•Web applications
•Thread pool
•Session management
•Connection pools
The localConnector-1.0 feature provides the ability for local JMX client applications to access this information using JMX and MBeans. The restConnector-1.0 feature provides remote access to the MBeans using remote RESTful calls into the Liberty secure HTTPS listener.
osgiConsole-1.0
Eclipse Equinox provides an OSGi console that you can use for debugging your OSGi runtime. It can be used to display information about bundles, packages, and services, which can be useful when developing your own features for product extensions.
sessionDatabase-1.0
The database session persistence feature enables HTTP sessions to be stored in a locally configured relational database. This allows servlet session persistence to be shared between multiple Liberty servers and to be recovered across a Liberty server restart. This can be utilized for HTTP connection balancing and high availability configurations. For more information about high availability, see Chapter 3, “Workload management” on page 45.
servlet-3.0, jsp-2.2 and jsf-2.0
The servlet-3.0 feature enables support for HTTP servlets written to the Java Servlet 3.0 specification. The jsp-2.2 feature enables support for JavaServer Pages (JSP) that are written in the JSP 2.2 specification. The jsf-2.0 feature enables support for web applications that use the JavaServer Faces framework. These three technologies make up the foundation of the web application framework for Java applications. For more information about these technologies, see 2.1.1, “Web invocation options” on page 18.
ssl-1.0
The ssl-1.0 feature enables support for Secure Sockets Layer (SSL) connections. A secure HTTPS listener is not started unless the ssl-1.0 feature is enabled.
wab-1.0
The wab-1.0 feature enables the use of web application bundles (WABs) in OSGi applications. WABs are OSGi bundles that are internally structured the same way as a war file and support the same web components. They are deployed in an enterprise bundle archive (EBA) when deployed into a Liberty JVM server.
webcache-1.0 and distributedMap-1.0
The webcache-1.0 feature enables local caching of web application responses to improve response times and throughput, by using the WebSphere DynaCache technology. It achieves this by enabling and using the distributed-Map-1.0 feature, which provides a local cache service.
1.4.2 CICS features
CICS provides a set of user feature extensions, which provide the integration between the CICS runtime and Liberty.
cicsts:core-1.0
This is the core integration feature that provides the runtime integration, the JCICS API, and the transaction support for JTA. It should always be configured.
cicsts:distributedIdentity-1.0
This provides support for distributed identity mapping of credentials from an LDAP registry. This allows an external LDAP registry to be used for authentication, in conjunction with the cicsts:security-1.0 feature and CICS transaction and resource security for authorization. This feature is new in CICS TS V5.3.
cicsts:jcaLocalEci-1.0
This provides support for the locally optimized JCA ECI resource adapter in CICS. This enables JCA-based applications developed using the CICS Transaction Gateway ECI resource adapter to be deployed into CICS without modification.
cicsts:jdbc-1.0
This provides support for JDBC applications that need to use the CICS local DB2 attachment facility via a data source definition and the JDBC type 2 driver.
cicsts:security-1.0
This is the core integration feature that provides the runtime integration, the JCICS API, and the transaction support for JTA.
cicsts:zosConnect-1.0
This provides support for RESTful services deployed into CICS using z/OS Connect.
1.4.3 Unsupported APIs
There are several technologies categorized as optional in Java EE 6 that are not supported in the WebSphere Application Server Liberty implementation, but were previously supported in the classic WebSphere Application Server Java EE 6 runtime. The key technologies that you might encounter are JAX-RPC 1.1, JAXR 1.0, and EJB Entity Beans. Here are some details:
•JAX-RPC: Java API for XML-based RPC (JAX-RPC) specification enables you to develop SOAP-based interoperable and portable web services and web service clients. Its use for web services has been superseded by JAX-WS, which is supported in WebSphere Liberty.
•JAX-R: Java API for XML Registries (JAX-R). The Java Platform, Enterprise Edition (Java EE) 6 platform began the deprecation process for JAX-R because it is based on Universal Description, Discovery, and Integration (UD-DI) 2 technology, which is no longer relevant. If your applications use JAX-R, you might consider using UDDI 3.
•EJB: EJB Entity Beans are declared optional in Java EE 6 specification and are not supported in WebSphere Liberty. They provided a way of abstracting persistent data maintained in a relational database. Their usage has largely been superseded by the Java Persistence API (JPA) or third-party frameworks, such as Hibernate.
In addition, the EJB 1.1 and 2.0 interfaces are only supported by the JEE7 EJB remote feature on Liberty. Therefore, the ejbLite-3.2 feature does not support deployment of EJB 1.1 and 2.0 components.
Migration tools
The WebSphere Application Server Migration Toolkit Version 8.5.5 can be used to help in migrating your existing web applications to Liberty V8.5.5. This can be done by scanning the source code or static binary files of your applications and provide you with information about the preceding Java EE application API compatibility and highlight any changes that you might be required to make when moving from one version of Liberty to another. It also highlights any vendor-specific APIs that are not portable between Java Platform, Enterprise Edition application server. The toolkit can also be used when moving from other Java EE servers to Liberty.
For more information about the WebSphere Application Server Migration Toolkit, see 2.7, “Migrating a Java EE application to Liberty” on page 42.
..................Content has been hidden....................
You can't read the all page of ebook, please click here login for view all page.