反射
-
是 Java API，是Java提供的现成的类！
-
是Java提供的动态执行机制，动态加载类，动态创建对象，动态访问属性，动态调用方法！
静态与动态
-
静态：事先约定的规则，执行期间按照固定规则执行。
-
动态：事先没有约定，在执行期间动态确定执行规则。
-
Java中静态执行：编译已经确定执行规则（执行次序），在运行期间按照编译结果顺序执行。
Foo foo = new Foo();
foo.hello();
-
Java中动态执行：运行期间才能确定加载哪些类，创建哪些对象，执行那些方法…
动态加载类
-
语法：Class cls = Class.forName(包名.类名);
-
加载指定的类，并返回一个Class对象，该对象表示的是指定类的相关信息。
动态创建对象
-
语法：Object obj = cls.newInstance();
-
执行cls引用的类信息中的无参数构造器，动态创建对象的实例，如果类没有无参数构造器，则抛出异常。
提示：反射也可以调用有参构造器。
动态获取类的方法信息
-
语法：Method[] methods = cls.getDeclaredMethods();
-
从cls代表的类信息中获取全部的方法信息，返回一个Methd类型的数组。
-
Method对象代表一个方法的信息：返回值类型，修饰符，方法名，参数列表，方法体。
动态执行方法
-
语法：Object obj = Method.invoke(对象, 参数列表);
-
参数1：对象，是指该Method对象代表的方法所属对象。
在对象上执行一个非静态方法，调用方法时必须有对象。
在invoke方法执行时候，必须传递包含当前方法的对象。
-
参数2：参数列表，是指该Method对象代表的方法需要传递的参数，可以为空。
-
obj：为执行Method代表的方法后的返回值。
-
invoke 可以调用私有方法。
案例
package demo;
public class Foo {
public void hello() {
}
public void test111() {
System.out.println("test111()被执行");
}
public void test222() {
System.out.println("test222()被执行");
}
public void demo111(String name, int age) {
System.out.println("demo222()被执行,该方法需要传递参数,参数为:" + name + "," + age);
}
private void demo222() {
System.out.println("demo111()被执行,该方法是私有方法");
}
public int demo333() {
System.out.println("demo333该()被执行,该方法有返回值");
return 1;
}
private String demo444(String name, int age) {
System.out.println("demo444()被执行");
return "name:" + name + ",年龄:" + age;
}
}
-------------------------------------------------------------------------
package demo;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Scanner;
/**
* 动态加载类
*/
public class Demo {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入类名：");
String className = sc.nextLine();
try {
// 动态加载类
Class cls = Class.forName(className);
System.out.println(cls); // class demo.Foo
System.out.println("----------------------------------------");
// 动态创建对象
Object obj = cls.newInstance();
System.out.println(obj); // demo.Foo@28d93b30
System.out.println("----------------------------------------");
// 动态获取类方法的信息
Method[] ary = cls.getDeclaredMethods();
for (Method method : ary) {
System.out.println(method);
/*
* public void demo.Foo.test()
* public void demo.Foo.hello()
* public void demo.Foo.testDemo()
*/
System.out.println("方法名：" + method.getName()); //方法名
System.out.println("返回值类型：" + method.getReturnType()); //返回值类型
if (method.getName().startsWith("test")) {
// 动态执行方法
method.invoke(obj);
}
System.out.println("----------------------------------------");
}
//Class提供了根据方法签名找到指定方法信息的API
String name = "demo"; //方法名
//String.class 表示字符串的类型
//int.class 表示int的类型
Class[] types = { String.class, int.class }; //类型列表
Method method = cls.getDeclaredMethod("demo111", types);
method.invoke(obj, "黄强", 11);
System.out.println("----------------------------------------");
method = cls.getDeclaredMethod("demo222");
//执行私有方法
//打开方法的执行权限！！！违反封装！
method.setAccessible(true);
method.invoke(obj);
System.out.println("----------------------------------------");
method = cls.getDeclaredMethod("demo333");
Object o = method.invoke(obj);
System.out.println("返回值为:" + (Integer) o);
System.out.println("----------------------------------------");
method = cls.getDeclaredMethod("demo444", types);
method.setAccessible(true);
o = method.invoke(obj, "黄强", 22);
System.out.println((String) o);
} catch (ClassNotFoundException e) {
System.out.println("无法找到指定的类异常");
e.printStackTrace();
} catch (InstantiationException e) {
System.out.println("实例化异常");
e.printStackTrace();
} catch (IllegalAccessException e) {
System.out.println("没有访问权限");
e.printStackTrace();
} catch (IllegalArgumentException e) {
System.out.println("非法参数异常");
e.printStackTrace();
} catch (InvocationTargetException e) {
System.out.println("反射异常:当被调用的方法的内部抛出了异常而没有被捕获时,将由此异常接收");
e.printStackTrace();
} catch (NoSuchMethodException e) {
System.out.println("没有找到指定方法异常");
e.printStackTrace();
} catch (SecurityException e) {
System.out.println("安全错误异常");
e.printStackTrace();
}
}
}
反射用途
-
eclipse中解析类的结构使用了反射
-
JUnit识别被测试方法使用了反射
-
JUnit利用反射查找test开头的方法
-
JUnit4利用反射解析@Test查找测试方法
-
-
Spring管理Bean对象，注入Bean属性使用了反射
- 利用反射创建Bean对象实例，利用反射注入Bean的属性
-
注解的解析使用了反射
- 利用反射API支持注解
-
强行执行私有方法、访问私有属性
案例
package demo;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
/*
* RetentionPolicy有3个常量,分别是:
* SOURCE:默认值，表示该注解只存在于源代码,代码编译后该注解自动被擦除
* ClASS:表示该注解可以存在于.class文件中,代码运行后注解也自动被擦除
* RUNTIME:表示该注解可以存在于运行的时候
*/
@Retention(RetentionPolicy.RUNTIME)
public @interface Test {
}
---------------------------------------------------------------
package demo;
public class TestCase {
@Test
public void eat() {
System.out.println("吃饭");
}
@Test
public void drink() {
System.out.println("喝水");
}
public void sleep() {
System.out.println("睡觉");
}
}
---------------------------------------------------------------
package demo;
import java.lang.reflect.Method;
import java.util.Scanner;
/*
* 动态执行一个类中全部以@Test注解标注的方法
*/
public class Demo {
public static void main(String[] args) throws Exception {
Scanner sc = new Scanner(System.in);
System.out.println("请输入类名:");
Class cls = Class.forName(sc.nextLine());
Object obj = cls.newInstance();
Method[] ary = cls.getDeclaredMethods();
for (Method method : ary) {
/*
* 检查一个方法的注解信息
* method.getAnnotation(被检查的注解类型)
* 返回注解类型,如果为空表示没有注解,不为空表示找到了被检查的注解
*/
Test ann = method.getAnnotation(Test.class);
if (ann != null) {
method.invoke(obj);
}
}
}
}
案例
package demo;
import java.io.InputStream;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
public class ApplicationContext {
//用来缓存Spring容器中的Bean对象
private Map<String, Object> beans;
//利用XML配置文件初始化全部的Bean对象
public ApplicationContext(String xml) throws Exception {
beans = new HashMap<String, Object>();
//利用DOM4J读取XML文件
//获取从resouce中读取文件的低级流
InputStream in = getClass().getClassLoader().getResourceAsStream(xml);
SAXReader reader = new SAXReader();
Document doc = reader.read(in);
in.close();
//解析XML文件内容,得到Bean的类名和id
Element root = doc.getRootElement();
List<Element> list = root.elements("bean");
for (Element e : list) {
String id = e.attributeValue("id");
String className = e.attributeValue("class");
//根据类名动态加载类并创建对象
Class cls = Class.forName(className);
Object bean = cls.newInstance();
//将对象和对应的id添加到map缓存中
beans.put(id, bean);
}
}
public Object getBean(String id) {
//根据id在map中获取Bean对象并返回
return beans.get(id);
}
public <T> T getBean(String id, Class<T> cls) {
return (T) beans.get(id);
}
}
-------------------------------------------------------------------------
<?xml version="1.0" encoding="UTF-8"?>
<beans>
<bean id="foo" class="demo.Foo"></bean>
<bean id="date" class="java.util.Date"></bean>
<bean id="testCase" class="demo.TestCase"></bean>
</beans>
-------------------------------------------------------------------------
package demo;
public class Demo {
public static void main(String[] args) throws Exception {
ApplicationContext ctx = new ApplicationContext("spring-context.xml");
Foo foo = (Foo) ctx.getBean("foo");
System.out.println(foo);
foo = ctx.getBean("foo", Foo.class);
}
}
205
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
