Use o código e tenha 10% de desconto!

Componentes Reutilizáveis em Java com Reflexão e Anotações

Eduardo Guerra
Capa

Reflexão e Anotações

Agradecimentos pessoais

A Deus primeiro agradeço
Por ter iluminado meu caminho
Pois sei em meu coração
Que eu nunca estou sozinho

Agradeço aos meus pais
Por cada ensinamento
Deles aprendi valores
Presentes a todo momento

A Duda filhinha querida
De quem além de pai sou amigo
Seu sorriso e seu carinho
Carrego sempre comigo

A Bia filhinha querida 
Mais esperta a cada dia
A cada coisinha que fala
Vai trazendo sempre alegria

A Roberta esposa amada
Companheira sempre presente
Sempre firme ao meu lado
Me fazendo seguir em frente

Adiciono mais um verso
Não que tenha me esquecido
Pra dizer que minha vida
Sem vocês não faz sentido

Agradecimentos profissionais

Antes de mencionar alguém de forma específica, gostaria de agradecer a todos meus professores, alunos, colegas de trabalho, amigos e companheiros que de alguma forma contribuíram para meu conhecimento e me incentivaram a seguir em frente. Nossa vida é feita de pessoas e de experiências, e é a partir disso que seguimos nossos caminhos e realizamos nossas escolhas.

Primeiramente deixo um agradecimento institucional ao ITA, um instituto que é referência nacional e internacional em engenharia, em onde me formei em Engenharia da Computação e fiz meu mestrado e doutorado. Além disso, também foi um local onde tive a oportunidade de atuar como professor por mais de 5 anos. Foram experiências que me marcaram e são uma importante parte da minha história. Eu saí do ITA, mas com certeza o ITA não saiu de mim! Agradeço em especial ao professor Clovis Fernandes, meu orientador na graduação, no mestrado e no doutorado. Um grande amigo, que sempre me incentivou e que foi grande mentor, cujos ensinamentos foram muito além de questões técnicas.

Agradeço à revista MundoJ, principalmente ao Marco Guapo, inicialmente por ter aberto espaço para que eu escrevesse sobre minhas ideias e meus conhecimentos. Em seguida, Guapo confiou a mim o conteúdo da revista como editor-chefe. Através da minha atuação na revista eu pude aprender muita coisa e me manter sempre atualizado durante os últimos anos. Por meio dos artigos que escrevi, ganhei experiência e tomei gosto pela escrita de conteúdo técnico. Posso afirmar com certeza que a semente desse livro foi plantada em alguns de meus artigos durante os últimos anos.

Agradeço também à comunidade de padrões, tanto nacional quanto internacional, por ter me influenciado com toda sua cultura e ideias. Sou grato por terem me recebido de braços abertos e por terem fornecido um fórum onde foi possível debater as minhas ideias e obter feedback dos trabalhos que estou realizando. Agradeço em especial pelo apoio e incentivo de Fabio Kon, Fábio Silveira, Jefferson Souza, Uirá Kulezsa, Ademar Aguiar e Filipe Correia. Também agradeço pelos meus gurus Joseph Yoder e Rebecca Wirfs-Brock, com quem aprendi demais e tive discussões muito interessantes sobre modelagem e arquitetura de software.

Agradeço ao INPE, instituição onde trabalho e desenvolvo minha pesquisa. Apesar de estar aqui a pouco tempo, eu me identifiquei muito com seu ambiente propício para o desenvolvimento e aplicação de novas ideias. Agradeço por ter me recebido de braços abertos e confiado em minhas ideias. Tenho certeza de que nos próximos anos poderei contribuir para seu crescimento a partir de minha ideias e da minha pesquisa.

Finalmente, agradeço à Casa do Código por confiar em mim para escrita desse livro. Deixo um agradecimento em especial ao Paulo Silveira e ao Adriano Almeida, por estarem sempre disponíveis a discussões relacionadas ao conteúdo desse livro.

Minibiografia do autor

Eduardo Martins Guerra nasceu em Juiz de Fora em 1980 e cursou o ensino básico e médio em escola pública, o Colégio de Aplicação João XXIII. Desde essa época, ele já despertou seu interesse pela programação, começando com a digitação de código Basic que vinha em revistas no seu defasado computador Exato Pro. A diversão era mais ver o efeito de pequenas modificações no código do que o jogo que saía como resultado. Nessa época, pouco depois, também fez um curso de Clipper, onde desenvolveu seu primeiro software: um gerenciador de canil!

Incentivado por seus professores, pela facilidade com disciplinas na área de exatas, prestou o vestibular para o ITA em 1998, logo após o término de seus estudos, e foi aprovado. Durante o curso, ele optou pela carreira militar e pelo curso de computação, além de participar de atividades extracurriculares como projetos para a empresa júnior e aulas no curso pré-vestibular para pessoas carentes, CASD Vestibulares. Nesses cinco anos, Eduardo se apaixonou pela área de desenvolvimento de software e pela possibilidade de usar constantemente sua criatividade para propor sempre soluções inteligentes e inovadoras. Dois dias depois de se formar, casou-se com sua mais forte paixão, sua atual esposa, Roberta.

Após formado, em 2003, foi alocado no Centro de Computação da Aeronáutica de São José dos Campos (CCA-SJ), onde ficaria pelos próximos 4 anos. Durante esse período, trabalhou com o desenvolvimento de software operacional para atender às necessidades da Força Aérea Brasileira, adquirindo uma valiosa experiência na área.

No final de 2005, com dedicação em tempo parcial, Eduardo conseguiu seu título de mestre em Engenharia da Computação e Eletrônica apresentando a dissertação “Um Estudo sobre Refatoração de Código de Teste”. Nesse trabalho, Eduardo desenvolve sua paixão pelo design de software, realizando um estudo inovador sobre boas práticas ao se codificar testes automatizados. Essa dissertação talvez tenha sido um dos primeiros trabalhos acadêmicos no Brasil no contexto de desenvolvimento ágil. No ano de conclusão de seu mestrado, veio sua primeira filha, Maria Eduarda.

Devido à sua sede de conhecimento, ainda nesse período, estudou por conta própria e tirou sete certificações referentes à tecnologia Java, sendo na época um dos profissionais brasileiros com maior número de certificações na área. Além disso, tem ocupado o cargo de editor-chefe da revista MundoJ desde 2006, na qual já publicou dezenas de artigos técnicos de reconhecida qualidade. Esses fatos lhe deram uma visão da indústria de desenvolvimento de software que foi muito importante em sua trajetória, direcionando sua pesquisa e seus trabalhos para problemas reais e relevantes.

No CCA-SJ, Eduardo atuou de forma decisiva no desenvolvimento de frameworks. Seus frameworks simplificaram a criação das aplicações e deram maior produtividade para a equipe de implementação. Um deles, o SwingBean, foi transformado em um projeto open-source e já possui mais de 5000 downloads. A grande inovação e diferencial de seus frameworks estavam no fato de serem baseados em metadados. A partir desse caso de sucesso, ele decidiu estudar mais sobre como a utilização de metadados poderia ser feita em outros contextos. Foi uma surpresa descobrir que, apesar de outros frameworks líderes de mercado utilizarem essas técnicas, ainda não havia nenhum estudo sobre o assunto. Foi, então, que Eduardo começou sua jornada para estudar e tornar acessível o uso dessa técnica por outros desenvolvedores, pois ele sabia do potencial que os frameworks baseados em metadados têm para agilizar o desenvolvimento de software e o tornar mais flexível.

Então, em 2007, ele ingressou no curso de doutorado do ITA pelo Programa de Pós-Graduação em Aplicações Operacionais – PPGAO. A pesquisa sobre frameworks baseados em metadados se encaixava perfeitamente no objetivo do programa. A criação de arquiteturas flexíveis, nas quais se pode acrescentar funcionalidade de forma mais fácil, é algo crítico para aplicações de comando e controle, foco de uma das áreas do programa. Orientado pelo professor Clovis Torres Fernandes, começou uma pesquisa que envolveu a análise de frameworks existentes, a abstração de técnicas e práticas, a criação de novos frameworks de código aberto e a execução de experimentos para avaliar os conceitos propostos.

Foi nessa época que Eduardo começou a participar e se envolveu na comunidade de padrões. Em 2008 submeteu para o SugarLoafPLoP em Fortaleza os primeiros padrões que identificou em frameworks que utilizavam metadados. Nesse momento, ele se empolgou com o espírito de colaboração da comunidade de padrões, onde recebeu um imenso feedback do trabalho que estava realizando. Desde então se tornou um membro ativo da comunidade, publicando artigos com novos padrões em eventos no Brasil e no exterior. Além disso, em 2011 participou da organização do MiniPLoP Brasil, em 2012 foi o primeiro brasileiro a ser chair da principal conferência internacional de padrões, o PLoP, e em 2013 também participou da organização do próximo MiniPLoP.

Enquanto realizava seu doutorado, Eduardo foi incorporado, ainda como militar, no corpo docente do Departamento de Ciência da Computação do ITA, onde pôde desenvolver uma nova paixão: ensinar! Durante esse período, ministrou aulas na graduação e em cursos de especialização, e orientou uma série de trabalhos que, de certa forma, complementavam e exploravam outros aspectos do que estava desenvolvendo em sua tese. Em consequência do bom trabalho realizado, foi convidado por três vezes consecutivas para ser o professor homenageado da turma de graduação Engenharia da Computação e duas vezes para a turma de especialização em Engenharia de Software.

Em 2010, apresentou seu doutorado chamado "A Conceptual Model for Metadata-based Frameworks" e concluiu com sucesso essa jornada que deixou diversas contribuições. Devido à relevância do tema, foi incentivado pelos membros da banca a continuar os estudos que vinha realizando nessa área. Apesar de a tese ter trazido grandes avanços, ele tem consciência de que ainda há muito a ser feito. Uma de suas iniciativas nessa área foi o projeto Esfinge (http://esfinge.sf.net), que é um projeto guarda-chuva para a criação de diversos frameworks com essa abordagem baseada em metadados. Até o momento, já existem cinco frameworks disponíveis e vários artigos científicos em cima de inovações realizadas nesses projetos. No mesmo ano em que terminou seu doutorado, veio sua segunda filhinha, a Ana Beatriz.

Em 2012, Eduardo prestou concurso para o Instituto Nacional de Pesquisas Espaciais, onde assumiu o cargo de pesquisador no início 2013. Hoje ele segue com sua pesquisa na área de arquitetura, testes e design de software, buscando aplicar as técnicas que desenvolve para projetos na área científica e espacial. Adicionalmente, atua como docente na pós-graduação de Computação Aplicada desse instituto, onde busca passar o conhecimento que adquiriu e orientar alunos para contribuírem com essas áreas.

Por que um livro sobre reflexão e anotações?

Quando descobri a API de reflexão na linguagem Java foi como se um novo mundo se abrisse para mim. Logo busquei aprender mais sobre o tema para conseguir aplicar esse conhecimento da melhor forma possível nos softwares que desenvolvia. Foi então que conheci o livro "Java Reflection in Action" dos autores Ira Forman e Nate Forman, publicado em 2004. A partir desse livro, conheci a base da API de reflexão e comecei a trabalhar nas minhas próprias soluções. Foi nessa época que desenvolvi o framework SwingBean (http://swingbean.sf.net), um framework para a geração de interfaces gráficas a partir das informações de classes.

Não demorou muito e foi lançada a JDK 1.5, que dava suporte nativo a anotações de código. Como utilizar aquele novo conceito? Só que, para responder essa pergunta, não esperei sair um livro sobre o assunto. Quando percebi que esse seria um tema que ainda tinha muito a ser explorado, ingressei no doutorado com o desafio de estudar boas práticas para componentes e frameworks que utilizam metadados. Desde essa época até hoje, foram diversos trabalhos com esse foco, não apenas buscando aplicações para utilização de metadados, mas também estudando práticas mais gerais na utilização dessa abordagem.

Desde então, nenhum livro saiu sobre o assunto. Nem no Brasil, nem no exterior. Isso me fez sentir com a obrigação de consolidar todo esse conhecimento que estava adquirindo e desenvolvendo nos últimos anos em um lugar só. Eu já vinha publicando artigos mais voltados para a aplicação desses conceitos na indústria na revista MundoJ e para a comunidade acadêmica em conferências e periódicos científicos. Porém, ainda faltava consolidar todo esse conhecimento em um lugar só. Então veio a ideia desse livro!

O que você tem nas mãos agora é a consolidação do conhecimento que adquiri nos últimos anos sobre reflexão e metadados, costurado e desenvolvido com muito cuidado com o objetivo de tornar acessível a todos os desenvolvedores algo considerado por muitos como complicado. Houve também uma preocupação com a completude do livro em relação ao tema: não queria deixar nada importante de fora! Sendo assim, diferente do livro citado anteriormente que abordava somente a API de reflexão, esse livro, além da adição das anotações, também aborda outras questões, como técnicas de teste, uso de ferramentas de código aberto, boas práticas e manipulação de bytecode. Também houve a preocupação em levar ao leitor um conteúdo atualizado, apresentando as adições trazidas pelo Java 8 na área de reflexão e configuração de metadados.

O conhecimento sobre esse tema foi, e ainda é, um grande diferencial nos projetos de software que participo e participei. Com ele, é possível desenvolver soluções mais inteligentes, com potencial de tornar o software mais flexível e diminuir o tempo de desenvolvimento. Mas por que guardar esse conhecimento só para mim? Sendo assim, aí está! Pegue esse conhecimento e faça você agora a diferença!

Lista de discussão

A aplicação de reflexão e anotações para o desenvolvimento de frameworks e componentes abre novas possibilidades que permitem que se utilize a criatividade para o desenvolvimento de soluções mais reutilizáveis e flexíveis. Apesar de ter procurado expressar todo conhecimento que consegui reunir sobre esse assunto nos últimos anos nesse livro, certamente ainda há muito a ser discutido e muito a ser desenvolvido. A cada dia, nas pesquisas que realizo sobre o assunto, estou sempre buscando desenvolver novas soluções, abstrair padrões e aplicar esse conhecimento em diferentes domínios.

Sendo assim, criei uma lista de discussão com o nome "Reflexão e Anotações" no endereço reflexao-e-anotacoes@googlegroups.com.

Se você quer discutir, colocar suas dúvidas e saber eventos e novidades reflexão e anotações, deixo aqui o meu convite para a participação no grupo!

Prefácio ─ Olhando para trás sobre o olhar para dentro

Por Brian Foote

As ideias-chave que fundamentam a reflexão estão por aí desde os primórdios da computação moderna. No entanto, não foi antes que a API para reflexão fosse publicada para Java, nos meados da década de 1990, que "reflexão" virou uma palavra "de casa", pelo menos naquelas casas afortunadas o suficientes para serem habitadas por desenvolvedores de software.

A ideia de que os dados é que direcionam a computação, assim como de que os dados a respeito dessa computação coabitam em um local de armazenamento comum, foi um elemento essencial na máquina universal de Turing. A ideia de que o programa que dirige a execução da unidade de controle do computador deveria ser armazenado na mesma memória compartilhada que os seus dados foi fundamental para o que seria conhecido como a arquitetura de Von Neumann.

Uma consequência de se ter um programa armazenado coabitando a mesma memória que seus dados, ou seja, fazendo que ele seja também um dado, permite que um programa possa ver e modificar qualquer coisa nesse armazenamento, até ele mesmo, caso seja necessário. Em outras palavras, um programa pode escrever outros programas, ou reescrever a si próprio.

Nós dizemos que um programa é introspectivo quando ele examina os dados que dirigem seu comportamento. E dizemos que ele é totalmente reflexivo quando essa autoexaminação influencia na forma como ele se comporta.

Uma explicação possível pela atual onda de interesse em reflexão, particularmente na comunidade orientada a objetos, é a sua herança na longa tradição de tentar fazer linguagens de programação serem mais abertas possível.

A definição de metacircular foi dada em Lisp por McCarthy em 1962. Essa definição permitiu a criação de um "modelo" para um programa que pode pegar outros programas em Lisp na forma de estruturas de dados em Lisp e executá-los. Esse programa, por sua vez, permitia que estrutura de dados em Lisp (s-expressions) fossem passadas para uma função (eval) e executadas como código.

Estava claro que McCarthy reconhecia que uma linguagem de programação poderia, pelo menos de forma tão efetiva quanto abordagens formais, definir como uma linguagem de programação funciona. McCarthy e seu grupo não viu a princípio o potencial prático que essa sua abordagem tinha para metaprogramação. Porém, a composição e execução de listas que representam programas rapidamente se tornou uma indispensável parte da mala de truques de um programador Lisp avançado.

Dados descrevem ou caracterizam algum aspecto de um domínio, quantitativamente ou qualitativamente. Metadados são dados também. Eles apenas são dados que descrevem outros dados. Objetos são construídos de dados, e código que opera esses dados. Os objetos que descrevem os objetos dos quais os programas são construídos são chamados de Metaobjetos.

A ideia de construir programas a partir de objetos apareceu primeiro em Smalltalk-76, e foi em seguida refinada em Smalltalk-80. O requisito de que o usuário deveria ser capaz de examinar ou alterar o máximo do sistema possível se encaixa perfeitamente com nossas definições contemporâneas de reflexão. De fato, o extensivo conjunto de metaobjetos de Smalltalk-80 é um dos melhores exemplos existentes do poder desse tipo de objeto. Por exemplo, em Smalltalk-80, Classes, Processes, Methods, MethodDictionaries, CompiledMethods, Contexts, Blocks, e o próprio compilador eram todos criados a partir de objetos. Como resultado, Smalltalk possui um conjunto muito rico do que agora chamamos de reflective facilities.

Brian Cantwell Smith foi o primeiro a utilizar os termos introspecção e reflexão para descrever como programas podem tratar a si mesmos como "sujeitos" em 1983, em seu trabalho sobre torres reflexivas em 3-Lisp. Em 1987, Pattie Maes trouxe essas ideias de volta à comunidade orientada a objetos, ganhando uma audiência que aos poucos foi gerando mais repercussão. Mesmo assim, essas ideias foram tratadas como obscuras e impraticáveis por grande parte de comunidade que realizava pesquisa em programação. Smith recebeu de um revisor a crítica de que "ele tinha resolvido um problema que ninguém nunca tinha tido".

Isso foi até que, vinte anos atrás, quando o Java, no ápice do boom da internet, incorporou sua API de reflexão e um nível de bytecode, a descrição do arquivo de uma classe em seu código. Então, essas ideias começaram a ganhar uma certa tração.

Os metadados vêm em três diferentes sabores. O "Markup" que mistura os dados de fato com sua descrição. As anotações em Java são um exemplo onde as descrições do código são misturadas com o próprio código. HTML e XML são exemplos primordiais dessa abordagem, onde as descrições dos dados, como tags e atributos, são entrelaçadas com os dados que eles descrevem.

O "Manifesto" é um descrição ou um mapa separado dos dados que estão sendo descritos. Da mesma forma que um manifesto de carga que deve estar na parte de fora do container que está descrevendo. O manifesto é normalmente mantido a parte das instâncias de seus dados. Devido ao fato do manifesto ser dado e ser mutável, os próprios dados não precisam carregar a própria descrição.

Você tem os dados, é claro, e uma descrição separada que permite você, ou a um programa, ler, mapear e interpretá-la. Isso pode economizar um bom espeço quando comparado com as abordagens "embutidas", especialmente quando os dados que são mapeados são arrays de estruturas, o que, em essência, acaba sendo o caso na maioria das vezes.

Pense em um manifesto como um roteiro, ou uma Pedra de Roseta. Ele ajuda você, ou um programa, a compreender o que de outra forma seriam incompreensíveis zeros e uns.

Aliás, o próprio manifesto é muitas vezes escrito em uma linguagem ou estilo de notação diferente da informação que ele mapeia. Assim como as convenções utilizadas pelo estilo "markup", esses mapas podem ser escritos utilizando padrões e convenções diferentes do que o conteúdo que ele descreve. A vantagem é que permite que parsers de dados existentes possam trabalhar sem modificação quando os layouts dos dados são alterados. A desvantagem é que os manifestos podem se tornar obsoletos, necessitando que você encontre o manifesto correto de um determinada carga que ele descreve.

Por fim, os computáveis "Metaobjetos" proveem metadados em tempo de execução: Smalltalk, Java, C#, CLOS, e qualquer outra API de reflexão os proveem. Oh, e o também chamado Document Object Model (DOM), visto nos modernos navegadores. A vantagem é que metaobjetos permitem que programas inspecionem, ou mesmo modifiquem a forma que se comportam on-the-fly. Eles criam uma ponte com uma linha de demarcação entre o código e os dados. As desvantagens: o desempenho e, claro, a verbosidade.

As APIs de reflexão em Java geraram uma onda de invocação dirigida pela reflexão que continua inabalada até hoje. JUnit, talvez o framework orientado a objetos de maior influência construído até hoje, mostrou as facilidades da reflexão em Java utilizando-as para localizar testes e as suítes de teste automaticamente, somente pelo framework, em tempo de execução, on-the-fly.

Plataformas como o Eclipse amarram vários plugins utilizando metadados e reflexão para colar o sistema em tempo de execução, permitindo que novas funcionalidades sejam introduzidas e incorporadas dinamicamente. Frameworks de injeção de dependência, como o Spring, dependem da reflexão para localizar e resolver dependências, ou fazer decisões de "casting" baseadas em descrições dinâmicas. De fato, esse estilo de integração do sistema em tempo de execução, de colar juntos plugins, componentes e classes on-the-fly, é um triunfo da reflexão!

Com o Java 8, a introdução de closures adicionam um vigor renovado a essa renascença dinâmica que a Lei de Moore e o poder da reflexão desencadearam. Essas funcionalidades também mostram o poder de escrever programas em bytecode, outra noção que surgiu a partir de nossa herança reflexiva.

Alguém pode argumentar que os metadados e a reflexão floresceram como as velhas ideias da orientação a objetos, e estão diminuindo em importância. "Meta" venceu! "Objetos" perderam!

Viva la revolucion!

Sumário

  • 1 - Conhecendo a Reflexão
    • 1.1 - Ainda falta alguma coisa na orientação a objetos?
    • 1.2 - Reflexão, muito prazer!
    • 1.3 - O primeiro contato com a API Reflection
    • 1.4 - Usar reflexão tem um preço?
    • 1.5 - Considerações finais
  • 2 - Java Reflection API
    • 2.1 - Obtendo informações sobre as classes
    • 2.2 - Trabalhando com classes
    • 2.3 - Manipulando objetos
    • 2.4 - Procurando métodos e atributos para validação
    • 2.5 - Coisas que podem dar errado
    • 2.6 - Considerações finais
  • 3 - Metadados e Anotações
    • 3.1 - Definição de metadados
    • 3.2 - Criando anotações
    • 3.3 - Lendo anotações em tempo de execução
    • 3.4 - Limitações das anotações
    • 3.5 - Mapeando parâmetros de linha de comando para uma classe
    • 3.6 - Considerações finais
  • 4 - Proxy Dinâmico
    • 4.1 - O que é um proxy?
    • 4.2 - Proxy dinâmico com a API Reflection
    • 4.3 - Gerando a implementação de uma interface
    • 4.4 - Proxy de classes com CGLib
    • 4.5 - Consumindo anotações em proxies
    • 4.6 - Outras formas de interceptar métodos
    • 4.7 - Considerações finais
  • 5 - Testando classes que usam Reflexão
    • 5.1 - Variando estrutura da classe para teste
    • 5.2 - Teste de proxies dinâmicos
    • 5.3 - Testando a configuração de metadados
    • 5.4 - Gerando classes com ClassMock
    • 5.5 - Considerações finais
  • 6 - Práticas no uso de anotações
    • 6.1 - Mais de uma anotação do mesmo tipo
    • 6.2 - Reduzindo a quantidade de configurações
    • 6.3 - Expressões em anotações
    • 6.4 - Associando comportamento a anotação
    • 6.5 - Mapeamento de anotações
    • 6.6 - Considerações finais
  • 7 - Consumindo e processando metadados
    • 7.1 - Componente base para o exemplo
    • 7.2 - Separando a leitura do processamento de metadados
    • 7.3 - Estendendo a leitura de metadados
    • 7.4 - Tornando os metadados extensíveis
    • 7.5 - Camadas de processamento de metadados
    • 7.6 - Considerações finais
  • 8 - Ferramentas: indo além na reflexão
    • 8.1 - Manipulando beans com BeanUtils
    • 8.2 - Interfaces fluentes para reflexão
    • 8.3 - Procurando por classes
    • 8.4 - Inserindo e substituindo anotações com AspectJ
    • 8.5 - Considerações finais
  • 9 - Manipulação de bytecode
    • 9.1 - Entendendo o bytecode
    • 9.2 - Entendendo o ASM
    • 9.3 - Quando o bytecode pode ser alterado?
    • 9.4 - Criando um bean a partir de um mapa
    • 9.5 - Data da última modificação de um objeto
    • 9.6 - Considerações finais
  • 10 - Reflexão no Java 8
    • 10.1 - Acessando nomes de parâmetros
    • 10.2 - Múltiplas anotações
    • 10.3 - Anotações de Tipo
    • 10.4 - Reflexão e expressões lambda
    • 10.5 - Considerações finais
  • 11 - Truques da API de reflexão
    • 11.1 - Quem me chamou?
    • 11.2 - Recuperando tipos genéricos com reflexão
    • 11.3 - Acessando membros privados
    • 11.4 - API Method Handle
    • 11.5 - Considerações finais
  • 12 - Palavras finais

    Dados do produto

    Número de páginas:
    378
    ISBN:
    978-85-66250-50-3
    Data publicação:
    02/2014

    Compartilhe!

    Compartilhe no Facebook Compartilhe no Twitter