The Well-Grounded Java Developer: Vital techniques of Java 7 and polyglot programming

How can I obtain all declared method through MethodHandles.lookup()? How can I obtain all declared fields?

Think of java.lang.invoke as a (fast performing) extension to reflection (java.lang.reflect) - i.e. "invoke" classes are dependent upon "reflection" classes.

• You obtain reference to all methods/constructors/fields via reflection (java.lang.Class and java.lang.reflect):

  java.lang.Class<?> someClass = ...;  // obtain a Class somehow
  
  // Returns all constructors/methods/fields declared in class, 
  // whether public/protected/package/private, 
  // but does NOT include definitions from any ancestors:
  
  java.lang.reflect.Constructor<?>[] declaredConstructors = someClass.getDeclaredConstructors();
  java.lang.reflect.Method[] declaredMethods = someClass.getDeclaredMethods();
  java.lang.reflect.Field[] declaredFields   = someClass.getDeclaredFields();
  
  // Returns all constructors/methods/fields declared as public members 
  // in the class AND all ancestors: 
  
  java.lang.reflect.Constructor<?>[] publicInheritedConstructors = someClass.getConstructors();
  java.lang.reflect.Method[] publicInheritedMethods = someClass.getMethods();
  java.lang.reflect.Field[] publicInheritedFields   = someClass.getFields();
  

• You convert them to MethodHandles via java.lang.invoke.MethodHandles.Lookup:

  java.lang.invoke.MethodType mt; 
  java.lang.invoke.MethodHandle mh;
  java.lang.invoke.MethodHandles.Lookup lookup = MethodHandles.lookup();
  
  // process methods
  for (java.lang.reflect.Method method: declaredMethods) {
      mh = lookup.unreflect(method);
  
      // can call mh.invokeExact (requiring first parameter to be the class' 
      // object instance upon which the method will be invoked, followed by 
      // the methodparameter types, with an exact match parameter and return 
      // types) or
      // mh.invoke/invokeWithArguments (requiring first parameter to be the 
      // class' object instance upon which the method will be invoked, 
      // followed by the method parameter types, with compatible conversions 
      // performed on input/output types)
  }
  
  // process constructors
  for (java.lang.reflect.Constructor<?> constructor: declaredConstructors) {
      mh = lookup.unreflectConstructor(constructor);
  
      // can call mh.invokeExact or
      // mh.invoke/invokeWithArguments 
  }
  
  // process field setters
  for (java.lang.reflect.Field field: declaredFields) {
      mh = lookup.unreflectSetter(field);
  
      // can call mh.invokeExact or
      // mh.invoke/invokeWithArguments 
  }
  
  // process field getters
  for (java.lang.reflect.Field field: declaredFields) {
      mh = lookup.unreflectGetter(field);
  
      // can call mh.invokeExact or
      // mh.invoke/invokeWithArguments 
  }
  

• You can determine if the signature of methods/constructors/fields via java.lang.reflect:

  // If generics involved in method signature:
  Type[] paramTypes = method.getGenericParameterTypes(); 
  Type returnType = method.getGenericReturnType(); 
  // Note: if Class is non-static inner class, first parameter of 
  // getGenericParameterTypes() is the enclosing class
  
  // If no generics involved in method signature:
  Class<?>[] paramTypes = declaredMethod.getParameterTypes(); 
  Class<?> returnType = declaredMethod.getReturnType(); 
  // Note: if Class is non-static inner class, first parameter of 
  // getParameterTypes() is the enclosing class
  
  // Same method calls for declaredConstructor
  

• You can determine if the methods/constructors/fields are static via java.lang.reflect:

  int modifiers = method.getModifiers();  // same method for constructor/field
  boolean isStatic = java.lang.Modifier.isStatic(modifiers);
  

What is difference betweeen MethodHandle.invoke(), MethodHandle.invokeExact() and MethodHandle.invokeWithArguments()?

• see http://docs.oracle.com/javase/7/docs/api/java/lang/invoke/MethodHandle.html#invoke%28java.lang.Object...%29
• If the MethodHandle is for a non-static method, the first parameter provided to these methods is an instance of the Class which declares the method. The method is invoked on this instance of the class (or on the Class itself for static methods). If the Class is a non-static inner class, the second parameter is an instance of the enclosing/declaring class. The subsequent parameters are the method signature parameters, in order.
• invokeExact does not do automatic compatible type conversion on input parameters. It requires parameter values (or parameter expressions) to be an exact type match to the method signature, with each parameter provided as a separate argument OR all arguments provided together as an array (signature: Object invokeExact(Object... args)).
• invoke requires the parameter values (or parameter expressions) to be type compatible match to the method signature - automatic type conversions are performed, with each parameter provided as a separate argument OR all arguments provided together as an array (signature: Object invoke(Object... args))
• invokeWithArguments requires the parameter values (or parameter expressions) to be type compatible match to the method signature - automatic type conversions are performed, with each parameter provided within a List (signature: Object invokeWithArguments(List<?> arguments))

I will be appreciate for tutorial about using MethodHandle API for Java devloper

There's not much out there, unfortunately. You could try the following. Hopefully, I've given enough info above :^)

http://docs.oracle.com/javase/7/docs/api/java/lang/invoke/MethodHandle.html
http://docs.oracle.com/javase/7/docs/api/java/lang/invoke/MethodHandles.Lookup.html
http://www.java7developer.com/blog/?p=191
http://www.oraclejavamagazine-digital.com/javamagazine/20130102?pg=52&search_term=methodhandle&doc_id=-1#pg50
http://www.amazon.com/Well-Grounded-Java-Developer-techniques-programming/dp/1617290068