java反射详解
本文主要针对java反射进行学习，以java.lang.reflect包中的接口和类进行学习和理解。文章目录以下：java
java反射概念spring
java反射包接口详解数组
java发射包中类详解安全
java反射的应用例子app
一：java反射概念
JAVA反射机制是在运行状态中，对于任意一个类，都可以知道这个类的全部属性和方法；对于任意一个对象，都可以调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
java反射能起到的做用：
- 在运行中分析类的能力，即动态获取类的基本状况；
- 经过反射机制访问java对象的属性，方法，构造方法等；
- 主要是为工具构造者提供的便利机制。jvm
二：java反射包中的接口
1：AnnotatedElement
java.lang.reflect.AnnotatedElement接口是全部程序元素（例如java.lang.Class、java.lang.reflect.Method、java.lang.reflect.Constructor等）的父接口。该接口主要是功能是是获取指定元素上全部类型注解、判断指定元素上是否有指定的注解。下边举例：本文定义一个MyTag注解，而后使用AnnotatedElement接口提供的isAnnotationPresent（Class<? extends Annotation> annotationClass)方法来判断指定方法上是否有该注解。ide
public class Person {
private String name;
private Integer age;
private String address;
public Person() {// TODO Auto-generated constructor stubsetName("peter");
}
public Person(String name,Integer age,String address) {
this.address=address;this.age=age;this.name=name;
}
public String getName() {
return name;
}
public void setName(String name) {this.name = name;
}
public Integer getAge() {return age;
}public void setAge(Integer age) {this.age = age;
}public String getAddress() {return address;
}public void setAddress(String address) {this.address = address;
}
@MyTag(name="peter")public void getInfo()
{
System.out.println("I am student!");
}
@Overridepublic String toString() {// TODO Auto-generated method stubreturn "Person:"+name+";"+address+";"+age;
}
}
自定义注解函数
import java.lang.annotation.ElementType;import java.lang.annotation.Retention;import java.lang.annotation.RetentionPolicy;import java.lang.annotation.Target;@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MyTag {
String name() default "test";}
测试端工具
public class AnnotatedElementTest {public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException {// TODO Auto-generated method stubClass<?> person=Class.forName("com.csu.reflect.Person");
boolean result=person.getMethod("getInfo", null).isAnnotationPresent( MyTag.class);
System.out.println(result);
｝
}
运行结果：学习
true
经过上述例子发现，该接口为java反射获取类元素注解信息提供方法，经过该接口能够方便的获取类、方法、变量等上边的注解类型、名称等。
2：InvocationHandler接口
InvocationHandler接口主要为用户建立动态代理，即每个代理都须要实现该接口，它只有一个方法：invoke(Object proxy, Method method, Object[] args)。
proxy：在其上调用方法的代理实例；
method：对应于在代理实例上调用的接口方法的 Method 实例；
args：包含传入代理实例上方法调用的参数值的对象数组，若是接口方法不使用参数，则为 null
下面建立一个动态代理，来讲明该接口的使用过程：
建立日志处理接口及实现
public interface LogInfo { public void recordLog ();public void getLength();
}
public class RealLogInfo implements LogInfo{@Overridepublic void recordLog() {// TODO Auto-generated method stubSystem.out.println("记录系统运行的日志！");
}@Overridepublic void getLength() {// TODO Auto-generated method stubSystem.out.println("获取日志长度！");
}
}
import java.lang.reflect.Method;public class DynamicLogProxy implements InvocationHandler{private Object infoObject;public DynamicLogProxy(Object object) {// TODO Auto-generated constructor stubthis.infoObject=object;
}@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {// TODO Auto-generated method stub//对象方法执行前调用一些方法，如spring的AOPSystem.out.println("Before happen something!");
method.invoke(infoObject, args);
System.out.println("After happen something!");return null;
}
}
测试端：
import java.lang.reflect.InvocationHandler;import java.lang.reflect.Proxy;public class InvocationHandlerDemo {
public static void main(String[] args) {
// TODO Auto-generated method stub
//真实对象
LogInfo realInfo=new RealLogInfo(); InvocationHandler handler=new DynamicLogProxy(realInfo); //经过Proxy的newProxyInstance方法来建立咱们的代理对象
LogInfo info=(LogInfo)Proxy.newProxyInstance(handler.getClass().getClassLoader(), realInfo.getClass().getInterfaces(), handler); System.out.println(info.getClass().getName()); info.recordLog(); info.getLength();}
}
运行结果：
com.sun.proxy.$Proxy0 Before happen something! 记录系统运行的日志！After happen something! --------------------Before happen something! 获取日志长度！ After happen something!
从运行结果中发现：info实例获取的类名称居然是$Proxy0，是的这就是代理的独特之处，在jvm中对代理类进行了统一的命名管理。同时咱们发现，经过代理咱们能够在方法运行先后进行一些特殊逻辑处理，Spring AOP正式使用这种思想。
三：java反射包中的类
AccessibleObject：设置反射过程元素是否经过java安全检查，默认未false，它是类
Field, Method, Constructor, ReflectPermission父类；Array：主要用于动态的建立数字，当反射方法参数是数组时，可使用Array来赋值。
Field：主要获取类中字段信息
Method：主要获取类中方法信息
Constructor：获取类中全部构造器函数信息
Modifier：获取类元素的权限访问标识
经过上述类中方法的调用，经过反射动态的获取类中全部信息，下面经过三个实例来讲明java反射包中类的使用方法。
实例一：获取某个类的全部信息
import java.lang.reflect.Constructor;import java.lang.reflect.Field;import java.lang.reflect.Method;import java.lang.reflect.Modifier;/** *经过反射方法获取类中详细信息 */public class GetClassInfoByReflect {/** * 获取类中全部构造函数 */@SuppressWarnings("rawtypes")public static void getAllConstructors(Class clazz)
{
Constructor[] constructors=clazz.getConstructors();for(Constructor c:constructors)
{
String name=c.getName();
System.out.print(" ");
String modifiers=Modifier.toString(clazz.getModifiers());if(modifiers.length()>0)
System.out.print(modifiers+" ");
System.out.print(name+"(");
Class []paramTypes=c.getParameterTypes();for(int i=0;i<paramTypes.length;i++)
{if(i>0)
System.out.print(", ");
System.out.print(paramTypes[i].getName());
}
System.out.println(");");
}
}/** * 获取类中所用方法 * @param clazz */@SuppressWarnings("rawtypes")public static void getAllMethods(Class clazz)
{
Method[] methods=clazz.getMethods();for(Method m:methods)
{
Class returntype=m.getReturnType();
String name=m.getName();
System.out.print(" ");
String modifiers=Modifier.toString(m.getModifiers());if(modifiers.length()>0)
System.out.print(modifiers+" ");
System.out.print(returntype.getName()+" "+name+"(");
Class [] paramTypes=m.getParameterTypes();for(int i=0;i<paramTypes.length;i++)
{if(i>0)
System.out.print(",");
System.out.print(paramTypes[i].getName());
}
System.out.println(");");
}
}/** * 获取类中全部字段信息 * @param clazz */@SuppressWarnings("rawtypes")public static void getAllFields(Class clazz)
{
Field [] fields=clazz.getDeclaredFields();for(Field f:fields)
{
Class type=f.getType();
String name=f.getName();
System.out.print(" ");
String modifier=Modifier.toString(f.getModifiers());if(modifier.length()>0)
System.out.print(modifier+" ");
System.out.println(type.getName()+" "+name+";");
}
}
}
测试端实例：
public class ReflectTest {public static void main(String[] args) throws ClassNotFoundException {// TODO Auto-generated method stubClass clazz=Class.forName("com.csu.reflect.Person");
System.out.println("构造函数");
GetClassInfoByReflect.getAllConstructors(clazz);
System.out.println("类函数");
GetClassInfoByReflect.getAllMethods(clazz);
System.out.println("成员变量");
GetClassInfoByReflect.getAllFields(clazz);
}
}
运行结果：
构造函数 public com.csu.reflect.Person(); public com.csu.reflect.Person(java.lang.String, java.lang.Integer, java.lang.String); 类函数 public java.lang.String toString(); public java.lang.String getAddress(); public java.lang.String getName(); public void setName(java.lang.String); public java.lang.Integer getAge(); public void getInfo(); public void setAge(java.lang.Integer); public void setAddress(java.lang.String); public final void wait(long,int); public final native void wait(long); public final void wait(); public boolean equals(java.lang.Object); public native int hashCode(); public final native java.lang.Class getClass(); public final native void notify(); public final native void notifyAll(); 成员变量 private java.lang.String name; private java.lang.Integer age; private java.lang.String address;
实例二：使用反射类Array实现全部数组拷贝
public class GenericCopyArray {/** * 通用数组拷贝方法 * @param array * @param length * @return */@SuppressWarnings("rawtypes")public static Object copyArray(Object array,int newlength)
{
Class clazz=array.getClass();if(!clazz.isArray())return null;
Class type=clazz.getComponentType();int length=Array.getLength(array);
Object newArray=Array.newInstance(type, newlength);
System.arraycopy(array, 0, newArray, 0, Math.min(length, newlength));return newArray;
}
}
测试端实例：
import java.util.Arrays;public class Arraytest {public static void main(String[] args) {// TODO Auto-generated method stub/** * GenericCopyArray.copyArray不只能够对象数组，还能够扩展任意类型的数组 */ int[] a={1,2,3};
a=(int[])GenericCopyArray.copyArray(a, 2);
System.out.println(Arrays.toString(a));
Person person1=new Person("zp", 28, "changsha");
Person person2=new Person("wang", 29, "shandong");
Person person3=new Person("liu", 29, "wuhan");
Person [] persons={person1,person2};
Person []personCopy=(Person[])GenericCopyArray.copyArray(persons,2);
System.out.println("拷贝结果："+Arrays.toString(personCopy)); //改变拷贝数字的值 personCopy[0]=person3;
System.out.println("改变拷贝结果"+Arrays.toString(personCopy));
System.out.println("原始结果未发生变化："+Arrays.toString(persons));
}
｝
运行结果：
[1, 2] 拷贝结果：[Person:zp;address;28, Person:wang;address;29] 改变拷贝结果[Person:liu;address;29, Person:wang;address;29] 原始结果未发生变化：[Person:zp;address;28, Person:wang;address;29]
经过运行实例发现：经过这种方式不只可以拷贝对象数组，并且能够扩展为任意类型数组。
实例三：经过Array给反射调用方法赋值
public class Target {public void printValue(String[] values)
{for(String value:values)
{
System.out.println(value);
}
}
}
测试端：
public static void main(String[] args) {// TODO Auto-generated method stub Class<Target> clazz =Target.class; try {
Object object=clazz.newInstance();
Method printValue=clazz.getMethod("printValue", String[].class);
Object array=Array.newInstance(String.class, 2);
Array.set(array, 0, "blue");
Array.set(array, 1, "green");
printValue.invoke(object, array);
} catch (Exception e) {// TODO: handle exceptione.printStackTrace();
}
}
运行结果：
blue green
引用块内容 ［1］java核心技术 卷I
相关文章
- 1. java反射详解
- 2. Java反射详解
- 3. Java 反射详解
- 4. java反射 详解！！！！
- 5. java 反射详解
- 6. 转：java反射详解 java反射详解
- 7. Java反射机制详解
- 更多相关文章...
- • C# 反射（Reflection） - C#教程
- • *.hbm.xml映射文件详解 - Hibernate教程
- • Flink 数据传输及反压详解
- • 为了进字节跳动，我精选了29道Java经典算法题，带详细讲解
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
欢迎关注本站公众号,获取更多信息
相关文章
- 1. java反射详解
- 2. Java反射详解
- 3. Java 反射详解
- 4. java反射 详解！！！！
- 5. java 反射详解
- 6. 转：java反射详解 java反射详解
- 7. Java反射机制详解