public DynamicMBeanProxy() 
{

}

Create a Dynamic proxy, using introspection to manage a real tomcat component.

 public static String createMBean(Object proxy,
    String domain,
    String name) 
{
        try {
            DynamicMBeanProxy mbean=new DynamicMBeanProxy();
            mbean.setReal( proxy );
            if( name!=null ) {
                mbean.setName( name );
            } else {
                mbean.setName( generateName( proxy.getClass() ));
            }
            return mbean.registerMBean( domain );
        } catch( Throwable t ) {
            log.error( "Error creating mbean ", t );
            return null;
        }
}

 public static String generateName(Class realClass) 
{
        String name=realClass.getName();
        name=name.substring( name.lastIndexOf( ".") + 1 );
        Integer iInt=(Integer)instances.get(name );
        int seq=0;
        if (iInt != null) {
            seq = iInt.intValue();
            seq++;
            instances.put(name, Integer.valueOf(seq));
        }
        else {
            instances.put(name, Integer.valueOf(0));
        }
        return "name=" + name + ",seq=" + seq;
}

If a name was not provided, generate a name based on the class name and a sequence number.

 public Object getAttribute(String attribute) throws AttributeNotFoundException, MBeanException, ReflectionException 
{
        if( methods==null ) init();
        Method m=(Method)getAttMap.get( attribute );
        if( m==null ) throw new AttributeNotFoundException(attribute);
        try {
            if( log.isDebugEnabled() )
                log.debug(real.getClass().getName() +  " getAttribute " + attribute);
            return m.invoke(real, NO_ARGS_PARAM );
        } catch( IllegalAccessException ex ) {
            ex.printStackTrace();
            throw new MBeanException( ex );
        } catch( InvocationTargetException ex1 ) {
            ex1.printStackTrace();
            throw new MBeanException( ex1 );
        }
}

 public AttributeList getAttributes(String[] attributes) 
{
        AttributeList al=new AttributeList();
        if( attributes==null ) return null;
        for( int i=0; i< attributes.length; i++ ) {
            try {
                Attribute att=new Attribute( attributes[i], getAttribute( attributes[i] ));
                al.add( att );
            } catch( Exception ex ) {
                ex.printStackTrace();
            }
        }
        return al;
}

 public MBeanInfo getMBeanInfo() 
{
        if( methods==null ) {
            init();
        }
        try {
            MBeanAttributeInfo attributes[]=new MBeanAttributeInfo[attMap.size()];
            Enumeration en=attMap.keys();
            int i=0;
            while( en.hasMoreElements() ) {
                String name=(String)en.nextElement();
                attributes[i++]=new MBeanAttributeInfo(name, "Attribute " + name ,
                                                       (Method)getAttMap.get(name),
                                                       (Method)setAttMap.get(name));
            }
            MBeanOperationInfo operations[]=new MBeanOperationInfo[invokeAttMap.size()];
            en=invokeAttMap.keys();
            i=0;
            while( en.hasMoreElements() ) {
                String name=(String)en.nextElement();
                Method m=(Method)invokeAttMap.get(name);
                if( m!=null && name != null ) {
                    operations[i++]=new MBeanOperationInfo(name, m);
                } else {
                    if (log.isDebugEnabled())
                        log.debug("Null arg " + name + " " + m );
                }
            }
            if( log.isDebugEnabled() )
                log.debug(real.getClass().getName() +  " getMBeanInfo()");
            return new MBeanInfo( real.getClass().getName(), /* ??? */
                                  "MBean for " + getName(),
                                  attributes,
                                  new MBeanConstructorInfo[0],
                                  operations,
                                  new MBeanNotificationInfo[0]);
        } catch( Exception ex ) {
            ex.printStackTrace();
            return null;
        }
}

 public static MBeanServer getMBeanServer() 
{
        if( mserver==null ) {
            if( MBeanServerFactory.findMBeanServer(null).size()  > 0 ) {
                mserver=(MBeanServer)MBeanServerFactory.findMBeanServer(null).get(0);
            } else {
                mserver=MBeanServerFactory.createMBeanServer();
            }
        }
        return mserver;
}

 public String getName() 
{
        if( name!=null ) return name;
        if( real==null ) return null;
        name=generateName(real.getClass());
        return name;
}

 public Object invoke(String method,
    Object[] arguments,
    String[] params) throws MBeanException, ReflectionException 
{
        if( methods==null ) init();
        Method m=(Method)invokeAttMap.get( method );
        if( m==null ) return null;
        try {
            log.info(real.getClass().getName() +  "invoke " + m.getName());
            return m.invoke(real, NO_ARGS_PARAM );
        } catch( IllegalAccessException ex ) {
            throw new MBeanException( ex );
        } catch( InvocationTargetException ex1 ) {
            throw new MBeanException( ex1 );
        }
}

Invoke a method. Only no param methods are supported at the moment ( init, start, execute, etc ) ( that's the most common pattern we have in tomcat/ant/etc )

 public String registerMBean(String domain) 
{
        try {
            // XXX use aliases, suffix only, proxy.getName(), etc
            String fullName=domain + ": " +  getName();
            ObjectName oname=new ObjectName( fullName );
            if(  getMBeanServer().isRegistered( oname )) {
                log.info("Unregistering " + oname );
                getMBeanServer().unregisterMBean( oname );
            }
            getMBeanServer().registerMBean( this, oname );
            return fullName;
        } catch( Throwable t ) {
            log.error( "Error creating mbean ", t );
            return null;
        }
}

 public  void setAttribute(Attribute attribute) throws AttributeNotFoundException, InvalidAttributeValueException, MBeanException, ReflectionException 
{
        if( methods==null ) init();
        // XXX Send notification !!!
        Method m=(Method)setAttMap.get( attribute.getName() );
        if( m==null ) throw new AttributeNotFoundException(attribute.getName());
        try {
            log.info(real.getClass().getName() +  "setAttribute " + attribute.getName());
            m.invoke(real, new Object[] { attribute.getValue() } );
        } catch( IllegalAccessException ex ) {
            ex.printStackTrace();
            throw new MBeanException( ex );
        } catch( InvocationTargetException ex1 ) {
            ex1.printStackTrace();
            throw new MBeanException( ex1 );
        }
}

 public AttributeList setAttributes(AttributeList attributes) 
{
        Iterator attE=attributes.iterator();
        while( attE.hasNext() ) {
            Attribute att=(Attribute)attE.next();
            try {
                setAttribute( att );
            } catch( Exception ex ) {
                ex.printStackTrace();
            }
        }
        return attributes;
}

 public  void setName(String name) 
{
        this.name=name;
}

 public  void setReal(Object realBean) 
{
        real=realBean;
}

Set the managed object.

 public static String unCapitalize(String name) 
{
	if (name == null || name.length() == 0) {
	    return name;
	}
	char chars[] = name.toCharArray();
	chars[0] = Character.toLowerCase(chars[0]);
	return new String(chars);
}

 public static  void unregisterMBean(Object o,
    String name) 
{
        try {
            ObjectName oname=new ObjectName( name );
            getMBeanServer().unregisterMBean( oname );
        } catch( Throwable t ) {
            log.error( "Error unregistering mbean ", t );
        }
}