View Javadoc

    1   /*
    2    * $Id: ShowValidatorAction.java 471756 2006-11-06 15:01:43Z husted $
    3    *
    4    * Licensed to the Apache Software Foundation (ASF) under one
    5    * or more contributor license agreements.  See the NOTICE file
    6    * distributed with this work for additional information
    7    * regarding copyright ownership.  The ASF licenses this file
    8    * to you under the Apache License, Version 2.0 (the
    9    * "License"); you may not use this file except in compliance
    10   * with the License.  You may obtain a copy of the License at
    11   *
    12   *  http://www.apache.org/licenses/LICENSE-2.0
    13   *
    14   * Unless required by applicable law or agreed to in writing,
    15   * software distributed under the License is distributed on an
    16   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
    17   * KIND, either express or implied.  See the License for the
    18   * specific language governing permissions and limitations
    19   * under the License.
    20   */
    21  package org.apache.struts2.config_browser;
    22
    23  import java.beans.BeanInfo;
    24  import java.beans.IntrospectionException;
    25  import java.beans.Introspector;
    26  import java.beans.PropertyDescriptor;
    27  import java.util.Collections;
    28  import java.util.Map;
    29  import java.util.Set;
    30  import java.util.TreeSet;
    31
    32  import ognl.Ognl;
    33  import ognl.OgnlException;
    34
    35  import org.apache.commons.logging.Log;
    36  import org.apache.commons.logging.LogFactory;
    37
    38  import com.opensymphony.xwork2.util.OgnlUtil;
    39  import com.opensymphony.xwork2.validator.Validator;
    40
    41  /***
    42   * ShowValidatorAction
    43   *
    44   */
    45  public class ShowValidatorAction extends ListValidatorsAction {
    46      private static final long serialVersionUID = 4061534149317835177L;
    47
    48      private static Log log = LogFactory.getLog(ShowValidatorAction.class);
    49
    50      Set properties = Collections.EMPTY_SET;
    51      int selected = 0;
    52
    53      public int getSelected() {
    54          return selected;
    55      }
    56
    57      public void setSelected(int selected) {
    58          this.selected = selected;
    59      }
    60
    61      public Set getProperties() {
    62          return properties;
    63      }
    64
    65      public Validator getSelectedValidator() {
    66          return (Validator) validators.get(selected);
    67      }
    68
    69      public String execute() throws Exception {
    70          loadValidators();
    71          Validator validator = getSelectedValidator();
    72          properties = new TreeSet();
    73          try {
    74              Map context = Ognl.createDefaultContext(validator);
    75              BeanInfo beanInfoFrom = null;
    76              try {
    77                  beanInfoFrom = Introspector.getBeanInfo(validator.getClass(), Object.class);
    78              } catch (IntrospectionException e) {
    79                  log.error("An error occurred", e);
    80                  addActionError("An error occurred while introspecting a validator of type " + validator.getClass().getName());
    81                  return ERROR;
    82              }
    83
    84              PropertyDescriptor[] pds = beanInfoFrom.getPropertyDescriptors();
    85
    86              for (int i = 0; i < pds.length; i++) {
    87                  PropertyDescriptor pd = pds[i];
    88                  String name = pd.getName();
    89                  Object value = null;
    90                  if (pd.getReadMethod() == null) {
    91                      value = "No read method for property";
    92                  } else {
    93                      try {
    94                          Object expr = OgnlUtil.compile(name);
    95                          value = Ognl.getValue(expr, context, validator);
    96                      } catch (OgnlException e) {
    97                          addActionError("Caught OGNL exception while getting property value for '" + name + "' on validator of type " + validator.getClass().getName());
    98                      }
    99                  }
    100                 properties.add(new PropertyInfo(name, pd.getPropertyType(), value));
    101             }
    102         } catch (Exception e) {
    103             log.warn("Unable to retrieve properties.", e);
    104             addActionError("Unable to retrieve properties: " + e.toString());
    105         }
    106
    107         if (hasErrors())
    108             return ERROR;
    109         else
    110             return SUCCESS;
    111     }
    112
    113     public static class PropertyInfo implements Comparable {
    114         private String name;
    115         private Class type;
    116         private Object value;
    117
    118         public PropertyInfo(String name, Class type, Object value) {
    119             if (name == null) {
    120                 throw new IllegalArgumentException("Name must not be null");
    121             }
    122             if (type == null) {
    123                 throw new IllegalArgumentException("Type must not be null");
    124             }
    125             this.name = name;
    126             this.type = type;
    127             this.value = value;
    128         }
    129
    130         public Class getType() {
    131             return type;
    132         }
    133
    134         public void setType(Class type) {
    135             this.type = type;
    136         }
    137
    138         public Object getValue() {
    139             return value;
    140         }
    141
    142         public void setValue(Object value) {
    143             this.value = value;
    144         }
    145
    146         public String getName() {
    147             return name;
    148         }
    149
    150         public void setName(String name) {
    151             this.name = name;
    152         }
    153
    154         public boolean equals(Object o) {
    155             if (this == o) return true;
    156             if (!(o instanceof PropertyInfo)) return false;
    157
    158             final PropertyInfo propertyInfo = (PropertyInfo) o;
    159
    160             if (!name.equals(propertyInfo.name)) return false;
    161             if (!type.equals(propertyInfo.type)) return false;
    162             if (value != null ? !value.equals(propertyInfo.value) : propertyInfo.value != null) return false;
    163
    164             return true;
    165         }
    166
    167         public int hashCode() {
    168             int result;
    169             result = name.hashCode();
    170             result = 29 * result + type.hashCode();
    171             result = 29 * result + (value != null ? value.hashCode() : 0);
    172             return result;
    173         }
    174
    175         public int compareTo(Object o) {
    176             PropertyInfo other = (PropertyInfo) o;
    177             return this.name.compareTo(other.name);
    178         }
    179     }
    180 }