Java基础&增强 反射 注解 类加载器

原创 2013年12月03日 19:10:08

         ---------------------- ASP.Net+Android+IOS开发.Net培训、期待与您交流! ----------------------

 1.反射

     Java反射允许动态的发现和绑定类、方法、字段以及所有由语言产生的元素。反射是Java被视为动态语言的关键。

     总的来说,Java 反射机制主要提供了一下功能:

      

      1.在运行时判断任意一个对象所属类

      2.在运行时构造任意一个类的对象

      3.在运行时判断任意一个类所具有的的成员变量和方法

      4.在运行时可以调用任意对象的方法,甚至是 private 的方法

      5.生成动态代理


  Java 反射所需要的类不多,主要有java.lang.Class类和java.lang.reflect包中的Field、Constructor、Method、Array类。


       Class 类:Class类的实例是表示正在运行的 Java应用程序中的类和接口。

       Field 类: 提供有关类或接口的属性的信息,以及对它的动态访问的权限。

       Constructor类: 提供关于类的单个构造方法的信息以及对它的动态访问的权限。

       Method类: 提供关于类或接口上单独某个方法的信息。

       Array类: 提供了动态创建数组和访问数组的静态方法。


下面是使用的列子:

       domain类:

   

public class domain {
	/*
	 * 无参构造函数
	 */
	public domain(){}
	/*
	 * 有参构造函数
	 */
	public domain(String name,int age){
		this.name = name;
		this.age = age;
	}
	
	/*
	 * 公有成员变量 
	 */
	public String name = "老鼠";
	/*
	 * 私有成员变量
	 */
	private int age = 20;
	/*
	 * 私有成员函数
	 */
	private void show(){
		System.out.println("name : " + name + " age : " + age);
	}
	/*
	 * 公有成员函数
	 */
	public int getAge(){
		return this.age;
	}
	/*
	 * 公有静态函数 (无参数,无返回值)
	 */
	public static void sayHello(){
		System.out.println("Hello World");
	}
	/*
	 * 公有静态函数 (有数组类型参数,返回整型值)
	 */
	public static int getLength(String[] strs){
		return strs.length;
	}

}

下面就通过反射来访问domain类的字段或方法

 首先要获得这个类的字节码:

Class<domain> clazz = (Class<domain>) Class.forName("....domain");

先访问公有无参静态方法:

        domain obj = clazz.newInstance(); // 调用默认无参构造函数
        Method staticMethod = clazz.getMethod("sayHello", null);// 公有无参静态方法
        staticMethod.invoke(null, null);

其中clazz.getMethod("sayHello",null)  : 方法名为 sayHello 并且没有参数

         staticMethod.invoke(null,null) ::第一个null表示不需要对象就可以调用 第二个null 表示没有参数

访问公有有参静态方法:
staticMethod = clazz.getMethod("getLength", String[].class); // 公有有参静态方法
        int result = (int) staticMethod.invoke(null, (Object)new String[]{"1","2","3"});
        System.out.println(result);
和上面的差不多, staticMethod.invoke(null,(Object) new String[]{....}) : JDK5.0为了和JDK1.4兼容,因为JDK1.4没有可变参数,所以在这个地方这样写:new String[]{....} 编译器会将数组解开当作多个参数,从而会报 参数个数不对的异常。

访问公有成员方法

Method publicMethod = clazz.getMethod("getAge", null); // 公有成员方法
        int age = (int) publicMethod.invoke(obj, null);
        System.out.println("age : " + age);

这里的 publicMethod.invoke(obj,null); 是表示在obj这个对象上调用该方法

访问私有成员方法:

Method privateMethod = clazz.getDeclaredMethod("show", null); // 私有成员方法
        privateMethod.setAccessible(true);
        privateMethod.invoke(obj, null);

其中getDecclaredMethod 获得所有声明的方法

        setAccessible(true)  设为true则为取消Java的语言访问检查,false则执行Java的语言访问检查


访问共有成员方法:

Constructor constructor = clazz.getConstructor(String.class,int.class); // 公有成员方法
        domain obj2 = (domain) constructor.newInstance("XiaoQiang",12);
        privateMethod.invoke(obj2, null);

访问公有成员变量:

 Field publicField = clazz.getField("name"); // 公有成员变量
        String name = (String) publicField.get(obj2);
        System.out.println("name : " + name);

   publicField,get(obj2); 在指定对象上获取该字段的值

访问私有成员变量:

Field privateField = clazz.getDeclaredField("age"); // 私有成员变量
        privateField.setAccessible(true);
        int age = (int) privateField.get(obj2);
        System.out.println("age : " + age);


2.注解

     注解又是JDK5.0的又一个新特性。

我们都有用过注解:@Override 、@Deprecated、@SuppressWarnings("unchecked") 等

@Override
public String toString(){
   //return something
}
但是注解不仅仅只是这些

首先我们可以定义注解 关键字: @interface :

public @interface OtherAnnotation {
	
	int years();

}


@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD , ElementType.TYPE})
public @interface MyAnnotation {
	
	String name() default "name";
	String value();
	String[] arr();
	OtherAnnotation annotation();

}

@Retention @Target 都是一种元数据,是对注解起作用的注解。

@Retention(RetentionPolicy.RUNTIME) :表示注解作用期间

RetentionPolicy是一个枚举,其中有 : 

       CLASS : 编译器将把注释记录在类文件中,但在运行时 VM 不需要保留注释。

       RUNTIME : 编译器将把注释记录在类文件中,在运行时 VM 将保留注释,因此可以反射性地读取。

       SOURCE :  编译器要丢弃的注释。

@Target({ElementType.METHOD , ElementType.TYPE})  表示注解作用目标

      ElementType 是一个枚举,其中有:

      FIELD : 字段声明

      METHOD : 方法声明

      TYPE : 类、接口(包括注解类型)或枚举声明

下面是使用该注解:

@MyAnnotation(value="哈哈",arr={"1","2"},annotation = @OtherAnnotation(years = 1) )
public class AnnotationTest {

}
在MyAnnotation中定义了一些属性: name,value,arr,annotaion

下面则是对几个属性赋值

value="哈哈"

arr={"1","2"}

annotation = @OtherAnnotation(years = 1)

下面在这个类中获取这些值:

if(AnnotationTest.class.isAnnotationPresent(MyAnnotation.class)){
			 MyAnnotation annotation = (MyAnnotation) AnnotationTest.class.getAnnotation(MyAnnotation.class); // 是不是该类注解
			 System.out.println(annotation.name());  // 获取name属性的值
			 System.out.println(annotation.value());  // 获取value属性的值
			 System.out.println(Arrays.asList(annotation.arr())); // 获取arr属性的值		 	 
			 System.out.println(annotation.annotation().years());  // 获取annotation属性的years属性值
		}



3.类加载器


         虚拟机在执行程序时,需要加载该程序需要的类文件,打个比方,假设程序从MyClass.class开始执行,则执行步骤为:

        1.虚拟机有一个用于加载类文件的机制,(例如从磁盘上读取文件或者请求WEB上的文件;)它用这种机制加载MyClass类文件中的类容。

        2.如果MyClass类用友其他类的类型,这这些类也会被加载。

        3.如果main方法运行需要更多地类,则这些类也会被加载

      

        类加载机制并非只使用一个类加载器,每个Java程序至少拥有3个类加载器

            1.引导类加载器 

            2.扩展类加载器

            3.系统类加载器

           引导类加载器负责加载系统类,它是虚拟机整体的一部分。引导类加载器没有对应的ClassLoader对象,列如:

        

String.class.getClassLoader();
将会返回null

           类加载器有一种父/子关系。除了引导类加载器外,每个加载器都有一个父类加载器,根据规定,每个类加载器会为其父类加载器提供一个机会,以便加载任何给定的类,并且只有在其父类加载器加载失败时,它才会加载给定的类。

          类加载器层次结构图:


                                                  

         

           每个Java程序员都知道,报的命名是为了消除名字冲突。在标准类库中有两个Date类,它们的全名分别是java.util.Date和java.sql.Date。在一个正在执行的程序中,所有类名都包含它们的包名。

           在同一个虚拟机中可以有两个类,它们的类名和包名都是相同的,这是因为类是由它的全名和类加载器决定的。

     编写自己的类加载器:

          首先有一个目标类:

         

public class MyTestTarget{
	public String toString() {
		return "你好啊";
	}	
}
           先让其编译得到MyTestTarget.class文件

        然后编写自己的类加密工具:

   

public class MyClassCompiler {
	
	public static void main(String [] args) throws Exception{
		String fileName = "....MyTestTarget.class"; // 没经过加密的MyTestTarget.class路径
		String outputName = "...MyTestTarget.class"; // 经过加密的MyTestTarget.class路径
		FileInputStream fis = new FileInputStream(fileName);
		FileOutputStream fos = new FileOutputStream(outputName);
		compiler(fis,fos);
		fos.close();
		fis.close();
	}
	
	private static void  compiler(InputStream input, OutputStream output) throws Exception{
		int c;
		while((c = input.read()) != -1){
			output.write(c ^ key);
		}
	}

	public static final int key = 0;
	
}
    该工具中,将读进来的每个字节都与key进行异或运算,这里我是用的key是0。 

    运行该工具,然后将加密后的MyTestTarget.class替代原来的

    这样,其他任何类加载器都无法加载该类了,现在就编写我们自己的类加载器:

   

public class MyClassLoader extends ClassLoader{
	
	protected Class<?> findClass(String name) throws ClassNotFoundException {
		try{
			FileInputStream input = new FileInputStream(name);
			ByteArrayOutputStream output = new ByteArrayOutputStream();
			decompile(input, output);
			input.close();
			byte[] bytes = output.toByteArray();
			return this.defineClass(bytes, 0, bytes.length);
			
		}catch(Exception e){
			e.printStackTrace();
		}
		return super.findClass(name);
	}
	
	public void decompile(InputStream input, OutputStream output)throws Exception{
		int c;
		while((c = input.read()) != -1){
			output.write(c ^ MyClassCompiler.key);
		}
		
	}

}
我的类加载器很简单,就是将读到的每个自己都与key进行异或运算,这里的key也是0。

编写自己的类加载器很简单只要继承ClassLoader这个抽象类,然后覆盖findClass(String name)这个方法就行了。

MyClassLoader classLoader = new MyClassLoader();
Object date = (Object) classLoader.loadClass("...\\MyTestTarget.class").newInstance();  //找到MyTestTarget.class的绝对路径
System.out.println(date);
运行结果: 你好啊


相关文章推荐

Java基础---内省、注解、类加载器 (黑马程序员)

第一讲     内省引出JavaBean 一、内省         1、内省对应的英文单词为IntroSpector,英文意思是检查、视察、体检之意,对于程序即对内部进行检查,了解更多的底层细节。...

Java基础加强二注解、泛型、类加载器、代理类

Java基础加强二  三、注解 1)  内省:主要用于对JavaBean进行操作,JDK中提供了对JavaBean进行操作的一些API,这套API就称为内省 2)  JavaBean:  ...
  • lhy349
  • lhy349
  • 2013年11月12日 14:31
  • 629

黑马程序员 -java基础 类加载器注解内省

---------------------- android培训 、java培训 、期待与您交流! ----------------------   ClassLoader  类加载器 java...
  • hks2012
  • hks2012
  • 2012年06月14日 17:03
  • 213

框架学习前基础加强 泛型高级,注解,反射(泛型&注解)应用案例,IOC,Servlet3.0,动态代理,类加载器

泛型 1. 泛型类 :具有一个或多个类型变量的类,称之为泛型类!   class A { }   2. 在创建泛型类实例时,需要为其类型变量赋值   A a = new A();   * 如果创建实例...

Java基础学习第二十七天——类加载器和反射

类加载器和反射 类加载初始化的时机 类加载器 类加载器的作用 反射 通过反射获取构造方法 反射的各项应用 模板设计模式 装饰设计模式 装饰设计模式在IO流中的广泛应用...

java基础加强(反射、内省、BeanUtils工具类、类加载器、动态代理)

------- android培训、java培训、期待与您交流! ---------- 反射:就是把java类中的各种成分映射成相应的java类。 1.获取类的字节码:     String ...

Java基础进阶_day18_(类加载器,反射,动态代理)

类加载器 反射 动态代理

Java基础 - 类的加载,类加载器,反射,动态代理,模板设计模式,JDK5新特性,枚举(类),JDK1.7新特性

Java基础 - 类的加载,类加载器,反射,动态代理,模板设计模式,JDK5新特性,枚举(类),JDK1.7新特性...

基础加强:类加载器 ---注解 ---动态代理(装饰设计模式)

基础加强 1.类加载器 2.注解 3.动态代理(装饰设计模式) 1.类加载器,作用? 见图1,2  怎么获取类加载器?(重点)      ClassLoader  字节码对象.getCla...

基础加强之内省、注解与类加载器

------- android培训、java培训、期待与您交流! ---------- 内省 注解 类加载器 一、内省 概述: IntroSpector:即内省,是对内部进行检查,了解更多的底层细节...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Java基础&增强 反射 注解 类加载器
举报原因:
原因补充:

(最多只允许输入30个字)