JAVA基础7(代码剖析)

源注解： 
@Target 
@Retention:需要在什么级别保存该注释信息 用于描述注解的生命周期

         SOURCE, CLASS, RUNTIME(可以被反射机制读取)

案例 自定义注解的一个例子

@Target(value={ElementType.METHOD,ElementType.TYPE}) //既可以修饰方法，也可以修饰类
@Retention(RetentionPolicy.RUNTIME) // 可以被反射读取到
public @interface SxtAnnotation01 {
	String studentName() default "";
	int age() default 0;
	int id() default -1;   //String indexOf("abc")  -1 一般表示不存在的情况
	String[] schools() default {"清华大学","北京上学堂"};
}

@Target(value={ElementType.METHOD,ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface SxtAnnotation02 {
	String value();  //如果参数只有一个 默认一般用value
}

@SxtAnnotation01
public class Demo02 {
	@SxtAnnotation01(age=19,studentName="老高",id=1001,
			schools={"北京大学","北京航空航天大学"})
	public void test(){
	}
	@SxtAnnotation02("aaaa")  //@SxtAnnotation02(value="aaaa")  一样的
	public void test2(){
	}
	
}	

案例 读取注解

public class Demo03 {
	public static void main(String[] args) {
		try {
			Class clazz = Class.forName("com.bjsxt.test.annotation.SxtStudent");
			
			//获得类的所有有效注解
			Annotation[] annotations=clazz.getAnnotations();
			for (Annotation a : annotations) {
				System.out.println(a);
			}
			//获得类的指定的注解
			SxtTable st = (SxtTable) clazz.getAnnotation(SxtTable.class);
			System.out.println(st.value());
			
			//获得类的属性的注解
			Field f = clazz.getDeclaredField("studentName");
			SxtField sxtField = f.getAnnotation(SxtField.class);
			System.out.println(sxtField.columnName()+"--"+sxtField.type()+"--"+sxtField.length());
			//根据获得的表名、字段的信息，拼出DDL语句，然后，使用JDBC执行这个SQL，在数据库中生成相关的表	
		} catch (Exception e) {
			e.printStackTrace();
		}	
	}
}


实体类：
@SxtTable("tb_student")
public class SxtStudent {
	
	@SxtField(columnName="id",type="int",length=10)
	private int id;
	@SxtField(columnName="sname",type="varchar",length=10)
	private String studentName;
	@SxtField(columnName="age",type="int",length=3)
	private int age;
	。。。。。
}
两个注解类： 
@Target(value={ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface SxtTable {
	String value();
}

@Target(value={ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface SxtField {
	String columnName();
	String type();
	int length();
}

反射 
获取Clazz的三种方法： 1. Class clazz=Class.forName(path);
                   2.Class strClazz=String.class;
  3.Class strClazz2=path.getClass();


 属性：
Field[] fields = clazz.getFields(); //只能获得public的field
Field[] fields = clazz.getDeclaredFields();//获得所有的field
Field f = clazz.getDeclaredField("uname");


方法：
Method[] methods = clazz.getDeclaredMethods();// 同field一样 如果不加 Declared 则获取公共的
Method m01 = clazz.getDeclaredMethod("getUname", null);
//如果方法有参，则必须传递参数类型对应的class对象
Method m02 = clazz.getDeclaredMethod("setUname", String.class); 


构造方法
//获得构造器信息
Constructor[] constructors = clazz.getDeclaredConstructors(); // 同field一样 如果不加 Declared 则获取公共的
Constructor c = clazz.getDeclaredConstructor(int.class,int.class,String.class);

案例： 通过反射API动态的操作：构造器、方法、属性

public class Demo03 {
	public static void main(String[] args) {
		String path = "com.bjsxt.test.bean.User";
		try {
			Class<User> clazz = (Class<User>) Class.forName(path);
			//通过反射API调用构造方法，构造对象
			User u = clazz.newInstance();	//其实是调用了User的无参构造方法  作为JAVA BEAN  必须有无参的构造方法
			System.out.println(u);
			
			Constructor<User> c = clazz.getDeclaredConstructor(int.class,int.class,String.class);
			User u2 = c.newInstance(1001,18,"高淇二");
			System.out.println(u2.getUname());
			
			//通过反射API调用普通方法
			User u3 = clazz.newInstance();
			Method method = clazz.getDeclaredMethod("setUname", String.class);
			method.invoke(u3, "高淇三");   //u3.setUname("高淇三");
			System.out.println(u3.getUname());
			
			//通过反射API操作属性
			User u4 = clazz.newInstance();
			Field f = clazz.getDeclaredField("uname");
			f.setAccessible(true); //这个属性不需要做安全检查了，可以直接访问，同时也提高了效率
			f.set(u4, "高淇四");		//通过反射直接写属性
			System.out.println(u4.getUname());	//通过反射直接读属性的值
			System.out.println(f.get(u4));
			
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

反射操作泛型：
ParameteriedType: 表示一种参数化的类型 如 Collection <String>
GenericArrayType: 表示一种元素类型是参数化类型或者类型变量的数组类型
TypeVariable:是各种类型变量的公共父接口
WildcardType:代表一种通配符类型表达式  比如 ? extends number ? super Integer

案例：通过反射获取泛型信息

public class Demo04 {
	
	public void test01(Map<String,User> map,List<User> list){
		System.out.println("Demo04.test01()");
	}
	
	public Map<Integer,User> test02(){
		System.out.println("Demo04.test02()");
		return null;
	}
	
	public static void main(String[] args) {
		try {
			
			//获得指定方法参数泛型信息
			Method m = Demo04.class.getMethod("test01", Map.class,List.class);
			Type[] t = m.getGenericParameterTypes();
			for (Type paramType : t) {
				System.out.println("#"+paramType);
				if(paramType instanceof ParameterizedType){
					Type[] genericTypes = ((ParameterizedType) paramType).getActualTypeArguments();
					for (Type genericType : genericTypes) {
						System.out.println("泛型类型："+genericType);
					}
				}
			}
			
			//获得指定方法返回值泛型信息
			Method m2 = Demo04.class.getMethod("test02", null);
			Type returnType = m2.getGenericReturnType();
			if(returnType instanceof ParameterizedType){
					Type[] genericTypes = ((ParameterizedType) returnType).getActualTypeArguments();

					for (Type genericType : genericTypes) {
						System.out.println("返回值，泛型类型："+genericType);
					}
					
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

动态编译：
  通过JAVACompiler动态编译
  
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
int result = compiler.run(null, null, null, "c:/myjava/HelloWorld.java");
System.out.println(result==0?"编译成功":"编译失败");

    第一个参数： 为JAVA 编译器提供参数
第二个参数： 得到JAVA编译器的输出信息
第三个参数： 接受编译器的错误信息
第四个参数： 可变参数(是一个String 数组) 能传入一个或多个JAVA源文件
返回值：0表示编译成功   非0 表示编译失败

案例 动态编译

public class Demo01 {
	public static void main(String[] args) throws Exception {
		
		//通过IO流操作，将字符串存储成一个临时文件(Hi.java)，然后调用动态编译方法！
		String str = "public class Hi {public static void main(String[] args){System.out.println(\"HaHa,sxt!\");}}";
		
		JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
		int result = compiler.run(null, null, null, "c:/myjava/HelloWorld.java");
		System.out.println(result==0?"编译成功":"编译失败");
		
		//通过Runtime调用执行类
//		Runtime run = Runtime.getRuntime();  
//      Process process = run.exec("java -cp  c:/myjava    HelloWorld");  
//		以下内容是为了获取输出
//        InputStream in = process.getInputStream();
//        BufferedReader reader = new BufferedReader(new InputStreamReader(in));
//		String info = "";
//		while((info=reader.readLine())!=null){
//			System.out.println(info);
//		}
		 // 也可以通过反射来跑
		 try {
             URL[] urls = new URL[] {new URL("file:/"+"C:/myjava/")};
             URLClassLoader loader = new URLClassLoader(urls);
             Class c = loader.loadClass("HelloWorld");
             //调用加载类的main方法
             Method m = c.getMethod("main",String[].class);
             m.invoke(null, (Object)new String[]{});
             //由于可变参数是JDK5.0之后才有。
             //m.invoke(null, (Object)new String[]{});会编译成:m.invoke(null,"aa","bb"),就发生了参数个数不匹配的问题。
             //因此，必须要加上(Object)转型，避免这个问题。
             //public static void main(String[] args)
             
         } catch (Exception e) {
             e.printStackTrace();
         }
	}
}

案例： JAVAssist 直接生成  emp.class

public class Demo01 {
	public static void main(String[] args) throws Exception {
		ClassPool pool = ClassPool.getDefault();
		CtClass cc = pool.makeClass("com.bjsxt.bean.Emp");
		
		//创建属性
		CtField f1 = CtField.make("private int empno;", cc);
		CtField f2 = CtField.make("private String ename;", cc);
		cc.addField(f1);
		cc.addField(f2);
		
		//创建方法
		CtMethod m1 = CtMethod.make("public int getEmpno(){return empno;}", cc);
		CtMethod m2 = CtMethod.make("public void setEmpno(int empno){this.empno=empno;}", cc);
		cc.addMethod(m1);
		cc.addMethod(m2);
		
		//添加构造器
		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:/myjava"); //将上面构造好的类写入到c:/myjava中
		System.out.println("生成类，成功！");
	}
}

案例 JAVAssist 常用API

/**
 * 测试javassist的API
 * @author 尚学堂高淇 www.sxt.cn
 *
 */
public class Demo02 {
	/**
	 * 处理类的基本用法
	 * @throws Exception 
	 */
	public static void test01() throws Exception{
		ClassPool pool = ClassPool.getDefault();
		CtClass cc = pool.get("com.bjsxt.test.Emp");
		
		byte[] bytes = cc.toBytecode();
		System.out.println(Arrays.toString(bytes));
		
		System.out.println(cc.getName()); //获取类名
		System.out.println(cc.getSimpleName()); //获取简要类名
		System.out.println(cc.getSuperclass()); //获得父类
		System.out.println(cc.getInterfaces()); //获得接口
		
	}
	
	/**
	 * 测试产生新的方法
	 * @throws Exception 
	 */
	public static void test02() throws Exception{
		ClassPool pool = ClassPool.getDefault();
		CtClass cc = pool.get("com.bjsxt.test.Emp");
		
//		CtMethod m = CtNewMethod.make("public int add(int a,int b){return a+b;}", cc);
		
		CtMethod m = new CtMethod(CtClass.intType,"add",
				new CtClass[]{CtClass.intType,CtClass.intType},cc);
		m.setModifiers(Modifier.PUBLIC);
		m.setBody("{System.out.println(\"www.sxt.cn\");return $1+$2;}");  
		//$1,$2占位符   $0 this对象
		cc.addMethod(m);
		
		//通过反射调用新生成的方法
		Class clazz = cc.toClass();
		Object obj = clazz.newInstance();  //通过调用Emp无参构造器，创建新的Emp对象
		Method method = clazz.getDeclaredMethod("add", int.class,int.class);
		Object result = method.invoke(obj, 200,300);
		System.out.println(result);
	}
	
	/**
	 * 修改已有的方法的信息，修改方法体的内容
	 * @throws Exception
	 */
	public static void test03() throws Exception{
		ClassPool pool = ClassPool.getDefault();
		CtClass cc = pool.get("com.bjsxt.test.Emp");
		
		CtMethod cm = cc.getDeclaredMethod("sayHello",new CtClass[]{CtClass.intType});
		cm.insertBefore("System.out.println($1);System.out.println(\"start!!!\");");
		cm.insertAt(9, "int b=3;System.out.println(\"b=\"+b);");
		cm.insertAfter("System.out.println(\"end!!!\");");
		
		//通过反射调用新生成的方法
		Class clazz = cc.toClass();
		Object obj = clazz.newInstance();  //通过调用Emp无参构造器，创建新的Emp对象
		Method method = clazz.getDeclaredMethod("sayHello", int.class);
		method.invoke(obj, 300);
	}

	/**
	 * 属性的操作
	 * @throws Exception
	 */
	public static void test04() throws Exception{
		ClassPool pool = ClassPool.getDefault();
		CtClass cc = pool.get("com.bjsxt.test.Emp");
		
//		CtField f1 = CtField.make("private int empno;", cc);
		CtField f1 = new CtField(CtClass.intType,"salary",cc);
		f1.setModifiers(Modifier.PRIVATE);
		cc.addField(f1);
		
//		cc.getDeclaredField("ename");   //获取指定的属性
		
		//增加相应的set和get方法
		cc.addMethod(CtNewMethod.getter("getSalary", f1));;
		cc.addMethod(CtNewMethod.getter("setSalary", f1));;
		
	}
	
	/**
	 * 构造方法的操作
	 * @throws Exception
	 */
	public static void test05() throws Exception {
		ClassPool pool = ClassPool.getDefault();
		CtClass cc = pool.get("com.bjsxt.test.Emp");
		
		CtConstructor[] cs = cc.getConstructors();
		for (CtConstructor c : cs) {
			System.out.println(c.getLongName());
		}
	}
	
	
	public static void test06() throws Exception{
		 CtClass cc = ClassPool.getDefault().get("com.bjsxt.test.Emp"); 
		 Object[] all = cc.getAnnotations();
		 Author a = (Author)all[0]; 
		 String name = a.name();
		 int year = a.year();
		 System.out.println("name: " + name + ", year: " + year);

	}
	
	
	public static void main(String[] args) throws Exception {
		test06();
	}
}