Updated your writeInLogger method. I also added to check for the write method, else you get Class also as a property and the stack blows.

private static void writeInLogger(Object obj, String str) {
    Class klazz = obj.getClass();
    if (klazz.isPrimitive() || obj instanceof String || obj instanceof Integer || obj instanceof Double
            || obj instanceof Boolean)
        System.out.println(str + obj.toString());
    else {
        try {
            for (PropertyDescriptor propertyDescriptor : Introspector.getBeanInfo(klazz).getPropertyDescriptors()) {
                if(propertyDescriptor.getWriteMethod() == null)
                    continue;
                Method m = propertyDescriptor.getReadMethod();
                if (m != null) {
                    Object object = m.invoke(obj);
                    if(object != null)
                        writeInLogger(object, str);
                }
            }
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (IntrospectionException e) {
            e.printStackTrace();
        }
    }
}

I guess this code might help. I haven't added the functionality for processing Map, but it works with List:

public static void main(String[] args) throws ClassNotFoundException 
{
    SomeClass s = new SomeClass();
    Class c = s.getClass();
    getMembers(c);
}

public static void getMembers(Class c) throws ClassNotFoundException 
{
    Field[] fields = c.getDeclaredFields();

    for (Field f : fields) 
    {
        if (f.getType().isPrimitive() || f.getType().equals(String.class))
        {
            System.out.println(c.getSimpleName() + ": " + f.getName() + " is a "+ f.getType().getSimpleName());
        }
        else 
        {
            if (Collection.class.isAssignableFrom(f.getType())) 
            {
                String s = f.toGenericString();
                String type = s.split("\\<")[1].split("\\>")[0];
                Class clazz = Class.forName(type);
                System.out.println(c.getSimpleName()+ ": "+ f.getName()+ " is a collection of "+ clazz.getSimpleName());
                getMembers(clazz);
            }
            else
            {
                System.out.println(c.getSimpleName() + ": " + f.getName() + " is a "+ f.getType().getSimpleName());
                getMembers(f.getType());
            }
        }
    }
}

Hope that helps.

    if (receivers.isEmpty() && providers.isEmpty()) {
        return;
    }

    if (providers.isEmpty()) {
        receivers.clear();
        return;
    }

You can remove the first if statement, it's not necessary. Clearing a list that has no elements is almost free anyway.

        for (T provider : providers) {
            if (idField.get(receiver).equals(idField.get(provider))) {
                found = true;
            }
        }

You could break out of the for loop here. No need to go over the rest of the providers once you've found a match.

field.getType()

You have a lot of those in your merge function. How about storing it in a temporary variable to increase readability?

To recursively modify all fields in an object annotated with a given annotation we have to determine first all fields.

Class.getFields() will return only "accessible public fields". This doesn't match the requirement. Therefore we have to use Class.getDeclaredFields(). This in turn returns only the fields "declared by the class". In order to get all fields we have to traverse the type hierarchy of a target object upwards and process for each type its declared fields.

For every field we have to distinguish some cases:

1. A Field is annotated with the specified annotation. Then the given value has to be applied to the field. In order to set the value, the field has to be (made) accessible and non final.
2. A Field is not annotated with the specified annotation. Then there are three cases to distinguish:
   • The field has a primitive type. Then it isn't an object, which could contain a String field.
   • The field has an array type. Then it cannot contain a String field.
   • Else: The field has a reference type. Then it has to be (made) accessible, to check if it has a value set and in this case to process its fields recursively for 1) and 2) again.

To check whether an annotation is set on a field, we use Field.getAnnotation(myAnnotationClass) where myAnnotationClass is declared as Class<MyAnnotation>. But we have to be aware of something additional:
Field.getAnnotation(myAnnotationClass) will return the fields's annotation only if

• it's set (quite self-explanatory)
• MyAnnotation itself is annotated with @Retention(RetentionPolicy.RUNTIME).

The corresponding code would look like that:

  public static <T extends Annotation> void setValueOnAnnotatedFields(String s, Class<T> annotationClass, Object target) {
    if (target != null) {
      // traversing the type hierarchy upward to process fields declared in classes target's class extends
      Class<?> clazz = target.getClass();
      do {
        setValueOnAnnotatedDeclaredFields(s, annotationClass, target, clazz);
      }
      while ((clazz = clazz.getSuperclass()) != null);
    }
  }

  private static <T extends Annotation> void setValueOnAnnotatedDeclaredFields(String s, Class<T> annotationClass, Object target, Class<?> clazz) {
    Field[] fields = clazz.getDeclaredFields();
    for (Field field : fields) {
      if (field.getAnnotation(annotationClass) != null) {
        set(field, target, s);
      } else if (!field.getType().isPrimitive() && !field.getType().isArray()) {
        setValueOnAnnotatedFields(s, annotationClass, get(field, target));
      }
    }
  }

  protected static void set(Field field, Object target, String value) {
    try {
      makeFiieldAccessibleNotFinal(field, target);
      field.set(target, value);
    }
    catch (Exception e) {
      String message = String.format("Failed to set the value on field %s", target.getClass().getSimpleName() + "." + field.getName());
      throw new IllegalStateException(message, e);
    }
  }

  protected static Object get(Field field, Object target) {
    try {
      makeFiieldAccessibleNotFinal(field, target);
      return field.get(target);
    }
    catch (Exception e) {
      String message = String.format("Failed to get the value on field %s", target.getClass().getSimpleName() + "." + field.getName());
      throw new IllegalStateException(message, e);
    }
  }

  protected static void makeFiieldAccessibleNotFinal(Field field, Object target) {
    try {
      Field modifiersField = Field.class.getDeclaredField("modifiers");
      modifiersField.setAccessible(true);
      modifiersField.setInt(field, field.getModifiers() & ~Modifier.FINAL);
    }
    catch (Exception e) {
      String message = String.format("Failed to remove final declaration of field %s", field.getName());
      throw new IllegalStateException(message, e);
    }
    try {
      field.setAccessible(true);
    }
    catch (Exception e) {
      String message = String.format("Failed to make field %s accessible", field.getName());
      throw new IllegalStateException(message, e);
    }
  }

An example:

  public static void main(String[] args) {
    A a = new A();
    System.out.println(a); // s: null / b: [null]

    setValueOnAnnotatedFields("1", MyAnnotation.class, a);
    System.out.println(a); // s: 1 / b: [null]

    a.b = new B();
    setValueOnAnnotatedFields("2", MyAnnotation.class, a);
    System.out.println(a); // s: 2 / b: [a: 2 / b: null]
  }

This implies class A to have toString() implemented like that:

@Override
public String toString() {
  return "s: " + s + " / b: [" + Optional.ofNullable(b).map(B::toString).orElse("null") + "]";
}

And class B to have toString() implemented like that:

@Override
public String toString() {
  return "a: " + a + " / b: " + b;
}

You can do it like this. You need to add more condition as per your requirement in filter:

public static List<Field> getAllFields(List<Field> fields, Class<?> type) {
    fields.addAll(
            Arrays.stream(type.getDeclaredFields())
                    .filter(field -> field.isAnnotationPresent(NotNull.class))
                    .collect(Collectors.toList())
    );
    if (type.getSuperclass() != null) {
        getAllFields(fields, type.getSuperclass());
    }
    return fields;
}

Call example:

List<Field> fieldList = new ArrayList<>();
getAllFields(fieldList,B.class);

You should pass the object to get method of the field, so

  import java.lang.reflect.Field;

  Field field = object.getClass().getDeclaredField(fieldName);    
  field.setAccessible(true);
  Object value = field.get(object);

no, you need to write it yourself. It is a simple recursive method called on Class.getSuperClass():

public static List<Field> getAllFields(List<Field> fields, Class<?> type) {
    fields.addAll(Arrays.asList(type.getDeclaredFields()));

    if (type.getSuperclass() != null) {
        getAllFields(fields, type.getSuperclass());
    }

    return fields;
}

@Test
public void getLinkedListFields() {
    System.out.println(getAllFields(new LinkedList<Field>(), LinkedList.class));
}