ActiveMQ example source code file (MBeansRegExQueryFilter.java)

This example ActiveMQ source code file (MBeansRegExQueryFilter.java) is included in the DevDaily.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Java - ActiveMQ tags/keywords

attribute, class, iterator, iterator, management, map, map, mbeansregexqueryfilter, mbeansregexqueryfilter, method, nosuchmethodexception, object, reflection, regex, regexqueryfilter, string, string, util

The ActiveMQ MBeansRegExQueryFilter.java source code

/**
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.activemq.console.filter;

import java.lang.reflect.Method;
import java.util.Iterator;
import java.util.Map;
import java.util.regex.Pattern;

import javax.management.Attribute;
import javax.management.AttributeList;
import javax.management.ObjectInstance;
import javax.management.ObjectName;

public class MBeansRegExQueryFilter extends RegExQueryFilter {
    /**
     * Creates a regular expression query that is able to match the values of
     * specific mbeans
     * 
     * @param next - next query filter
     */
    public MBeansRegExQueryFilter(QueryFilter next) {
        super(next);
    }

    /**
     * Try to match the object data using the regular expression map. The regex
     * map contains a key-value mapping of an attribute key to a regular
     * expression the value of the key should match. The basic rule of matching
     * is that the data must contain a property key that is included in the
     * regex map, and that the value of the property key should match the regex
     * specified.
     * 
     * @param data - object data to match
     * @param regex - regex map
     * @return true if the data matches the regex map specified
     * @throws Exception
     */
    protected boolean matches(Object data, Map regex) throws Exception {
        // TODO why not just use instanceof?

        // Use reflection to determine where the object should go
        try {
            Method method = this.getClass().getDeclaredMethod("matches", new Class[] {
                data.getClass(), Map.class
            });
            return ((Boolean)method.invoke(this, new Object[] {
                data, regex
            })).booleanValue();
        } catch (NoSuchMethodException e) {
            return false;
        }
    }

    /**
     * Try to match the object instance using the regular expression map
     * 
     * @param data - object instance to match
     * @param regex - regex map
     * @return true if the object instance matches the regex map
     */
    protected boolean matches(ObjectInstance data, Map regex) {
        return matches(data.getObjectName(), regex);
    }

    /**
     * Try to match the object name instance using the regular expression map
     * 
     * @param data - object name to match
     * @param regex - regex map
     * @return true if the object name matches the regex map
     */
    protected boolean matches(ObjectName data, Map regex) {
        for (Iterator i = regex.keySet().iterator(); i.hasNext();) {
            String key = (String)i.next();
            String target = data.getKeyProperty(key);

            // Try to match the value of the property of the object name
            if (target != null && !((Pattern)regex.get(key)).matcher(target).matches()) {
                return false;
            }
        }
        return true;
    }

    /**
     * Try to match the attribute list using the regular expression map
     * 
     * @param data - attribute list to match
     * @param regex - regex map
     * @return true if the attribute list matches the regex map
     */
    protected boolean matches(AttributeList data, Map regex) {
        for (Iterator i = regex.keySet().iterator(); i.hasNext();) {
            String key = (String)i.next();

            // Try to match each regex to the attributes of the mbean including
            // its ObjectName
            for (Iterator j = data.iterator(); j.hasNext();) {
                Attribute attrib = (Attribute)j.next();

                // Try to match to the properties of the ObjectName
                if (attrib.getName().equals(MBeansAttributeQueryFilter.KEY_OBJECT_NAME_ATTRIBUTE)) {
                    String target = ((ObjectName)attrib.getValue()).getKeyProperty(key);

                    if (target == null || !((Pattern)regex.get(key)).matcher(target).matches()) {
                        return false;
                    } else {
                        // If match skip to the next regex
                        break;
                    }

                    // Try to match to the mbean attributes
                } else if (attrib.getName().equals(key)) {
                    if (!((Pattern)regex.get(key)).matcher(attrib.getValue().toString()).matches()) {
                        return false;
                    } else {
                        // If match skip to the next regex
                        break;
                    }

                    // If mbean does not contain the specified attribute
                } else {
                    return false;
                }
            }
        }
        return true;
    }
}