通过JMX获取weblogic的监控指标

最新推荐文章于 2025-06-24 09:04:03 发布
最新推荐文章于 2025-06-24 09:04:03 发布
阅读量2.3k 收藏 3
点赞数 1
分类专栏： weblogic

通过JMX获取weblogic的监控数据，包括JDBC,SESSION,SERVERLET,JVM等信息。主要用到weblogic自己的t3协议，所以要用到weblogic的jar包:wlfullclient.jar和wlclient.jar。这两个jar包怎么获取我专门在另外一篇文章中讲。下面贴一些获取监控指标的代码，做个备份只用吧。

1、对JDBC的监控，只取了最重要的监控指标：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
package test;
 
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 PrintJdbc {
    private static MBeanServerConnection connection;
    private static JMXConnector connector;
    private static final ObjectName service;
     
 
       static {
          try {
             service = new ObjectName("com.bea:Name=RuntimeService,Type=weblogic.management.mbeanservers.runtime.RuntimeServiceMBean");
          }catch (MalformedObjectNameException e) {
             throw new AssertionError(e.getMessage());
          }
       }
      
       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.runtime";
          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();
       }
     
       public static ObjectName getServerRuntimes() throws Exception {
            return (ObjectName)connection.getAttribute(service,
                  "ServerRuntime");
       }
        
       
       public  ObjectName getJDBCServer() throws Exception {
           ObjectName dc = getServerRuntimes();
           ObjectName jdbcService = (ObjectName)connection.getAttribute(dc,
                   "JDBCServiceRuntime");
           return jdbcService;
       }
        
        public ObjectName[] getJDBCDataSourceRuntime() throws Exception   {
            ObjectName[] jdbcDataSourceRTMB = (ObjectName[]) connection.getAttribute(getJDBCServer(), "JDBCDataSourceRuntimeMBeans");
            return jdbcDataSourceRTMB;
        }
         
         
       public void printJdbc() throws Exception {
           ObjectName[] objectList = getJDBCDataSourceRuntime();
           if(objectList != null && objectList.length > 0){
               for(ObjectName obj : objectList){
                   int connectionsTotalCount = (int) connection.getAttribute(obj, "ConnectionsTotalCount");
                   int activeConnectionsCurrentCount = (int)connection.getAttribute(obj, "ActiveConnectionsCurrentCount");
                   int activeConnectionsAverageCount = (int)connection.getAttribute(obj,"ActiveConnectionsAverageCount");
                   int failuresToReconnectCount = (int)connection.getAttribute(obj, "FailuresToReconnectCount");
                   String name = (String)connection.getAttribute(obj, "Name");
                   int waitingForConnectionCurrentCount = (int)connection.getAttribute(obj, "WaitingForConnectionCurrentCount");
                   long waitingForConnectionFailureTotal = (long)connection.getAttribute(obj, "WaitingForConnectionFailureTotal");
                   int waitSecondsHighCount = (int)connection.getAttribute(obj, "WaitSecondsHighCount");
                   int connectionDelayTime = (int)connection.getAttribute(obj, "ConnectionDelayTime");
                   int activeConnectionsHighCount = (int)connection.getAttribute(obj, "ActiveConnectionsHighCount");
                   int currCapacity = (int)connection.getAttribute(obj, "CurrCapacity");
                   System.out.println("currCapacity==" + currCapacity);
                   System.out.println("activeConnectionsHighCount==" + activeConnectionsHighCount);
                   System.out.println("connectionDelayTime==" + connectionDelayTime);
                   System.out.println("connectionsTotalCount==" + connectionsTotalCount);
                   System.out.println("activeConnectionsCurrentCount==" + activeConnectionsCurrentCount);
                   System.out.println("activeConnectionsAverageCount==" + activeConnectionsAverageCount);
                   System.out.println("failuresToReconnectCount==" + failuresToReconnectCount);
                   System.out.println("name==" + name);
                   System.out.println("waitingForConnectionCurrentCount==" +waitingForConnectionCurrentCount );
                   System.out.println("waitingForConnectionFailureTotal==" + waitingForConnectionFailureTotal);
                   System.out.println("waitSecondsHighCount==" + waitSecondsHighCount);
                   
                 
               }
           }
       }
       public static void main(String[] args) throws Exception {
          
              String hostname = "10.111.131.50";
              String portString = "7001";
              String username = "weblogic";
              String password = "weblogic123";
              PrintJdbc s = new PrintJdbc();
              initConnection(hostname, portString, username, password);
              s.printJdbc();
              connector.close();
           }
        
        
}

　　2、有关thread的监控：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
package test;
 
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 PrintThread {
 
    private static MBeanServerConnection connection;
    private static JMXConnector connector;
    private static final ObjectName service;
     
 
       static {
          try {
             service = new ObjectName("com.bea:Name=RuntimeService,Type=weblogic.management.mbeanservers.runtime.RuntimeServiceMBean");
          }catch (MalformedObjectNameException e) {
             throw new AssertionError(e.getMessage());
          }
       }
      
       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.runtime";
          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();
       }
     
       public static ObjectName getServerRuntimes() throws Exception {
            return (ObjectName)connection.getAttribute(service,
                  "ServerRuntime");
       }
        
       public void printInfo() throws Exception{
           ObjectName objThreadPool = null;
           ObjectName serverRT = getServerRuntimes();
            
           objThreadPool = (ObjectName) connection.getAttribute(serverRT, "ThreadPoolRuntime");
           double throughput  = Double.parseDouble(String.valueOf(connection.getAttribute(
                   objThreadPool,"Throughput")));
           System.out.println("throughput:" + throughput);
            
           int executeThreadTotalCount = Integer.parseInt(String.valueOf(connection.getAttribute(objThreadPool, "ExecuteThreadTotalCount")));
           System.out.println("executeThreadTotalCount:" + executeThreadTotalCount);
          
         
           int executeThreadIdleCount = Integer.parseInt(String.valueOf(connection.getAttribute(objThreadPool, "ExecuteThreadIdleCount")));
           System.out.println("executeThreadIdleCount:" + executeThreadIdleCount);
           
           int StandbyThreadCount = Integer.parseInt(String.valueOf(connection.getAttribute(objThreadPool, "StandbyThreadCount")));
           System.out.println("StandbyThreadCount:" + StandbyThreadCount);
            
            
           long timestamp = System.currentTimeMillis() / 1000;
            String metricJson = "";
            String jsonFormat = "{\"name\": \"weblogic_threadpool_metric_demo\", " +
                    "\"command\":\"weblogic_threadpool_metric\"," +
                    "\"type\": \"metric\"," +
                    "\"handlers\": [\"influxdb\"],"+
                    "\"output\": \"%s %.5f %d\\n%s %d %d\\n%s %d %d\\n\"," +
                    "\"status\": 0}";
            metricJson = String.format(jsonFormat,
                      ".weblogic.threadpool.throughput", (double)throughput, timestamp,
                      ".weblogic.threadpool.executeThreadTotalCount", (int)executeThreadTotalCount, timestamp,
                      ".weblogic.threadpool.executeThreadIdleCount", (int)executeThreadIdleCount, timestamp);
            System.out.println("metricJson==" + metricJson);
             
             
             
       }
        
        
    public static void main(String args[]) throws Exception {
         String hostname = "10.111.131.50";
          String portString = "7001";
          String username = "weblogic";
          String password = "weblogic123";
          PrintThread s = new PrintThread();
          initConnection(hostname, portString, username, password);
          s.printInfo();
          connector.close();
    }
}

　　3、有关session的监控：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
package test;
 
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 PrintServerState {
    private static MBeanServerConnection connection;
    private static JMXConnector connector;
    private static final ObjectName service;
     
     
       static {
          try {
             service = new ObjectName("com.bea:Name=DomainRuntimeService,Type=weblogic.management.mbeanservers.domainruntime.DomainRuntimeServiceMBean");
          }catch (MalformedObjectNameException e) {
             throw new AssertionError(e.getMessage());
          }
       }
        
       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();
       }
        
       public static ObjectName[] getServerRuntimes() throws Exception {
          return (ObjectName[]) connection.getAttribute(service,
             "ServerRuntimes");
       }
        
       public static ObjectName[] getApplicationRuntimes(ObjectName serverRuntime) throws Exception {
           return (ObjectName[])connection.getAttribute(serverRuntime, "ApplicationRuntimes");
       }
        
       public static ObjectName[] getComponentRuntimes(ObjectName componentRutime) throws Exception {
           return (ObjectName[]) connection.getAttribute(componentRutime, "ComponentRuntimes");
       }
        
        
       public void printSessionState() throws Exception {
           ObjectName[] serverRT = getServerRuntimes();
           int length = (int) serverRT.length;
           
           for(int i = 0;i<length;i++){
               ObjectName[] applicationRT = getApplicationRuntimes(serverRT[i]);
               int length_app = (int)applicationRT.length;
              
               for(int y = 0;y<length_app;y++){
                   String applicationName =  (String)connection.getAttribute(applicationRT[y], "ApplicationName");
                   
                   if(applicationName.equals("helloworld")){
                       
                   ObjectName[]  componentRuntime = getComponentRuntimes(applicationRT[y]);
                   int length_component = (int)componentRuntime.length;
                   System.out.println("length_component==" + length_component);
                   for(int z = 0;z<length_component;z++){
                        
                       String type =  (String)connection.getAttribute(componentRuntime[z], "Type");
                       if(type.equals("WebAppComponentRuntime")){
                            
                       
                       int SessionsOpenedTotalCount = (int)connection.getAttribute(componentRuntime[z], "SessionsOpenedTotalCount");
                       System.out.println("SessionsOpenedTotalCount==" + SessionsOpenedTotalCount);
                        
                       int openSessionsHighCount = (int)connection.getAttribute(componentRuntime[z], "OpenSessionsHighCount");
                       System.out.println("openSessionsHighCount==" + openSessionsHighCount);
                        
                       int openSessionsCurrentCount = (int)connection.getAttribute(componentRuntime[z], "OpenSessionsCurrentCount");
                       System.out.println("openSessionsCurrentCount==" + openSessionsCurrentCount);
                       break;
                       }
                        
                     }
                     break;
                  }
               }
           }
       }
        
       public void printNameAndState() throws Exception {
          ObjectName[] serverRT = getServerRuntimes();
          System.out.println("got server runtimes");
          int length = (int) serverRT.length;
          for (int i = 0; i < length; i++) {
             
             String name = (String) connection.getAttribute(serverRT[i],
                "Name");
              
             String state = (String) connection.getAttribute(serverRT[i],
                "State");
              
           
             long activationTime  = (Long)connection.getAttribute(serverRT[i], "ActivationTime");
             System.out.println("Server name: " + name);
             System.out.println("Server state:" + state);
             System.out.println("Server activationTime:" + activationTime);
            
             String weblogicVersion  = (String) connection.getAttribute(serverRT[i], "WeblogicVersion");
             System.out.println("Server weblogicVersion:" + weblogicVersion);
              
             String weblogicHome = (String) connection.getAttribute(serverRT[i], "WeblogicHome");
             System.out.println("Server WeblogicHome:" +weblogicHome );
              
              
          }
       }
        public static void main(String[] args) throws Exception {
          String hostname = "10.111.131.50";
          String portString = "7001";
          String username = "weblogic";
          String password = "weblogic123";
           PrintServerState s = new PrintServerState();
          initConnection(hostname, portString, username, password);
          s.printNameAndState();
          s.printSessionState();
          connector.close();
       }
}

　　4、有关serverlet的监控：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
package test;
 
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 PrintServerlet {
 
    private static MBeanServerConnection connection;
       private static JMXConnector connector;
       private static final ObjectName service;
       private final String applicationName_app="helloworld";
       private final String serverletName1="index.jsp";
       private final String serverletName2="helloworld.jsp";
         
       static {
          try {
             service = new ObjectName(
              "com.bea:Name=DomainRuntimeService,Type=weblogic.management.mbeanservers.domainruntime.DomainRuntimeServiceMBean");
          }catch (MalformedObjectNameException e) {
             throw new AssertionError(e.getMessage());
          }
       }
        
       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();
       }
        
       public static ObjectName[] getServerRuntimes() throws Exception {
          return (ObjectName[]) connection.getAttribute(service,
             "ServerRuntimes");
       }
        
       public String getApplicationName(ObjectName objectName) throws Exception {
           return (String)connection.getAttribute(objectName, "Name");
       }
        
       public String getServletName(ObjectName objectName) throws Exception {
           return (String)connection.getAttribute(objectName,"Name");
       }
        
       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++) {
                 String applicationName = getApplicationName(appRT[x]);
                 if(applicationName_app.equals(applicationName)){
                     System.out.println("Application name: " + applicationName);
                     ObjectName[] compRT =
                               (ObjectName[]) connection.getAttribute(appRT[x],
                               "ComponentRuntimes");
                     int compLength = (int) compRT.length;
                  
                for (int y = 0; y < compLength; y++) {
                    printValue("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++) {
                          String servletName = getServletName(servletRTs[z]);
                          if (servletName.contains(serverletName1) || servletName.contains(serverletName2)){
                               printValue("Servlet name",servletName);
 
                               printValue("Servlet context path" ,
                                (String)connection.getAttribute(servletRTs[z],
                                 "ContextPath"));
                                printValue("Invocation Total Count" ,
                                        (Object)connection.getAttribute(servletRTs[z],
                                         "InvocationTotalCount"));
                               printValue("ExecutionTimeHigh",
                                            (Object)connection.getAttribute(servletRTs[z],
                                             "ExecutionTimeHigh"));
                                printValue("ExecutionTimeTotal",(Object)connection.getAttribute(servletRTs[z],
                                     "ExecutionTimeTotal"));
                                printValue("ExecutionTimeAverage",(Object)connection.getAttribute(servletRTs[z],
                                        "ExecutionTimeAverage"));
                            
                          }
                         
                          
                    
                      }
                   }
                }
               }
             }
          }
       }
        
       private void printValue(String key,Object value){
           System.out.println("  " + key + " : " + value);
       }
        public static void main(String[] args) throws Exception {
             String hostname = "10.111.131.50";
              String portString = "7001";
              String username = "weblogic";
              String password = "weblogic123";
              PrintServerlet s = new PrintServerlet();
              initConnection(hostname, portString, username, password);
              s.getServletData();
              connector.close();
       }
}
Java 版jmx 监控中间件weblogic
10-18
Java版 jmx 监控weblogic 生成html
jmx监控weblogic,tomcat,websphere源码
04-16
通过JMX，你可以获取到WebLogic服务器的运行时信息，如JVM内存使用情况、线程状态、应用程序的健康状况等。 Tomcat则是一个开源的轻量级应用服务器，主要用于Servlet和JSP的部署。虽然Tomcat相对较小巧，但同样支持...
通过JMX监控weblogic服务
lipeng的博客
04-09 1152
一、JMX简介 　　JMX是一种JAVA的正式规范，它主要目的是让程序有被管理的功能，那么怎么理解所谓的“被管理”呢？试想你开发了一个软件（如ＷＥＢ网站），它是在２４小时不间断运行的，那么你可能会想要“监控”这个软件的运行情况，比如收到了多少数据，有多少人登录等等。或者你又想“配置”这个软件，比如现在访问人数比较多，你想把数据连接池设置得大一些。 　　当然，你也许会专门为这些管理来开发软件...
JMX监控栈中Kafka集群请求/响应队列指标的监控增强
最新发布
gitblog_07396的博客
06-24 226
JMX监控栈中Kafka集群请求/响应队列指标的监控增强 在分布式消息系统Kafka的运维监控中，请求队列(RequestQueue)和响应队列(ResponseQueue)的实时状态监控是评估Broker节点处理能力的关键指标。Confluent官方维护的JMX监控栈项目近期针对这一核心需求进行了重要增强。 监控指标的技术意义 Kafka网络层采用Reactor模式处理请求，其核心组件Reque...
JMX对weblogic的监控指标小结
weixin_33995481的博客
04-20 442
weblogicServier实现了JMX规范，提供了各种各样的MBeans对WebLogic Server的各项配置及性能进行监控的API。通过weblogic提供的API可以对server(服务),cluster(集群)等进行监控。下面主要罗列对server进行监控的指标。1、常用一般监控指标指标名指标描述MBean属性服务状态此服务器的当前生命周期状态。例如，服务器可以...
通过JMX监控管理weblogic的运行
java专栏
05-23 735
google_ad_client = "pub-8800625213955058";/* 336x280, 创建于 07-11-21 */google_ad_slot = "0989131976";google_ad_width = 336;google_ad_height = 280;//<script type="text/java
Java版JMX监控WebLogic中间件技术解析
1. **MBean的编写和注册**：首先需要在WebLogic服务器上部署自定义的MBean，这些MBean需要通过编程实现对WebLogic服务器的监控指标的收集。 2. **JMX连接**：监控工具或者自编程序需要通过JMX连接到WebLogic的MBean...
源码解析：JMX监控WebLogic、Tomcat、WebSphere实现
通过 JMX 连接到 WebLogic 服务器的 MBean 服务器，可以远程获取和调整服务器状态和性能指标。 #### Tomcat Apache Tomcat 是一个开源的 Web 应用服务器，由 Apache 软件基金会维护。它支持作为单独的服务器运行，...
Linux下 通过jconsole远程监控weblogic
01-09
通过JConsole工具，我们可以有效地监视WebLogic服务器的性能，包括内存使用、线程状态、类加载器以及MBeans等关键指标。以下是如何在CentOS 7.5上配置和使用JConsole来远程监控WebLogic 12c的详细步骤： 1. **环境...
weblogic监控脚本
03-18
这篇博客文章“Weblogic监控脚本”可能涉及了如何利用脚本来自动化监控WebLogic服务器的关键指标，如内存使用、CPU利用率、JVM性能等。 在WebLogic中，监控可以通过多种方式实现，包括使用内置的管理控制台、WLST...
通过jmx监控管理weblogic
09-26
JMX(Java Management Extensions)是SUN创建的一套规范。BEA WebLogic Server实现了JMX大部分的API,并且提供了一个完全兼容JMX的控制台来管理各种资源。OPEN SOURCE的应用服务器JBoss也是基于JMX来实现。并且对之评价很高，认为是目前为止最好的软件集成工具。JBoss的成功依靠于JMX。
WeblogicJMX:Weblogic JMX 实用程序
06-14
网络逻辑JMX 这是一个正在进行的工作，将经常更新，直到完成 一组用于 9.X 及更高版本的 Weblogic 服务器的 JMX 服务器实用程序。 目前实时给出一些监控统计，后续会更新更多功能 特征 目前可以使用以下功能： JVM 监控统计 服务器线程池运行时统计 服务器统计 JDBC 数据源统计信息 应用程序部署列表和状态 世贸中心现状 概念 WeblogicJMX 使用 Java JMX 进行 MBean 服务器调用并获取连接到 DomainRuntimeMBean 的统计信息 先决条件 设置 需要有兼容的 JDK 1.6 及更高版本。 需要以下需要手动放置的库，直到项目被 mavenized slf4j-api-1.6.6 logback-core-1.0.13 logback-classic-1.0.13 weblogicfullclient.jar (* 关于构建 w
WebLogic JMX
allway2的博客
06-28 807
https://github.com/geraldo-netto/weblogic-mon import java.io.IOException; import java.text.SimpleDateFormat; import java.util.Date; import java.util.HashMap; import java.util.Map; import javax.mana...
jmx远程调用tomcat和weblogic获取服务器监控性能数据
abigale-csdn
05-15 1217
前言 JMX(Java Management Extensions)是一个为应用程序植入管理功能的框架。JMX是一套标准的代理和服务，实际上，用户可以在任何Java应用程序中使用这些代理和服务实现管理。 应用场景：中间件tomcat和weblogic都支持jmx，需要对其进行配置即可通过接口或者jdk自带的工具jcode获取监控数据 下面通过程序和jcode工具展示数据 一、tomcat和weblogic配置jmx 这里提供tomcat和weblogic的jmx配置和第三方调用，was的待研究 1.tomc
使用WebLogic JMX进行定制调试
上善若水.class
12-18 2566
     维护复杂的遗留系统是一项挑战，而文档、理性设计以及编码实践的缺乏通常会使情况变得更为糟糕。遗憾的是，几乎所有的软件开发人员在其职业生涯中都会遇到此类任务。 　　对于任何使用数据库的应用程序，跟踪应用程序所生成的SQL语句是非常有益的。这样的跟踪有助于分析性能瓶颈和调试错误，还可以帮助开发人员了解与应用程序相关的业务流程。 　　对于遗留的应用程序，我们希望可以进行这样的跟踪而不必修改任何代
apache kafka系列之jmx监控指标参数
热门推荐
李志涛的专栏
06-30 1万+
Kafka使用Yammer Metrics来
在WebLogic Server上驯服JMX
最佳 Java 编程
05-16 427
让我们先假设几件事： 我假设您听说过Java的JMX功能并熟悉它的功能（远程公开和管理您的服务）。 您应该知道默认JVM将具有一个可以注册MBean的Platform MBeanServer实例。 您可以使用JDK中的jconsole命令查看它们。 到目前为止，我认为到目前为止，可以将应用程序中的任何服务公开给JMX MBeanServer的最简单方法是使用Spring的导出器。 ...
通过 JMX 获取zookeeper监控指标
紫蝶侠的博客
06-15 813
目前zookeeper获取监控指标有两种方式： 通过JMX来监控； 通过zookeeper自带的四字命令来获取各种监控指标。 通过JMX来监控： zookeeper监控之JMX篇 JMX监控Zookeeper状态Java API
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值