Previous | Home | Next

Working with applications

Integrated standards-base programming models and extensions

Many of the core programming models in WAS V8.5 were available through feature packs in Versions 7.0 and 8.0. Now, these programming models are built into WAS V8.5.

Available programming models:

• Session Initiation Protocol applications
• WebSphere Batch programming model
• OSGi applications programming model
• Communications enabled applications
• Service Component Architecture programming model
• Extensible Markup Language programming model
• Integrated Web Services support
• Integrated WAS Web 2.0 and Mobile Toolkit support
• Simplified development of server-side REST applications using Java API for RESTful Web Services

• IBM WebSphere SDK Java Technology Edition v7.0

Session Initiation Protocol applications

Session Initiation Protocol (SIP) applications are Java programs that use at least one SIP servlet written to the JSR 116 specification. WAS V8.5 also supports SIP Servlet Specification 1.1, also referred to as JSR 289. SIP is used to establish, modify, and terminate multimedia IP sessions. SIP negotiates the medium, the transport, and the encoding for the call. After the SIP call is established, the communication takes place over the specified transport mechanism, independent of SIP. Examples of application types that use SIP are voice over IP (VOIP), click-to-call, and instant messaging.

Session Initiation Protocol (SIP) applications are packaged as SIP archive (SAR) files, and are deployed to the application server using the standard WAS administrative tools. SAR files can also be bundled in a Java EE application archive (EAR file), similar to other Java EE components.

In the application server, the web container and SIP container are converged and are able to share session management, security, and other attributes. High availability of these converged applications is made possible because of the integration of HTTP and SIP in the base application server. More information: SIP applications, see the following resources:

WebSphere Batch programming model

WebSphere Batch provides a transactional batch programming model (large number of small and repetitive operations) and a compute-intensive programming model (small number of CPU/Memory intensive operations). Both the transactional batch and compute-intensive programming models are implemented as Java objects. They run as background jobs, described by a job control language and are supported by infrastructure components that aim to support batch workloads.

The control language for batch jobs is called XML job control language (xJCL). The xJCL allows users to describe the job steps involved in a batch job. The application runs in batch containers that run in designated WAS environments. The batch container ultimately processes a job definition and carries out the lifecycle of a job.

The batch container provides the following services:

• Checkpointing, which involves resuming batch work from a selected position.
• Result processing, which involves intercepting and processing step and job return codes.
• Batch data stream management, which involves reading, positioning, and repositioning data streams to files, relational databases, native z/OS data sets, and many other different types of input and output resources.

The batch workload...

1. Batch jobs are submitted to the system using the Job Management Console or programmatically by EJBs (EJB), JMS, or web services.

2. Each job is submitted in the form of an XML Job Control Language (xJCL) document.

3. The batch scheduler analyzes the request.

4. The job is dispatched to the best endpoint for job execution based on several different metrics.

5. The endpoint sets up the jobs in the batch container and begins executing the batch steps based on the definitions in the xJCL.

6. The batch application is invoked.

The Job Dispatcher aggregates job logs and provides lifecycle management functions, such as start, stop, cancel, and so on.

Features in WAS V8.5 for WebSphere Batch

In addition to fully incorporating WebSphere batch functions into WAS V8.5, the following new enhancements are included:

• Parallel batch, which has the ability to split the work and process jobs as multiple subordinate jobs concurrently.

• Enterprise integration, which allows for management of Batch Jobs from an external workload scheduler tool, such as Tivoli Workload Scheduler.

• Cobol support, which allows the usage of Cobol modules in WebSphere applications.

• CommandRunner utility job step, which allows shell command lines (including scripts and compiled programs) to be run as job steps.

See:

• WAS V8.5 Concepts, Planning, and Design Guide, chapter 6

OSGi applications programming model

OSGi applications are modular applications that use both Java EE and OSGi technologies.

We can design and build applications and suites of applications from coherent, versioned, and reusable OSGi modules that are accessed only through well-defined interfaces. This enables the same, or different, applications to use different versions of the same third-party libraries without interference.

OSGi applications allow the composition of isolated enterprise applications using multiple, multi-version bundles that have dynamic life cycles. Application maintenance and upgrades can be simplified using standard OSGi mechanisms to simultaneously load multiple versions of classes in the same application.

The OSGi applications support in WAS includes the following major capabilities:

• Use the OSGi Service Platform Release 4 Version 4.2 Enterprise Specification Blueprint Container for declarative assembly of components. The container simplifies unit tests outside of the application server.

• Use extensions to the Blueprint component model for declarative transactions and container-managed Java Persistence API (JPA).

• Develop OSGi application projects using Rational Application Developer, which enforces OSGi visibility rules.These rules allow projects to only access packages from other projects that explicitly declare them as part of the project externals. This provides environmental support to development best practices.

• Compose isolated enterprise applications using multiple, versioned bundles with a dynamic lifecycle.

• Deploy applications in archive files containing only application-specific content and metadata that points to shared bundles. This means that application archive files can be smaller. It also means that, when a library is shared by several OSGi applications, only one copy of the library is loaded into memory.

• Extend and scale running applications as business needs change without changing the underlying application.

• Update a running application only impacting those bundles affected by the update.

• Use an integrated bundle repository, and configure the locations of external repositories, to support the provisioning of bundles to applications.

• Deploy existing web application archive (WAR) files as web application bundles (WABs). This allows web applications to use the OSGi module system.

• Deploy web applications that use v3.0 of the Java Servlet Specification.

• Deployment of EJB in OSGi bundles (New in V8.5).

• Enhanced security provided by bean security in the Blueprint XML file of OSGi Applications (New in V8.5).

• Simultaneously load multiple versions of classes in the same application using standard OSGi mechanisms.

• Administratively update deployed applications in a modular fashion, at the bundle-level.

• Deploy applications that use their own versions of common utility classes, distinct from the versions used by the server runtime environment. This can be done without configuring application Java EE class loader policies, such as PARENT_LAST mode.

• Use federated lookup mechanisms between the local JNDI and the OSGi service registry.

See:

1. WAS V8.5 Concepts, Planning, and Design Guide, section 11.2.2
2. Overview of the purpose of OSGi
3. The OSGI home page

Communications enabled applications

The Communications Enabled Applications (CEA) support in WAS V8.5 allows you to add dynamic web communications to any application or business process. CEA provides Representational State Transfer (REST) and web service interfaces to enable existing applications to take advantage of communication features involving phone calls and web collaboration.

With the CEA capability, enterprise solution architects and developers can use a single core application to enable multiple modes of communication. CEA applications do not require developers to have extensive knowledge of telephony or SIP. CEA capabilities deliver call control, notifications, and interactivity, providing the platform for more complex communications.

Using this simplified programming model for adding web-based communications, enterprise developers can perform the following tasks:

• Quickly add communications support to any application, for example, click-to-call integration.

• Enable shared sessions between users and company representatives.
• Push relevant session data for application use, for example, customer phone numbers.
• Deliver automated notifications and instant messaging support.
• Provide enterprise-grade security, scalability, and high availability.
• Integrate with customer private branch exchange (PBX) systems.

Deprecated feature: CEA Dojo widgets encapsulate various user interfaces that are based on the CEA REST API. These widgets are deprecated. We can also obtain the source for these widgets from IBM developerWorks®.

Service Component Architecture programming model

Service Component Architecture (SCA) is a set of specifications that constitute a programming model for building applications using an SOA. SCA extends other SOA technologies, such as web services, and provides a platform and language-neutral component model based on open standards specified by the Open SOA Collaboration. SCA allows the creation of complex composite applications based on previously existing service components.

The features of SCA support include:

• POJO service-component implementations, including support for annotations
• Asynchronous capability
• Recursive composition model support
• Support for SCA services developed from existing WSDL files or Java code
• Deployment of SCA composites in business-level applications
• SCA authorization and security identity policies
• PassByReference optimization for SCA applications
• Several binding types, including web services binding, SCA default binding, EJB, JMS, Atom, and HTTP bindings

• Support for JAXB data bindings in SCA applications

• SCA annotations for Java EE web modules, session beans, and message-driven beans

• Preview of native SCA deployment

• Spring 2.5.5 containers in SCA applications

• OSGi applications as SCA implementations

• Service Data Objects 2.1.1

• Support for SCA OASIS programming model implementation

• Sample SCA composites compiled specifically for use with the product

See: WAS V8.5 Concepts, Planning, and Design Guide, section 11.2.1

Extensible Markup Language programming model

XML structured data has become the predominant format for data interchange. XML data is navigated, queried, or transformed in almost every existing application that runs on WAS V8.5. This release delivers critical technology that provides application developers with support for the following key World Wide Web Consortium (W3C) XML standards:

• Extensible Stylesheet Language Transformations (XSLT) 2.0
• XML Path Language (XPath) 2.0
• XML Query Language (XQuery) 1.0

These W3C XML standards offer application developers numerous advanced capabilities for building XML applications. WAS V8.5 support for XML has the following key features and capabilities:

• An XML application development environment tuned for developer productivity
• An XML runtime API that offers consistent execution and data navigation API that allows access to existing Java logic

• The ability to query large amounts of data stored in XML outside of a database with XQuery 1.0
• Optimum XML-application performance
• XML-application reliability with support for XML schema-aware processing and validation
• 40+ preconfigured samples including four end-to-end scenarios

Integrated Web Services support

WAS V8.5 supports web services developed and implemented based on the Web Services for Java EE specification, V1.3. This specification supports WSDL v1.1, SOAP v1.1 and SOAP V1.2. The application server supports the Java API for the XML Web Services (JAX-WS) programming model and the JAX-RPC programming model.

Java Architecture for XML Binding (JAXB) 2.2 provides a convenient way to map Java classes and XML schema for simplified development of web services. v2.2 provides minor enhancements to its annotations for improved schema generation and better integration with Java API for XML-based web services.

JAX-WS 2.2 simplifies the development of web services with more platform independence for Java applications by the use of proxies and Java annotations. JAX-WS 2.2 requires JAXB 2.2.

Integrated WAS Web 2.0 and Mobile Toolkit> support

The WAS Web 2.0 and Mobile Toolkit simplifies the addition of AJAX rich desktop and mobile user interfaces and REST web services to web applications. Web 2.0 capabilities, such as AJAX and REST, help application developers to create more connected, interactive applications, that result in higher customer satisfaction, user productivity, and enhanced decision making. New mobile AJAX components enable developers to create mobile web applications that run on devices, such as smart phones and tablets.

Simplified development of server-side REST applications using Java

API for RESTful Web Services Java API for RESTful Web Services (JAX-RS) offers a simpler way to develop, consume, and scale REST applications. It is composed of a collection of interfaces and Java annotations that simplifies the development process. With the annotations, we can declare resource classes and the data types they support. It also allows developers to gain access to the runtime context. Through its extensible framework, it is also possible to integrate custom content handlers.

IBM WebSphere SDK Java Technology Edition v7.0

WAS V8.5 supports IBM WebSphere SDK Java Technology Edition v7.0 as a pluggable JDK. Java 6 is installed with the product and used by default. Java 7 can be optionally installed and enabled using the managesdk tool. This IBM SDK provides a full-function SDK for Java compliant with the Java SE 7 APIs. The SDK contains the Java application Runtime Environment and other tools that enable developers to create Java applications.

Monitored directory support

Simply by dragging and dropping applications into a defined and monitored directory, we can speed the process of editing, compiling, deploying, debugging, updating, and uninstalling applications. When an application is moved into the directory, after a defined interval, it is automatically installed and started. Likewise, if the application is removed from the directory, it is stopped and uninstalled. If the application or module is moved into the directory again, it is updated. The supported file types are:

• Enterprise Archive (EAR)
• Web Application Archive (WAR)
• JAR
• SIP Application Resource (SAR)

The Liberty profile

The Liberty profile is a highly composable, fast to start, dynamic application server runtime environment. It allows you to provision only the features required by the application (or set of applications) and deployed to the server. For example, if an application requires just a servlet engine, the Liberty profile can be configured to only start the WAS kernel, the HTTP transport, and the web container.

The Liberty profile provides a simplified and lightweight application-serving and development environment optimized for operational and developer productivity. This profile is intended for use with web applications that do not require a full Java Platform, Enterprise Edition (Java EE) stack. The Liberty profile also provides enterprise qualities of service, such as security and transaction integrity.

The Liberty profile includes the following key features:

• A dynamic and flexible runtime to load only what the application needs
• A quick startup time (under five seconds with simple web applications)
• A simplified configuration that uses a single configuration file or modular configuration
• Support for deploying applications developed in the Liberty profile to run in the full profile
• Support of web applications, OSGi applications, and Java Persistence API (JPA)
• Support for LDAP registry
• Ability to deploy an application and configured server as a package
• Managed, centralized deployment to many nodes of a packaged application and server
• Availability of WAS Developer Tools as Eclipse plug-ins for broad tooling support
• Support for z/OS platform native features like System Authorization Facility (SAF), Resource Recovery Service (RRS) and z/OS workload management (WLM).

IBM Assembly and Deploy Tools for WebSphere Administration

The IBM Assembly and Deploy Tools for WebSphere Administration is targeted to help in the assembly and deployment of applications only. It does not provide development capabilities.

The IBM Assembly and Deploy Tools have the following key components:

• Import and validate applications
• Edit deployment descriptors and binding files
• Edit EAR-level configuration (Enhanced EAR)

• Create and debug Jython and wsadmin scripts
• Deploy EJB and web services
• Deploy applications to local or remote WAS V8.5 servers
• Debug applications on WAS V8.5

WAS Developer Tools for Eclipse, V8.5

The IBM WAS Developer Tools for Eclipse, V8.5 is a lightweight set of tools for developing, assembling, and deploying Java EE, OSGi, Web 2.0 and mobile applications. The tool supports WAS V8.5 (including the Liberty profile), WAS V8.0, and WAS V7.0. In combination with the WAS V8.5 Liberty profile, this tool provides a fast and lightweight environment for the rapid development and unit testing of web, Web 2.0, mobile, and OSGi applications.

For more information, refer to the Information Center

Rational Application Developer for WebSphere Software V8.5

Rational Application Developer for WebSphere Software V8.5 offers a more extensive set of tools that support enterprise development. IBM Rational Application Developer for WebSphere Software V8.5 can be used to design, develop, analyze, test, profile, and deploy high-quality web, SOA, Java, Java EE, and portal applications.

This product includes the following features:

• Fully-integrated tools and support for IBM WAS V6.1 through V8.5
• Tools, including many simple wizards and visual editors, that fully support the Java EE programming model, including web, Java, web services, and EJB applications
• Code quality, testing, and deployment tools, such as the enhanced runtime analysis to detect memory leaks or thread locks
• Web 2.0, OSGi, Java Persistence API 2.0, SCA, XML, CEA, portal and web services development features
• IBM Workload Deployer (cloud) support
• Support for Java 7
• Ant scripting and JUnit testing framework
• WebSphere performance profiling and logging
• Agile development support with tools for refactoring code and unit testing
• Automated tools to manage server instances and server configurations, including automated creation and submission of wsadmin scripts
• Integration with IBM Rational Team Concert and IBM Rational ClearCase so that management operations can be performed within the development environment and increase collaboration and team productivity

WebSphere Adapter Support for third-party products, such as SAP, PeopleSoft Enterprise, Siebel, Oracle E-Business Suite, and JD Edwards

Unified Modeling Language (UML) modeling function Rational Application Developer for WebSphere Software V8.5 provides support for batch and Java Persistence API development. The Liberty tool provides support for installing the Liberty run time from a compressed file and creating and editing liberty bindings and extensions. The Liberty tool provides applications that can be created, compiled, profiled, and debugged using Java 7.

New features of Rational Application Developer for WebSphere Software V8.