public ComposedEntityFieldAccessor andThenApply(Function<Object, Object> then) { ComposedEntityFieldAccessor composed = new ComposedEntityFieldAccessor(then); this.nextAccessor = composed; return composed; }
public EntityInfoBuilder(Class<T> entityClass, String tableName) { this.entityInspector = new JFleetEntityInspector(entityClass); this.entityClass = entityClass; this.tableName = tableName; }
public FieldsCollection override(FieldsCollection fieldsCollection) { return fieldsCollection.overrideAtttributes(mapping); }
public FieldsCollection getFieldsFromClass(Class<?> entityClass) { if (entityClass == Object.class) { return EMPTY_FIELD_COLLECTION; } FieldsCollection parentClassFields = getFieldsFromClass(entityClass.getSuperclass()); if (!isEntityOrMapped(entityClass)) { return parentClassFields; } MappingOverride mappingOverride = new MappingOverride(entityClass); FieldsCollection overwrittenClassFields = mappingOverride.override(parentClassFields); FieldsCollection currentClassFields = new FieldsCollection(Stream.of(entityClass.getDeclaredFields()) .map(FieldInspector::new).map(FieldInspector::inspect).flatMap(List::stream)); currentClassFields.addNotPresent(overwrittenClassFields); return currentClassFields; }
public EntityInfo inspect() { JpaFieldsInspector fieldsInspector = new JpaFieldsInspector(); List<FieldInfo> fieldsFromClass = fieldsInspector.getFieldsFromClass(entityClass); EntityFieldAccesorFactory factory = new EntityFieldAccesorFactory(); List<ColumnInfo> columns = fieldsFromClass.stream().map(field -> { Function<Object, Object> accessor = factory.getAccessor(entityClass, field.getFieldName()); return new ColumnInfo(field.getColumnName(), field.getFieldType(), accessor); }).collect(Collectors.toList()); return new EntityInfo(entityClass, getTableName(), columns); }
public JdbcConfiguration build() { if (entityInfo == null) { JpaEntityInspector inspector = new JpaEntityInspector(clazz); entityInfo = inspector.inspect(); } JdbcConfiguration conf = new JdbcConfiguration(); conf.autocommit = this.autocommit; conf.batchSize = this.batchSize; conf.entityInfo = this.entityInfo; return conf; } }
private FieldsCollection getFieldsFromClass(Class<?> entityClass) { if (entityClass == Object.class) { return EMPTY_FIELD_COLLECTION; } FieldsCollection parentClassFields = getFieldsFromClass(entityClass.getSuperclass()); FieldsCollection currentClassFields = new FieldsCollection(Stream.of(entityClass.getDeclaredFields()) .map(FieldInspector::new).map(FieldInspector::inspect).flatMap(List::stream)); currentClassFields.addNotPresent(parentClassFields); MappingOverride mappingOverride = new MappingOverride(field); return mappingOverride.override(currentClassFields); }
@Test public void testColumnChildEntity() { EntityInfoBuilder<SimpleEntity> builder = new EntityInfoBuilder<>(SimpleEntity.class, "simple_entity"); builder.addColumn("city_name", FieldTypeEnum.STRING, obj -> obj.getCity().getName()); EntityInfoHelper entityInfo = new EntityInfoHelper(builder); ColumnInfo column = entityInfo.findColumn("city_name"); assertEquals("city_name", column.getColumnName()); assertEquals(FieldTypeEnum.STRING, column.getFieldType().getFieldType()); assertFalse(column.getFieldType().isPrimitive()); assertEquals(simple.getCity().getName(), column.getAccessor().apply(simple)); }
private boolean isSkippable() { return isStaticField() || isTransient() || isInnerClassThisReference(); }
private Function<Object, Object> getFieldAccessor(Class<?> entityClass, String fieldName) { return getAccessorByPublicField(entityClass, fieldName) .orElseGet(() -> getAccessorByPropertyDescriptor(entityClass, fieldName) .orElseGet(() -> getAccessorByPrivateField(entityClass, fieldName).orElse(null))); }
private FieldsCollection getIdFieldsFromClass(Class<?> entityClass) { if (entityClass == Object.class) { return EMPTY_FIELD_COLLECTION; } FieldsCollection parentClassFields = getIdFieldsFromClass(entityClass.getSuperclass()); FieldsCollection currentClassFields = new FieldsCollection( Stream.of(entityClass.getDeclaredFields()).filter(this::isIdAnnotated).map(FieldInspector::new) .map(FieldInspector::inspect).flatMap(List::stream)); currentClassFields.addNotPresent(parentClassFields); return currentClassFields; }
public EntityFieldType buildFieldTypeByPath(String fieldPath, Optional<FieldTypeEnum> fieldTypeEnum) { Field field = findReferencedField(entityClass, fieldPath); JFleetFieldInspector fieldTypeInspector = new JFleetFieldInspector(field); EntityFieldType fieldType = fieldTypeInspector.getFieldType(); return fieldTypeEnum.map(type -> new EntityFieldType(type, fieldType.isPrimitive())).orElse(fieldType); }
public Function<Object, Object> getAccessor(Class<?> entityClass, String fieldPath) { if (!fieldPath.contains(".")) { return getFieldAccessor(entityClass, fieldPath); } return getComposedAccessor(entityClass, fieldPath); }
public EntityFieldType getFieldType() { Class<?> javaType = field.getType(); Optional<EntityFieldType> fieldType = fieldTypeInspector.getFieldType(javaType); EntityFieldType type = fieldType.orElseGet(() -> getAnnotatedType(javaType) .orElseThrow(() -> new RuntimeException("Unexpected type on " + field.toString()))); return type; }
public EntityInspectHelper(Class<?> clasz) { fields = fieldsInspector.getFieldsFromClass(clasz); }
MappingOverride(Class<?> entityClass) { AttributeOverrides multiple = entityClass.getAnnotation(AttributeOverrides.class); AttributeOverride simple = entityClass.getAnnotation(AttributeOverride.class); this.mapping = getMappingOverrride(multiple, simple); }
public ChildClass(int other, String bean, String parentPublic) { this.otherField = other; this.setBeanField(bean); this.publicField = parentPublic; }
public PgCopyConfiguration build() { if (entityInfo == null) { JpaEntityInspector inspector = new JpaEntityInspector(clazz); entityInfo = inspector.inspect(); } PgCopyConfiguration conf = new PgCopyConfiguration(); conf.autocommit = this.autocommit; conf.batchSize = this.batchSize; conf.concurrent = this.concurrent; conf.entityInfo = this.entityInfo; return conf; } }
MappingOverride(Field field) { AttributeOverrides multiple = field.getAnnotation(AttributeOverrides.class); AttributeOverride simple = field.getAnnotation(AttributeOverride.class); this.mapping = getMappingOverrride(multiple, simple); }
private EntityInfo getEntityInfo(CsvConfiguration<T> config) { EntityInfo entityInfo = config.getEntityInfo(); if (entityInfo != null) { return entityInfo; } return new JpaEntityInspector(config.getClazz()).inspect(); }