精华内容
下载资源
问答
  • Mbean

    千次阅读 2017-04-27 13:39:17
    Mbean名词解释 Mbean managed beans 被管理的bean 描述一个可管理的资源。 是一个Java对象,遵循以下一些语义: java对象的属性(property)叫属性(attribute),方法(method)叫操作(operations)。 Mbean的...

    Mbean

    名词解释

    1. Mbean
      managed beans 被管理的bean
      描述一个可管理的资源。
      是一个Java对象,遵循以下一些语义:
      java对象的属性(property)叫属性(attribute),方法(method)叫操作(operations)。

      • Mbean的定义:
        必须:是公用的,非抽象的类
        必须:有至少一个公用的构造器
        必须:实现它自己的相应的MBean接口或者实现 javax.management.DynamicMBean 接口
        可选:一个MBean可以实现 javax.management.NotificationBroadcaster 接口
      • Mbean的类型
        标准MBean
        动态MBean
        模型MBean
        开放MBean
      • Mbean的使用步骤
        1)注册Mbean
        一个MBeanServer的主要职责是在一个JMX代理中维护一个MBean的注册表。
        MBean能够以下面两个方法中的任意一个注册:
        <1>创建一个MBean实例并注册它到MBeanServer用方法:

        public ObjectInstance registerMBean(Object object, ObjectName name)   
        

        这里,object是创建的MBean实例,name部分是MBean的一个唯一标志符。
        <2>使用createMBean 方法中的一个:

        public ObjectInstance createMBean(String classname, ObjectName name) 
        public ObjectInstance createMBean(String classname, ObjectName name, ObjectName loader) 
        public ObjectInstance createMBean(String classname, ObjectName name, Object[] params, String[] types) 
        public ObjectInstance createMBean(String classname, ObjectName name, ObjectName loader, Object[] params, String[] types) 
        

        createMBean方法使用java自省来创建一个MBean实例。对所有的createMBean方法,有两个变量是通用的:
        String classname – 要创建的MBean的实例的类名。
        ObjectName name – MBean要注册的对象名称。
        如果用两个变量的createMBean构造器,缺省的类装载器(class loader)用来装载MBean类,MBean被使用缺省的构造器初始化。如果MBean已经被初始化,这个实例将被MBeanServer用第二个变量的对象名称注册。如果你想使用指定的类装载器,那么可以使用三个变量的构造器。这个类装载器将被MBeanServer注册为一个MBean。这个类装载器的对象名称将用做第三个变量。
        当实例化一个类,如果任何参数必须传入,那么可以使用四个参数的createMBean方法。这个createMBean方法的最后的两个参数分别包含对象数组(类的初始化必须的)和他们的署名。如果MBean类必须用其他指定的类装载器装载,那么应该使用五个参数的构造器。
        2)注册一个MBean的多个实例
        你可能需要监控十多个Web 服务器。如果所有的web服务器的管理信息是相同的,那么你不必编写十个MBean。一个MBean足够了。我们能够创建多个实例并注册每一个实例以一个唯一的对象名称。
        现在可以看到使用对象名称来避免混淆的重要性。
        很明显服务器的端口数字和服务器的名称将是任意服务器的唯一,那是因为,在一个机器上,你不能运行两个服务器在一个端口上。
        于是,可以创建对象名称如
        Servers:hostName=localhost,portNumber=xxxx
        假设超过一个服务器在同一个机器上启动,那么对象名称应该为
        Servers:hostName=localhost,portNumber=yyyy
        由于对象名称是注册MBean的唯一标志,多个MBean的实例将被注册为不同的对象名称。
        对象名称通常用他们包含的关键值对来区分,如一个服务器MBean的主机名和端口名关键字及他们各自的值。同理,唯一标志相似的MBean组,对象名称将用相应的关键字和值对拼装。例如,type=ServerMBean指出这个MBean是一个服务器MBean类型。由此,对象名称值Server:type=ServerMBean,hostName=localhost,portNumber=8050 提供一个简单的MBean分组,产生为服务器MBean的实现。并且也提供了一个方法来唯一标志在localhost:8050上运行的服务器的MBean实例。
        一个简单的示范
        让提供管理信息(所有web服务器通用的)的Mbean为动态MBean,并且起名为ServerInfo。
        让两个web服务器运行在机器A(machineA)的端口8080和80。让一个web服务器运行在机器B(machineB)的8080端口,另一个web服务器运行在机器C(machineC)的80端口。总之,我们需要管理这四个web服务器。我们能够用ServerInfo 类和创建四个实例来管理每一个web服务器。注册四个MBean的代码片断如下:

        ServerInfo srvr1 = new ServerInfo(); 
        ServerInfo srvr2 = new ServerInfo(); 
        ServerInfo srvr3 = new ServerInfo(); 
        ServerInfo srvr4 = new ServerInfo();
        MBeanServer mbs = null;
        try { 
            mbs = MBeanServerFactory.createMBeanServer( ); 
            mbs.registerMBean(srvr1, new ObjectName("Server:hostName=machineA,portNumber=8080")); 
            mbs.registerMBean(srvr2, new ObjectName("Server:hostName=machineA,portNumber=80")); 
            mbs.registerMBean(srvr3, new ObjectName("Server:hostName=machineB,portNumber=8080")); 
            mbs.registerMBean(srvr4, new ObjectName("Server:hostName=machineC,portNumber=80")); 
        } catch (Exception e) {
         e.printStackTrace(); 
        }
        

        3)注销MBean
        MBean能够用MBeanServer的下面方法注销:

        public void unregisterMBean(ObjectName name) 
        

        这里name是这个MBean实例注册的对象名称。
        注销MBean后,MBeanServer将不再保存任何这个MBean实例的关联。
        控制MBeanRegistration
        JMX定义了一个接口叫MBeanRegistration。这个接口的目的是允许MBean开发者对在MBeanServer上注册和注销进行一些控制。这通过MBean实现javax.management.MBeanRegistration接口来达到。
        MBeanRegistration接口定义注册控制机制的行为。它定义了以下四个方法:

        public ObjectName preRegister(MBeanServer mbs, ObjectName name) 
        public void postRegister() 
        public void preDeRegister() 
        public void postDeRegister()
        

        所有以上的方法都是回调方法,MBeanServer将在恰当的时机调用这些方法。
        如果一个MBean实现MBeanRegistration并且这个MBean被注册,MBeanServer在注册前调用preRegister方法。这个方法返回的对象名称将在MBean注册过程中使用。在成功完成MBean注册后,MBeanServer调用postRegister方法。
        如果以上的MBean被注销,在注销前MBeanServer调用preDeRegister方法。如果注销成功,MBeanServer调用postDeRegister方法。
        需要记住的几点
        对于一个单一MBean类,多个实例能够被创建,并能够被注册为注册时MBean提供的对象名称。
        无论何时一个MBean被注册,MBeanServer创建一个类型为 jmx.mbean.created 的消息。MBeanServerDelegate MBean 广播这个消息到所有注册的监听者。
        MBeanRegistration接口提供注册和注销过程监控的钩点。

    2. JMX

      • 知识简介
        JMX(Java Management Extensions,即Java管理扩展)是一个为应用程序、设备、系统等植入管理功能的框架。JMX可以跨越一系列异构操作系统平台、系统体系结构和网络传输协议,灵活的开发无缝集成的系统、网络和服务管理应用。
        JMX在Java编程语言中定义了应用程序以及网络管理和监控的体系结构、设计模式、应用程序接口以及服务。通常使用JMX来监控系统的运行状态或管理系统的某些方面,比如清空缓存、重新加载配置文件等。
        优点是可以非常容易的使应用程序被管理
        伸缩性的架构使每个JMX Agent服务可以很容易的放入到Agent中,每个JMX的实现都提供几个核心的Agent服务,你也可以自己编写服务,服务可以很容易的部署,取消部署。
        主要作用是提供接口,允许有不同的实现 。
      • JMX架构分层
        JMX体系结构分为以下四个层次:
        设备层
        设备层(Instrumentation Level):主要定义了信息模型。在JMX中,各种管理对象以管理构件的形式存在,需要管理时,向MBean服务器进行注册。该层还定义了通知机制以及一些辅助元数据类。
        代理层
        代理层(Agent Level):主要定义了各种服务以及通信模型。该层的核心是一个MBean服务器,所有的管理构件都需要向它注册,才能被管理。注册在MBean服务器上管理构件并不直接和远程应用程序进行通信,它们通过协议适配器和连接器进行通信。而协议适配器和连接器也以管理构件的形式向MBean服务器注册才能提供相应的服务。
        分布服务层
        分布服务层(Distributed Service Level):主要定义了能对代理层进行操作的管理接口和构件,这样管理者就可以操作代理。然而,当前的JMX规范并没有给出这一层的具体规范。
        附加管理协议API
        定义的API主要用来支持当前已经存在的网络管理协议,如SNMP、TMN、CIM/WBEM等。
    3. Spring中对Mbean的支持
      Spring中提供了MbeanExporter,将Spring bean的属性和方法导出为MBean服务器中的JMX属性和操作。通过JMX服务器,JMX管理工具(例如JConsole)可以查看到正在运行的应用程序的内部情况。
      Spring的MbeanExporter使用方法如下

      //args为将要导出的bean对象
      @Bean  
      public MbeanExporter mbeanExporter(Object args) {
          MbeanExporter exporter = new MbeanExporter();
          Map<String, Object> beans = new HashMap<>();
          beans.put("ObjectName", args);
          exporter.setBeans(beans);
          return exporter;
      }
      

      另外一种XML配置的方法

      <bean id="mbeanExporter" class="org.springframework.jmx.export.MBeanExporter">  
          <property name="beans">  
              <util:map>  
                  <!-- 这里的value-ref都为之前定义的bean的id -->
                  <entry key="bean:name=requestRule" value-ref="requestRule"/>  
                  <entry key="bean:name=responseRule" value-ref="responseRule"/> 
              </util:map>  
          </property>  
      </bean>
      

      对MbeanExporter代码的阅读,本文中只摘取部分说明
      MebanExporter.java

      public class MBeanExporter extends MBeanRegistrationSupport
        implements MBeanExportOperations, BeanClassLoaderAware, 
        BeanFactoryAware, InitializingBean, SmartInitializingSingleton, DisposableBean{
          public static final int AUTODETECT_NONE = 0;
          public static final int AUTODETECT_MBEAN = 1;
          public static final int AUTODETECT_ASSEMBLER = 2;
          public static final int AUTODETECT_ALL = 3;
          private static final String WILDCARD = "*";
          private static final String MR_TYPE_OBJECT_REFERENCE = "ObjectReference";
          private static final String CONSTANT_PREFIX_AUTODETECT = "AUTODETECT_";
          private static final Constants constants = new Constants(MBeanExporter.class);
          private Map<String, Object> beans;
          private Integer autodetectMode;
          private boolean allowEagerInit;
          private MBeanInfoAssembler assembler;
          private ObjectNamingStrategy namingStrategy;
          private boolean ensureUniqueRuntimeObjectNames;
          private boolean exposeManagedResourceClassLoader;
          private Set<String> excludedBeans;
          private MBeanExporterListener[] listeners;
          private NotificationListenerBean[] notificationListeners;
          private final Map<NotificationListenerBean, ObjectName[]> registeredNotificationListeners;
          private ClassLoader beanClassLoader;
          private ListableBeanFactory beanFactory;
      
          ......
          ......
      
          //随容器启动而启动
          public void afterPropertiesSet() {
              //获取到MbeanServer
              if (this.server == null)
                this.server = JmxUtils.locateMBeanServer();
          }
      
          public void destroy() {
              this.logger.info("Unregistering JMX-exposed beans on shutdown");
              unregisterNotificationListeners();
              unregisterBeans();
          }
      
          public ObjectName registerManagedResource(Object managedResource)
              throws MBeanExportException  {
              Assert.notNull(managedResource, "Managed resource must not be null");
              try {
                ObjectName objectName = getObjectName(managedResource, null);
                if (this.ensureUniqueRuntimeObjectNames)
                  objectName = JmxUtils.appendIdentityToObjectName(objectName, managedResource);
              } catch (Exception ex) {
                throw new MBeanExportException("Unable to generate ObjectName for MBean [" + managedResource + "]", ex);
              }
              ObjectName objectName;
              registerManagedResource(managedResource, objectName);
              return objectName;
          }
      
          public void registerManagedResource(Object managedResource, ObjectName objectName) throws MBeanExportException {
              Assert.notNull(managedResource, "Managed resource must not be null");
              Assert.notNull(objectName, "ObjectName must not be null");
              try {
                  if (isMBean(managedResource.getClass())) {
                      doRegister(managedResource, objectName);
                  } else {
                      ModelMBean mbean = createAndConfigureMBean(managedResource, managedResource.getClass().getName());
                      doRegister(mbean, objectName);
                      injectNotificationPublisherIfNecessary(managedResource, mbean, objectName);
                  }
              } catch (JMException ex) {
                  throw new UnableToRegisterMBeanException("Unable to register MBean [" + managedResource + "] with object name [" + objectName + "]", ex);
              }
          }
      
          public void unregisterManagedResource(ObjectName objectName) {
              Assert.notNull(objectName, "ObjectName must not be null");
              doUnregister(objectName);
          }
      
          protected void registerBeans() {
              if (this.beans == null) {
                  this.beans = new HashMap();
                  if (this.autodetectMode == null) {
                      this.autodetectMode = Integer.valueOf(3);
                  }
              }
              int mode = (this.autodetectMode != null) ? this.autodetectMode.intValue() : 0;
              if (mode != 0) {
                  if (this.beanFactory == null) {
                      throw new MBeanExportException("Cannot autodetect MBeans if not running in a BeanFactory");
                  }
                  if ((mode == 1) || (mode == 3)) {
                      this.logger.debug("Autodetecting user-defined JMX MBeans");
                      autodetectMBeans();
                  }
                  if ((((mode == 2) || (mode == 3))) && (this.assembler instanceof AutodetectCapableMBeanInfoAssembler)) {
                      autodetectBeans((AutodetectCapableMBeanInfoAssembler)this.assembler);
                  }
              }
              if (!(this.beans.isEmpty()))
                  for (Map.Entry entry : this.beans.entrySet())
                      registerBeanNameOrInstance(entry.getValue(), (String)entry.getKey());
          }
      
          protected ObjectName registerBeanNameOrInstance(Object mapValue, String beanKey)
          throws MBeanExportException {
              try {
                  Object bean;
                  if (mapValue instanceof String) {
                      if (this.beanFactory == null) {
                          throw new MBeanExportException("Cannot resolve bean names if not running in a BeanFactory");
                      }
                      String beanName = (String)mapValue;
                      if (isBeanDefinitionLazyInit(this.beanFactory, beanName)) {
                          ObjectName objectName = registerLazyInit(beanName, beanKey);
                          replaceNotificationListenerBeanNameKeysIfNecessary(beanName, objectName);
                          return objectName;
                      }
      
                      bean = this.beanFactory.getBean(beanName);
                      ObjectName objectName = registerBeanInstance(bean, beanKey);
                      replaceNotificationListenerBeanNameKeysIfNecessary(beanName, objectName);
                      return objectName;
                  }
      
                  if (this.beanFactory != null) {
                      Map beansOfSameType = this.beanFactory.getBeansOfType(mapValue.getClass(),false, this.allowEagerInit);
                      for (Map.Entry entry : beansOfSameType.entrySet()) {
                          if (entry.getValue() == mapValue) {
                              String beanName = (String)entry.getKey();
                              ObjectName objectName = registerBeanInstance(mapValue, beanKey);
                              replaceNotificationListenerBeanNameKeysIfNecessary(beanName, objectName);
                              return objectName;
                          }
                      }
                  }
                  return registerBeanInstance(mapValue, beanKey);
              } catch (Exception ex) {
                  throw new UnableToRegisterMBeanException("Unable to register MBean [" + mapValue + "] with key '" + beanKey + "'", ex);
              }
          }
      
          private ObjectName registerBeanInstance(Object bean, String beanKey) throws JMException {
              ObjectName objectName = getObjectName(bean, beanKey);
              Object mbeanToExpose = null;
              if (isMBean(bean.getClass())) {
                  mbeanToExpose = bean;
              } else {
                  DynamicMBean adaptedBean = adaptMBeanIfPossible(bean);
                  if (adaptedBean != null) {
                      mbeanToExpose = adaptedBean;
                  }
              }
              if (mbeanToExpose != null) {
                  if (this.logger.isInfoEnabled()) {
                      this.logger.info("Located MBean '" + beanKey + "': registering with JMX server as MBean [" + objectName + "]");
                  }
      
                  doRegister(mbeanToExpose, objectName);
              } else {
                  if (this.logger.isInfoEnabled()) {
                      this.logger.info("Located managed bean '" + beanKey + "': registering with JMX server as MBean [" + objectName + "]");
                  }
      
                  ModelMBean mbean = createAndConfigureMBean(bean, beanKey);
                  doRegister(mbean, objectName);
                  injectNotificationPublisherIfNecessary(bean, mbean, objectName);
              }
              return objectName;
          }
          ......
          ......
      
      }
      

      MbeanRegistrationSupport.java(部分代码段)

      protected void doRegister(Object mbean, ObjectName objectName) throws JMException {
          ObjectName actualObjectName;
          synchronized (this.registeredBeans) {
              ObjectInstance registeredBean = null;
              try {
                  registeredBean = this.server.registerMBean(mbean, objectName);
              } catch (InstanceAlreadyExistsException ex) {
                  if (this.registrationPolicy == RegistrationPolicy.IGNORE_EXISTING) {
                      if (this.logger.isDebugEnabled()) {
                          this.logger.debug("Ignoring existing MBean at [" + objectName + "]");
                      }
                  } else if (this.registrationPolicy == RegistrationPolicy.REPLACE_EXISTING) {
                      try {
                          if (this.logger.isDebugEnabled()) {
                              this.logger.debug("Replacing existing MBean at [" + objectName + "]");
                          }
                          this.server.unregisterMBean(objectName);
                          registeredBean = this.server.registerMBean(mbean, objectName);
                      } catch (InstanceNotFoundException ex2) {
                          this.logger.error("Unable to replace existing MBean at [" + objectName + "]", ex2);
                          throw ex;
                      }
                  } else {
                      throw ex;
                  }
              }
      
              actualObjectName = (registeredBean != null) ? registeredBean.getObjectName() : null;
              if (actualObjectName == null) {
                  actualObjectName = objectName;
              }
              this.registeredBeans.add(actualObjectName);
          }
          onRegister(actualObjectName, mbean);
      }
      

      研究源码得出:Spring的MbeanExporter中声明了一个beans(类型为map)用来保存将要被导出到Mbean的对象,底层是使用MbeanServer的registerMBean方法实现。
      对于Spring中Mbean的一些具体操作,会在后续章节详述。

    展开全文
  • MBean的学习

    2021-02-28 06:17:01
    这里以MBean对象进行...1.MBean接口,接口名必须以MBean结尾1 packagegofAndJavaSourceStudy.jmxstudy.jmxImpl;23 public interfaceHelloMBean {4 //管理属性5 public voidsetName(String name);67 publicString g...

    这里以MBean对象进行演示向服务器注册,调用的过程。

    1.MBean接口,接口名必须以MBean结尾

    1 packagegofAndJavaSourceStudy.jmxstudy.jmxImpl;2

    3 public interfaceHelloMBean {4 //管理属性

    5 public voidsetName(String name);6

    7 publicString getName();8

    9 //管理操作

    10 publicString print();11 }

    2.实现这个接口,定义属性和行为

    1 packagegofAndJavaSourceStudy.jmxstudy.jmxImpl;2

    3 importjava.lang.management.ManagementFactory;4

    5 importjavax.management.Attribute;6 importjavax.management.MBeanServer;7 importjavax.management.ObjectName;8

    9 //MBean的接口和实现类必须位于同一个包中

    10

    11 public class Hello implementsHelloMBean {12 publicString name;13

    14 public voidsetName(String name) {15 //TODO Auto-generated method stub

    16 this.name =name;17 }18

    19 publicString getName() {20 //TODO Auto-generated method stub

    21 returnname;22 }23

    24 publicString print() {25 //TODO Auto-generated method stub

    26 String result = "Hello," + name + "!!";27 System.out.println(result);28 returnresult;29 }30

    31 public static void main(String args[]) throwsException {32 MBeanServer mbs = ManagementFactory.getPlatformMBeanServer(); //获取MBeanServer

    33 ObjectName name = new ObjectName("fjs:type=hello"); //构造一个名字

    34 Hello hello = new Hello(); //创建需要注册的对象

    35 mbs.registerMBean(hello, name); //注册这个对象

    36

    37 mbs.setAttribute(name, new Attribute("Name", "bianjie"));  //属性首字母必须大写38 mbs.invoke(name, "print", null, null);  //第三个参数为Object[],为传入的参数值,第四个参数为String[],指明参数类型39 Thread.sleep(Long.MAX_VALUE);40 }41

    42 }

    main方法中演示了申请服务器,向服务器注册MBean以及调用的过程。通过objectname,我们可以获得对象的属性,传参调用方法等等。

    几个需要注意的点:1.MBean接口和实现类必须位于同一包下2.Thread.sleep()必须有,阻塞线程,否则服务器和对象的生命周期都结束了,也就无管理可言了。所以运用在监控服务器上的应用程序。

    3.几个工具

    oracle java mission control :可以连接虚拟机,并监控虚拟机的各项指标状态,远程管理应用。今后可以深入研究,应该对性能测试,虚拟机调优作用非常大

    简单调用了一下上面注册的MBean

    e97d1a03e608aa8ed5b8564f61082a82.png

    ---------------------------

    操作对象:JMX和JNDI都可以对Java类和对象进行查找和定位(JMX中还支持对MBean的查找,并有特定的Query类)。但是在实际应用中,JMX一般用于系统重要的功能性组件;JNDI用来查找部署在服务器中的各个应用程序中的资源,例如servlet、EJB和POJO等,并会为每个应用程序建立独立的隔离的Context.各个Context中,只能定位在这个Context中的资源。

    展开全文
  • JavaBean与MBean详解

    2021-02-28 06:16:59
    ◆至于none类型MBean,应该只能得到新的实例了。 当然,JSF提供了另外的访问MBean的方法,我们可以用如下的代码得到MBean的实例: FacesContext context = FacesContext.getCurrentInstance(); ValueBinding ...

    首先从Model1中的JavaBean说起,大家知道,Model1的基本架构就是JSP页面通过JavaBean访问数据层,那么JavaBean到底是什么东东呢?

    其实JavaBean只是一个特别的Java类而已。在JavaBean中,对私有的域用getXXX和setXXX来实现存取,并且必须有一个无参数的构造函数,如下类就是一个JavaBean文件。packagenet.moon.beans;

    publicclassUserInfo {

    privateString userName;

    privateString password;

    publicString getUserName(){

    returnuserName;

    }

    publicString getPassword(){

    returnpassword;

    }

    publicvoidsetUserName(String userName){

    this.userName = userName;

    }

    publicvoidsetPassword(String password){

    this.password = password;

    }

    //如果一个类中无构造函数,Java会为它加一个默认的空的无参数的构造函数,

    //因此,如无其它构造函数,可省略该构造函数

    publicUserInfo(){

    }

    }

    需注意其中的格式要求,域名为***个单词首字母小写的(usernName),对应一个域,分别有一个getUserName和setUserName两个方法,来读取和设置这一域,方法名为get/set + 域名(首字母大写)。

    做过Model1开发的人会知道,JavaBean的引入方式可以是使用标签<jsp:useBean>来引入的,不需开发人员实例化即可产生一个该类的实例,因为实例是由Web容器产生的,所以我们必须提供无参数的构造函数由Web容器来调用。

    再来解释JSF中的MBean,其实MBean就是一个JavaBean,因此它有着和JavaBean相同的要求。

    ***是MBean的配置,JSF的MBean需要在faces-config文件中做配置,配置方法如下:

    demo of config

    userInfo

    user

    net.moon.beans.UserInfo

    session

    对其中的managed-bean-name,managed-bean-class和managed-bean-scope做一下解释。

    managed-bean-name是这一MBean的名字,用于其它位置的调用。

    managed-bean-class是这一MBean的完整路径,用于指明该MBean的类文件位置。

    managed-bean-scope是这一MBean的有效范围。

    下面再对manage-bean-scope进行一下详细的解释,其有效取值为:application, session, request, none。很容易理解,它们的存活周期分别如下:

    Name          Scope

    Application  整个应用

    Session      整个对话

    Request      整个请求

    None         需要时,临时

    大家知道,JSF是以JSP为基础的,那么,对于JSP的九大对象来说,这四种scope的信息到底是怎么存储的呢?

    ◆经过测试证明,scope为applicatoin的MBean的实例保存在ServletContext中,也就是JSP中的application中,因此我们可以用如下的方法得到某个类的引用: FacesContext fc = FacesContext.getCurrentInstance();

    UserInfo ui = (serInfo)fc.getExternalContext().getApplicationMap().get("user");

    ◆对session级别的MBean,我们可以用如下方法得到其引用:

    FacesContext fc = FacesContext.getCurrentInstance();

    UserInfo ub = (UserInfo)fc.getExternalContext().getSessionMap().get("userInfo");

    当然,我们也可以用其它的方法得到session对象后,从session中取出实例。

    ◆对request级别的MBean,我们可从request对象中取得,代码如下:

    FacesContext fc = FacesContext.getCurrentInstance();

    HttpServletRequest request = (HttpServletRequest)fc.getExternalContext().getRequest();

    UserInfo ui = (UserInfo)request.getAttribute("user");

    ◆至于none类型的MBean,应该只能得到新的实例了。

    当然,JSF提供了另外的访问MBean的方法,我们可以用如下的代码得到MBean的实例:

    FacesContext context = FacesContext.getCurrentInstance();

    ValueBinding binding = context.getApplication().createValueBinding("#{user}");

    UserBean user = (UserBean) binding.getValue(context);

    也可用如下的代码直接得到MBean的一个属性:

    FacesContext context = FacesContext.getCurrentInstance();

    ValueBinding binding = context.getApplication().createValueBinding("#{user.name}");

    String name = (String) binding.getValue(context);

    【编辑推荐】

    【责任编辑:red7 TEL:(010)68476606】

    点赞 0

    展开全文
  • JMX监控(MBean

    2016-11-23 22:16:27
    一共有四种类型MBean , 分别是标准类型 MBean, 动态类型 MBean, 开放类型 MBean 和模型类型 MBean 1)标准MBeans(Standard MBeans)设计和实现是最简单的,这类MBean使用自己的方法名作为管理接口;——在前...
    一、引言 写道
    随着企业 IT 规模的不断增长,IT 资源(IT resource)数量不断增加,IT 资源的分布也越来越分散。可以想象,甚至对于一家只有几百台 PC 公司的 IT 管理人员来说,分发一个安全补丁并且保证其在每台 PC 上的安装,如果只依赖人工来完成那简直就是一场噩梦。这样,IT 管理系统就应运而生。
    JMX可以监控与管理系统资源,一般小公司不注重IT资源监控,而大公司非常得视。目前JSE支持JMX接口规范,如Tomcat源码采用大量JMX Mbean监控资源。

     

    写道
    MX 使用了 Java Bean 模式来传递信息。一般说来,JMX 使用有名的 MBean,其内部包含了数据信息,这些信息可能是:应用程序配置信息、模块信息、系统信息、统计信息等。另外,MBean 也可以设立可读写的属性、直接操作某些函数甚至启动 MBean 可发送的 notification 等。
    JMX 规范可以分为三层: 设备层, 代理层, 分布式服务层。 设备层规范定义了编写可由 JMX 管理的资源的标准,即如何写 MBean; 代理曾规范定义了创建代理的规范,封装了 MBean Server;分布式服务层主要定义了对代理层进行操作的管理接口和构件。
    javax.management.MBeanServer实现了 Agent 的功能,以标准的方式给出了管理系统访问 JMX 框架的接口。而 javax.management.MBeans实现了以标准的方式给出了 JMX 框架访问资源的接口。而从类库的层次上看,JMX 包括了核心类库 java.lang.management和 javax.management包。java.lang.management包提供了基本的 VM 监控功能,而 javax.management包则向用户提供了扩展功能。



     

    写道
    要使一个 Java 对象可管理,则必须创建相应的 MBean 对象,并通过这些 MBean 对象管理相应的 Java 对象。当拥有 MBean 类后,需要将其实例化并注册到 MBeanServer 上。
    一共有四种类型的 MBean , 分别是标准类型 MBean, 动态类型 MBean, 开放类型 MBean 和模型类型 MBean
    1)标准MBeans(Standard MBeans)设计和实现是最简单的,这类MBean使用自己的方法名作为管理接口;——在前一篇中的Hello、HelloMBean就是一个标准MBeans(Standard MBeans)
    2)动态MBeans(Dynamic MBeans)必须实现一个指定的接口,由于动态MBeans在运行期间暴露它们的管理接口,因此更为灵活;
    3)开放MBeans(Open MBeans)属于动态MBeans,这类MBean依靠基础数据类型来实现通用管理,并为友情用户进行自我声明;
    4)模型MBeans(Model MBeans)同样也是动态MBeans,这类MBeans是完全可配置的,在运行期间进行自我声明;它们为资源动态工具提供一个一般性的,有默认行为的MBeans类。

       

    了解一下ObjectName对象 写道
    domain(域)下的一些属性,属性的存储采取key-value的方式来存储,这个类的一个精华所在就是domian及属性(key或者value)都是支持正则的,比如:*表示匹配所有,?表示匹配一个字符。
    格式如下:
    domain: key1 = value1 , key2 = value2
    一般实例化ObjectName都传入域(domain),key,value
    1) ObjectName.getInstance("domain:key1=value1")
    2) ObjectName.getInstance("domain", "key1", "value1")
    3) ObjectName.getInstance("domain", hashtable)
    也可以直接调用构造法实例化,如 ObjectName objectName = new ObjectName("domain:key1=value1")
    下面将Mbean注到MBeanServer需要用到ObjectName,所以提前了解一下。

     

    public static ObjectName getInstance(ObjectName name)
    	    throws NullPointerException {
    	if (name.getClass().equals(ObjectName.class))
    	    return name;
    	try {
    	    return new ObjectName(name.getSerializedNameString());
    	} catch (MalformedObjectNameException e) {
    	    throw new IllegalArgumentException("Unexpected: " + e);
    	    // can't happen
    	}
        }
      public static ObjectName getInstance(String domain,
    					 Hashtable<String,String> table)
    	throws MalformedObjectNameException, NullPointerException {
            return new ObjectName(domain, table);
        } 
    
    public ObjectName(String domain, String key, String value)
    	throws MalformedObjectNameException, NullPointerException {
    	// If key or value are null a NullPointerException
    	// will be thrown by the put method in Hashtable.
    	//
    	Map<String,String> table = Collections.singletonMap(key, value);
    	construct(domain, table);
     }

     

    二、MBean 类型 写道
    依次描述MBean各种类型标准MBeans、动态MBeans、模型MBeans

     

    2.1 标准 MBean 写道
    标准 MBean 是最简单的一类 MBean,与动态 Bean 不同,它并不实现 javax.management包中的特殊的接口。说它是标准 MBean, 是因为其向外部公开其接口的方法和普通的 Java Bean 相同,是通过 lexical,或者说 coding convention 进行的,代码实现如下:

     

    /**
    * 与普通接口定义一样
    */
    public interface HelloMBean { 
        public void sayHello(); 
        public int add(int x, int y);  
        public String getName();     
        public int getCacheSize(); 
        public void setCacheSize(int size); 
    } 

     

    public class Hello implements HelloMBean { 
        public void sayHello() { 
            System.out.println("hello, world"); 
        } 
         
        public int add(int x, int y) { 
            return x + y; 
        } 
         
        public String getName() { 
            return this.name; 
        }  
         
        public int getCacheSize() { 
            return this.cacheSize; 
        } 
         
        public synchronized void setCacheSize(int size) {
            ...
        
            this.cacheSize = size; 
            System.out.println("Cache size now " + this.cacheSize); 
        } 
        ...
         
        private final String name = "Reginald"; 
        private int cacheSize = DEFAULT_CACHE_SIZE; 
        private static final int 
            DEFAULT_CACHE_SIZE = 200; 
    }

     

    public class ITAgentMain { 
     
        public static void main(String[] args) throws Exception { 
            // MBeanServer对象获取
            // 或采用MBeanServerFactory.createMBeanServer()获取MBeanServer对象
            MBeanServer mbs = ManagementFactory.getPlatformMBeanServer(); 
            // 构建ObjectName
            ObjectName name = new ObjectName("com.example:type=Hello"); 
            Hello mbean = new HelloMBean (); 
            // 将Mbean注册到MBeanServer 
            mbs.registerMBean(mbean, name); 
            //创建一个AdaptorServer,这个类将决定MBean的管理界面,这里用最普通的Html型界面。AdaptorServer其实也是一个MBean。  
            // alpha:name=HelloWorld的名字是有一定规则的,格式为:“域名:name=MBean名称”,域名和MBean名称都可以任意取。  
            ObjectName adapterName = new ObjectName("HelloAgent:name=htmladapter,port=8082"); //     
             HtmlAdaptorServer adapter = new HtmlAdaptorServer();     
             server.registerMBean(adapter, adapterName);     
             adapter.start();     
             System.out.println("start.....");  
        } 
    } 

     

    JMX注册服务端口 写道
    需要注册一个端口,绑定url后,客户端就可以使用rmi通过url方式来连接JMXConnectorServer,就可以远程监控资源,目很多开源软件都支持如Apache activeMQ可以用JDK 自带的jconsole监控对列、主题资源。
    这里的8888(默认为1099)是通讯端口或者查找端口,服务端在createRegistry时实际上会new ServerSocket(8888),客户端的socket通过与端口号为8888的服务端端口互联lookup到server对象。客户端获取到的server对象在和服务端的sketon对象进行通讯时实际上也会建立socket连接,数据传输时的ServerSocket也需要一个端口(不同于通讯端口),称之为数据端口。

     

    //JMXConnectorServer service 
    		try {
    			//这句话非常重要,不能缺少!注册一个端口,绑定url后,客户端就可以使用rmi通过url方式来连接JMXConnectorServer
    			LocateRegistry.createRegistry(8888);
    			JMXServiceURL url = new JMXServiceURL("service:jmx:rmi:///jndi/rmi://localhost:8888/server");
                            // 注意:server为MBeanServer对象(Mbean注册到此对象)
    			JMXConnectorServer cs = JMXConnectorServerFactory.newJMXConnectorServer(url, null, server);
    			System.out.println("....................begin rmi start.....");
    			cs.start();
    			System.out.println("....................rmi start....."); 
    		} catch (MalformedURLException e) {
    			e.printStackTrace();
    		} catch (IOException e) {
    			e.printStackTrace();
    		} 

     

         动态Mbeans、模型Mbeans(apache 开源实现)待续.....

    展开全文
  • 2 MBean简介2.1. MBeans简要介绍本课程介绍JMX API的基本概念,它被称之为被管理的bean,或者MBeanMBean是一个被管理的Java对象,...
  • unable to register MBean

    千次阅读 2019-04-12 15:40:21
    spring boot启动报错:Unable to register MBean 原因:在tomcat下有多个项目 解决方案:在第二个项目中的application.properties配置文件中添加 spring.jmx.enabled=false 2019-04-11 16:40:21.391 [localhost...
  • MBean类型分为多种,常见的不管是Standard MBean,还是Dynamic MBean,当创建一个MBean时需要满足以下规则: MBean是一个具体的java类,不能是抽象类,因此可以进行实例化。 MBean必须有一个公共的构造器,构造器...
  • MBean,MXBean简介 MBean是一个托管的java bean对象,MBean是一个托管Java对象,类似于JavaBeans组件,遵循JMX(Java Management Extensions...JMX 规范中定义了五种类型MBean,本文主要描述standard MBeans以及MXBea
  • 最近在看一个开源的Cache框架,里面提到使用JMX来查看Cache的命中率以及响应时间等,于是翻...问题:JMX以及Mbean中的 概念都有那些? 问题:如何编写一个简单的Standard MBean? 问题:如何编写一个DynamicMBean?
  • MBean

    2011-02-11 16:45:16
    什么是MBean?    Managed Bean (MBean) 描述一个可管理的资源.是一个java对象,遵循以下一些语义.java对象的属性(property)叫属性(attribute),方法 (method)叫操作(operations). 定义MBean...
  • MBean与JMX

    2019-07-10 15:07:29
    MBean与JMX 欢迎查看Eetal的第二十二篇博客–MBean与JMX JMX JMX(java Management Exetensions)在Java编程语言中定义了应用程序以及网络管理和监控的体系结构、设计模式、应用程序接口以及服务。 通常使用JMX来监控...
  • mbean 参数类型

    2010-09-09 14:34:38
    In addition, any array of the open MBean data types may be used in open MBeans. A special class, javax.management.openmbean.ArrayType is used to represent the definition of single or multi-dimensional...
  • jmx mbean 与java监控

    2021-02-28 06:16:29
    读 接口HelloMBean get开头的函数 写 接口HelloMBeanset开头的函数 操作 接口HelloMBean其它函数 通知 实现类 Hello 去继承 extends NotificationBroadcasterSupport 二 MXBean 当xxxMBean中有自定义类型时,...
  • 在排查线上问题的时候,我们经常使用jstat、...发现之前有人写了个jtop的工具,能够全面获取java应用的信息,一看作者,原来是阿里的同事,原理是使用了java中的MBean,借这个机会,把MBean的东西简单了解一下。...
  • 高速缓存将在给定的时间段后重置自身,并且可以通过调用REST端点或MBean方法“手动”清除。 这篇文章实际上是在以前的文章的基础上建立的 。 唯一的不同是,我将使用Ehcache缓存,而不是将数据存储在...
  • MBean和MXBean 区别

    2019-10-07 14:23:06
    MXBean与MBean的区别主要是在于在接口中会引用到一些其他类型的类时,其表现方式的不一样。在MXBean中,如果一个MXBean的接口定义了一个属性是一个自定义类型,如MemoryMXBean中定义了heapMemoryUsage属性,这个属性...
  • 03-12_MBean层次结构

    2018-01-24 23:25:00
    WebLogic Mbeans的类型 weblogic服务器的MBeans生命周期 Mbeans层次结构与WLST关系介绍: WLST online提供对MBeans的简化访问,WLST使您能够以类似于浏览文件系统中文件层次结构的方式浏览...
  • 第2章 JMX MBean 基础知识

    千次阅读 2017-10-07 16:38:45
    JMX MBean 基础知识 1 引言 这节课介绍JMX API的基本概念,即被管理的beans,或者叫MBeans。 一个MBean是一个被管理的Java对象,有点类似于JavaBean,它遵循了JMX规范的一些设计模式。一个设备、一个应用或者...
  • 6.先定义一个MBeanBase接口类(什么名字不重要,是interface类型就行),这个接口我们要求它有个sayHello方法。 package com.example.demo; public interface MBeanBase { public void sayHello(); } 7.然后...
  • weblogic 理解MBean

    千次阅读 2014-11-13 19:27:08
     WebLogic服务器使用两种基本类型MBean——配置MBean和运行时MBean——来配置、监视和管理服务器以及其资源。  配置MBean包含服务器和资源的配置信息,存储在域配置文件中,比如“config.xml”文件或者其它...
  • 动态MBean

    2018-06-06 10:13:57
    一共有四种MBean:标准MBeans(Standard MBeans)设计和实现是最简单的,这类MBean使用自己的方法名作为管理接口;——在前一篇中的Hello、HelloMBean就是一个标准MBeans(Standard MBeans)动态MBeans(Dynamic ...
  • Java JMX 二:MBean and MBean Server

    千次阅读 2018-11-21 22:05:17
    文章目录1.MBean2.ObjectName3.MBeanServer3.1 MBeanServer接口 1.MBean MBean分为如下四种 ...类型 ...standard MBean ...这种类型MBean最简单,它能管理的资源(包括属性,方法,时间)必须...
  • Weblogic 脚本工具 导航和编辑 MBean

    千次阅读 2012-05-25 15:25:01
    导航和询问 MBean浏览运行时 MBeanMBean 层次中导航查找 MBean访问自定义 MBean编辑配置 MBean   导航和询问 MBean WLST 提供了对 MBean 的简化访问。而 weblogic.Admin 实用工具(不赞成在此版本 ...
  • 最近在看一个开源的Cache框架,里面提到使用JMX来查看Cache的命中率以及响应时间等,于是翻了一些JMX的文章,整理了一下。问题:什么是JMX?...问题:Open MBean 和Mode MBean是作用是啥?问题:按照M...
  • Tomcat7中的JMX使用(二)Dynamic MBean

    千次阅读 2016-05-29 00:52:45
    如上一篇文章所见Standard MBean在Tomcat的例子并不多,在jconsole中所看到的大量MBean(如Catalina下的Connector、Engine、Server、Service等),实际上是动态MBean(Dynamic MBean)。本文主要讲述Tomcat7中如何...
  • MBean的实现

    2013-07-16 16:28:14
    JMX分析1-MBean的实现  本文只是JDK7中JMX在本地,MBeanServer管理MBeans的默认实现的探索学习,没有涉及JMX Remote。  JMX 使用了 Java Bean 模式来传递信息。一般说来,JMX 使用有名的 MBean,其内部包含了...
  • jmx之Model MBean

    2018-04-28 09:22:41
    相对于Standard MBean,Model MBean更加灵活。如果我们不能修改已有的Java类,那么使用Model MBean是不错的选择。Model MBean也是一种专门化的动态管理构件。它是预制的、通用的和动态的 MBean 类,已经包含了所有...
  • MBean与MXBean的区别

    千次阅读 2019-04-22 20:05:33
    MBean与MXBean的区别
  • 什么是MBean?

    万次阅读 2007-12-07 16:04:00
    Managed Bean (MBean) 描述一个可管理的资源.是一个java对象,遵循以下一些语义.java对象的属性(property)叫属性(attribute),方法(method)叫操作(operations).定义MBean一个MBean的语义必须是公用的,非抽象的类 必须...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,584
精华内容 2,633
关键字:

mbean类型