MBeanRegistration 인터페이스를 사용한 MBean 의라이프 사이클 관리

738847 MBeanRegistration 인터페이스를 사용한 MBean 의라이프 사이클 관리 738842 2008-01-24T04:53:53Z http://kyeseon.springnote.com/pages/738847 2008-01-24T04:36:45Z Rack과 그 안의 Card의 예를 통해 MBean의 라이프 사이클을 이해하기 쉽도록 한 좋은 예제라고 생각한다.또한 지금 구상하고 있는 솔류션에 MBean을 어떻게 구성하고 MBean의 라이프 사이클을 어떻게 관리할 것인가를 고민하고 있었는데 좋은 아이디어와 정보를 제공해준 글이라고 생각된다. 실 세계의 Rack과 Card를 Modeling을 통해 어떻게 추상화하는지에 대해서도 살짝 엿볼 수 있었다.   URL: <a href="http://sdnkorea.com/blog/484">http://sdnkorea.com/blog/484</a> <hr /> <a href="http://java.sun.com/javase/technologies/core/mntr-mgmt/javamanagement/">JMX(Java Management Extensions)</a>는 J2SE 5.0 이후로 계속 JDK에 포함되었습니다. JDK 6에서 썬은 새롭고 진보된 JMX 샘플을 JDK <code>sample</code> 디렉토리에 추가했습니다. 새로운 샘플(<code>$JDK_HOME/sample/jmx/jmx-scandir</code>)은 <a href="http://java.sun.com/javase/technologies/core/mntr-mgmt/javamanagement/best-practices.jsp">JMX best practices</a>를 바탕으로 하며, JMX를 이용하여 관리 인터페이스를 설계할 때의 몇 가지 보편적인 JMX 패턴과 피해야 할 몇 가지 함정에 대해서도 검토합니다. 특히 <code>jmx-scandir</code> 샘플은 <code><a href="http://java.sun.com/javase/6/docs/api/javax/management/MBeanRegistration.html">MBeanRegistration</a></code> 인터페이스를 구현함으로써 해결될 수 있는 여러 가지 용례를 보여줍니다. 본 테크팁은 그러한 용례에 초점을 둘 것입니다 : <code>MBeanRegistration</code> 인터페이스를 사용한 MBean(Management Bean) 라이프 사이클 관리. JMX와 MBean의 개념에 익숙하지 않은 독자는 더 나아가기 전에 <a href="http://java.sun.com/docs/books/tutorial/">자바 튜토리얼</a>에서 <a href="http://java.sun.com/docs/books/tutorial/jmx/index.html">JMX trail</a>을 살펴보십시오. MBeanRegistration 인터페이스 <code><a href="http://java.sun.com/javase/6/docs/api/javax/management/MBeanRegistration.html">MBeanRegistration</a></code> 인터페이스는 콜백 인터페이스입니다. 그것은 MBean으로 구현될 수 있으며, 이 때 <a href="http://java.sun.com/javase/6/docs/api/javax/management/MBeanServer.html"><code>MBeanServer</code></a>로 등록 또는 등록 해제할 때 특정한 액션을 수행해야 할 필요가 있습니다. MBean이 <code>MBeanRegistration</code>을 구현할 때, 그 인터페이스에 정의된 메소드는 MBean이 <code>MBeanServer</code>로부터 등록 및 등록 해제하기 전과 후에 <code>MBeanServer</code>에 의해 호출됩니다. <code>MBeanRegistration</code> 인터페이스를 구현하는 MBean은 자신이 등록될 <code>MBeanServer</code>로의 레퍼런스를 획득하며, 등록되기 전에 자신의 <code><a href="http://java.sun.com/javase/6/docs/api/javax/management/ObjectName.html">ObjectName</a></code>을 획득할-그리고 아마도 변경할- 수 있게 되며, 자기 자신의 등록 또는 등록 해제를 수락 또는 거부할 수도 있을 것입니다. 다음 코드에서는 <code>Rack</code> MBean이 <code>MBeanRegistration</code> 인터페이스를 구현합니다. <pre> ------------------------------------------------------------------ package jmxtechtip; public interface RackMBean { /... defines methods exposed for management .../ } ------------------------------------------------------------------ package jmxtechtip; public class Rack implements RackMBean, MBeanRegistration { /... implements RackMBean methods .../ /... implements MBeanRegistration methods .../ } ------------------------------------------------------------------ </pre> MBean 인터페이스는 <code>MBeanRegistration</code>을 확장(extend)하지 않습니다. 오직 실제의 MBean 클래스가 그것을 구현(implement)합니다. 실제로, <code>MBeanRegistration</code> 메소드는 등록 시에 오직 <code>MBeanServer</code> 에 의해서만 호출되는 것으로 설계되었으므로 관리 인터페이스를 통해 <code>MBeanRegistration</code>에 정의된 메소드를 노출하는 것은 위반에 해당합니다. 이 테크팁에서는 종속 MBean들을 등록 및 등록 해제하기 위한 <code>MBeanRegistration</code>의 메소드를 구현하는 방법을 제시합니다. 랙과 카드의 용례 하드웨어의 일부를 노출할 JMX 애플리케이션을 설계하고 있다고 가정해 봅시다. 장비에는 랙이 하나 있습니다. -- <code>RackMBean</code>으로 나타냅니다. 랙 자체는 카드를 꽂을 수 있는 다수의 슬롯을 가지고 있습니다. 각 카드가 꽂히게 되면 <code>CardMBean</code> 또는 <code>CardMBean</code>의 서브클래스로 표시됩니다. 이 예에서 <code>RackMBean</code>이 <code>CardMBean</code> 인스턴스를 생성하고 등록하는 것에 대해 완전히 책임이 있다고 가정합니다. 클래스 <code>Card</code>는 <code>Card</code>에 특정한 구현을 제공하도록 확장될 수 있습니다. 클래스 <code>Rack</code>은 자신의 <code>createCard(...)</code> 메소드를 override하기 위해 확장(extend)될 수 있습니다. 다음은 사용자가 이루고자 하는 목표입니다. * <code>Rack</code> 클래스에서 <code>RackMBean</code>이 등록될 때, 어떤 슬롯이 이미 카드를 갖고 있는지를 알아내고, 그들 각각에 대해 <code>CardMBean</code>을 생성 및 등록합니다. * <code>Rack</code> 클래스에서 <code>RackMBean</code>이 등록 해제될 때, 모든 그에 대응하는 <code>Card</code> 인스턴스들도 등록 해제합니다. * <code>Card</code> 클래스에서 <code>CardMBean</code>은 오직 <code>Rack</code>에 의해서만 등록될 수 있음을 확실히 하고, <code>CardMBean</code>은 예를 들어 <code>CardMBean</code>에 대해 직접적으로 <code>MBeanServer.unregisterMBean(...)</code>을 호출하는 클라이언트 JMX 애플리케이션에 의해서가 아니라 오직 <code>Rack</code>에 의해서만 등록 해제될 수 있음을 분명히 하십시오. 참고: 여기서의 의도는 랙 또는 카드를 모델링하는 방법을 보여주는 것이 아닙니다. 저자는 오직 예를 들기 위해서 랙과 카드를 선택했습니다. 왜냐하면 그들의 관계가 이해하기 쉽기 때문입니다. <code>MBeanRegistration</code> 인터페이스 구현 다음 코드는 <code>Rack</code> MBean이 <code>MBeanRegistration</code> 인터페이스를 구현하는 방법을 보여줍니다. <pre> /** * A Rack contains Cards. */ public class Rack implements RackMBean, MBeanRegistration { // MBeans must be multi-thread safe. // 'rackName' and 'server' will be set at registration time, so you // must therefore take care of synchronization issues. // Use 'volatile' to make sure that you always use an accurate value. // // Name of this rack, extracted from the ObjectName. private volatile String rackName; // The MBeanServer in which this MBean is registered private volatile MBeanServer server; // An array of slots that may be occupied (and contain a card) or may be // unoccupied. slots[i]==null means that slot 'i' is unoccupied. private final Card[] slots; /** * Creates a new rack. * @param slotCount Total number of slots. **/ public Rack(int slotCount) { if (slotCount < 0) throw new IllegalArgumentException(Integer.toString(slotCount)); this.slots = new Card[slotCount]; ... } // -------------------------------------------------------------------- // *Implementation of the MBeanRegistration Interface* // -------------------------------------------------------------------- /** * Allows the MBean to perform any operations it needs before * being registered in the MBean server. * If any exception is raised, the MBean will not be registered * in the MBean server. * * RackMBean uses this method to check the validity of the supplied * ObjectName, and in particular that it corresponds to a valid rack. * * It also uses this method to obtain a reference to the MBeanServer in * which it is registered. * * @param server -- The MBean server in which the MBean will be registered. * @param name -- The object name of the MBean. In this implementation, the * supplied name must not be null. * * @return -- The name under which the MBean is to be registered. If null, * the registration will fail. * * @throws Exception -- This exception will be caught by the MBean * server and rethrown as an MBeanRegistrationException. */ *public ObjectName preRegister(MBeanServer server, ObjectName name) throws Exception {* // A null ObjectName is not allowed. Let MBeanServer throw // the exception. if (name == null) return null; // Get rackname. rackName = name.getKeyProperty(RACK_KEY); if (rackName == null) throw new MalformedObjectNameException("missing rack name: " + name); if (!isValidRack(rackName)) throw new IllegalArgumentException(rackName + ": not a valid rack"); this.server = server; return name; } /** * Allows the MBean to perform any operations needed after having * been registered in the MBean server or after the registration * has failed. * * If the registration is successful, the Rack MBean will * register all its related CardMBeans. * * @param registrationDone -- Indicates whether or not the MBean * has been successfully registered in the MBean server. * The value false means that the registration has failed. */ *public void postRegister(Boolean registrationDone) {* if (!registrationDone) return; for (int i = 0; i < slots.length; i++) { final String cardType = discoverCardType(i); if (cardType != null) { try { final Card card = createCard(i, cardType); final ObjectName cardName = createCardName(rackName, i); // Avoid calling an MBeanServer operation // from within a synchronized block. card.registerSelf(server, cardName); synchronized (slots) { slots[i] = card; } } catch (Exception x) { LOG.warning("Couldn't create CardMBean for " + cardType + "[" + i + "]"); } } } } /** * Allows the MBean to perform any operations it needs before being * unregistered by the MBean server * * The RackMBean uses this method to unregister all its related * CardMBeans. If for some reason, unregistration of one of these * MBeans fails, the RackMBean will no be unregistered either. * * @throws Exception -- This exception will be caught by the MBean * server and rethrown as an MBeanRegistrationException. */ *public void preDeregister() throws Exception {* for (int i=0; i<SLOTS.LENGTH; class="" implementation="" i++) ... return name; } /** * Returns the rack name embedded in the given ObjectName. **/ public static String getRackName(ObjectName name) { final String rackName = name.getKeyProperty(RACK_KEY); if (rackName == null) throw new IllegalArgumentException(" missing name: ?=" + rackName + " + name); return rackName; </pre> <code>preRegister <#preRegisterRack></code>에서 <code>Rack</code> MBean은 그것이 등록된 <code>MBeanServer</code>로의 레퍼런스와 자기 자신의 <code>ObjectName</code>에 대한 레퍼런스를 획득합니다. 그것은 제공된 <code>ObjectName</code>이 유효한지 체크할 수 있으며 -- 이 예에서는 그것이 <code>rack</code> 키를 포함하고 있으면 유효한 것으로 간주함 -- 그것은 실제로 자신이 모델링하기로 요청 받은 랙을 모델링할 수있다는 것을 체크할 수 있습니다. 여기서 이것은 <code>isValidRack(...)</code> 메소드에 의해 행해지게 되어 있으며, 이 메소드의 구현은 표시되지 않습니다. 이러한 조건이 맞지 않으면 <code>Rack</code> MBean은 exception을 발생시킬 것이며 따라서 등록이 거부될 것입니다. <code>postRegister <#postRegisterRack></code>에서 <code>Rack MBean</code>은 등록 성공 여부를 확인합니다. 실패였으면 여기서 중단합니다. 그렇지 않으면 그것은 어느 슬롯이 이미 카드가 꽂혀있는지를 알아내고 그것들 각각에 대해 <code>CardMBean</code>을 생성 및 등록합니다. 그러나 일반적인 <code>MBeanServer.registerMBean(...)</code>을 사용하는 대신, 생성된 <code>Card</code> 인스턴스에 대한 package-protected 메소드를 호출합니다. 이 예에서는 <code>Card.registerSelf() <#registerSelf></code>입니다. 이 메소드는 로직과 함께 생성되었기 때문에 CardMBean은 그것의 <code>registerSelf(...)</code> 메소드를 호출하여 <code>MBeanServer</code> 에 단지 등록만 될 수 있습니다. <code>postRegister</code>는 exception을 발생시키지 않도록 되어 있다는 점에 유의하십시오. 따라서 모든 <code>Card</code> MBean 등록을 <code>try { } catch { }</code> 블럭으로 보호했습니다. 애플리케이션 로직에 따르면 <code>Card</code> MBean 등록은 이 시점에서 실패하지 않을 것이므로 이렇게 해도 괜찮습니다. 만약 그렇다면, 단순히 경고 메시지만 기록할 것입니다. Had you wanted the <code>Card</code> MBean이 등록 실패일 때마다 <code>Rack</code> MBean 등록도 실패하도록 해야한다면, 대신 <code>preRegister <#preRegisterRack></code>에서 <code>Card</code> 등록 로직을 구현했을 것입니다. 그렇게 되면 그 로직은 더 복잡해졌을 것입니다. 왜냐면 그들 중 하나가 등록에 실패한 경우에 이미 등록된 <code>Card</code> MBeans의 등록을 <code>rollback</code> 하는 코드를 구현해야 하기 때문입니다. <code>preDeregister <#preDeregisterRack></code>에서, <code>Rack</code> MBean은 그것이 전에 등록했던 모든 <code>Card</code> MBean들을 등록 해제합니다. 다시 여기서, 일반적인 <code>MBeanServer.unregisterMBean(...)</code>을 사용하는 대신, 등록된 <code>Card</code> 인스턴스에 대한 package-protected 메소드를 호출합니다. 이 예에서는 <code>Card.unregisterSelf() <#unregisterSelf></code>입니다. 이 메소드는 로직과 함께 생성되었기 때문에 <code>Card</code> MBean은 그것의 <code>unregisterSelf(...)</code> 메소드를 호출하여 <code>MBeanServer</code>로부터 오직 등록 해제만 될 수 있습니다. 단순히 <code>MBeanServer.unregisterMBean(...)</code>을 호출하면 실패일 것입니다. 이는 <code>Card</code> MBean의 생성자만이 그것을 등록 및 등록 해제할 수 있다는 것을 확실히 합니다. JMX 클라이언트가 <code>Card</code> MBean 상에서 <code>MBeanServer.unregisterMBean(...)</code>을 직접적으로 호출하려고 하면 이는 실패합니다. 이제 어떻게 <code>Card</code> MBean이 <a href="http://java.sun.com/javase/6/docs/api/javax/management/MBeanRegistration.html"><code>MBeanRegistration</code></a> 인터페이스를 사용하는지를 살펴봅시다. 다음 코드는 어떻게 <code>Card</code> MBean이 구현되었는지를 보여줍니다. <pre> /** * A Card is plugged in a Rack slot. */ public class Card implements CardMBean, MBeanRegistration { // This MBean will accept to be registered or unregistered // only if 'isRegistrationAllowed' is 'true'. private volatile boolean isRegistrationAllowed = false; private volatile ObjectName name; private volatile MBeanServer server; public Card(int occupiedSlot, String cardType) { ... } // This method sets 'isRegistrationAllowed' to 'true', calls // server.registerMBean(this, name), and finally sets // 'isRegistrationAllowed' back to false. // *void registerSelf(MBeanServer server, ObjectName name) throws JMException {* *isRegistrationAllowed = true;* try { this.server = server; this.name = name; this.name = server.registerMBean(this, name).getObjectName(); } finally { *isRegistrationAllowed = false;* } } // This method sets 'isRegistrationAllowed' to 'true', // calls server.unregisterMBean(name), and finally sets // 'isRegistrationAllowed' back to false. // *void unregisterSelf() throws JMException {* *isRegistrationAllowed = true;* try { if (server != null && server.isRegistered(name)) server.unregisterMBean(name); this.server = null; this.name = null; } finally { *isRegistrationAllowed = false;* } } /** * Allows the MBean to perform any operations it needs before being * registered in the MBean server. * * *In this example, the CardMBean will refuse to be registered if * 'isRegistrationAllowed' is false -- which means that Card MBeans * can only be registered by {@link #registerSelf registerSelf()}.* * * {@code registerSelf()} is a package method which is only called by * {@link Rack}. */ *public final ObjectName preRegister(MBeanServer server, ObjectName name) throws Exception {* if (*!isRegistrationAllowed*) throw new IllegalStateException("Illegal registration attempt"); assert server == this.server && name == this.name; return name; } /** * Allows the MBean to perform any operations needed after having * been registered in the MBean server or after the registration has * failed. * *The CardMBean does not need to do anything here.* * @param registrationDone -- Indicates whether or not the MBean * has been successfully registered in the MBean server. The value * 'false' means that the registration has failed. */ *public void postRegister(Boolean registrationDone) {}* /** * Allows the MBean to perform any operations it needs before * being unregistered by the MBean server. * *The CardMBean will refuse to let itself be unregistered if * 'isRegistrationAllowed' is false, which means that Card MBeans * can only be unregistered by {@link #unregisterSelf unregisterSelf()}.* * * {@code unregisterSelf()} is a package method which is only called by * {@link Rack}. * * @throws Exception -- This exception will be caught by the MBean * server and rethrown as an MBeanRegistrationException. */ *public final void preDeregister() throws Exception {* if (*!isRegistrationAllowed*) throw new IllegalStateException("Illegal unregistration attempt"); } /** * Allows the MBean to perform any operations needed after having been * unregistered in the MBean server. * *The CardMBean does not need to do anything here.* */ *public void postDeregister() { }* } </pre> <code>preRegister <#preRegisterCard></code>, <code>preDeregister <#preDeregisterCard></code>, <code>registerSelf <#registerSelf></code> 및 <code>unregisterSelf <#unregisterSelf></code>에서의 로직은 <code>Card</code> MBean이 그것을 생성한 <code>Rack</code> MBean이 아닌 누군가에 의해 등록 또는 등록 해제 되는 것을 방지하는 것입니다. <code>registerSelf</code> 및 <code>unregisterSelf</code> 메소드는 package-protected 상태를 유지하므로 <code>Rack</code> MBean 만이 이를 호출할 수 있습니다. <code>preRegister</code> 및 <code>preDeregister</code> 메소드는 final로 선언되었기 때문에 서브클래스들이 해당 로직을 변경할 수 없습니다. 참고: <code>Card</code>의 등록 또는 등록 해제 시 서브클래스에서 특정 추가 액션을 수행해야 하는 경우, <a href="http://www.martinfowler.com/bliki/CallSuper.html">Martin Fowler's note</a>에서 설명하는 대로 목적에 맞는 새로운 protected hook을 사용할 수 있습니다. 그러나 단순한 <code>volatile boolean isRegistrationAllowed</code> 플래그를 사용하게 되면 쓰레드 경합(thread contention)에 대한 약간의 여지가 여전히 남게 됩니다. 실제로 <code>Rack</code> MBean이 <code>unregisterSelf <#unregisterSelf></code>를 호출할 때, 다른 쓰레드가 살짝 들어와서 <code>isRegistrationAllowed</code> 플래그는 설정된 직후이지만 <code>unregisterSelf</code>가 완료되기 전에 <code>MBeanServer.unregisterMBean</code>을 호출할 수도 있습니다. 따라서 더 나은 솔루션으로는 <code>isRegistrationAllowed</code> 플래그를 <a href="http://java.sun.com/javase/6/docs/api/java/lang/ThreadLocal.html"><code>ThreadLocal</code></a>로 저장하는 방법이 있습니다. 다음 코드에서는 <code>Card</code> MBean 구현에서 변경이 필요한 사항을 보여줍니다. <pre> // initialization of isRegistrationAllowed flag: // private volatile boolean isRegistrationAllowed = false; // => replaced by: private final static ThreadLocal isRegistrationAllowed = new ThreadLocal() { @Override protected Boolean initialValue() {return false;} }; // in registerSelf / unregisterSelf .... // isRegistrationAllowed = true; // => replaced by: *isRegistrationAllowed.set(true);* try { ... } finally { // isRegistrationAllowed = false; // => replaced by: *isRegistrationAllowed.set(false);* } .... // in preRegister / preDeregister ... // if (!isRegistrationAllowed) // => replaced by: if (*!isRegistrationAllowed.get()*) throw new IllegalStateException(...); ... </pre> 결론 이 테크팁은 MBean이 종속 MBean을 등록 및 등록 해제하기 위해 <a href="http://java.sun.com/javase/6/docs/api/javax/management/MBeanRegistration.html"><code>MBeanRegistration</code></a> 인터페이스를 어떻게 이용하는지를 소개했습니다. 또한 생성자만이 이를 등록 및 등록 해제할 수 있도록 하는 방법을 통해 종속 MBean를 보호할 수 있다는 것도 살펴 보았습니다. JDK 6용 고급 JMX 샘플(<code>$JDK_HOME/sample/jmx/jmx-scandir</code>)에서는 <a href="http://java.sun.com/javase/6/docs/api/javax/management/MBeanRegistration.html"><code>MBeanRegistration</code></a> 인터페이스 사용에 대해 많은 다른 가능성들을 제시합니다. 저자 정보 <a href="http://blogs.sun.com/jmxetc">Daniel Fuchs</a>는 프랑스 Grenoble 소재 썬마이크로시스템즈의 Java DMK, JMX, Java SE 팀에서 일하고 있습니다. * 이 아티클의 영어 원본은 <a href="http://blogs.sun.com/CoreJavaTechTips/entry/using_the_mbeanregistration_interface_to">http://blogs.sun.com/CoreJavaTechTips/entry/using_the_mbeanregistration_interface_to</a>에서 보실 수 있습니다. http://kyeseon.myid.net/ http://kyeseon.myid.net/ 21 jmx,mbean,mbeanregistration