private static OpenMBeanParameterInfo[] params(ReflectMethod rm) { final OpenMBeanParameterInfo[] params = new OpenMBeanParameterInfo[rm.getParameters().length]; for (int i=0;i<params.length;i++) { ReflectParameter p = rm.getParameters()[i]; params[i] = new OpenMBeanParameterInfoSupport(p.getName(), p.getName(), MBeanTypes.of(p.getType(),p.getGenericType())); } return params; }
public boolean configure(Object[] args, ReflectParameter p, String keyPrefix) { keyPrefix = keyPrefix(keyPrefix); if(Property.class.isAssignableFrom(p.getType())) { doBeanConfigure(args, p, keyPrefix, p.getAnnotation(ConfigProperty.class)); return true; } ConfigProperty a = p.getAnnotation(ConfigProperty.class); if(null != a) { doBeanConfigure(args, p, keyPrefix, a); return true; } return false; }
@Override public Annotation[] getAnnotations() { return p.getAnnotations(); }
for(int i=0;i<cargs.length;i++) { ReflectParameter p = method.getParameters()[i]; cargs[i] = JsConvert.convert(args[i], p.getType(), p.getGenericType());
if(p.isAnnotationPresent(Inject.class)) { args[i] = resolveInjectValue(beanFactory, bd, p.getName(), p.getType(), p.getGenericType(), p.getAnnotations()); continue;
@Override public Class<?> getType() { return p.getType(); }
@Override public Type getGenericType() { return p.getGenericType(); }
@Override public String getName() { return p.getName(); }
public final boolean isAnnotationPresent(Class<? extends Annotation> annotationType){ return getAnnotation(annotationType) != null; }
private void initialize() { this.parameters = new ReflectParameter[reflectedMethod.getParameterTypes().length]; if(this.parameters.length > 0){ String[] names = Reflection.getParameterNames(reflectedMethod); if(null == names){ names = createUnknowParameterNames(parameters.length); } for(int i=0;i<parameters.length;i++){ Parameter p = reflectedMethod.getParameters()[i]; parameters[i] = new ReflectParameter(i+ 1, names[i], p, reflectedMethod.getGenericParameterTypes()[i]); } } }
protected Doc searchUp(ReflectMethod m, ReflectParameter p) { Class<?> c = m.getReflectedMethod().getDeclaringClass(); for(Class<?> ic : c.getInterfaces()) { try { Method im = ic.getMethod(m.getName(), m.getReflectedMethod().getParameterTypes()); return im.getParameters()[p.getIndex()-1].getAnnotation(Doc.class); } catch (NoSuchMethodException e) { //do nothing. } } return null; }
if(null != extraSetter) { ReflectParameter p = extraSetter.getParameters()[0]; value = Converts.convert(value, p.getType(), p.getGenericType(), context); extraSetter.invoke(bean, value); return; try { ReflectParameter p = extraSetter.getParameters()[0]; value = Converts.convert(value, p.getType(), p.getGenericType(), context); extraSetter.invoke(bean, value); return;
@SuppressWarnings("unchecked") public <T> T newInstance(Object... args){ try { return (T)reflectedConstructor.newInstance(args); } catch (Exception e) { StringBuilder s = new StringBuilder(); for(int i=0;i<parameters.length;i++){ if(i>0){ s.append(','); } s.append(parameters[i].getName()); } throw new ReflectException(Strings.format( "Error newInstance in constructor '{0}({1})'", getDeclaringClass().getSimpleName(), s.toString()),e); } }
parameters[i] = new ReflectParameter(i+1, names[i], reflectedConstructor.getParameters()[i], parameters[i] = new ReflectParameter(i+1, names[i], reflectedConstructor.getParameters()[i],
protected Object newInstance(ConvertContext context, BeanType bt, Map<String, Object> map){ ReflectClass cls = bt.getReflectClass(); ConvertContext.ConcreteTypes types = null == context ? null : context.getConcreteTypes(); if(null != types) { Object instance = types.newInstance(context, bt.getBeanClass(), null, map); if(null != instance) { return instance; } } if(cls.isAbstract() || cls.isInterface()) { throw new ConvertException("Cannot new instance for abstract class or interface '" + bt.getBeanClass().getName() + "'"); }else if(cls.hasDefaultConstructor()){ return bt.newInstance(); }else{ ReflectConstructor c = cls.getConstructors()[0]; ReflectParameter[] ps = c.getParameters(); Object[] args = new Object[c.getParameters().length]; for(int i=0;i<args.length;i++){ ReflectParameter p = ps[i]; args[i] = Converts.convert(map.get(p.getName()), p.getType(), p.getGenericType(), context); } return c.newInstance(args); } }
ReflectMethod m = bt.getReflectClass().getMethod("$"); if(null != m && m.getParameters().length == 1) { m.invoke(bean, Converts.convert(v, m.getParameters()[0].getType(), m.getParameters()[0].getGenericType(), context));
protected void addExtraSetter(ReflectMethod setter) { if (null == extraSetters) { extraSetters = new LinkedHashMap<>(1); } extraSetters.put(setter.getParameters()[0].getType(), setter); }
public ReflectDeleteEntityListener(Object inst, ReflectMethod m) { this.inst = inst; this.method = m; if(m.getParameters().length == 1) { this.transactional = false; ReflectParameter p = m.getParameters()[0]; if(p.getType().equals(Object.class)) { func = (e) -> m.invoke(inst, e.getId()); return; }else if(p.getType().equals(DeleteEntityEvent.class)) { func = (e) -> m.invoke(inst, e); return; } } else if(m.getParameters().length == 2) { this.transactional = true; ReflectParameter p0 = m.getParameters()[0]; ReflectParameter p1 = m.getParameters()[1]; if(p0.getType().equals(Object.class) && p1.getType().equals(TransactionStatus.class)) { func = (e) -> m.invoke(inst, e.getId(), e.getTransactionStatus()); return; } if(p0.getType().equals(DeleteEntityEvent.class) && p1.getType().equals(TransactionStatus.class)) { func = (e) -> m.invoke(inst, e, e.getTransactionStatus()); return; } } throw new IllegalArgumentException("Incorrect parameters in method '" + Reflection.fullQualifyName(m.getReflectedMethod()) + "' for 'DeleteEntity' event"); }
public Object invokeStatic(Object... args) { try { if(parameters.length != args.length){ throw new IllegalArgumentException("argument's length must be " + parameters.length); } for(int i=0;i<args.length;i++){ if(null == args[i]) { args[i] = Classes.getDefaultValue(parameters[i].getType()); } } return reflectedMethod.invoke(null, args); // if(index == -1){ // return javaMethod.invoke(null, args); // }else{ // return accessor.invokeMethod(null, index, args); // } } catch (Throwable e) { if(e instanceof InvocationTargetException){ e = e.getCause(); } if(e instanceof RuntimeException){ throw (RuntimeException)e; } throw new ReflectException(Strings.format("Error invoking method '{0}'",getName()),e); } }