If your JMX client runs in its own JVM (that is, a JVM that is not a WebLogic Server instance), include the following JAR file in the client's classpath:

WL_HOME\server\lib\weblogic.jar 

where, WL_HOME is the directory in which you installed WebLogic Server.

Oracle provides the wlthint3client.jar library for remote access, and this library enables connectivity over the T3 or T3S protocol to access MBeans for a WebLogic Server instance or domain. The T3 protocol is an optimized, high-performance protocol for interoperating with WebLogic Server. Oracle recommends that you use the T3 protocol whenever possible.

To use the wlthint3client.jar, include the wlthint3client.jar in the classpath of your client. 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. See Understanding the WebLogic Thin T3 Client.

1. Describe the address of the MBean server by constructing a javax.management.remote.JMXServiceURL object.

   Pass the following parameter values to the constructor (see JMXServiceURL in the Java SE 8 API Specification at http://docs.oracle.com/javase/8/docs/api/javax/management/remote/JMXServiceURL.html):

   • One of the following values as the protocol for communicating with the MBean server:

     t3, t3s, http, https, iiop, iiops 
     

   • Listen address of the WebLogic Server instance that hosts the MBean server

   • Listen port of the WebLogic Server instance

   • Absolute JNDI name of the MBean server. The JNDI name must start with /jndi/ and be followed by one of the JNDI names described in Table 4-1.

   Table 4-1 JNDI Names for WebLogic MBean Servers

   MBean Server	JNDI Name
   Domain Runtime MBean Server	weblogic.management.mbeanservers.domainruntime
   Runtime MBean Server	weblogic.management.mbeanservers.runtime
   Edit MBean Server	weblogic.management.mbeanservers.edit

2. Construct a javax.management.remote.JMXConnector object. This object contains methods that JMX clients use to connect to MBean servers.

   The constructor method for JMXConnector is:

   javax.management.remote.JMXConnectorFactory.
   connector(JMXServiceURL serviceURL, Map<String,?> environment) 
   

   Pass the following parameter values to the constructor (see JMXConnectorFactory in the Java SE 8 API Specification at http://docs.oracle.com/javase/8/docs/api/javax/management/remote/JMXConnectorFactory.html):

   • The JMXServiceURL object you created in the previous step.

   • A hash map that contains the following name-value pairs:

     javax.naming.Context.SECURITY_PRINCIPAL, admin-user-name 
     
     javax.naming.Context.SECURITY_CREDENTIALS, admin-user-password 
     
     javax.management.remote.JMXConnectorFactory.PROTOCOL_PROVIDER_PACKAGES, 
     "weblogic.management.remote" 
     

   The weblogic.management.remote package defines the protocols that can be used to connect to the WebLogic MBean servers. Remote JMX clients must include the classes in this package on their classpath. See Set Up the Classpath for Remote Clients.

   Optionally include the following name-value pair in the hash map:

   jmx.remote.x.request.waiting.timeout, milliseconds 
   

   where milliseconds is a java.lang.Long object that contains the number of milliseconds that your JMX client waits for the invocation of an MBean-server method to return. If a method does not return by the end of the time-out period, the client moves to its next set of instructions. By default, a client waits indefinitely for a method to return; if the MBean server is unable to complete an invocation, the JMX client will hang indefinitely.

3. Connect to the WebLogic MBean server by invoking the JMXConnector.getMBeanServerConnection() method.

   The method returns an object of type javax.management.MBeanServerConnection.

   The MBeanServerConnection object is your connection to the WebLogic MBean server. You can use it for local and remote connections. See MBeanServerConnection in the Java SE 8 API Specification at http://docs.oracle.com/javase/8/docs/api/javax/management/MBeanServerConnection.html.

4. Oracle recommends that when your client finishes its work, close the connection to the MBean server by invoking the JMXConnector.close() method.

Local clients can access a WebLogic Server instance's Runtime MBean Server through the JNDI tree instead of constructing a JMXServiceURL object.

When accessed from JNDI, the Runtime MBean Server returns its javax.management.MBeanServer interface. This interface contains all the methods in the MBeanServerConnection interface plus additional methods such as registerMBean(), which a local process can use to register custom MBeans. (See MBeanServer in the Java SE 8 API Specification at http://docs.oracle.com/javase/8/docs/api/javax/management/MBeanServer.html.)

If the classes for the JMX client are located in a Java EE module, such as an EJB or Web application, then the JNDI name for the Runtime MBeanServer is:

java:comp/weblogic/jmx/runtime

For example:

InitialContext ctx = new InitialContext();
server = (MBeanServer)ctx.lookup("java:comp/weblogic/jmx/runtime"); 

If the classes for the JMX client are not part of a Java EE module, then the JNDI name for the Runtime MBean Server is:

java:comp/jmx/runtime 

Local clients can also access a WebLogic Server instance's Domain Runtime MBean Server through the JNDI tree instead of constructing a JMXServiceURL object.

When accessed from JNDI, the Domain Runtime MBean Server returns its javax.management.MBeanServer interface. This interface contains all the methods in the MBeanServerConnection interface plus additional methods such as registerMBean(), which a local process can use to register custom MBeans, and other methods such as getMBeanCount(), instatiate(), and getClassLoader(). (See MBeanServer in the Java SE 8 API Specification at http://docs.oracle.com/javase/8/docs/api/javax/management/MBeanServer.html.)

If the classes for the JMX client are located in a Java EE module, such as an EJB or Web application, then the JNDI name for the Domain Runtime MBeanServer is:

java:comp/weblogic/jmx/domainRuntime

For example:

InitialContext ctx = new InitialContext();
server = (MBeanServer)ctx.lookup("java:comp/weblogic/jmx/domainRuntime"); 

If the classes for the JMX client are not part of a Java EE module, then the JNDI name for the Domain Runtime MBean Server is:

java:comp/jmx/domainRuntime 

The Domain Runtime MBean Server is present only on the Administration Server. Because the ctx.lookup() call returns a reference to the local MBeanServer, the lookup method can only be called when running on the Administration Server. If called when running on a Managed Server, a NameNotFound exception is thrown.

1. Initiate a connection to an MBean server.

   See the previous section, Make Remote Connections to an MBean Server.

   Initiating the connection returns an object of type

   javax.management.MBeanServerConnection
   

2. Obtain the object name for an MBean at the root of an MBean hierarchy by invoking the MBeanServerConnection.getAttribute(ObjectName object-name, String attribute) method where:

   • object-name represents the object name of the service MBean that is registered in the MBean server. (See Service MBeans.)

     Table 2-3 describes the type of service MBeans that are available in each type of MBean server.

   • attribute represents the name of a service MBean attribute that contains the root MBean.

3. Successively invoke code similar to the following:

   ObjectName on = 
   MBeanServerConnection.getAttribute(object-name, attribute) 
   

   In the preceding syntax:

   • object-name represents the object name of the current node (MBean) in the MBean hierarchy.

   • attribute represents the name of an attribute in the current MBean that contains one or more instances of a child MBean. If the attribute contains multiple children, assign the output to an object name array, ObjectName[].

1. The Domain Runtime MBean Server (for all servlets on all servers in the domain), or the Runtime MBean Server on a specific server instance.
2. DomainRuntimeServiceMBean or RuntimeServiceMBean, ServerRuntimes attribute.
3. ServerRuntimeMBean, ApplicationRuntimes attribute.
4. ApplicationRuntimeMBean, ComponentRuntimes attribute.

   The ComponentRuntimes attribute contains many types of component run-time MBeans, one of which is WebAppComponentRuntimeMBean. When you get the value of this attribute, you use the child MBean's Type attribute to get a specific type of component run-time MBean.

5. WebAppComponentRuntimeMBean, ServletRuntimes attribute.

import java.io.IOException;
import java.net.MalformedURLException;
import java.util.Hashtable;

import javax.management.MBeanServerConnection;
import javax.management.MalformedObjectNameException;
import javax.management.ObjectName;
import javax.management.remote.JMXConnector;
import javax.management.remote.JMXConnectorFactory;
import javax.management.remote.JMXServiceURL;
import javax.naming.Context;

public class MonitorServlets {
   private static MBeanServerConnection connection;
   private static JMXConnector connector;
   private static final ObjectName service;

   // Initializing the object name for DomainRuntimeServiceMBean
   // so it can be used throughout the class.
   static {
      try {
         service = new ObjectName(
          "com.bea:Name=DomainRuntimeService,Type=weblogic.management.mbeanservers.domainruntime.DomainRuntimeServiceMBean");
      }catch (MalformedObjectNameException e) {
         throw new AssertionError(e.getMessage());
      }
   }

   /*
   * Initialize connection to the Domain Runtime MBean Server
   */
   public static void initConnection(String hostname, String portString, 
      String username, String password) throws IOException,
      MalformedURLException { 
      String protocol = "t3";
      Integer portInteger = Integer.valueOf(portString);
      int port = portInteger.intValue();
      String jndiroot = "/jndi/";
      String mserver = "weblogic.management.mbeanservers.domainruntime";

      JMXServiceURL serviceURL = new JMXServiceURL(protocol, hostname,
         port, jndiroot + mserver);
      Hashtable h = new Hashtable();
      h.put(Context.SECURITY_PRINCIPAL, username);
      h.put(Context.SECURITY_CREDENTIALS, password);
      h.put(JMXConnectorFactory.PROTOCOL_PROVIDER_PACKAGES,
         "weblogic.management.remote");
      connector = JMXConnectorFactory.connect(serviceURL, h);
      connection = connector.getMBeanServerConnection();
   }

   /*
   * Get an array of ServerRuntimeMBeans
   */
   public static ObjectName[] getServerRuntimes() throws Exception {
      return (ObjectName[]) connection.getAttribute(service,
         "ServerRuntimes");
   }

   /*
   * Get an array of WebAppComponentRuntimeMBeans
   */
   public void getServletData() throws Exception {
      ObjectName[] serverRT = getServerRuntimes();
      int length = (int) serverRT.length;
      for (int i = 0; i < length; i++) {
         ObjectName[] appRT = 
            (ObjectName[]) connection.getAttribute(serverRT[i],
            "ApplicationRuntimes");
         int appLength = (int) appRT.length;
         for (int x = 0; x < appLength; x++) {
            System.out.println("Application name: " +
              (String)connection.getAttribute(appRT[x], "Name"));
            ObjectName[] compRT = 
               (ObjectName[]) connection.getAttribute(appRT[x],
               "ComponentRuntimes");
            int compLength = (int) compRT.length;
            for (int y = 0; y < compLength; y++) {
               System.out.println("  Component name: " +
                 (String)connection.getAttribute(compRT[y], "Name"));
               String componentType = 
                  (String) connection.getAttribute(compRT[y], "Type");
               System.out.println(componentType.toString());
               if (componentType.toString().equals("WebAppComponentRuntime")){
                  ObjectName[] servletRTs = (ObjectName[])
                     connection.getAttribute(compRT[y], "Servlets");
                  int servletLength = (int) servletRTs.length;
                  for (int z = 0; z < servletLength; z++) {
                     System.out.println("    Servlet name: " +
                        (String)connection.getAttribute(servletRTs[z],
                         "Name"));
                     System.out.println("       Servlet context path: " +
                        (String)connection.getAttribute(servletRTs[z],
                         "ContextPath"));
                     System.out.println("       Invocation Total Count : " +
                        (Object)connection.getAttribute(servletRTs[z],
                         "InvocationTotalCount"));
                  }
               }
            }
         }
      }
   }

   public static void main(String[] args) throws Exception {
      String hostname = args[0];
      String portString = args[1];
      String username = args[2];
      String password = args[3];

      MonitorServlets s = new MonitorServlets();
      initConnection(hostname, portString, username, password);
      s.getServletData();
      connector.close();
   }
}