java动态性之反射机制reflection

动态语言：程序运行时仍可改变程序结构或变量类型
python/ruby/javascript
JAVA有一定的动态性，称为“准动态语言”（反射机制、字节码操作获得类似动态语言的特性）
反射机制
包名+类名

		String path="Annotation.sxtStudent";//同样的类只会被加载一次，一个类只对应一个class对象
		try {
			Class clazz=Class.forName(path);
			//对象是表示或封装一些数据，一个类被加载后，JVM会创建一个对应该类的class对象，类的整个结构信息放到对应的Class对象中
			//这个class对象像镜子一样，可以看到对应的类的全部信息
			System.out.println(clazz.hashCode());
			
			Class strClazz=String.class;
			Class strClazz2=path.getClass();
			System.out.println(strClazz==strClazz2);//true
			
			Class intClazz=int.class;
			
			int[] arr01=new int[10];
			int[] arr02=new int[30];//均为1维，class对象相同
			System.out.println(arr01.getClass().hashCode());
			System.out.println(arr02.getClass().hashCode());
			
			
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	

常见操作：

/*
 * 应用反射API，获取类的信息（类名、方法、属性、构造器）
 * 
 * */
public class Demo02 {
	public static void main(String[] args) {
		String path="Annotation.sxtStudent";//同样的类只会被加载一次，一个类只对应一个class对象
		try {
			Class clazz=Class.forName(path);
			
			//类名
			System.out.println(clazz.getName());//package+name
			System.out.println(clazz.getSimpleName());//only name
			//获得属性信息
			Field[] field=clazz.getFields();//获得public field
			Field[] fields=clazz.getDeclaredFields();//获得all field
			Field f=clazz.getDeclaredField("id");
			System.out.println(f);
			System.out.println(fields.length);
			
			for(Field temp:fields){
				System.out.println("属性"+temp);
			}
			//获得方法信息
			Method[] methods=clazz.getDeclaredMethods();
			Method m=clazz.getDeclaredMethod("getId", null);
			Method m01=clazz.getDeclaredMethod("setId", int.class);//参数名 参数的class对象
			
			//获得构造器信息
			Constructor[] constructors=clazz.getConstructors();
			Constructor[] constructors01=clazz.getDeclaredConstructors();
			
			for(Constructor temp:constructors){
				System.out.println(temp);
			}
			
			
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

}

/*
 * 通过反射API动态操作：构造器、方法、属性
 * 
 * */
public class Demo03 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		String path="Annotation.sxtStudent";//同样的类只会被加载一次，一个类只对应一个class对象
		try {
			Class<sxtStudent> clazz=(Class<sxtStudent>)Class.forName(path);
			
			//获得反射API调用构造方法构造对象
			sxtStudent student=clazz.newInstance();//调用了sxtStudent的无参构造方法
			Constructor<sxtStudent> c=clazz.getDeclaredConstructor(int.class,String.class,int.class);//调用了sxtStudent的有参构造方法
			sxtStudent student01=c.newInstance(18,"hello",101);
			System.out.println(student01.getAge());
			
			
			//通过反射API调用普通方法
			sxtStudent stu3=clazz.newInstance();
			Method method=clazz.getDeclaredMethod("setId",int.class);
			method.invoke(stu3, 101);
			System.out.println(stu3.getId());
			
			//通过反射API操作属性
			sxtStudent stu4=clazz.newInstance();
			Field f=clazz.getDeclaredField("id");
			f.setAccessible(true);//告诉属性无需做安全检查，可以直接访问
			f.set(stu4, 102);//通过反射直接写属性
			System.out.println(stu4.getId());
			System.out.println(f.get(stu4));//通过反射直接读属性
			
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	

	}

}

反射机制性能问题：
反射会降低程序性能分别为1：30：7
反射操作泛型

反射操作注解

//使用反射处理注解信息，模拟处理注解信息的流程
public class Demo03 {
	public static void main(String[] args) {
		try {
			Class clazz=Class.forName("Annotation.sxtStudent");
			Annotation[] annotation =clazz.getDeclaredAnnotations();//获取类的所有注解
			for(Annotation a:annotation){
				System.out.println(a);
			}
			//获得类指定注解
			SxtTable st=(SxtTable)clazz.getAnnotation(SxtTable.class);
			System.out.println(st.value());
			//获得类的属性注解
			Field sf=clazz.getDeclaredField("studentName");
			sxtField sxtField=sf.getAnnotation(sxtField.class);
			System.out.println(sxtField.columnName()+"--->"+sxtField.type()+"--->"+sxtField.length());
		
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

}

动态编译javaCompiler

动态执行javascript代码
脚本引擎java执行js代码 JDK6.0以后
java脚本api是连通java平台和脚本语言的桥梁

1. 获得脚本引擎对象
2. 通过脚本引擎运行脚本并返回运行结果，这是最核心的接口

注：java可以使用各种不同的实现，从而通用的调用js、groovy、python等脚本 --js使用了Rhino

3. 通过脚本引擎的运行上下文在脚本和java平台间交换数据

//获得脚本引擎对象
		ScriptEngineManager sem = new ScriptEngineManager();
		ScriptEngine engine=sem.getEngineByName("javascript");
		
		//定义变量 会存储到引擎的上下文中
		engine.put("msg", "hello,huanxing test javascript");
		String str= "var user={name:'zhaojr',age:18,school:['tsing','beijing']};";
		str+="print(user.name);";
		
		//执行脚本
		engine.eval(str);
		engine.eval("msg ='java is the best';");//修改
		System.out.println(engine.get("msg"));
		System.out.println("###############");
		
		//定义函数
		engine.eval("function add(a,b){var sum=a+b;return sum;}");
		//取得调用接口
		Invocable jsInvoke=(Invocable) engine;
		//执行脚本中定义方法
		Object result1=jsInvoke.invokeFunction("add", new Object[]{13,20});
		System.out.println(result1);
		
		//导入其他java包，使用其他包中的java类
		String jsCode ="import Package(java.util); var list=Arrays.asList([\"hello\",\"tsinghua\",\"beijing\"]);";
		engine.eval(jsCode);
		
		List<String> list3=(List<String>)engine.get("list");
		for(String temp:list3){
			System.out.println(temp);
		}

动态字节码操作
java动态性实现方式 字节码操作、反射
运行时操作字节码实现功能：动态生成新的类、动态改变类结构
字节码操作优势：比反射开销小，性能高
常见字节码操作类库：

ClassPool pool=ClassPool.getDefault();
		CtClass cc = pool.makeClass("javaAssist.Emp");
		
		//创建属性
		CtField f1 = CtField.make("private int empno;", cc);
		CtField f2 = CtField.make("private String ename;", cc);
		cc.addField(f1);
		cc.addField(f2);
		//创建方法
		CtMethod m=CtMethod.make("public void setEmpno(int empno){this.empno=empno;}", cc);
		cc.addMethod(m);
		//添加构造器
		CtConstructor constructor=new CtConstructor(new CtClass[]{CtClass.intType,pool.get("java.lang.String")}, cc);
		constructor.setBody("{this.empno=empno;this.ename=ename;}");
		cc.addConstructor(constructor);
		
		cc.writeFile("C:/testJava");//将构建好的类写入该目录下
		System.out.println("yes");
		//反编译工具   XJad下载