src/org/objectweb/cjdbc/console/jmx/JmxClient.java

説明を見る。

package org.objectweb.cjdbc.console.jmx;

import java.io.IOException;
import java.rmi.RemoteException;

import javax.management.InstanceNotFoundException;
import javax.management.MBeanException;
import javax.management.MBeanServerConnection;
import javax.management.NotificationFilter;
import javax.management.NotificationListener;
import javax.management.ObjectName;
import javax.management.ReflectionException;
import javax.management.remote.JMXConnector;
import javax.management.remote.JMXConnectorFactory;
import javax.management.remote.JMXServiceURL;
import javax.naming.Context;

import org.objectweb.cjdbc.common.jmx.JmxConstants;
import org.objectweb.cjdbc.common.jmx.JmxException;

public abstract class JmxClient
{

  protected MBeanServerConnection server;
  protected String                remoteHostName;
  protected String                remoteHostAddress;
  protected String                remoteHostPort;
  protected Object                credentials;
  protected ObjectName            mbean;

  public void connect(String host, String port, Object credentials)
      throws JmxException
  {
    try
    {
      this.credentials = credentials;
      //Create a JRMPConnector
      javax.management.remote.JMXServiceURL address = new JMXServiceURL("rmi",
          host, 0, "/jndi/jrmp");

      // Pass in the adaptor's JNDI name, no properties
      java.util.Map environment = new java.util.HashMap();
      environment.put(Context.INITIAL_CONTEXT_FACTORY,
          "com.sun.jndi.rmi.registry.RegistryContextFactory");
      environment.put(Context.PROVIDER_URL, "rmi://" + host + ":" + port);

      if (credentials != null)
        environment.put(JMXConnector.CREDENTIALS, credentials);

      JMXConnector connector = JMXConnectorFactory.newJMXConnector(address,
          environment);
      connector.connect(environment);

      // Use the connector directly to retrieve some information
      // about host name and IP address
      remoteHostName = host;
      remoteHostAddress = host;
      remoteHostPort = port;

      // Get the remote MBeanServer from the connector
      // And use it as if it is an MBeanServer
      server = connector.getMBeanServerConnection();

    }
    catch (Exception e)
    {
      throw new JmxException(e);
    }
  }

  public void addNotificationListener(NotificationListener listener,
      NotificationFilter filter, Object handback)
      throws InstanceNotFoundException, IOException
  {
    server.addNotificationListener(mbean, listener, filter, handback);
  }

  public void checkConnection() throws JmxException
  {
    try
    {
      int count = server.getMBeanCount().intValue();
      //      MBeanInfo info = server.getMBeanInfo(mbean);
      //      MBeanOperationInfo[] infos = info.getOperations();
      //      for(int i = 0;i<infos.length;i++)
      //      {
      //        System.out.println(infos[i].getName());
      //      }
      if (JmxConstants.DEBUG)
        System.out.println("#DEBUG@Server Count " + count + " MBeans");
    }
    catch (Exception re)
    {
      try
      {
        if (JmxConstants.DEBUG)
          System.out.println("Connection lost. Trying to reconnect...");
        connect(remoteHostName, remoteHostPort, credentials);
      }
      catch (Exception e)
      {
        throw new JmxException("Could not reconnect to host:" + remoteHostName);
      }
    }
  }

  public boolean validateTarget()
  {
    try
    {
      return server.isRegistered(mbean);
    }
    catch (Exception e)
    {
      return false;
    }
  }

  public Object invoke(String methodName, Object[] parameters)
      throws JmxException, MBeanException
  {
    if (parameters == null)
      return this.invoke(methodName, null, null);
    else
    {
      int size = parameters.length;
      String[] paramTypes = new String[size];
      for (int i = 0; i < size; i++)
        paramTypes[i] = parameters[i].getClass().getName();
      return this.invoke(methodName, parameters, paramTypes);
    }
  }

  public Object invoke(String methodName, Object[] parameters,
      String[] paramTypes) throws JmxException, MBeanException
  {
    if (JmxConstants.DEBUG)
      System.out.println("#DEBUG#" + methodName + " for mbean:"
          + mbean.getCanonicalName() + " on:" + this.remoteHostName);
    if (JmxConstants.KEEP_CONNECTION_ALIVE)
      checkConnection();
    try
    {
      return server.invoke(mbean, methodName, parameters, paramTypes);
    }
    catch (InstanceNotFoundException e)
    {
      throw new JmxException(e.getMessage());
    }
    catch (MBeanException e)
    {
      throw e;
    }
    catch (ReflectionException e)
    {
      throw new JmxException(e.getMessage());
    }
    catch (RemoteException e)
    {
      throw new JmxException(e.getMessage());
    }
    catch (java.io.IOException e)
    {
      throw new JmxException(e.getMessage(), e);
    }
  }

  public String getRemoteHostAddress()
  {
    return remoteHostAddress;
  }

  public String getRemoteHostName()
  {
    return remoteHostName;
  }

  public String getRemoteHostPort()
  {
    return remoteHostPort;
  }

  public Object getCredentials()
  {
    return credentials;
  }

  public String getRemoteName()
  {
    return remoteHostName + ":" + remoteHostPort;
  }
}

---