/** * Constructor. * * @param interfaceClass the class representing the service contract */ public JavaServiceContract(Class<?> interfaceClass) { introspectInterface(interfaceClass); }
public String getMessage() { if (site instanceof FieldInjectionSite) { FieldInjectionSite field = (FieldInjectionSite) site; return "Unknown injection type " + type + " on field " + field.getName() + " in class " + clazz; } else if (site instanceof MethodInjectionSite) { MethodInjectionSite method = (MethodInjectionSite) site; return "Unknown injection type " + type + " on method " + method + " in class " + clazz; } else if (site instanceof ConstructorInjectionSite) { ConstructorInjectionSite ctor = (ConstructorInjectionSite) site; return "Unknown injection type " + type + " on constructor " + ctor.getConstructor() + " in class " + clazz; } else { return "Unknown injection type " + type + " found in class " + clazz; } } }
public JavaGenericType(JavaTypeInfo info) { super(info.getRawType()); this.info = info; }
public void visitField(PersistenceUnit annotation, Field field, Class<?> implClass, InjectingComponentType componentType, IntrospectionContext context) { FieldInjectionSite site = new FieldInjectionSite(field); PersistenceUnitResourceReference definition = createDefinition(annotation); componentType.add(definition, site); // record that the implementation requires JPA componentType.addRequiredCapability("jpa"); }
public void visitMethod(PersistenceUnit annotation, Method method, Class<?> implClass, InjectingComponentType componentType, IntrospectionContext context) { MethodInjectionSite site = new MethodInjectionSite(method, 0); PersistenceUnitResourceReference definition = createDefinition(annotation); componentType.add(definition, site); // record that the implementation requires JPA componentType.addRequiredCapability("jpa"); }
public void visitMethod(Callback annotation, Method method, Class<?> implClass, InjectingComponentType componentType, IntrospectionContext context) { validate(method, componentType, context); String name = helper.getSiteName(method, null); Type type = helper.getGenericType(method); MethodInjectionSite site = new MethodInjectionSite(method, 0); CallbackDefinition definition = createDefinition(name, type, implClass, componentType, context); componentType.add(definition, site); }
/** * Returns a data type from a logical and physical type pairing. * * @param rawType the raw type * @param actualType the type to construct the data type from * @param mapping the resolved generic type mappings * @return the data type */ @SuppressWarnings({"unchecked"}) private DataType createDataType(Class<?> rawType, Type actualType, TypeMapping mapping) { if (actualType instanceof Class) { // not a generic return new JavaType(rawType); } else { JavaTypeInfo info = helper.createTypeInfo(actualType, mapping); return new JavaGenericType(info); } }
@SuppressWarnings({"unchecked"}) private DataType<?> createDataType(Class<?> physicalType, Type type, TypeMapping mapping) { if (type instanceof Class) { // not a generic return new JavaClass(physicalType); } else { JavaTypeInfo info = helper.createTypeInfo(type, mapping); return new JavaGenericType(info); } }
private Method getMethod(MethodInjectionSite methodSite, String implementationClass, ClassLoader classLoader) throws ClassNotFoundException, NoSuchMethodException { Class<?> clazz = classLoader.loadClass(implementationClass); return methodSite.getSignature().getMethod(clazz); }
public void visitMethod(Init annotation, Method method, Class<?> implClass, InjectingComponentType componentType, IntrospectionContext context) { if (!validate(method, context, componentType)) { return; } componentType.setInitMethod(new Signature(method)); }
public void visitMethod(Destroy annotation, Method method, Class<?> implClass, InjectingComponentType componentType, IntrospectionContext context) { if (!validate(method, context, componentType)) { return; } componentType.setDestroyMethod(new Signature(method)); }
private Method getMethod(Class<?> implClass, Signature signature) throws NoSuchMethodException, ClassNotFoundException { return signature == null ? null : signature.getMethod(implClass); }
private <T> Constructor<T> getConstructor(Class<T> implClass, Signature signature) throws ClassNotFoundException, NoSuchMethodException { Constructor<T> ctr = signature.getConstructor(implClass); ctr.setAccessible(true); return ctr; }
public void visitType(EagerInit annotation, Class<?> type, InjectingComponentType componentType, IntrospectionContext context) { componentType.setInitLevel(50); }
public JavaType(Class<?> type, String databinding) { super(type); setDatabinding(databinding); }
public String toString() { StringBuilder builder = new StringBuilder(); write(this, builder); return builder.toString(); }
public void visitField(PersistenceUnit annotation, Field field, Class<?> implClass, I implementation, IntrospectionContext context) { FieldInjectionSite site = new FieldInjectionSite(field); PersistenceUnitResource definition = createDefinition(annotation); InjectingComponentType componentType = implementation.getComponentType(); componentType.add(definition, site); // record that the implementation requires JPA componentType.addRequiredCapability("jpa"); }
public void visitMethod(PersistenceUnit annotation, Method method, Class<?> implClass, I implementation, IntrospectionContext context) { MethodInjectionSite site = new MethodInjectionSite(method, 0); PersistenceUnitResource definition = createDefinition(annotation); InjectingComponentType componentType = implementation.getComponentType(); componentType.add(definition, site); // record that the implementation requires JPA componentType.addRequiredCapability("jpa"); }
public void visitField(PersistenceContext annotation, Field field, Class<?> implClass, I implementation, IntrospectionContext context) { FieldInjectionSite site = new FieldInjectionSite(field); InjectingComponentType componentType = implementation.getComponentType(); PersistenceContextResource definition = createDefinition(annotation, componentType); componentType.add(definition, site); // record that the implementation requires JPA componentType.addRequiredCapability("jpa"); }
public void visitMethod(PersistenceContext annotation, Method method, Class<?> implClass, I implementation, IntrospectionContext context) { MethodInjectionSite site = new MethodInjectionSite(method, 0); InjectingComponentType componentType = implementation.getComponentType(); PersistenceContextResource definition = createDefinition(annotation, componentType); componentType.add(definition, site); // record that the implementation requires JPA componentType.addRequiredCapability("jpa"); }