public synchronized <BEAN> void register(final Class<BEAN> clazz) { try { if (!containsTool(clazz)) { logger.debug("register new class: " + clazz.getName()); final ClassDescriptor<BEAN> classDescriptor = new ClassDescriptorBuilderImpl<>(clazz).build(); final Persistor<BEAN> ormPersistor = persistorFactory.generate(classDescriptor); final ClassTool<BEAN> classTool = new ClassToolImpl<>(classDescriptor, ormPersistor); classToolMap.put(clazz, classTool); } } catch (final Exception e) { throw new JpoException(e); } }
private <P> FieldDescriptorImpl<BEAN, P> buildClassField(final ClassDescriptorImpl<BEAN> classMap, final Field field, final List<Method> methods, final Class<P> fieldClass) { final Class<?> realClass = field.getType(); Class<P> processedClass = (Class<P>) field.getType(); // In future this should be more generic. Not required at the moment if (isOptional(realClass)) { processedClass = getGenericClass(field.getGenericType()); } final FieldDescriptorImpl<BEAN, P> classField = new FieldDescriptorImpl<>(field.getName(), processedClass, buildPropertyFieldWrapper(field), getGetter(field, methods), getSetter(field, methods, classMap.getMappedClass()) ); setIgnored(classField); setColumnInfo(classField); setIdentifier(classField); setGeneratorInfo(classField); setVersionInfo(classField); setJsonInfo(classField); this.logger.debug("DB column [" + classField.getColumnInfo().getDBColumnName() + "]" + " will be associated with object field [" //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ + classField.getFieldName() + "]"); //$NON-NLS-1$ return classField; }
private <P> void setIgnored(FieldDescriptorImpl<BEAN, P> classField) { classField.setIgnored(findAnnotation(classField, Ignore.class).isPresent()); }
private boolean isValidGetter(Field field, Method method) { return method.getParameterTypes().length == 0 && ( field.getType().isAssignableFrom(method.getReturnType()) || isOptional(method.getReturnType()) && field.getType().isAssignableFrom(getGenericClass(method.getGenericReturnType()))); }
@Override public ClassDescriptor<BEAN> build() { this.logger.debug("generate " + ClassDescriptor.class.getSimpleName() + " for Class " + this.mainClazz.getName()); //$NON-NLS-1$ //$NON-NLS-2$ final TableInfo tableInfo = TableInfoFactory.getTableInfo(this.mainClazz); this.logger.debug("Table name expected in relation with class " + this.mainClazz.getSimpleName() + ": " + tableInfo.getTableName() + " - schema: " //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ + tableInfo.getSchemaName()); final ClassDescriptorImpl<BEAN> classMap = new ClassDescriptorImpl<>(this.mainClazz, tableInfo); this.initializeClassFields(classMap); this.initializeColumnNames(classMap); return classMap; }
private void initializeClassFields(final ClassDescriptorImpl<BEAN> classMap) { final List<Method> methods = Arrays.asList(this.mainClazz.getMethods()); final List<Field> fields = ReflectionUtils.getAllInheritedFields(this.mainClazz); for (final Field field : fields) { if (!ReflectionUtils.isStatic(field) && !ignoredFieldNames.contains(field.getName())) { final FieldDescriptorImpl<BEAN, ?> classField = this.buildClassField(classMap, field, methods, field.getType()); if (!classField.isIgnored()) { classMap.addClassField(classField); } } } }
private <P> boolean isValidSetter(final Field field, Method method, final Class<P> clazz) { final Class<?>[] params = method.getParameterTypes(); final Class<?> returnType = method.getReturnType(); return params.length == 1 && (returnType.equals(Void.TYPE) || clazz.isAssignableFrom(returnType) ) && (params[0].isAssignableFrom(field.getType()) || isOptional(params[0]) && getGenericClass(method.getGenericParameterTypes()[0]).isAssignableFrom(field.getType())); }
@Override public synchronized <BEAN> JPOConfig register(final Class<BEAN> clazz) { try { if (!getServiceCatalog().getClassToolMap().containsTool(clazz)) { logger.debug("register new class: " + clazz.getName()); //$NON-NLS-1$ final ClassDescriptor<BEAN> classDescriptor = new ClassDescriptorBuilderImpl<BEAN>(clazz, getServiceCatalog().getTypeFactory()).build(); final Persistor<BEAN> ormPersistor = new PersistorGeneratorImpl<BEAN>(classDescriptor, getTypeFactory()).generate(); ClassTool<BEAN> classTool = new ClassToolImpl<BEAN>(classDescriptor, ormPersistor); serviceCatalog.getClassToolMap().put(clazz, classTool); } } catch (final Exception e) { throw new JpoException(e); } return this; }
private <P> void setIdentifier(FieldDescriptorImpl<BEAN, P> classField) { classField.setIdentifier(findAnnotation(classField, Id.class).isPresent()); }
private <P> void setVersionInfo(FieldDescriptorImpl<BEAN, P> classField) { classField.setVersionInfo(new VersionInfoImpl(findAnnotation(classField, Version.class).isPresent())); }
private <P> void setGeneratorInfo(FieldDescriptorImpl<BEAN, P> classField) { classField.setGeneratorInfo(new GeneratorInfoImpl(GeneratorType.NONE, "", false)); final Optional<Generator> generator = findAnnotation(classField, Generator.class); if (generator.isPresent()) { classField.setGeneratorInfo(new GeneratorInfoImpl(generator.get().generatorType(), generator.get().name(), true)); } }
private <P> void setJsonInfo(FieldDescriptorImpl<BEAN, P> classField) { classField.setJsonInfo(new JsonInfo(false, false)); findAnnotation(classField, JsonType.class) .ifPresent(jsonType -> { classField.setJsonInfo(new JsonInfo(true, jsonType.deepCopy())); }); }
private <P> void setColumnInfo(FieldDescriptorImpl<BEAN, P> classField) { classField.setColumnInfo(new InferedColumnName(classField.getFieldName())); findAnnotation(classField, Column.class) .ifPresent(column -> { classField.setColumnInfo(new AnnotationColumnInfo(column.name())); }); }