weblogic集群节点监控

天堂1111

由于项目需要，对weblogic集群做监控，并定时采集系统中队列执行时长、各节点占用内存
等情况。
第一步：获取MBeanHome

import javax.naming.Context;
import javax.naming.NamingException;
import weblogic.jndi.Environment;
import weblogic.management.MBeanHome;
public class WebLogicBeanHome
{
private MBeanHome mBeanHome;
private static final WebLogicBeanHome home = new WebLogicBeanHome();
private WebLogicBeanHome()
{
init();
}
private void init()
{
Environment environment = new Environment();
environment.setProviderUrl("t3://localhost:7001");
environment.setSecurityPrincipal("weblogic");
environment.setSecurityCredentials("weblogic");
Context context;
try
{
context = environment.getInitialContext();
mBeanHome = (MBeanHome) context.lookup(MBeanHome.ADMIN_JNDI_NAME);
}
catch(NamingException e)
{
e.printStackTrace();
}
catch(Exception ex)
{
ex.printStackTrace();
}
}
public static WebLogicBeanHome getInstance()
{
return home;
}
public MBeanHome getMBeanHome()
{
return mBeanHome;
}
public String getServerName()
{
return mBeanHome.getMBeanServer().getServerName();
}
public String getDomainName()
{
return mBeanHome.getDomainName();
}
public Set getMBeansByType(String type)
{
if(type == null || type.trim().length() == 0)
{
return null;
}
else
{
try
{
return mBeanHome.getMBeansByType(type);
}
catch(Exception e)
{
e.printStackTrace();
init();
return mBeanHome.getMBeansByType(type);
}
}
}
public Set getAllMBeans()
{
return mBeanHome.getAllMBeans();
}
}


第二步：将集群各节点状态信息构造成ServiceNode对象

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import com.huawei.netforce.server.common.ExecuteQueue;
import com.huawei.netforce.server.common.ServiceNode;
import com.huawei.netforce.server.home.WebLogicBeanHome;
import weblogic.management.runtime.ExecuteQueueRuntimeMBean;
import weblogic.management.runtime.ExecuteThread;
import weblogic.management.runtime.JVMRuntimeMBean;
import weblogic.management.runtime.ServerRuntimeMBean_Stub;
public class ServerRuntime
{
public static final String RUNNING = "RUNNING";
private static final ServerRuntime server = new ServerRuntime();
private ServerRuntime()
{
}
public static ServerRuntime getInstance()
{
return server;
}
/**
* 建造集群节点信息
* @param set
* @return
*/
public List buildServer(Set set)
{
List list = new ArrayList();
if(set == null)
return list;
Iterator it = set.iterator();
while(it.hasNext())
{
ServerRuntimeMBean_Stub stub = (ServerRuntimeMBean_Stub) it.next();
ServiceNode node = new ServiceNode();
//节点名称
node.setName(stub.getName());
//节点地址
node.setHost(stub.getListenAddress());
//节点端口
node.setPort(String.valueOf(stub.getListenPort()));
//节点状态
node.setStatus(stub.getState());
//节点当前可用内存
node.setFreeHeap(getJVMCurrentFreeHeap(stub));
//节点总内存
node.setTotalHeap(getJVMCurrentHeapSize(stub));
//节点总队列数
node.setQueueTotal(getExecuteQueueRuntime(stub).getExecuteThreadTotalCount());
//节点当前占用队列数
node.setQueueUsed(node.getQueueTotal() - getExecuteQueueRuntime(stub).getExecuteThreadCurrentIdleCount());
//节点队列详细列表
buildExcuteQueues(node, getExecuteQueueRuntime(stub).getExecuteThreads());
list.add(node);
}
return list;
}
/**
* 建造队列线程信息
*
* @param eths
*/
private void buildExcuteQueues(ServiceNode node, ExecuteThread[] eths)
{
if(eths == null)
{
return;
}
for(int i = 0; i < eths.length; i++)
{
ExecuteThread eThread = eths;
if(eThread.getCurrentRequest() == null || "".equals(eThread.getCurrentRequest()) || "null".equals(eThread.getCurrentRequest()))
{
continue;
}
ExecuteQueue queue = new ExecuteQueue();
queue.setNumber(i);
queue.setName(eThread.getName());
//队列请求地址URL
queue.setRequest(eThread.getCurrentRequest());
//队列请求时间
queue.setStartTime(eThread.getCurrentRequestStartTime());
queue.setTotal(eThread.getServicedRequestTotalCount());
node.add(queue);
}
}
public Set getServerRuntimes()
{
return WebLogicBeanHome.getInstance().getMBeansByType(Constant.ServerRuntime);
}
private boolean isStoped(ServerRuntimeMBean_Stub mBean)
{
return !RUNNING.equalsIgnoreCase(mBean.getState());
}
private JVMRuntimeMBean getJVMRuntime(ServerRuntimeMBean_Stub mBean)
{
return mBean.getJVMRuntime();
}
private ExecuteQueueRuntimeMBean getExecuteQueueRuntime(ServerRuntimeMBean_Stub mBean)
{
return mBean.getExecuteQueueRuntime();
}
private long getJVMCurrentFreeHeap(ServerRuntimeMBean_Stub mBean)
{
return getJVMRuntime(mBean).getHeapFreeCurrent();
}
private long getJVMCurrentHeapSize(ServerRuntimeMBean_Stub mBean)
{
return getJVMRuntime(mBean).getHeapSizeCurrent();
}
private String getOSVersion(ServerRuntimeMBean_Stub mBean)
{
return getJVMRuntime(mBean).getOSVersion();
}
private String getOSName(ServerRuntimeMBean_Stub mBean)
{
return getJVMRuntime(mBean).getOSName();
}
private String getJavaVersion(ServerRuntimeMBean_Stub mBean)
{
return getJVMRuntime(mBean).getJavaVersion();
}
private String getJavaVendor(ServerRuntimeMBean_Stub mBean)
{
return getJVMRuntime(mBean).getJavaVendor();
}
}


第三步：处理集群节点状态数据

import java.util.ArrayList;
import java.util.List;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import com.huawei.netforce.server.Handler;
import com.huawei.netforce.server.ServerRuntime;
import com.huawei.netforce.server.common.ServiceNode;
import com.huawei.netforce.server.handlers.LogHandler;
import com.huawei.netforce.server.handlers.MsgHandler;
public class ServerRuntimeJob implements Job
{
private static List handlers = new ArrayList();
static
{
//短信处理 如内存不足、队列堵塞等情况发送告警短信
handlers.add(new MsgHandler());
//日志处理 如将执行时间较长的队列记录日志，定期优化
handlers.add(new LogHandler());
}
//quartz定时执行 一般为5分钟执行一次   
public void execute(JobExecutionContext arg0) throws JobExecutionException
{
ServerRuntime runtime = ServerRuntime.getInstance();
List list = runtime.buildServer(runtime.getServerRuntimes());
try
{
processServerNode(list);
}
catch(Exception e)
{
e.printStackTrace();
}
}
//处理集群各服务节点状态数据
private void processServerNode(List list) throws Exception
{
ServiceNode node = null;
for(int i = 0; i < list.size(); i++)
{
node = (ServiceNode)list.get(i);
handle(node);
}
}
//handles链中的各Handle分别处理
private void handle(ServiceNode node) throws Exception
{
for(int i = 0; i < handlers.size(); i++)
{
Handler handler = (Handler)handlers.get(i);
handler.handle(node);
}
}
}