Componentes JavaBeans

Tutorial Java Reflection (Reflexo)

A reflexo comumente utilizada pelos programas que necessitam examinar ou modificar o
comportamento em tempo de execuo (real time) de um aplicativo executado na JVM (mquina
virtual Java).
A reflexo um recurso relativamente avanado e deve ser usado apenas por desenvolvedores
que tm uma forte compreenso dos fundamentos da linguagem. Com essa ressalva em mente,
a reflexo uma poderosa tcnica e pode habilitar os aplicativos para executar operaes que
seriam impossveis sem ela.
O conceito de reflexo frequentemente confundido com o conceito de introspeco
(introspection). A seguir esto as definies de cada um deles:
1. Introspeco a capacidade que um programa tem para examinar o tipo e as
propriedades de um objeto em tempo de execuo.

2. Reflexo a capacidade que um programa tem para examinar e modificar a estrutura e

o comportamento de um objeto em tempo de execuo.
A partir das definies, pode concluir que introspeco um subconjunto da reflexo. Algumas
linguagens do suporte introspeco, mas no reflexo, como por exemplo, C++.

Examinar Estrutura
Objeto de tipo
desconhecido

Introspeco

Reflexo
Modificar Estrutura e
Comportamento
O exemplo de introspeco abaixo, mostra como o operador instanceof determina se um objeto
pertence a uma classe particular.
// Com introspection
if(obj instanceof Pessoa){
Pessoa p = (Pessoa)obj;
p.fala();
}

O exemplo de reflexo abaixo, mostra o uso do mtodo Class.forName() que retorna o objeto
associado com uma classe ou interface e cujo nome foi dado (uma string contendo o nome e o
path). O mtodo forName invoca a classe a ser inicializada.
// com reflection
Class<?> c = Class.forName("classpath.and.classname");
Object Pesoa = c.newInstance();
Method m = c.getDeclaredMethod("fala", new
Class<?>[0]);
m.invoke(pessoa);

Em Java, a reflexo mais abrangente do que a introspeco, porque pode-se com ela alterar a
estrutura de um objeto. Existem algumas APIs para mudar os modificadores de acesso de
mtodos e atributos, mas no de estruturas.

Porque usar Java Reflection (Reflexo)?

A reflexo permite:

Examinar um objeto em tempo de execuo

Examinar atributos e mtodo de uma classe em tempo de execuo
Invocar qualquer mtodo de um objeto em tempo de execuo
Alterar acessibilidade do construtor, mtodo e campo etc.

A reflexo tem uso muito comum entre os frameworks. Por exemplo: JUnit usa reflexo para
identificar os mtodos com a anotao (@)Teste para cham-los quando estiver executando
testes unitrios.
Para desenvolvedores WEB usado para definir a sua prpria implementao de interfaces e
classes e colocar nos arquivos de configurao. O uso de reflexo, pode de forma rpida e
dinmica inicializar as classes necessrias para a aplicao.
Por exemplo, o framework Spring usa reflexo para a configurao de beans. Veja como:

<bean id="ID" class="pathName.className">

<property name="atributo" value="valor" />
</bean>
Quando o Spring processa o contexto do elemento < bean >, ele ir usar Class.forName(String)
com argumento de "pathName.className" para instanciar a classe. A partir da, usar
novamente a reflexo para obter os atributos do objeto < property > e atribuir a ele um valor
especificado.
Ele mesmo mecanismo tambm usado para aplicativos web que utilizam servlet. Veja como:
<servlet>
<servlet-name>nomeServlet</servlet-name>
<servlet-class>path.ServletName</servlet-class>
<servlet>

Exemplos de uso do Java Reflection (Reflexo)?

O uso da API Reflection pode ser demonstrado atravs de um pequeno conjunto de exemplos:

Exemplo 1: Obter o nome da classe de um objeto.

public class Reflexao1 {

public static void main(String[] args){
Dummy d = new Dummy();
System.out.println(d.getClass().getName());
}
}
public class Dummy {
public void print() {
System.out.println("abc");
}
}

Exemplo 2: Invocar o mtodo de objeto desconhecido.

public class Reflexao2 {

public static void main(String[] args){
Dummy d = new Dummy();
Method method;
try {
method = d.getClass().getMethod("print", new Class<?>[0]);
method.invoke(d);
} catch (NoSuchMethodException | SecurityException
| IllegalAccessException | IllegalArgumentException
| InvocationTargetException e) {
}
}
}

Exemplo 3: Criar um objeto de instncia de uma classe

public class Reflexao3{

public static void main(String[] args){
//cria uma instncia da "Class"
Class<?> c = null;
try{
c = Class.forName("reflection.Dummy");
} catch(Exception e){
}
//cria uma instncia de "Dummy"
Dummy d = null;
try {
d = (Dummy) c.newInstance();
} catch (InstantiationException | IllegalAccessException e) {
}
d.print();
}
}

Exemplo 4: Criar uma instncia da classe e obter seus construtores

import java.lang.reflect.Constructor;
public class Reflexao4 {
public static void main(String[] args) {
try {
Class cls = Class.forName("java.awt.Panel");
System.out.println("Constructores de Panel =");
/* returna um array Constructor com objetos representando os
construtores da classe */
Constructor c[] = cls.getConstructors();
for (Constructor c1 : c) {
System.out.println(c1);
}
}
catch (ClassNotFoundException | SecurityException e) {
System.out.println("Exception: " + e);
}
}
}

Exemplo 5: Obter interfaces implementadas pela classe e superclasses

public class Reflexao5 {

public static void main(String[] args) {
Class observer = Observer.class;
Class observable = Observable.class;
verifyInterface(observer);
verifyInterface(observable);
}
static void verifyInterface(Class c) {
String name = c.getName();
if (c.isInterface()) {
System.out.println(name + " is an interface.");
} else {
System.out.println(name + " is a class.");
}
}
}

Exemplo 6: Modificar um array usando reflexo

public class Reflexao6 {

public static void main(String[] args) {
int[] intArray = { 1, 2, 3, 4, 5 };
int[] newIntArray = (int[]) changeArraySize(intArray, 10);
print(newIntArray);
String[] atr = { "a", "b", "c", "d", "e" };
String[] str1 = (String[]) changeArraySize(atr, 12);
print(str1);
}
// muda o tamanho do array
public static Object changeArraySize(Object obj, int len) {
Class<?> arr = obj.getClass().getComponentType();
Object newArray = Array.newInstance(arr, len);
//copia o array
int co = Array.getLength(obj);
System.arraycopy(obj, 0, newArray, 0, co);
return newArray;
}
// print
public static void print(Object obj) {
Class<?> c = obj.getClass();
if (!c.isArray()) {
return;
}
System.out.println("\nTamanho do Array: " + Array.getLength(obj));
for (int i = 0; i < Array.getLength(obj); i++) {
System.out.print(Array.get(obj, i) + " ");
}
}
}