/* * Copyright (c) 2005, 2008, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation.  Oracle designates this * particular file as subject to the "Classpath" exception as provided * by Oracle in the LICENSE file that accompanied this code. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */ package com.sun.jmx.mbeanserver; import static com.sun.jmx.mbeanserver.Util.*; import java.lang.reflect.Method;import java.util.Map; import javax.management.Attribute;import javax.management.MBeanServerConnection;import javax.management.NotCompliantMBeanException;import javax.management.ObjectName; /**   <p>Helper class for an {@link InvocationHandler} that forwards methods from an   MXBean interface to a named   MXBean in an MBean Server and handles translation between the   arbitrary Java types in the interface and the Open Types used   by the MXBean.</p>    @since 1.6*/public class MXBeanProxy {    public MXBeanProxy(Class<?> mxbeanInterface) {         if (mxbeanInterface == null)            throw new IllegalArgumentException("Null parameter");         final MBeanAnalyzer<ConvertingMethod> analyzer;        try {            analyzer =                MXBeanIntrospector.getInstance().getAnalyzer(mxbeanInterface);        } catch (NotCompliantMBeanException e) {            throw new IllegalArgumentException(e);        }        analyzer.visit(new Visitor());    }     private class Visitor            implements MBeanAnalyzer.MBeanVisitor<ConvertingMethod> {        public void visitAttribute(String attributeName,                                   ConvertingMethod getter,                                   ConvertingMethod setter) {            if (getter != null) {                getter.checkCallToOpen();                Method getterMethod = getter.getMethod();                handlerMap.put(getterMethod,                               new GetHandler(attributeName, getter));            }            if (setter != null) {                // return type is void, no need for checkCallToOpen                Method setterMethod = setter.getMethod();                handlerMap.put(setterMethod,                               new SetHandler(attributeName, setter));            }        }         public void visitOperation(String operationName,                                   ConvertingMethod operation) {            operation.checkCallToOpen();            Method operationMethod = operation.getMethod();            String[] sig = operation.getOpenSignature();            handlerMap.put(operationMethod,                           new InvokeHandler(operationName, sig, operation));        }    }     private static abstract class Handler {        Handler(String name, ConvertingMethod cm) {            this.name = name;            this.convertingMethod = cm;        }         String getName() {            return name;        }         ConvertingMethod getConvertingMethod() {            return convertingMethod;        }         abstract Object invoke(MBeanServerConnection mbsc,                               ObjectName name, Object[] args) throws Exception;         private final String name;        private final ConvertingMethod convertingMethod;    }     private static class GetHandler extends Handler {        GetHandler(String attributeName, ConvertingMethod cm) {            super(attributeName, cm);        }         @Override        Object invoke(MBeanServerConnection mbsc, ObjectName name, Object[] args)                throws Exception {            assert(args == null || args.length == 0);            return mbsc.getAttribute(name, getName());        }    }     private static class SetHandler extends Handler {        SetHandler(String attributeName, ConvertingMethod cm) {            super(attributeName, cm);        }         @Override        Object invoke(MBeanServerConnection mbsc, ObjectName name, Object[] args)                throws Exception {            assert(args.length == 1);            Attribute attr = new Attribute(getName(), args[0]);            mbsc.setAttribute(name, attr);            return null;        }    }     private static class InvokeHandler extends Handler {        InvokeHandler(String operationName, String[] signature,                      ConvertingMethod cm) {            super(operationName, cm);            this.signature = signature;        }         Object invoke(MBeanServerConnection mbsc, ObjectName name, Object[] args)                throws Exception {            return mbsc.invoke(name, getName(), args, signature);        }         private final String[] signature;    }     public Object invoke(MBeanServerConnection mbsc, ObjectName name,                         Method method, Object[] args)            throws Throwable {         Handler handler = handlerMap.get(method);        ConvertingMethod cm = handler.getConvertingMethod();        MXBeanLookup lookup = MXBeanLookup.lookupFor(mbsc);        MXBeanLookup oldLookup = MXBeanLookup.getLookup();        try {            MXBeanLookup.setLookup(lookup);            Object[] openArgs = cm.toOpenParameters(lookup, args);            Object result = handler.invoke(mbsc, name, openArgs);            return cm.fromOpenReturnValue(lookup, result);        } finally {            MXBeanLookup.setLookup(oldLookup);        }    }     private final Map<Method, Handler> handlerMap = newMap();}