Palestra realiza no JustJava 2012 no dia 19/05/2012. Java 7 trouxe um novo bytecode (invokedynamic) e um novo pacote (java.lang.invoke) com classes para prover suporte a linguagens dinâmicas, porém o uso desta API pode trazer benefícios para o desenvolvimento de aplicativos Java que não utilizam linguagens dinâmicas, principalmente no desenvolvimento de frameworks devido a flexibilidade da API em comparação com a API de Reflection.

1. Código “invocado” com
java.lang.invoke
JustJava 2012

2. Marcelo de Castro Alexandre Castro
marcelo@castro.eti.br alexandre@castro.eti.br
@mcastroinfo @CastroAlexandre

3. Código “invocado com
java.lang.invoke
• Pacote java.lang.invoke
– JSR 292
• Show me the code!
– Exemplos de uso da API
– Comparativo do desempenho entre
Chamadas
• Diretas
• Reflection (java.lang.Method)
• MethodHandle (java.lang.invoke)
• CallSite (java.lang.invoke)

4. 0101010101011111000000000101001110001
1100011100000001111010101010110001110
1001001010000101001010101011010110111
java.lang.invoke

5. java.lang.invoke
• CallSite
– ConstantCallSite
– MutableCallSite
– VolatileCallSite
• MethodHandle
• MethodHandleProxies
• MethodHandles
• MethodHandles.Lookup
• MethodType
• SwitchPoint
• WrongMethodTypeException

6. java.lang.invoke
• CallSite
– ConstantCallSite
– MutableCallSite
– VolatileCallSite
• MethodHandle
• MethodHandleProxies
• MethodHandles
• MethodHandles.Lookup
• MethodType
• SwitchPoint
• WrongMethodTypeException

7. <abstract> CallSite
• Um CallSite detém um MethodHandle, que
é chamado de alvo (target)
• Uma instrução invokedynamic vinculada a
um CallSite delega todas as chamadas ao
alvo atual.
• Implementações
– ConstantCallSite
– MutableCallSite
– VolatileCallSite

8. Implementações de CallSite
• ConstantCallSite
– Não permite a alteração do MethodHandle alvo
(target)
– Toda chamada ao método setTarget lança uma
UnsupportedOperationException
• MutableCallSite
– Permite a alteração do MethodHandle alvo
("target“)
• VolatileCallSite
– O MethodHandle alvo ("target") funciona
como uma variável volátil (volatile*)

9. MethodHandle
• Pode referenciar
– um método (de classe ou instância)
– um campo (de classe ou instância)
– um construtor
– outro MethodHandle
• Pode opcionalmente sofrer alterações dos
argumentos e valores de retorno (ver
MethodHandles)

10. MethodHandleProxies
• Classe que contém métodos estáticos que criam
instâncias de MethodHandle capazes de
trabalhar com outros tipos de elementos, como
interfaces por exemplo

11. MethodHandles
• Provê apenas métodos estáticos que
possibilitam manipular uma referência de
MethodHandle
– Criando
– Combinando
– Transformando
– Convertendo

12. MethodHandle.Lookup
• fábrica para criação de MethodHandle quando
a criação requer verificação da restrição de
acesso.
• A restrição de acesso (visibilidade) do
MethodHandle é realizada neste momento e
não quando o MethodHandle é chamado.

13. MethodType
• Classe final que representa o tipo de retorno e
os argumentos (se houver) do métodos (colocar
campos etc) que será manipulado por um
MethodHandle
• Todas instâncias de MethodType são imutáveis
• Possui construtor privado, objetos são obtidos
por métodos

14. SwitchPoint
• Um SwitchPoint é um objeto que pode publicar
transições de estado para outras threads
• Transições de estado: válido → inválido
• Pode combinar um par de MethodHandle
(target, fallback com o mesmo MethodType)
em um novo MethodHandle “delegador”
• O estado do SwitchPoint determina qual vai
receber a delegação
– Válido => target
– Inválido => fallback

15. WrongMethodTypeException
• RuntimeException
• Indica que o ocorreu a tentativa de construção,
combinação, ou chamada de um MethodHandle
por meio de tipo errados (MethodType), o que
ocorrer primeiro

16. 0101010101011111000000000101001110001
1100011100000001111010101010110001110
1001001010000101001010101011010110111
SHOW ME THE CODE!

17. MethodTypeExample.java
MethodType mtStrRetStrArg =
MethodType.methodType(String.class, String.class);
MethodType mtIntRet =
MethodType.methodType(int.class);
MethodType mtStrRetIntArg =
MethodType.methodType(String.class, int.class);

18. MethodHandlerExample.java
MethodHandle mhConcat =
MethodHandles.lookup().findVirtual
(String.class,"concat", mtStrReturnStrArg);
String retConcat = (String) mhConcat.invokeExact("Ja", "va“);
System.out.println(retConcat);// Java
MethodHandle mhLength =
MethodHandles.lookup().findVirtual
(String.class, "length", mtIntReturn);
int retLength = (int) mhLength.invokeExact("Java“);
System.out.println(retLength);// 4
MethodHandle mhToBinaryString =
MethodHandles.lookup().findStatic
(Integer.class, "toBinaryString", stStrRetIntArg);
String bStr = (String) mhToBinaryString.invokeExact(10);
System.out.println(bStr);// 1010

19. DropArgumentsExample.java
MethodHandle mhConcat = getConcatMethodHandle();
String str0 =(String)mhConcat.invokeExact("x", "y");
//xy
MethodHandle mhIgnoreArg0 = MethodHandles.
dropArguments (mhConcat, 0, String.class);
String str1 =
(String)mhIgnoreArg0.invokeExact("x", "y", "z");
//yz
MethodHandle mhIgnoreArg1And2 MethodHandles.
dropArguments(mhConcat, 1, int.class, String.class);
String str2 =
(String) mhIgnoreArg1And2.invokeExact("x", 1, "y", "z");
//xz

20. InsertArgumentsExample.java
MethodHandle mhReplace = getReplaceMethodHandle();
String str0 = (String)
mhReplace.invokeExact("JustJava", 'a','4'));
// JustJ4v4
MethodHandle mhInsertArg1 = MethodHandles.
insertArguments(mhReplace, 1,'J');
String str1 = (String)
mhInsertArg1.invokeExact("JustJava", 'X'));
//XustXava
MethodHandle mhInserArg2 = MethodHandles.
insertArguments(mhInsertArg1, 0, "JustJava");
String str1 = (String)
mhInserArg2.invokeExact( 'T'));
//TustTava

21. InsertArgumentsExample.java
MethodHandle mhReplace = getReplaceMethodHandle();
String str0 = (String)
mhReplace.invokeExact("JustJava", 'a','4'));
// JustJ4v4
MethodHandle mhInsertArg1 = MethodHandles.
insertArguments(mhReplace, 1,'J');
String str1 = (String)
mhInsertArg1.invokeExact("JustJava",‘J’, 'X'));
//XustXava
MethodHandle mhInserArg2 = MethodHandles.
insertArguments(mhInsertArg1, 0, "JustJava");
String str1 = (String)
mhInserArg2.invokeExact( 'T'));
//TustTava

22. InsertArgumentsExample.java
MethodHandle mhReplace = getReplaceMethodHandle();
String str0 = (String)
mhReplace.invokeExact("JustJava", 'a','4'));
// JustJ4v4
MethodHandle mhInsertArg1 = MethodHandles.
insertArguments(mhReplace, 1,'J');
String str1 = (String)
mhInsertArg1.invokeExact("JustJava", 'X'));
//XustXava
MethodHandle mhInserArg2 = MethodHandles.
insertArguments(mhInsertArg1, 0, "JustJava");
String str1 = (String)
mhInserArg2.invokeExact(‘JustJava’, ‘J’, 'T'));
//TustTava

23. PermuteArgumentsExample.java
MethodHandle mhRePlace = getReplaceMethodHandle();
String str0 =
(String) mhRePlace.invokeExact("JustJava", 'a', 'u‘);
//JustJuvu
MethodHandle mhPlaceRe = MethodHandles.
permuteArguments(mhRePlace, mtNovo, 0, 2, 1);
String str0 = (String)
mhPlaceRe.invokeExact("JustJava", 'a', 'u'));
//JastJava

24. FilterReturnValueExample.java
/*O argumento do filtro (se houver)
deve ser o mesmo do tipo de retorno do alvo */
MethodHandle mhAdapter =
MethodHandles.
filterReturnValue(mhConcatTarget, mhLengthFilter);
mhAdapter.invoke(“Just", “Java")//8
/* mhConcatTarget.type()=> (String, String)String
* mhLengthFilter.type()=> (String)int
* mhAdapter.type(); => (String, String)int
*/

25. CallSiteExample.java
CallSite callSite = new MutableCallSite(mtStrReturn);
MethodHandle mhDynamic = callSite.dynamicInvoker();
callSite.setTarget(
MethodHandles.constant(String.class, “Just"));
String ret1 = (String) mhDynamic.invokeExact();//Just
MethodHandle worker =
MethodHandles.filterReturnValue(mhDynamic, mhUpper);
callSite.setTarget(
MethodHandles.constant(String.class, “Java"));
String ret2 = (String) worker.invokeExact();//JAVA

26. SwitchPointExample.java
SwitchPoint switchPoint = new SwitchPoint();
MethodHandle mhTarget = getConcatMethodHandle();
MethodHandle mhFallback = MethodHandles.
permuteArguments(mhTarget, mhTarget.type(), 1, 0);
MethodHandle mhDelegator =
switchPoint.guardWithTest(mhTarget, mhFallback);
válido inválido
String str=(String)mhDelegator.invoke("Just", "Java"));
//JustJava
SwitchPoint.
invalidateAll(new SwitchPoint[]{switchPoint});
String str=(String)mhDelegator.invoke("Just", "Java"));
//JavaJust

27. ReflectionToInvokeExample
Method methodConcat =
String.class.
getDeclaredMethod("concat", String.class);
MethodHandle mhConcat =
MethodHandles.lookup().unreflect(methodConcat);
System.out.println(mhConcat.invoke("Just", "Java"));
//JustJava

28. br.eti.castro.example.
invoke.accesscontrol
• ClassToAcess
– publicField, protectedField, packegeField, privateField
– public void publicMethod(){}
– protected void protectedMethod(){}
– void packageMethod(){}
– private void privateMethod(){}
• FieldAcessTest
– Acessando e atribuindo valores
• MethodAcessTest
– Invocando os métodos

29. br.eti.castro.example.
invoke.performance
• Increaser
– public int increase(int i){return i++;}
• ExampleDirectlyInvoke
– int r = inc.increase(i);
• ExampleReflect
– int r = (int) method.invoke(object, param);
• ExampleInvoke
– int r = (int) methodHandle.invokeExact(param);
• ExampleInvokeCallSite
– int r = (int) mhBinded.invokeExact(param);

30. Referências
• JSR 292: Supporting Dynamically Typed Languages on the JavaTM Platform
http://jcp.org/en/jsr/detail?id=292
• Javadoc SE 7 http://docs.oracle.com/javase/7/docs/api/
• Method Handles and Beyond… John R. Rose, Da Vinci Machine Project,
JSR 292 Lead http://www.parleys.com/#id=2631&st=5
@JVMLanguageSummit2011
• MethodHandle implemention tips and tricks Dan Heidinga
http://bit.ly/KtZYqb @JVMLanguageSummit2011
• Java 7: Soporte a lenguajes dinámicos Roberto Montero Miguel

31. OBRIGADO!
Marcelo de Castro Alexandre Castro
marcelo@castro.eti.br alexandre@castro.eti.br
@mcastroinfo @CastroAlexandre