@Nullable private static TypeWrapper wrap(Type type) { if (type == null) { return null; } else if (type instanceof Class) { return new ClassTypeWrapper((Class<?>) type); } else if (type instanceof ParameterizedType) { ParameterizedType parameterizedType = (ParameterizedType) type; return new ParameterizedTypeWrapper( toWrappers(parameterizedType.getActualTypeArguments()), (ClassTypeWrapper) wrap(parameterizedType.getRawType()), wrap(parameterizedType.getOwnerType())); } else if (type instanceof WildcardType) { WildcardType wildcardType = (WildcardType) type; return new WildcardTypeWrapper( toWrappers(wildcardType.getUpperBounds()), toWrappers(wildcardType.getLowerBounds()), type.hashCode()); } else if (type instanceof TypeVariable) { TypeVariable<?> typeVariable = (TypeVariable<?>) type; return new TypeVariableTypeWrapper( typeVariable.getName(), toWrappers(typeVariable.getBounds()), type.hashCode()); } else if (type instanceof GenericArrayType) { GenericArrayType genericArrayType = (GenericArrayType) type; return new GenericArrayTypeWrapper( wrap(genericArrayType.getGenericComponentType()), type.hashCode()); } else { throw new IllegalArgumentException("cannot wrap type of type " + type.getClass()); } }
public String toString() { StringBuilder sb = new StringBuilder(); if (ownerType != null) { if (ownerType instanceof Class) sb.append(((Class) ownerType).getName()); else sb.append(ownerType.toString()); sb.append("."); if (ownerType instanceof ParameterizedTypeImpl) { // Find simple name of nested type by removing the // shared prefix with owner. sb.append( rawType .getName() .replace(((ParameterizedTypeImpl) ownerType).rawType.getName() + "$", "")); } else sb.append(rawType.getName()); } else sb.append(rawType.getName()); if (actualTypeArguments != null && actualTypeArguments.length > 0) { sb.append("<"); boolean first = true; for (Type t : actualTypeArguments) { if (!first) sb.append(", "); if (t instanceof Class) sb.append(((Class) t).getName()); else sb.append(t.toString()); first = false; } sb.append(">"); } return sb.toString(); }
/** * Resolve current method generic return type to a {@link GenericMetadataSupport}. * * @param method Method to resolve the return type. * @return {@link GenericMetadataSupport} representing this generic return type. */ public GenericMetadataSupport resolveGenericReturnType(Method method) { Type genericReturnType = method.getGenericReturnType(); // logger.log("Method '" + method.toGenericString() + "' has return type : " + // genericReturnType.getClass().getInterfaces()[0].getSimpleName() + " : " + genericReturnType); if (genericReturnType instanceof Class) { return new NotGenericReturnTypeSupport(genericReturnType); } if (genericReturnType instanceof ParameterizedType) { return new ParameterizedReturnType( this, method.getTypeParameters(), (ParameterizedType) method.getGenericReturnType()); } if (genericReturnType instanceof TypeVariable) { return new TypeVariableReturnType( this, method.getTypeParameters(), (TypeVariable) genericReturnType); } throw new MockitoException( "Ouch, it shouldn't happen, type '" + genericReturnType.getClass().getCanonicalName() + "' on method : '" + method.toGenericString() + "' is not supported : " + genericReturnType); }
private static int checkParameterizedType( String subroutineName, ParameterizedType expectedType, ArgumentsList arguments, List<LispObject> args, int argsCounter, int i) { Type rawType = expectedType.getRawType(); Type expectedTypeArguments = expectedType.getActualTypeArguments()[0]; try { if (((Class) rawType).isInstance(args.get(argsCounter))) { Type actualTypeArguments = ((ParameterizedType) (Type) args.get(argsCounter).getClass()) .getActualTypeArguments()[0]; if (!expectedTypeArguments.equals(actualTypeArguments)) { throw new WrongTypeArgumentException( ((Class) rawType).getSimpleName() + "<" + ((Class) expectedTypeArguments).getSimpleName() + ">", args.get(argsCounter)); } arguments.setValue(i, args.get(argsCounter)); return argsCounter + 1; } else { if (arguments.isOptional(i)) return -1; throw new WrongTypeArgumentException(expectedType.toString(), args.get(argsCounter)); } } catch (IndexOutOfBoundsException e) { if (arguments.isOptional(i)) return -1; throw new WrongNumberOfArgumentsException(subroutineName, i); } }
/** * 通过反射, 获得Class定义中声明的父类的泛型参数的类型. 如无法找到, 返回Object.class. * * <p>如public UserDao extends HibernateDao<User,Long> * * @param clazz clazz The class to introspect * @param index the Index of the generic ddeclaration,start from 0. * @return the index generic declaration, or Object.class if cannot be determined */ @SuppressWarnings("rawtypes") public static Class getSuperClassGenricType(final Class clazz, final int index) { Type genType = clazz.getGenericSuperclass(); if (!(genType.getClass().isAssignableFrom(ParameterizedType.class))) { log.warn(clazz.getSimpleName() + "'s superclass not ParameterizedType"); return Object.class; } Type[] params = ((ParameterizedType) genType).getActualTypeArguments(); if (index >= params.length || index < 0) { log.warn( "Index: " + index + ", Size of " + clazz.getSimpleName() + "'s Parameterized Type: " + params.length); return Object.class; } if (!(params[index].getClass().isAssignableFrom(Class.class))) { log.warn(clazz.getSimpleName() + " not set the actual class on superclass generic parameter"); return Object.class; } return (Class) params[index]; }
private List<String> GetImplements(Class<?> cls) { List<String> list = new ArrayList<>(); for (Type interf : cls.getGenericInterfaces()) { list.add(interf.getTypeName()); } return list; }
protected Class<T> getTClass() { ParameterizedType type = (ParameterizedType) getClass().getGenericSuperclass(); Type resultType = type.getActualTypeArguments()[0]; // ImplForType, ParameterizedTypeImpl // if ("ParameterizedTypeImpl".equals(resultType.getClass().getSimpleName()) || // "ImplForType".equals(resultType.getClass().getSimpleName())) { // try { // Field field = resultType.getClass().getDeclaredField("rawTypeName"); // field.setAccessible(true); // String rawTypeName = (String) field.get(resultType); // return (Class<T>) Class.forName(rawTypeName); // } catch (Exception e) { // return (Class<T>) Collection.class; // } // } else { // return (Class<T>) resultType; // } if (resultType instanceof Class) { return (Class<T>) resultType; } else { // 处理集合 try { Field field = resultType.getClass().getDeclaredField("rawTypeName"); field.setAccessible(true); String rawTypeName = (String) field.get(resultType); return (Class<T>) Class.forName(rawTypeName); } catch (Exception e) { return (Class<T>) Collection.class; } } }
public Object inject(InjectionContext context) { if (injectionProvider == null) { return null; } Object injectedValue; try { injectedValue = injectionProvider.provideInjection(context); } catch (InjectionProviderException e) { Throwable ex = e; if (ex.getCause() != null) { ex = ex.getCause(); } String message = "InjectionProvider unable to resolve @" + injectionAnnotation.annotationType().getSimpleName() + " " + injectionType.toString(); throw new ConstructionException(message, ex); } if (injectedValue == null && !optional) { String message = "Non-optional @" + injectionAnnotation.annotationType().getSimpleName() + " " + injectionType.toString() + " was null in " + injectedClass.getName(); throw new ConstructionException(message); } return getInjectedValue(injectedValue); }
public <T> Class<T> inferValueClassForListOrSet(Type genericType, Class<?> entityClass) { log.debug( "Infer parameterized value class for collection type {} of entity class {} ", genericType.toString(), entityClass.getCanonicalName()); Class<T> valueClass; if (genericType instanceof ParameterizedType) { ParameterizedType pt = (ParameterizedType) genericType; Type[] actualTypeArguments = pt.getActualTypeArguments(); if (actualTypeArguments.length > 0) { Type type = actualTypeArguments[actualTypeArguments.length - 1]; valueClass = getClassFromType(type); } else { throw new AchillesBeanMappingException( "The type '" + genericType.getClass().getCanonicalName() + "' of the entity '" + entityClass.getCanonicalName() + "' should be parameterized"); } } else { throw new AchillesBeanMappingException( "The type '" + genericType.getClass().getCanonicalName() + "' of the entity '" + entityClass.getCanonicalName() + "' should be parameterized"); } log.trace("Inferred value class : {}", valueClass.getCanonicalName()); return valueClass; }
/** * Infer value type in one collection type * * @param genericType * @return */ public static Type inferElementTypeIn(Type collectionType) { if (collectionType instanceof Class) { return Object.class; } else if (collectionType instanceof ParameterizedType) { ParameterizedType parameterizedCollectionType = (ParameterizedType) collectionType; Type collectionValueType = parameterizedCollectionType.getActualTypeArguments()[0]; if (collectionValueType instanceof Class) { return (Class) collectionValueType; } else if (collectionValueType instanceof ParameterizedType) { ParameterizedType type = (ParameterizedType) collectionValueType; return type.getRawType(); } else if (collectionValueType instanceof WildcardType) { throw new UnusableTypeException( "we can't infer element type in widlcard type " + collectionType.toString()); } else if (collectionValueType instanceof TypeVariable) { throw new UnusableTypeException( "we can't infer element type in type variable " + collectionType.toString()); } } else if (collectionType instanceof WildcardType) { throw new UnusableTypeException( "we can't infer element type in widlcard type " + collectionType.toString()); } else if (collectionType instanceof TypeVariable) { throw new UnusableTypeException( "we can't infer element type in type variable " + collectionType.toString()); } throw new UnusableTypeException("we can't infer element type in " + collectionType.toString()); }
@Test public void testgeneric4() throws SecurityException, NoSuchMethodException { System.out.println("==== testgeneric4 ===="); Type type = GenericUtils.newArrayType(String.class); System.out.println(type.getClass().getName()); System.out.println("isRawArray:" + GenericUtils.isRawArray(type)); System.out.println("rawType:" + GenericUtils.getRawClass(type)); Class<?> c = new String[0].getClass(); System.out.println(c.getClass().getName()); System.out.println(c.getName()); System.out.println(c); System.out.println(type.equals(c)); System.out.println("==== testgeneric4b ===="); FieldEx field = BeanUtils.getField(GenericTypeTemplateTest.class, "field1"); System.out.println(field.getType().equals(c)); System.out.println(field.getGenericType().equals(c)); // 当不是泛型时,返回的是class对象 System.out.println(field.getType()); System.out.println(field.getGenericType()); System.out.println(type); System.out.println(field.getGenericType().equals(type)); System.out.println("==== testgeneric4c ===="); field = BeanUtils.getField(GenericTypeTemplateTest.class, "field2"); System.out.println(field.getType()); System.out.println(field.getGenericType()); type = field.getGenericType(); System.out.println("isRawArray:" + GenericUtils.isRawArray(type)); System.out.println("rawType:" + GenericUtils.getRawClass(type)); System.out.println(GenericUtils.getRawClass(type).equals(field.getType())); }
protected final boolean isInt(final JakExpression expr) { Type type = expr.type(this.context); return type.equals(boolean.class) || type.equals(byte.class) || type.equals(char.class) || type.equals(short.class) || type.equals(int.class); }
public static <T> Class<T> getGenericType(Class<?> klass, int index) { Type genericSuperclass = klass.getGenericSuperclass(); if (genericSuperclass instanceof ParameterizedType) return (Class<T>) ((ParameterizedType) klass.getGenericSuperclass()).getActualTypeArguments()[index]; if (genericSuperclass.equals(Object.class)) return null; return getGenericType(klass.getSuperclass(), index); }
protected boolean containsType(Type type) { for (Type providedType : providedHandlers.keySet()) { if (providedType.equals(type)) { return true; } } return false; }
/** * Checks if two types are the same or are equivalent under a variable mapping given in the type * map that was provided. */ private static boolean matches(Type from, Type to, Map<String, Type> typeMap) { if (to.equals(from)) return true; if (from instanceof TypeVariable) { return to.equals(typeMap.get(((TypeVariable<?>) from).getName())); } return false; }
protected Type rightTypeToGet(Type type) { for (Type providedType : providedHandlers.keySet()) { if (providedType.equals(type)) { return providedType; } } // Did not work... return type; }
/** * Checks if the subject type may be implicitly cast to the target parameterized type following * the Java generics rules. * * @param type the subject type to be assigned to the target type * @param toParameterizedType the target parameterized type * @return true if <code>type</code> is assignable to <code>toType</code>. */ private static boolean isAssignable( Type type, ParameterizedType toParameterizedType, Map<TypeVariable<?>, Type> typeVarAssigns) { if (type == null) { return true; } // only a null type can be assigned to null type which // would have cause the previous to return true if (toParameterizedType == null) { return false; } // all types are assignable to themselves if (toParameterizedType.equals(type)) { return true; } // get the target type's raw type Class<?> toClass = getRawType(toParameterizedType); // get the subject type's type arguments including owner type arguments // and supertype arguments up to and including the target class. Map<TypeVariable<?>, Type> fromTypeVarAssigns = getTypeArguments(type, toClass, null); // null means the two types are not compatible if (fromTypeVarAssigns == null) { return false; } // compatible types, but there's no type arguments. this is equivalent // to comparing Map< ?, ? > to Map, and raw types are always assignable // to parameterized types. if (fromTypeVarAssigns.isEmpty()) { return true; } // get the target type's type arguments including owner type arguments Map<TypeVariable<?>, Type> toTypeVarAssigns = getTypeArguments(toParameterizedType, toClass, typeVarAssigns); // now to check each type argument for (Map.Entry<TypeVariable<?>, Type> entry : toTypeVarAssigns.entrySet()) { Type toTypeArg = entry.getValue(); Type fromTypeArg = fromTypeVarAssigns.get(entry.getKey()); // parameters must either be absent from the subject type, within // the bounds of the wildcard type, or be an exact match to the // parameters of the target type. if (fromTypeArg != null && !toTypeArg.equals(fromTypeArg) && !(toTypeArg instanceof WildcardType && isAssignable(fromTypeArg, toTypeArg, typeVarAssigns))) { return false; } } return true; }
/** * Returns conversion for converting value of source-type to target-type, or throws exception if * there's no such conversion. */ @NotNull public TypeConversion getConversionFromDbValue(@NotNull Type source, @NotNull Type target) { TypeConversion conversion = findConversionFromDbValue(source, target).orElse(null); if (conversion != null) return conversion; else throw new InstantiationFailureException( "could not find a conversion from " + source.getTypeName() + " to " + target.getTypeName()); }
public void outject(@Observes MethodExecuted event, Result result, MethodInfo methodInfo) { Type returnType = event.getMethodReturnType(); if (!returnType.equals(Void.TYPE)) { String name = extractor.nameFor(returnType); Object value = methodInfo.getResult(); logger.debug("outjecting {}={}", name, value); result.include(name, value); } }
public static void main(String[]argv) throws Exception { Method m = Goo.class.getDeclaredMethod("getStrings"); Type t = m.getGenericReturnType(); if (!t.toString().equals("java.util.List<java.lang.String>")) throw new RuntimeException("Incorrect signature. Signature is "+t); m = IFace.class.getDeclaredMethod("getStrings"); t = m.getGenericReturnType(); if (!t.toString().equals("java.util.List<java.lang.String>")) throw new RuntimeException("Incorrect signature. Signature is "+t); }
/** * 获取一个类的某个一个泛型参数 * * @param klass 类 * @param index 参数下标 (从 0 开始) * @return 泛型参数类型 */ @SuppressWarnings("unchecked") public static <T> Class<T> getTypeParam(Class<?> klass, int index) { Type[] types = getTypeParams(klass); if (index >= 0 && index < types.length) { Type t = types[index]; Class<T> clazz = (Class<T>) Lang.getTypeClass(t); if (clazz == null) throw Lang.makeThrow("Type '%s' is not a Class", t.toString()); return clazz; } throw Lang.makeThrow("Class type param out of range %d/%d", index, types.length); }
@Test public void testgeneric5() throws SecurityException, NoSuchMethodException { System.out.println("==== testgeneric5 ===="); Type map1 = GenericUtils.newMapType(String.class, String.class); Type map2 = GenericUtils.newMapType(String.class, Object.class); Type map3 = Map.class; Type c = GenericUtils.newGenericType(GenericTypeTemplateTest.class, java.sql.Date.class); ClassEx cw = new ClassEx(c); MethodEx method = cw.getFirstMethodByName("test4"); System.out.println(map1.equals(method.getGenericParameterTypes()[0])); System.out.println(map2.equals(method.getGenericReturnType())); }
Foo() { Logger logger = Logger.getLogger(getClass()); Type t = TypeResolver.resolveInClass(Foo.class, Foo.class); logger.debug("........" + t.getClass()); Field field = null; try { field = Foo.class.getDeclaredField("var"); } catch (NoSuchFieldException e) { e.printStackTrace(); } logger.debug(field.getType()); // class java.lang.String. }
private boolean shouldTypeBeAdded(final Type t2, final ParameterizedType parameterizedType) { if (!(t2 instanceof TypeVariable)) { return true; } TypeVariable<?> typeVariable = (TypeVariable<?>) t2; final Type[] bounds = typeVariable.getBounds(); for (Type bound : bounds) { if (bound instanceof ParameterizedType && bound.equals(parameterizedType)) { return false; } } return true; }
/** * 当一个类使用<T,K>来定义泛型时,本方法返回类的一个字段的具体类型。 * * @param me * @param field * @return */ public static Type getFieldType(Mirror<?> me, Field field) { Type type = field.getGenericType(); Type[] types = me.getGenericsTypes(); if (type instanceof TypeVariable && types != null && types.length > 0) { Type[] tvs = me.getType().getTypeParameters(); for (int i = 0; i < tvs.length; i++) { if (type.equals(tvs[i])) { type = me.getGenericsType(i); break; } } } return type; }
/* * Don't consider parameter types that are available after conversion. * Message, Message<?> and Channel. */ private boolean isEligibleParameter(MethodParameter methodParameter) { Type parameterType = methodParameter.getGenericParameterType(); if (parameterType.equals(Channel.class) || parameterType.equals(org.springframework.amqp.core.Message.class)) { return false; } if (parameterType instanceof ParameterizedType) { ParameterizedType parameterizedType = (ParameterizedType) parameterType; if (parameterizedType.getRawType().equals(Message.class)) { return !(parameterizedType.getActualTypeArguments()[0] instanceof WildcardType); } } return !parameterType.equals(Message.class); // could be Message without a generic type }
public static void toJSON(ConfigurationAdmin admin, Writer osw, String filter) throws Exception { Configuration[] list = admin.listConfigurations(filter); Encoder encoder = codec.enc().to(osw); Protocol p = new Protocol(); p.version = 1; p.date = new Date(); p.size = list.length; encoder.put(p).append('\n'); if (list != null) for (Configuration c : list) { Dictionary<String, Object> d = c.getProperties(); Export export = new Export(); export.values = new HashMap<String, Object>(); export.factoryPid = c.getFactoryPid(); export.pid = c.getPid(); for (Enumeration<String> e = d.keys(); e.hasMoreElements(); ) { String k = e.nextElement(); Object v = d.get(k); if (!(v instanceof String)) { if (export.types == null) export.types = new HashMap<String, Type>(); Type type = new Type(); Class<?> clazz = v.getClass(); if (v instanceof Collection) { Collection<?> coll = (Collection<?>) v; clazz = String.class; if (coll.size() > 0) type.vectorOf = shortName(coll.iterator().next().getClass()); else type.vectorOf = shortName(String.class); } else if (v.getClass().isArray()) { type.arrayOf = shortName(clazz.getComponentType()); } else type.scalar = shortName(v.getClass()); export.types.put(k, type); } export.values.put(k, v); } encoder.mark().put(export); // encoder.put(encoder.digest()); encoder.append('\n'); } osw.flush(); }
public static void main(String... args) { try { Class<?> c = Class.forName(args[0]); out.format("Class:%n %s%n%n", c.getCanonicalName()); out.format("Modifiers:%n %s%n%n", Modifier.toString(c.getModifiers())); out.format("Type Parameters:%n"); TypeVariable<?>[] tv = c.getTypeParameters(); if (tv.length != 0) { out.format(" "); for (TypeVariable<?> t : tv) out.format("%s ", t.getName()); out.format("%n%n"); } else { out.format(" -- No Type Parameters --%n%n"); } out.format("Implemented Interfaces:%n"); Type[] intfs = c.getGenericInterfaces(); if (intfs.length != 0) { for (Type intf : intfs) out.format(" %s%n", intf.toString()); out.format("%n"); } else { out.format(" -- No Implemented Interfaces --%n%n"); } out.format("Inheritance Path:%n"); List<Class<?>> l = new ArrayList<Class<?>>(); printAncestor(c, l); if (l.size() != 0) { for (Class<?> cl : l) out.format(" %s%n", cl.getCanonicalName()); out.format("%n"); } else { out.format(" -- No Super Classes --%n%n"); } out.format("Annotations:%n"); Annotation[] ann = c.getAnnotations(); if (ann.length != 0) { for (Annotation a : ann) out.format(" %s%n", a.toString()); out.format("%n"); } else { out.format(" -- No Annotations --%n%n"); } // production code should handle this exception more gracefully } catch (ClassNotFoundException x) { x.printStackTrace(); } }
/** * @param types - Array of types to resolve. The unresolved type is replaced in the array with the * resolved type. * @param containingType - the shallowest type in the hierarchy where type is defined. * @return true if any of the types were resolved. */ private static boolean resolve(Type[] types, Type containingType) { boolean modified = false; for (int i = 0; i < types.length; ++i) { Type t = types[i]; if (!(t instanceof Class)) { modified = true; final Type resolved = resolve(t, containingType); if (!resolved.equals(t)) { types[i] = resolved; modified = true; } } } return modified; }
@Override public T deserialize(final JsonElement je, final Type type, final JsonDeserializationContext jdc) throws JsonParseException { // Get the "content" element from the parsed JSON JsonElement content = je; if (je.isJsonObject() && je.getAsJsonObject().has("contents")) { content = je.getAsJsonObject().get("contents"); final int lastIndex = type.toString().lastIndexOf('.'); final String name = type.toString().substring(lastIndex + 1).toLowerCase(); if (content.isJsonObject() && content.getAsJsonObject().has(name)) { content = content.getAsJsonObject().get(name); } } return new Gson().fromJson(content, type); }