3 Developing a WebLogic Thin T3 Client

Learn how to develop and use WebLogic Thin T3 clients.

Understanding the WebLogic Thin T3 Client

The WebLogic Thin T3 Client jar (wlthint3client.jar) is a light-weight, high performing alternative to the wlfullclient.jar and wlclient.jar (IIOP) remote client jars. The Thin T3 client has a minimal footprint while providing access to a rich set of APIs that are appropriate for client usage. As its name implies, the Thin T3 Client uses the WebLogic T3 protocol, which provides significant performance improvements over the wlclient.jar, which uses the IIOP protocol.

The Thin T3 Client is the recommended option for most remote client use cases. There are some limitations in the Thin t3 client as outlined below. For those few use cases, you may need to use the full client or the IIOP thin client.

The Thin T3 client can be used in standalone applications, and is also designed for applications running on foreign (non-WebLogic) servers. One common use case is integration with WebLogic JMS destinations.

WebLogic Thin T3 Features

This release supports the following:

  • Oracle WebLogic's T3/T3S protocol for Remote Method Invocation (RMI), including: RMI over HTTP (HTTP tunneling) and RMI over HTTPS (HTTP Tunneling over SSL). For more information on WebLogic T3 communication, see Using WebLogic RMI with T3 Protocol in Developing RMI Applications for Oracle WebLogic Server.

  • Access to JMS, JMX, JNDI, and EJB resources available in WebLogic Server.

  • The WebLogic Store-and-Forward (SAF) Service using the wlsaft3client.jar.

  • Transaction initiation and termination (rollback or commit) using JTA.

  • WebLogic client JMS features, including Unit-of-Order, Unit-of-Work, message compression, XML messages, JMS automatic client reconnect, and Destination Availability Helper APIs.

  • Client-side clustering allowing a client application to participate in failover and load balancing of a WebLogic Server instance. See Clustered RMI Applications in Developing RMI Applications for Oracle WebLogic Server.

  • JAAS authentication and JSSE SSL. See Security.

  • Network class loading. By default the network class loading for the Thin T3 client is disabled. Use the following system property to enable network classloading:

    -Dweblogic.rmi.networkclassloadingenabled=true

Limitations and Considerations

This release does not support the following:

  • Mbean-based utilities (such as JMS Helper, JMS Module Helper), and JMS multicast are not supported. You can use JMX calls as an alternative to "mbean-based helpers."

  • JDBC resources, including WebLogic JDBC extensions.

  • Running a WebLogic RMI server in the client.

The Thin T3 client uses JDK classes to connect to the host, including when connecting to dual-stacked machines. If multiple addresses available on the host, the connection may attempt to go to the wrong address and fail if the host is not properly configured.

Interoperability

This release of the WebLogic Thin T3 client has the following interoperability support:

Prior WebLogic Server Releases

For information on WebLogic Thin T3 client support for communicating with previous WebLogic releases, see Protocol Compatibility in Understanding Oracle WebLogic Server.

Foreign Application Servers

The WebLogic Thin T3 client jar is supported on the following application servers:

  • GlassFish

  • IBM WebSphere Application Server

  • Red Hat JBoss Application Server

Security

For general information on client security see:

Connection Considerations

The WebLogic Thin T3 client uses JDK classes to connect to the host. If your host has multiple addresses (Dual-Stack) available, your client may connect to the wrong IP address if the host is not configured properly.

Developing a Basic WebLogic Thin T3 Client

Learn how to create a basic WebLogic Thin T3 client using a WebLogic Initial Context.

Use the following steps to create a basic WebLogic Thin T3 client:

  1. Obtain a reference to the remote object.

    1. Get the initial context of the server that hosts the service using a T3 URL in the form of t3://ip address:port or t3s://ip address:port.

    2. Obtain an instance of the service object by performing a lookup using the initial context. This instance can then be used just like a local object reference.

  2. Call the remote objects methods.

  3. Place the wlthint3client.jar in your client classpath. It is located in the WL_HOME\server\lib directory of your WebLogic Server installation.

    Note:

    Oracle does not support combining clients to create extended feature sets. Never add the wlfullclient.jar, wlthint3client.jar, or wlclient.jar to a WebLogic Server classpath or a classpath that references the weblogic.jar file in a full WebLogic install. The behavior is undefined. WebLogic Server applications already have full access to WebLogic client functionality.

Sample code to for a basic WebLogic Thin T3 client is provided in Example 3-1.

Example 3-1 Creating and Using a WebLogic Initial Context

Hashtable env = new Hashtable();
env.put("java.naming.factory.initial",
  "weblogic.jndi.WLInitialContextFactory");
env.put("java.naming.provider.url","t3://host:7001");
env.put("java.naming.security.principal","user");
env.put("java.naming.security.credentials","password");
Context ctx = new InitialContext(env);
try {
  Object homeObject =
    context.lookup("EmployeeBean");
//use the EmployeeBean
}
catch (NamingException e) {
// a failure occurred
}
finally {
  try {ctx.close();}
  catch (Exception e) {
// a failure occurred
}
}

Foreign Server Applications

A foreign server hosted application can use the wlthint3client.jar to act as a remote client to a WebLogic Server instance. To provide access to remote services such as JMS, servlets, EJBs, and start-up classes, deploy any necessary application code along with the wlthint3client.jar to your application server.

The following steps provide a guideline to connect to and access WebLogic Server resources from a foreign application server using JNDI:

  1. Include the wlthint3client.jar on the classpath of your client.
  2. In your client application, create a WebLogic initial context and use the context to lookup and use a resource. See Example 3-1 for more details.
  3. It may be necessary to explicitly set the initial context factory as system property in the client code to the following value:

    env.put("java.naming.factory.initial", "weblogic.jndi.WLInitialContextFactory");

  4. Deploy any necessary application code along with the wlthint3client.jar file to your application server using standard Java EE methods, such as embedding the wlthint3client.jar file in a servlet or using a shared library. See Deployment Considerations.
  5. Start or deploy the client.

The following sections outline specific items to consider when interoperating with a foreign servers.

Deployment Considerations

You can deploy the wlthint3client.jar using standard Java EE methods. However, when determining what deployment method to use, you must account for client footprint, class loading, performance, and tolerance of the risk for code incompatibility. For example:

  • If you embed the wlthint3client.jar in your application, such as a servlet, the application footprint is increased by the size of the wlthint3client.jar but the risk of code incompatibility is limited to the scope of your application.

  • If you deploy the wlthint3client.jar to your lib directory, the application footprint is not affected but the risk of code incompatibility can include the entire foreign server container.