通过JMX获取weblogic的监控指标

最新推荐文章于 2024-06-04 09:45:09 发布
最新推荐文章于 2024-06-04 09:45:09 发布
阅读量2.2k 收藏 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();
        }
}
高尔夫golf
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
weblogic使用JMX监控应用程序内、外部的状况
Magister_Feng的专栏
07-21 1040
自WebLogic 6.0以来，Java管理API (JMX)对管理WebLogic服务器而言是必需的。通过这个API，你可以在应用程序服务器里搜索管理beans (mbeans) 并且通过它们你既可以查询配置信息又可以查询runtime监控信息。 此外，通过这个API还可以用来
jmx监控weblogic,tomcat,websphere源码
04-16
通过JMX，你可以获取到WebLogic服务器的运行时信息，如JVM内存使用情况、线程状态、应用程序的健康状况等。 Tomcat则是一个开源的轻量级应用服务器，主要用于Servlet和JSP的部署。虽然Tomcat相对较小巧，但同样支持...
Java 版jmx 监控中间件weblogic
10-18
Java版 jmx 监控weblogic 生成html
通过JMX监控weblogic服务
lipeng的博客
04-09 970
一、JMX简介 　　JMX是一种JAVA的正式规范，它主要目的是让程序有被管理的功能，那么怎么理解所谓的“被管理”呢？试想你开发了一个软件（如ＷＥＢ网站），它是在２４小时不间断运行的，那么你可能会想要“监控”这个软件的运行情况，比如收到了多少数据，有多少人登录等等。或者你又想“配置”这个软件，比如现在访问人数比较多，你想把数据连接池设置得大一些。 　　当然，你也许会专门为这些管理来开发软件...
如何在Weblogic环境中启动认证方式对接Zabbix监控
最新发布
乐维社区的博客
06-04 789
本文将详细介绍如何在Weblogic环境中配置启动认证并对接Zabbix监控，通过设置Weblogic的相关配置文件、创建认证文件并配置监控部分，确保只有授权用户才能启动Weblogic服务器，并实现对其运行状态的实时监控。注：access文件前面的weblogic为用户，设为只读，password文件前面为用户后面为密码，权限修改必做，否则可能会发生错误无法启动！到此，全部配置完成。大家好，我是乐乐，专注IT运维技术研究与分享，更多运维技巧及运维问题欢迎关注乐维社区并留言~
JMX对weblogic的监控指标小结
weixin_33995481的博客
04-20 357
weblogicServier实现了JMX规范，提供了各种各样的MBeans对WebLogic Server的各项配置及性能进行监控的API。通过weblogic提供的API可以对server(服务),cluster(集群)等进行监控。下面主要罗列对server进行监控的指标。1、常用一般监控指标指标名指标描述MBean属性服务状态此服务器的当前生命周期状态。例如，服务器可以...
通过JMX监控管理weblogic的运行
java专栏
05-23 678
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
Linux下 通过jconsole远程监控weblogic
01-09
通过JConsole工具，我们可以有效地监视WebLogic服务器的性能，包括内存使用、线程状态、类加载器以及MBeans等关键指标。以下是如何在CentOS 7.5上配置和使用JConsole来远程监控WebLogic 12c的详细步骤： 1. **环境...
weblogic监控脚本
03-18
这篇博客文章“Weblogic监控脚本”可能涉及了如何利用脚本来自动化监控WebLogic服务器的关键指标，如内存使用、CPU利用率、JVM性能等。 在WebLogic中，监控可以通过多种方式实现，包括使用内置的管理控制台、WLST...
android-weblogic-monitor:用于通过 REST API 监控 WebLogic Server 12c 的 Android 应用程序
06-21
通过调用这些API，android-weblogic-monitor能够获取服务器的运行状态、性能指标、应用部署情况等关键信息，并在Android设备上展示。 在实际应用中，android-weblogic-monitor具有以下主要功能： 1. 实时监控：...
通过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
Nagios Check Weblogic:监控 Weblogic 的 Nagios 插件-开源
06-29
通过MBean Server，用户可以查询和操作MBeans，获取WebLogic服务器的实时状态。 在开源社区的支持下，Nagios Check Weblogic保持持续更新和优化，以适应WebLogic的新版本和用户的新需求。使用者可以通过参与社区，...
WebLogic JMX
allway2的博客
06-28 776
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 943
前言 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 2490
     维护复杂的遗留系统是一项挑战，而文档、理性设计以及编码实践的缺乏通常会使情况变得更为糟糕。遗憾的是，几乎所有的软件开发人员在其职业生涯中都会遇到此类任务。 　　对于任何使用数据库的应用程序，跟踪应用程序所生成的SQL语句是非常有益的。这样的跟踪有助于分析性能瓶颈和调试错误，还可以帮助开发人员了解与应用程序相关的业务流程。 　　对于遗留的应用程序，我们希望可以进行这样的跟踪而不必修改任何代
apache kafka系列之jmx监控指标参数
热门推荐
李志涛的专栏
06-30 1万+
Kafka使用Yammer Metrics来
通过 JMX 获取zookeeper监控指标
紫蝶侠的博客
06-15 730
目前zookeeper获取监控指标有两种方式： 通过JMX来监控； 通过zookeeper自带的四字命令来获取各种监控指标。 通过JMX来监控： zookeeper监控之JMX篇 JMX监控Zookeeper状态Java API
weblogic的jmx监控
06-07
WebLogic Server支持Java Management Extensions（JMX）监控。可以使用JMX监控WebLogic Server的运行时状态，包括服务器实例、集群、JMS服务器、JDBC连接池、Web应用程序和EJB组件等。 以下是使用JMX监控WebLogic ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值