@Override
public List<T> handle(ResultSet rs) throws SQLException {
List<T> list = new LinkedList<>();
while (rs.next()) {
try {
T t = this.clz.newInstance();
BeanInfo beanInfo = Introspector.getBeanInfo(this.clz, Object.class);
PropertyDescriptor[] descriptors = beanInfo.getPropertyDescriptors();
Map<String, Object> map = new HashMap<String, Object>();
for (PropertyDescriptor pd : descriptors) {
String propertyName = pd.getName();
Class<?> propertyType = pd.getPropertyType();
if (propertyType.isAnnotationPresent(Entry.class)) {
propertyName = propertyName + "_id";
}
Object value = rs.getObject(propertyName);
if (propertyType.isAnnotationPresent(Entry.class)) {
value = getObject(value, propertyType);
}
map.put(pd.getName(), value);
}
BeanUtils.copyProperties(t, map);
list.add(t);
} catch (InstantiationException
| IllegalAccessException
| IntrospectionException
| InvocationTargetException e) {
e.printStackTrace();
}
}
return list;
}
/**
* @Description: 将一个 Map 对象转化为一个 JavaBean
*
* @param @param obj
* @param @param map
* @param @return
* @param @throws IntrospectionException
* @param @throws IllegalAccessException
* @param @throws InstantiationException
* @param @throws InvocationTargetException
* @return Model
*/
@SuppressWarnings("rawtypes")
public static <Model> Model convertMap(Model obj, Map map)
throws IntrospectionException, IllegalAccessException, InstantiationException,
InvocationTargetException {
BeanInfo beanInfo = Introspector.getBeanInfo(obj.getClass()); // 获取类属性
// Model obj = type.newInstance(); // 创建 JavaBean 对象
// 给 JavaBean 对象的属性赋值
PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
for (int i = 0; i < propertyDescriptors.length; i++) {
PropertyDescriptor descriptor = propertyDescriptors[i];
String propertyName = descriptor.getName();
if (map.containsKey(propertyName)) {
// 下面一句可以 try 起来，这样当一个属性赋值失败的时候就不会影响其他属性赋值。
Object value = map.get(propertyName);
Object[] args = new Object[1];
args[0] = value;
descriptor.getWriteMethod().invoke(obj, args);
}
}
return obj;
}
/**
* Returns the bean property descriptor of an attribute
*
* @param beanClass the class that holds the attribute
* @param propertyName the name of the property
* @return the attribute's property descriptor
*/
public static PropertyDescriptor getPropertyDescriptor(Class<?> beanClass, String propertyName) {
if (beanClass == null) throw new IllegalArgumentException("beanClass is null");
String propertyId = beanClass.getName() + '#' + propertyName;
PropertyDescriptor result = propertyDescriptors.get(propertyId);
if (result != null) return result;
// descriptor is new
int separatorIndex = propertyName.indexOf('.');
if (separatorIndex >= 0) {
String localProperty = propertyName.substring(0, separatorIndex);
String remoteProperty = propertyName.substring(separatorIndex + 1);
Class<?> localPropertyType =
getPropertyDescriptor(beanClass, localProperty).getPropertyType();
result = getPropertyDescriptor(localPropertyType, remoteProperty);
} else {
try {
BeanInfo beanInfo = Introspector.getBeanInfo(beanClass);
PropertyDescriptor[] descriptors = beanInfo.getPropertyDescriptors();
for (PropertyDescriptor descriptor : descriptors) {
String name = descriptor.getName();
if (name.equals(propertyName)) {
result = descriptor;
break;
}
}
} catch (IntrospectionException e) {
throw ExceptionMapper.configurationException(e, propertyName);
}
}
propertyDescriptors.put(propertyId, result);
return result;
}
private ObjectConverter generateConverter(Class cls) {
BeanInfo beanInfo = null;
try {
beanInfo = Introspector.getBeanInfo(cls);
} catch (IntrospectionException e) {
throw new RuntimeException(e);
}
PropertyDescriptor[] props = beanInfo.getPropertyDescriptors();
List<ObjectConverterEntry> list = new ArrayList<ObjectConverterEntry>();
for (int i = 0, length = props.length; i < length; i++) {
PropertyDescriptor prop = props[i];
if ("class".equals(prop.getName())) {
continue;
}
list.add(
new ObjectConverterEntry(
prop.getName(), prop.getReadMethod(), getType(prop.getPropertyType())));
}
return new ObjectConverter(cls, list.toArray(new ObjectConverterEntry[list.size()]));
}
public static Object buildBean(Class<?> beanClass, Map<String, String> values) {
try {
Object obj = null;
if (beanClass.isInterface()) {
@SuppressWarnings("unchecked")
Class<? extends OpenEngSBModel> model = (Class<? extends OpenEngSBModel>) beanClass;
obj = ekbService.createEmptyModelObject(model);
} else {
obj = beanClass.newInstance();
}
BeanInfo beanInfo = Introspector.getBeanInfo(beanClass);
PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
for (PropertyDescriptor propertyDescriptor : propertyDescriptors) {
if (propertyDescriptor.getWriteMethod() == null
|| !Modifier.isPublic(propertyDescriptor.getWriteMethod().getModifiers())) {
continue;
}
String value = values.get(propertyDescriptor.getName());
Object ob = convertToCorrectClass(propertyDescriptor.getPropertyType(), value);
propertyDescriptor.getWriteMethod().invoke(obj, ob);
}
return obj;
} catch (Exception e) {
throw new IllegalArgumentException(e);
}
}
public TypeWrapper(Class c) throws IntrospectionException {
Map<String, Field> fields = new HashMap();
loadFields(c, fields);
BeanInfo bi = Introspector.getBeanInfo(c, Object.class);
PropertyDescriptor[] props = bi.getPropertyDescriptors();
for (int i = 0; i < props.length; i++) {
PropertyDescriptor pd = props[i];
Annotation[] ann = null;
Field f = fields.get(pd.getName());
if (f != null) {
f.getAnnotations();
}
Class type = pd.getPropertyType();
boolean arrayFlag = type.isArray();
PropertyInfo pi =
new PropertyInfo(
pd.getName(),
ann,
(arrayFlag ? type.getComponentType() : type),
arrayFlag,
pd.getReadMethod(),
pd.getWriteMethod());
this.properties.put(pi.getName(), pi);
}
}
public static void main(String[] args) throws IntrospectionException {
BeanInfo beanInfo = Introspector.getBeanInfo(User.class);
System.out.println("==>MethodDescriptor");
MethodDescriptor[] methodDescs = beanInfo.getMethodDescriptors();
for (MethodDescriptor method : methodDescs) {
System.out.println(method.getName());
System.out.println(method.getDisplayName());
System.out.println(method.getShortDescription());
System.out.println(method.getValue("getName"));
System.out.println("==>MethodDescriptor/ReflectionMethod");
Method reflectMethod = method.getMethod();
System.out.println(reflectMethod.getName());
System.out.println("==>MethodDescriptor/ParameterDescriptor");
ParameterDescriptor[] paramDescs = method.getParameterDescriptors();
if (paramDescs != null) {
for (ParameterDescriptor paramDesc : paramDescs) {
System.out.println(paramDesc.getName());
System.out.println(paramDesc.getDisplayName());
System.out.println(paramDesc.getShortDescription());
System.out.println(paramDesc.getValue("name"));
}
}
}
}
public void setBeanInfo() {
BeanInfo info = null;
try {
info = Introspector.getBeanInfo(bean.getClass());
} catch (IntrospectionException ex) {
ex.printStackTrace();
}
for (PropertyDescriptor pd : info.getPropertyDescriptors()) {
if (!pd.getName().equals("class")) {
try {
Object value = null;
if (properties.get(pd.getName()) != null) {
value = properties.get(pd.getName());
if (value.equals("false") || value.equals("true")) {
pd.getWriteMethod().invoke(bean, new Object[] {Boolean.valueOf((String) value)});
} else {
pd.getWriteMethod().invoke(bean, new Object[] {value});
}
} else {
value = pd.getReadMethod().invoke(bean, new Object[] {});
pd.getWriteMethod().invoke(bean, new Object[] {value});
}
} catch (IllegalArgumentException ex) {
ex.printStackTrace();
} catch (IllegalAccessException ex) {
ex.printStackTrace();
} catch (InvocationTargetException ex) {
ex.printStackTrace();
}
}
}
}
private List<PropertyDescriptor> getAdapterPropertyDescriptors0(Class<?> type) {
if (type == null) {
throw new IllegalArgumentException("Type must be non-null");
}
loadProvidersIfNecessary();
ArrayList<PropertyDescriptor> des = new ArrayList<PropertyDescriptor>();
for (BeanAdapterProvider provider : providers) {
Class<?> pdType = provider.getAdapterClass(type);
if (pdType != null) {
BeanInfo info = getBeanInfo(pdType);
if (info != null) {
PropertyDescriptor[] pds = info.getPropertyDescriptors();
if (pds != null) {
for (PropertyDescriptor pd : pds) {
if (provider.providesAdapter(type, pd.getName())) {
des.add(pd);
}
}
}
}
}
}
return des;
}
String getPrincipalProperty(Object principal, String property) throws TemplateModelException {
try {
BeanInfo beanInfo = Introspector.getBeanInfo(principal.getClass());
// Loop through the properties to get the string value of the specified property
for (PropertyDescriptor propertyDescriptor : beanInfo.getPropertyDescriptors()) {
if (propertyDescriptor.getName().equals(property)) {
Object value = propertyDescriptor.getReadMethod().invoke(principal, (Object[]) null);
return String.valueOf(value);
}
}
// property not found, throw
throw new TemplateModelException(
"Property ["
+ property
+ "] not found in principal of type ["
+ principal.getClass().getName()
+ "]");
} catch (Exception ex) {
throw new TemplateModelException(
"Error reading property ["
+ property
+ "] from principal of type ["
+ principal.getClass().getName()
+ "]",
ex);
}
}
/**
* Wrap the given {@link BeanInfo} instance; copy all its existing property descriptors locally,
* wrapping each in a custom {@link SimpleIndexedPropertyDescriptor indexed} or {@link
* SimplePropertyDescriptor non-indexed} {@code PropertyDescriptor} variant that bypasses default
* JDK weak/soft reference management; then search through its method descriptors to find any
* non-void returning write methods and update or create the corresponding {@link
* PropertyDescriptor} for each one found.
*
* @param delegate the wrapped {@code BeanInfo}, which is never modified
* @throws IntrospectionException if any problems occur creating and adding new property
* descriptors
* @see #getPropertyDescriptors()
*/
public ExtendedBeanInfo(BeanInfo delegate) throws IntrospectionException {
this.delegate = delegate;
for (PropertyDescriptor pd : delegate.getPropertyDescriptors()) {
try {
this.propertyDescriptors.add(
pd instanceof IndexedPropertyDescriptor
? new SimpleIndexedPropertyDescriptor((IndexedPropertyDescriptor) pd)
: new SimplePropertyDescriptor(pd));
} catch (IntrospectionException ex) {
// Probably simply a method that wasn't meant to follow the JavaBeans pattern...
if (logger.isDebugEnabled()) {
logger.debug("Ignoring invalid bean property '" + pd.getName() + "': " + ex.getMessage());
}
}
}
MethodDescriptor[] methodDescriptors = delegate.getMethodDescriptors();
if (methodDescriptors != null) {
for (Method method : findCandidateWriteMethods(methodDescriptors)) {
try {
handleCandidateWriteMethod(method);
} catch (IntrospectionException ex) {
// We're only trying to find candidates, can easily ignore extra ones here...
if (logger.isDebugEnabled()) {
logger.debug("Ignoring candidate write method [" + method + "]: " + ex.getMessage());
}
}
}
}
}
private static void loadPropertyNamesValues(
Class clazz, Object instance, List names, List values) {
PropertyDescriptor pd;
BeanInfo info = null;
try {
info = Introspector.getBeanInfo(clazz);
} catch (IntrospectionException ex) {
Err.error(ex);
}
PropertyDescriptor[] propertyDescriptors = info.getPropertyDescriptors();
for (int i = 0; i < propertyDescriptors.length; ++i) {
pd = propertyDescriptors[i];
Object value = SelfReferenceUtils.invokeReadProperty(info, pd, instance, pd.getName());
if (value == null) { // Err.pr( "No property set for " + pd.getName() + " in " + clazz);
} else {
names.add(pd.getName());
values.add(value);
}
}
if (names.isEmpty()) {
Err.error("Strange that there are no properties with values in " + clazz);
}
}
@Test
public void overloadedNonStandardWriteMethodsOnly_orderB()
throws IntrospectionException, SecurityException, NoSuchMethodException {
@SuppressWarnings("unused")
class C {
public Object setFoo(int p) {
return new Object();
}
public Object setFoo(String p) {
return new Object();
}
}
BeanInfo bi = Introspector.getBeanInfo(C.class);
assertThat(hasReadMethodForProperty(bi, "foo"), is(false));
assertThat(hasWriteMethodForProperty(bi, "foo"), is(false));
BeanInfo ebi = new ExtendedBeanInfo(bi);
assertThat(hasReadMethodForProperty(bi, "foo"), is(false));
assertThat(hasWriteMethodForProperty(bi, "foo"), is(false));
assertThat(hasReadMethodForProperty(ebi, "foo"), is(false));
assertThat(hasWriteMethodForProperty(ebi, "foo"), is(true));
for (PropertyDescriptor pd : ebi.getPropertyDescriptors()) {
if (pd.getName().equals("foo")) {
assertThat(pd.getWriteMethod(), is(C.class.getMethod("setFoo", String.class)));
return;
}
}
fail("never matched write method");
}
@Test
public void propertyCountsMatch() throws IntrospectionException {
BeanInfo bi = Introspector.getBeanInfo(TestBean.class);
BeanInfo ebi = new ExtendedBeanInfo(bi);
assertThat(ebi.getPropertyDescriptors().length, equalTo(bi.getPropertyDescriptors().length));
}
@Test
public void shouldUseExtendedBeanInfoWhenApplicable()
throws NoSuchMethodException, SecurityException {
// given a class with a non-void returning setter method
@SuppressWarnings("unused")
class C {
public Object setFoo(String s) {
return this;
}
public String getFoo() {
return null;
}
}
// CachedIntrospectionResults should delegate to ExtendedBeanInfo
CachedIntrospectionResults results = CachedIntrospectionResults.forClass(C.class);
BeanInfo info = results.getBeanInfo();
PropertyDescriptor pd = null;
for (PropertyDescriptor candidate : info.getPropertyDescriptors()) {
if (candidate.getName().equals("foo")) {
pd = candidate;
}
}
// resulting in a property descriptor including the non-standard setFoo method
assertThat(pd, notNullValue());
assertThat(pd.getReadMethod(), equalTo(C.class.getMethod("getFoo")));
assertThat(
"No write method found for non-void returning 'setFoo' method. "
+ "Check to see if CachedIntrospectionResults is delegating to "
+ "ExtendedBeanInfo as expected",
pd.getWriteMethod(),
equalTo(C.class.getMethod("setFoo", String.class)));
}
public Object getPrincipalProperty(String property) {
Subject subject = SecurityUtils.getSubject();
if (subject != null) {
Object principal = subject.getPrincipal();
try {
BeanInfo bi = Introspector.getBeanInfo(principal.getClass());
for (PropertyDescriptor pd : bi.getPropertyDescriptors()) {
if (pd.getName().equals(property) == true) {
return pd.getReadMethod().invoke(principal, (Object[]) null);
}
}
logger.trace(
"Property [{}] not found in principal of type [{}]",
property,
principal.getClass().getName());
} catch (Exception e) {
logger.trace(
"Error reading property [{}] from principal of type [{}]",
property,
principal.getClass().getName());
}
}
return null;
}
/** Return an entry from the property descrpitor cache for a class. */
private PropertyDescriptorCacheEntry getPropertyDescriptorCacheEntry(Class c) {
PropertyDescriptorCacheEntry pce =
(PropertyDescriptorCacheEntry) propertyDescriptorCache.get(c);
try {
if (pce == null) {
BeanInfo beanInfo = Introspector.getBeanInfo(c, stopClass);
pce = new PropertyDescriptorCacheEntry();
pce.propertyDescriptors = beanInfo.getPropertyDescriptors();
pce.propertiesByName = createPropertiesByNameMap(pce.propertyDescriptors, c.getFields());
if (cachePropertiesDescriptors) {
synchronized (propertyDescriptorCache) {
PropertyDescriptorCacheEntry pce2 =
(PropertyDescriptorCacheEntry) propertyDescriptorCache.get(c);
if (pce2 == null) propertyDescriptorCache.put(c, pce);
else pce = pce2;
}
}
}
} catch (IntrospectionException ex) {
// Log failed property set errors
if (Log.isError()) {
Logger log = Log.getLogger(LOG_CATEGORY);
log.error(
"Failed to introspect object of type: " + c + " error: " + ExceptionUtil.toString(ex));
}
// Return an empty descriptor rather than crashing
pce = new PropertyDescriptorCacheEntry();
pce.propertyDescriptors = new PropertyDescriptor[0];
pce.propertiesByName = new TreeMap();
}
return pce;
}
private static String[] getPropertyNames(Class<?> clazz, boolean only4Copy) {
List<String> ret_all = new ArrayList<String>();
List<String> ret = new ArrayList<String>();
Field[] fields = CE.of(clazz).getFields(Object.class);
for (Field fld : fields) {
if (fld.getModifiers() == Modifier.PUBLIC) {
ret.add(fld.getName());
}
ret_all.add(fld.getName());
}
BeanInfo info = null;
try {
info = Introspector.getBeanInfo(clazz);
} catch (IntrospectionException e) {
}
if (info != null) {
PropertyDescriptor[] properties = info.getPropertyDescriptors();
for (int i = 0; i < properties.length; i++) {
PropertyDescriptor pd = properties[i];
if (ret_all.contains(pd.getName()) && !ret.contains(pd.getName())) {
if (!only4Copy || (pd.getReadMethod() != null && pd.getWriteMethod() != null))
ret.add(properties[i].getName());
}
}
}
return ret.toArray(new String[ret.size()]);
}
ClassDescr(Class<?> clazz) throws IntrospectionException {
this.clazz = clazz;
BeanInfo bi = Introspector.getBeanInfo(clazz);
PropertyDescriptor[] pds = bi.getPropertyDescriptors();
for (PropertyDescriptor pd : pds) {
props.put(pd.getName(), pd);
}
// ignoreCase=(clazz.getAnnotation(IgnoreCase.class)!=null);
/*
Sequence seq = clazz.getAnnotation(Sequence.class);
if (seq != null) {
sequence = seq.value();
for (int k=0; k<sequence.length; k++) {
String attrName=sequence[k];
if (ignoreCase) {
attrName = attrName.toLowerCase();
}
sequence[k]=attrName;
seqSet.add(attrName);
}
}
*/
if (sequence == null) {
sequence = seqSet.toArray(new String[seqSet.size()]);
} else {
for (String attr : sequence) {
if (props.get(attr) == null) {
throw new IntrospectionException("invalid attr:" + clazz.getName() + "." + attr);
}
}
}
}
/**
* Analyzes the bean and returns a map containing the property-values. Works similar to {@link
* BeanUtils#describe(Object)} but does not convert everything to strings.
*
* @throws IllegalArgumentException if the bean cannot be analyzed properly. Probably because some
* getter throw an Exception
*/
public static Map<String, Object> buildObjectAttributeMap(Object bean)
throws IllegalArgumentException {
BeanInfo beanInfo;
try {
beanInfo = Introspector.getBeanInfo(bean.getClass(), Object.class);
} catch (IntrospectionException e1) {
throw new IllegalArgumentException(e1);
}
Map<String, Object> result;
result = Maps.newHashMap();
for (PropertyDescriptor pDesc : beanInfo.getPropertyDescriptors()) {
String name = pDesc.getName();
Object propertyValue;
try {
propertyValue = pDesc.getReadMethod().invoke(bean);
} catch (IllegalAccessException e) {
// this should never happen since the Introspector only returns accessible read-methods
LOGGER.error("WTF: got property descriptor with inaccessible read-method");
throw new IllegalStateException(e);
} catch (InvocationTargetException e) {
ReflectionUtils.handleInvocationTargetException(e);
throw new IllegalStateException("Should never get here");
}
if (propertyValue != null) {
result.put(name, propertyValue);
}
}
return result;
}
/**
* Uses reflection to fill public fields and optionally Bean properties of the target object from
* the source Map.
*/
public static Object fill(Object target, Map<String, Object> source, boolean useProperties)
throws IntrospectionException, IllegalAccessException, InvocationTargetException {
if (useProperties) {
BeanInfo info = Introspector.getBeanInfo(target.getClass());
PropertyDescriptor[] props = info.getPropertyDescriptors();
for (int i = 0; i < props.length; ++i) {
PropertyDescriptor prop = props[i];
String name = prop.getName();
Method setter = prop.getWriteMethod();
if (setter != null && !Modifier.isStatic(setter.getModifiers())) {
// System.out.println(target + " " + name + " <- " + source.get(name));
setter.invoke(target, new Object[] {source.get(name)});
}
}
}
Field[] ff = target.getClass().getDeclaredFields();
for (int i = 0; i < ff.length; ++i) {
Field field = ff[i];
int fieldMod = field.getModifiers();
if (Modifier.isPublic(fieldMod)
&& !(Modifier.isFinal(fieldMod) || Modifier.isStatic(fieldMod))) {
// System.out.println(target + " " + field.getName() + " := " +
// source.get(field.getName()));
try {
field.set(target, source.get(field.getName()));
} catch (IllegalArgumentException iae) {
// no special error processing required
}
}
}
return target;
}
/**
* bean转化成字符串
*
* @param bean
* @param beanName
* @return beanStr
*/
public static String convertBean2Str(Object bean, String beanName) {
StringBuffer str = new StringBuffer();
Class<? extends Object> type = bean.getClass();
try {
BeanInfo beanInfo = Introspector.getBeanInfo(type);
PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
for (int i = 0; i < propertyDescriptors.length; i++) {
PropertyDescriptor descriptor = propertyDescriptors[i];
String propertyName = descriptor.getName();
if (!propertyName.equals("class")) {
Method readMethod = descriptor.getReadMethod();
Object result = readMethod.invoke(bean, new Object[0]);
if (result != null && StringUtils.trim(result.toString()).length() != 0) {
str.append("&")
.append(beanName)
.append(".")
.append(propertyName)
.append("=")
.append(result);
}
}
}
} catch (Exception e) {
log.error(e.getMessage(), e);
}
return str.indexOf("&") != -1 ? str.substring(1) : str.toString();
}
public static Method getReadMethod(Class<?> beanClass, String prop) throws JasperException {
Method method = null;
Class<?> type = null;
try {
java.beans.BeanInfo info = java.beans.Introspector.getBeanInfo(beanClass);
if (info != null) {
java.beans.PropertyDescriptor pd[] = info.getPropertyDescriptors();
for (int i = 0; i < pd.length; i++) {
if (pd[i].getName().equals(prop)) {
method = pd[i].getReadMethod();
type = pd[i].getPropertyType();
break;
}
}
} else {
// just in case introspection silently fails.
throw new JasperException(
Localizer.getMessage("jsp.error.beans.nobeaninfo", beanClass.getName()));
}
} catch (Exception ex) {
throw new JasperException(ex);
}
if (method == null) {
if (type == null) {
throw new JasperException(
Localizer.getMessage("jsp.error.beans.noproperty", prop, beanClass.getName()));
} else {
throw new JasperException(
Localizer.getMessage("jsp.error.beans.nomethod", prop, beanClass.getName()));
}
}
return method;
}
private void getInterfacePropertyDescriptors(
Class<?> clazz, List<PropertyDescriptor> pds, Set<Class<?>> classes) {
if (classes.contains(clazz)) {
return;
}
classes.add(clazz);
try {
Class[] interfaces = clazz.getInterfaces();
/** add base interface information */
BeanInfo info = Introspector.getBeanInfo(clazz);
for (int j = 0; j < info.getPropertyDescriptors().length; j++) {
PropertyDescriptor pd = info.getPropertyDescriptors()[j];
if (!containsPropertyName(pds, pd.getName())) {
pds.add(pd);
}
}
/** add extended interface information */
for (int i = 0; i < interfaces.length; i++) {
getInterfacePropertyDescriptors(interfaces[i], pds, classes);
}
} catch (IntrospectionException e) {
// do nothing
}
}
private JPanel getRemoveOptionsPanel() {
if (pnlRemoveOptions == null) {
pnlRemoveOptions = new JPanel(new BorderLayout());
DefaultBeanInfoResolver resolver = new DefaultBeanInfoResolver();
BeanInfo beanInfo = resolver.getBeanInfo(options);
PropertySheetPanel sheet = new PropertySheetPanel();
sheet.setMode(PropertySheet.VIEW_AS_CATEGORIES);
sheet.setProperties(beanInfo.getPropertyDescriptors());
sheet.readFromObject(options);
sheet.setDescriptionVisible(true);
sheet.setSortingCategories(true);
sheet.setSortingProperties(true);
pnlRemoveOptions.add(sheet, BorderLayout.CENTER);
// everytime a property change, update the button with it
PropertyChangeListener listener =
new PropertyChangeListener() {
public void propertyChange(PropertyChangeEvent evt) {
Property prop = (Property) evt.getSource();
prop.writeToObject(options);
}
};
sheet.addPropertySheetChangeListener(listener);
}
return pnlRemoveOptions;
}
/**
* Load bean information into a cache, because this operation will be slow.
*
* @param clazz
* @throws IntrospectionException
*/
protected PropertyDescriptor[] loadIntrospectionForClass(Class<?> clazz) {
if (null == clazz) {
throw new IllegalArgumentException("No bean class specified");
}
PropertyDescriptor[] descriptors = null;
descriptors = introspectionCache.get(clazz);
if (descriptors != null) {
return descriptors;
}
BeanInfo beanInfo = null;
try {
beanInfo = Introspector.getBeanInfo(clazz);
descriptors = beanInfo.getPropertyDescriptors();
if (null == descriptors) {
descriptors = new PropertyDescriptor[0];
}
} catch (IntrospectionException e) {
e.printStackTrace();
descriptors = new PropertyDescriptor[0];
}
introspectionCache.put(clazz, descriptors);
return descriptors;
}
private void fixNullOutputsForSOAP(CrownCounselIndexGetList_Properties fromClient) {
// Transform null to "null"
Class c = fromClient.getClass();
java.beans.BeanInfo beanInfo = null;
try {
beanInfo = java.beans.Introspector.getBeanInfo(c);
} catch (Exception e) {
}
java.beans.PropertyDescriptor[] properties = beanInfo.getPropertyDescriptors();
for (int i = 0; i < properties.length; i++) {
java.beans.PropertyDescriptor property = properties[i];
java.lang.reflect.Method readMethod = property.getReadMethod();
java.lang.reflect.Method writeMethod = property.getWriteMethod();
if ((readMethod != null) && (writeMethod != null)) {
String currentvalue = new String("");
if (readMethod.getReturnType() == currentvalue.getClass()) {
try {
currentvalue = (String) (readMethod.invoke(fromClient, null));
} catch (java.lang.reflect.InvocationTargetException a1) // Null argument
{
try {
Object[] args1 = new Object[1];
args1[0] = new String("null");
writeMethod.invoke(fromClient, args1);
} catch (Exception e2) {
}
} catch (Exception e1) {
}
} else {
}
}
}
}
@Override
public PropertyDescriptor[] getPropertyDescriptors(String name, URI uri) {
// platform:/resource/simple-jdbc-dao/src/main/resources/statements.meta
if (allLoaders == null) init();
Class<?> beanClass = loadClass(name, uri);
if (beanClass == null) return null;
// Look up any cached descriptors for this bean class
PropertyDescriptor[] descriptors = null;
// descriptors = (PropertyDescriptor[]) descriptorsCache.get(beanClass);
// if (descriptors != null) {
// return (descriptors);
// }
// Introspect the bean and cache the generated descriptors
BeanInfo beanInfo = null;
try {
beanInfo = Introspector.getBeanInfo(beanClass);
} catch (IntrospectionException e) {
return (new PropertyDescriptor[0]);
}
descriptors = beanInfo.getPropertyDescriptors();
if (descriptors == null) {
descriptors = new PropertyDescriptor[0];
}
// descriptorsCache.put(beanClass, descriptors);
return descriptors;
}
public PropertySheetApplicationStats() {
setLayout(LookAndFeelTweaks.createVerticalPercentLayout());
final Bean data = new Bean();
TimeSpan timespan = null;
// counts of objects
long discCount = HibernateDao.countAll(Disc.class);
data.setCountArtists(Long.toString(HibernateDao.countAll(Artist.class)));
data.setCountDiscs(Long.toString(discCount));
data.setCountTracks(Long.toString(HibernateDao.countAll(Track.class)));
// time stats
long totalTime = 0;
long totalSize = 0;
long avgTimePerDisc = 0;
long avgSizePerDisc = 0;
try {
totalTime = HibernateDao.sum(Disc.class, Disc.PROPERTYNAME_DURATION);
totalSize = HibernateDao.sum(Track.class, Track.PROPERTYNAME_TRACK_SIZE);
avgTimePerDisc = (totalTime / discCount) * 1000;
avgSizePerDisc = (totalSize / discCount);
} catch (RuntimeException ex) {
totalTime = 0;
}
// calculate time fields to display properly
timespan = new TimeSpan(totalTime * 1000);
data.setTimeTotal(timespan.toString());
timespan = new TimeSpan(avgTimePerDisc);
data.setTimeAveragePerDisc(timespan.toString());
// file stats
data.setFileTotal(FileUtils.byteCountToDisplaySize(totalSize));
data.setFileAveragePerDisc(FileUtils.byteCountToDisplaySize(avgSizePerDisc));
DefaultBeanInfoResolver resolver = new DefaultBeanInfoResolver();
BeanInfo beanInfo = resolver.getBeanInfo(data);
PropertySheetPanel sheet = new PropertySheetPanel();
sheet.setMode(PropertySheet.VIEW_AS_CATEGORIES);
sheet.setProperties(beanInfo.getPropertyDescriptors());
sheet.readFromObject(data);
sheet.setDescriptionVisible(true);
sheet.setSortingCategories(true);
sheet.setSortingProperties(true);
add(sheet, "*");
// everytime a property change, update the button with it
PropertyChangeListener listener =
new PropertyChangeListener() {
public void propertyChange(PropertyChangeEvent evt) {
Property prop = (Property) evt.getSource();
prop.writeToObject(data);
}
};
sheet.addPropertySheetChangeListener(listener);
}
public static Method methodFor(String methodName) throws IntrospectionException {
BeanInfo beanInfo = Introspector.getBeanInfo(SomeSteps.class);
for (MethodDescriptor md : beanInfo.getMethodDescriptors()) {
if (md.getMethod().getName().equals(methodName)) {
return md.getMethod();
}
}
return null;
}
