反射概述及应用

反射

1、概述

反向探知，在程序运行中动态的获取或操作类中的属性就是反射。

1.1、初探反射：

获取Class对象的四种方式

 Class clazz1 = User.class; 
2 Class<?> clazz2 = Class.forName("com.tledu.pojo.User"); 
3 Class<? extends User> clazz3 = new User().getClass();
 4 Class<?> clazz4 = UserTest.class.getClassLoader().loadClass("com.tledu.p ojo.User");

1.2、获取类的基本信息

1
System.out.println(clazz1.getPackage());//获取的包名
2
System.out.println(Modifier.toString(clazz1.getModifiers()));//获取类的修
饰符
3
System.out.println(clazz1.getSimpleName());//获取的类名
4
System.out.println(clazz1.getClassLoader());//获取的类加载器
5
System.out.println(clazz1.getInterfaces().length);//获取的是这个类实现的接
口
6
System.out.println(clazz1.getAnnotations().length);//获取类的注解
7
System.out.println(clazz1.getName()); //获取全类名

优缺点

优点：

增加程序的灵活性，避免固有逻辑写死到程序中

代码相对简洁，可以提高程序的复用性

缺点：

相比于直接调用反射有比较大的性能销毁

内部暴露和安全隐患

通过反射获取对象为什么性能销毁较大？

1、native //调用底层

2、checkMemberAccess //安全校验

2、反射的属性操作

public static void main(String[] args) throws Exception {
 2 //获取User的Class对象 
3 Class clazz = User.class;
 4 //通过反射的newInstance()方法创建对象
 5 User user = (User) clazz.newInstance();
 67 //getFields()获取本类及父类中的公共的属性
 8 Field[] fields = clazz.getFields(); 
9 for (Field field : fields) { 
10 System.out.println(Modifier.toString(field.getModifiers())+" "+field.ge tName());
 11 } 
1213 System.out.println("‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐");
 14 //getDeclaredFields()获取本类中的所有属性包括私有的 
15 Field[] fields2 = clazz.getDeclaredFields(); 
16 for (Field field : fields2) {
 17 System.out.println(Modifier.toString(field.getModifiers())+" "+field.ge tName()); 18 } 
19 System.out.println("‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐"); 
20 //
 21 Field field = clazz.getDeclaredField("name"); 
22 //对于私有的属性在操作时要开放权限 
23 field.setAccessible(true);
 24 field.set(user, "钱枫"); 
2526 System.out.println(field.get(user)); 
2728 //关于静态属性的赋值 
29 Field field2 = clazz.getDeclaredField("address"); 
30 field2.set(null, "湖南"); 
31 System.out.println(field2.get(null)); 3233 }

3、反射的方法操作

public static void main(String[] args) throws Exception { 
2 Class<User> clazz = User.class; 
3 User user = (User)clazz.newInstance();
//getMethods()获取本类及父类的公共的方法 
6 Method[] methods = clazz.getMethods(); 
7 for (Method method : methods) { 
8 System.out.println(Modifier.toString(method.getModifiers())+" "+method.g etName()); 
9 } 
10 System.out.println("‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐"); 
11 //getDeclaredMethods()获取本类中所有的方法 
12 Method[] methods2 = clazz.getDeclaredMethods(); 
13 for (Method method : methods2) { 
14 System.out.println(Modifier.toString(method.getModifiers())+" "+method.getName()); 
15 } 
16 System.out.println("‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐"); 
1718 //普通方法的调用执行 
19 Method method = clazz.getDeclaredMethod("eat"); 
20 method.setAccessible(true); 
21 method.invoke(user); 
22 System.out.println("‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐"); 
23 //静态方法的调用执行 
24 Method method2 = clazz.getDeclaredMethod("say", String.class); 
25 method2.invoke(null, "上海话"); 2627 }

3、反射的构造器操作

1public static void main(String[] args) throws Exception { 
2 Class<User> clazz = User.class; 
3 User user = (User)clazz.newInstance(); 
4
5 //获取类中的构造器 
6 Constructor<?>[] constructors = clazz.getDeclaredConstructors(); 
7 for (Constructor<?> constructor : constructors) { 
8 System.out.println(constructor.getName()); 
9 } 
10 System.out.println("‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐"); 
11 //构造器的调用 
12 Constructor<User> constructor = clazz.getDeclaredConstructor(String.cla ss,String.class); 
13 User user2 = constructor.newInstance("田源","男")
14System.out.println(user2.getName()+" "+user2.getSex()); 
15
16 }

4、单例破局

1 public class Singleton { 
2 private static Singleton s; 
3 private Singleton() { 
4 if(s != null) { 
5 throw new RuntimeException(); 
6 } 
7 } 
8 public static Singleton getInstance() { 
9 if(s == null) { 
10 s = new Singleton(); 
11 } 
12 return s; 
13 } 
14 } 
1 public static void main(String[] args) throws Exception { 
2 //单例：只能初始化一次，也就是只能创建一个实例 
3 Singleton s1 = Singleton.getInstance(); 
4 Singleton s2 = Singleton.getInstance(); 
5
6 System.out.println(s1); 
7 System.out.println(s2); 
8
9 System.out.println("‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐"); 
10
11 Class<Singleton> clazz = Singleton.class; 
12 Constructor<Singleton> constructor = clazz.getDeclaredConstructor(); 
13 constructor.setAccessible(true); 
14 Singleton s3 = constructor.newInstance(); 
15 Singleton s4 = constructor.newInstance(); 
16 System.out.println(s3); 
17 System.out.println(s4); 1819 }