Initializes & registers this MBean with the local MBean server.
182987
public void start() {
        ObjectName beanName = null;
        try {
            MBeanServer server = ManagementFactory.getPlatformMBeanServer();
            beanName = getObjectName();
            server.registerMBean(this, beanName);
        } catch (InstanceAlreadyExistsException e) {
            LOGGER.warn(JcrI18n.mBeanAlreadyRegistered, beanName);
        } catch (Exception e) {
            LOGGER.error(e, JcrI18n.cannotRegisterMBean, beanName);
        }
    }
290082
private static void registerServer(Server server, Database db) {

        if (!serverMap.containsKey(server)) {
            serverMap.put(server, new HashSet());
        }

        HashSet databases = (HashSet) serverMap.get(server);

        databases.add(db);
    }
371819
@Override
    public void initialize() {
        this.fileAlterationObserver = new FileAlterationObserver(directory, fileFilter);
        this.fileAlterationObserver.addListener(this);
        try {
            this.fileAlterationObserver.initialize();
        } catch (Exception e) {
        }
    }
10326
public void initialize()
    {
        super.initialize();

        //
        // Register the ServletService classes associated with the ServletServiceProvider
        //
        ServletServiceProvider ssp = ServletServiceProvider.getProvider();
        addService(ServletContext.class, ssp);
        addService(ServletRequest.class, ssp);
        addService(ServletResponse.class, ssp);
        addService(HttpServletRequest.class, ssp);
        addService(HttpServletResponse.class, ssp);

        //
        // Register an *internal* service that is used to create ControlBeanContext objects for
        // children of this control container
        //
        _bcsp = WebContextFactoryProvider.getProvider();
        addService(ControlBeanContextFactory.class, _bcsp);
    }
318826
void registerMBean(Configuration conf) {
    // We wrap to bypass standard mbean naming convention.
    // This wraping can be removed in java 6 as it is more flexible in
    // package naming for mbeans and their impl.
    StandardMBean bean;
    try {
      versionBeanName = VersionInfo.registerJMX("NameNode");
      myFSMetrics = new FSNamesystemMetrics(conf, this);
      bean = new StandardMBean(this, FSNamesystemMBean.class);
      mbeanName = MBeanUtil.registerMBean("NameNode", "FSNamesystemState", bean);
    } catch (NotCompliantMBeanException e) {
      e.printStackTrace();
    }

    LOG.info("Registered FSNamesystemStatusMBean");
  }
1103371
public void init(HttpInboundConnection conn, SessionManager sessMgr) {
        this.connection = conn;
        this.request = conn.getRequest();
        this.sessionData = new SessionInfo(this, sessMgr);
    }
163857
public static void register(String name, Object instance) {
    try {
      Class<Object> mbeanInterface = guessMBeanInterface(instance);
      ManagementFactory.getPlatformMBeanServer().registerMBean(new StandardMBean(instance, mbeanInterface), new ObjectName(name));

    } catch (MalformedObjectNameException | NotCompliantMBeanException | InstanceAlreadyExistsException | MBeanRegistrationException e) {
      throw new IllegalStateException("Can not register MBean [" + name + "]", e);
    }
  }
457347
protected void initialize() {
        super.initialize();
        _serviceProviders = Collections.synchronizedMap(new HashMap<Class, ServiceProvider>());
        _bcsListeners = Collections.synchronizedList(new ArrayList<BeanContextServicesListener>());
    }
706706
@PostConstruct
    public void init() {
        logger.info("Using localeAware={}", localeAware);
        logger.info("Using portalLocalesProperty='{}'", portalLocalesProperty);
        if (StringUtils.isNotBlank(portalLocalesProperty)) {
            final List<Locale> list = new ArrayList<>();
            for (String token : portalLocalesProperty.split(",")) {
                list.add(parseLocale(token.trim()));
            }
            portalLocales = Collections.unmodifiableList(list);
            logger.info("Loaded the following portalLocales:  {}", portalLocales);
        }
    }
863898
public static void initMBeans() {
		// rq: en général, il y a 2 connecteurs (http et ajp 1.3) définis dans server.xml et donc
		// 2 threadPools et 2 globalRequestProcessors de même nom : http-8080 et jk-8009 (ajp13)
		THREAD_POOLS.clear();
		GLOBAL_REQUEST_PROCESSORS.clear();
		THREAD_POOLS.addAll(MBeansAccessor.getTomcatThreadPools());
		GLOBAL_REQUEST_PROCESSORS.addAll(MBeansAccessor.getTomcatGlobalRequestProcessors());
	}
822959
public static synchronized void init() {
        if (initialized)
            return;
        if (tc.isEntryEnabled()) {
            Tr.entry(tc, "init");
        }

        initialized = true;
        //defaultLevel = StatConstants.STATISTIC_SET_EXTENDED;
        defaultLevel = StatConstants.STATISTIC_SET_BASIC;
        moduleRoot = new ModuleItem();
        setInstrumentationLevel(defaultLevel);
        //disabled = false;
        try {
            MBeanServer mServer = ManagementFactory.getPlatformMBeanServer();
            ObjectName pmiMBean = new ObjectName(PmiConstants.MBEAN_NAME);
            mServer.registerMBean(PmiCollaboratorFactory.getPmiCollaborator(), pmiMBean);
            printAllMBeans();
        } catch (Exception e) {
            Tr.error(tc, "Unable to create Perf MBean.");
            FFDCFilter.processException(e, "com.ibm.ws.pmi.server.PmiRegistry", "Init");
        }
        if (tc.isEntryEnabled()) {
            Tr.exit(tc, "init");
        }
    }
1225575
public static void populateMBeanServer() {
		if(populated)
			return;
		
		synchronized (lock) {
			populated = true;
			
			if (serverMonitor == null) {
				logger.info("Creating and registering the ServerMonitor MXBean");
				try { serverMonitor = new ServerMonitor(true); } catch(Exception ex) {
					logger.warn("Can't publish ServerMonitor MXBean.", ex);
					logger.warn("Nonpublic instance of the ServerMonitor MXBean will be used in current session.");
					serverMonitor = new ServerMonitor(false);
				}
			}
			if (storageManager == null) {
				logger.info("Creating and registering the StorageManager MXBean");
				try{ storageManager = new StorageManager(true); } catch(Exception ex) {
					logger.warn("Can't publish StorageManager MXBean.", ex);
					logger.warn("Nonpublic instance of the StorageManager MXBean will be used in current session.");
					storageManager = new StorageManager(false);
				}
			}
		}
	}
860719
@Override
  public void register(Monitor<?> monitor) {
    try {
      List<MonitorMBean> beans = MonitorMBean.createMBeans(name, monitor, mapper);
      for (MonitorMBean bean : beans) {
        register(bean.getObjectName(), bean);
      }
      monitors.put(monitor.getConfig(), monitor);
      updatePending.set(true);
    } catch (Exception e) {
      LOG.warn("Unable to register Monitor:" + monitor.getConfig(), e);
    }
  }
1125956
protected synchronized void initialize() {
        String invocationServiceName = this.invocationServiceName;
        invocationService = (InvocationService)
                CacheFactory.getService(invocationServiceName);
        if (invocationService == null) {
            throw new IllegalArgumentException("Invocation service ["
                                               + invocationServiceName
                                               + "] is not defined.");
        }

        invocationService.addMemberListener(this);
        serviceMembers = invocationService.getInfo().getServiceMembers();
        memberIterator = serviceMembers.iterator();
    }
8627
public static void register(final Server s) {
        final ServletHolder sh = new ServletHolder(ServletContainer.class);
        sh.setInitParameter("com.sun.jersey.config.property.resourceConfigClass",
            "com.sun.jersey.api.core.PackagesResourceConfig");
        sh.setInitParameter("com.sun.jersey.config.property.packages", "org.jaxrx.resource");

        new Context(s, "/", Context.SESSIONS).addServlet(sh, "/");
    }
260219
private void initializeLocalhostNI() {
    InetAddress localhost;
    try {
      localhost = InetAddress.getLocalHost();
      NetworkInterface ni = NetworkInterface.getByInetAddress(localhost);

      if (ni != null)
        getNIList().add(ni.getName());

    } catch (UnknownHostException | SocketException e) {
      Console.severe("Cannot get the Network Interface for localhost");
      Console.severe(e.getMessage());
    }

  }
325368
@Override
	public void initialize() {
		final List<IResourceProvider> providers = new ArrayList<IResourceProvider>();
		providers.add(new SomeResourceProvider());
		setResourceProviders(providers);


		registerInterceptor(new ResponseHighlighterInterceptor());

	}