java之 ------ JUnit、注解、类加载器

JUnit软件测试技术(工具)

在项目中建立专门用户测试的包结构。

在Junit中，通过@Test注解，可以运行一个方法（鼠标放在选择要运行的方法名上，单击右键，选择Run As，再选择JUnit Test即可）。

这样做的好处就是不用在主代码中添加测试代码，避免了代码的冗余。而且一个测试类，可以测试多项功能，不需要main方法。

一、 Junit注解说明

使用了@Test注解应该满足以下条件：

    1) 必须是无参数的非静态方法。

    2) 添加@Test注解的类，必须拥有一个无参数的公开构造

[java]  view plain copy print ?

1. package junit.test;  
2.   
3. import org.junit.Test;  
4.   
5. import junit.UserDaoImpl;  
6.   
7. public class TestUserDaoImpl {  
8.       
9.     @Test  
10.     public void testFun1(){  
11.         new UserDaoImpl().fun1();  
12.     }  
13.       
14.     @Test  
15.     public void testFun2(){  
16.         new UserDaoImpl().fun2();  
17.     }  
18.       
19.     @Test  
20.     public void testFun3(){  
21.         new UserDaoImpl().fun3();  
22.     }  
23.       
24. }  

二、 JUnit测试示例演示

1、运行完成后，可以在Junit的窗口上看到运行所用的时间和结果信息。

2、被测试程序的运行结果出现在控制台（Console）上。

三、 JUnit中的其它注解

@BeforeClass、@AfterClass、@Before、@After

[java]  view plain copy print ?

1. package junit.test;  
2.   
3. import junit.UserDaoImpl;  
4.   
5. import org.junit.AfterClass;  
6. import org.junit.BeforeClass;  
7. import org.junit.Test;  
8.   
9. public class TestUserDaoImpl2 {  
10.     static UserDaoImpl obj = null;  
11.       
12.       
13.     @Test  
14.     public void testFun1(){  
15.         obj.fun1();  
16.     }  
17.       
18.     @BeforeClass  
19.     public static void init(){  
20.         obj = new UserDaoImpl();  
21.         System.out.println("111111111111");  
22.     }  
23.     @Test  
24.     public void testFun2(){  
25.         obj.fun2();  
26.     }  
27.       
28.     @Test  
29.     public void testFun3(){  
30.         obj.fun3();  
31.     }  
32.       
33.     @AfterClass  
34.     public static void finish(){  
35.         obj = null;  
36.         System.out.println("clearing....");  
37.     }  
38. }  

结果：111111111111
fun1......
8787
fun2......
fun3......
clearing....

注解 ( Annotation )

一、元数据

所谓元数据就是数据的数据。也就是说，元数据是描述数据的。就象数据表中的字段一样，每个字段描述了这个字段下的数据的含义。

       元数据可以用于创建文档，跟踪代码中的依赖性，甚至执行基本编译时检查。许多元数据工具，如XDoclet，将这些功能添加到核心Java语言中，暂时成为Java编程功能的一部分。

        一般来说，元数据的好处分为三类：文档编制、编译器检查和代码分析。代码级文档最常被引用。元数据提供了一种有用的方法来指明方法是否取决于其他方法，它们是否完整，特

定类是否必须引用其他类，等等。

二、 什么是注解 

Java中的注解就是Java源代码的元数据，也就是说注解是用来描述Java源代码的。  基本语法就是：@后面跟注解的名称。 

三、 Java中预定义注解 （Java.lang包当中的三个预定注解）

①Override：标识某一个方法是否正确覆盖了它的父类的方法。

②Deprecated：表示已经不建议使用这个类成员了。  它是一个标记注解。

③SuppressWarnings：用来抑制警告信息。

四、自定义注解

自定义注解的语法很简单，跟定义接口类似，只是在名称前面加上@符号。 

1、 最简单的自定义注解

[java]  view plain copy print ?

1. <span style="font-size:14px;">public @interface MyAnno {  
2. }</span>  

2、 使用这个注解

[java]  view plain copy print ?

1. <span style="font-size:14px;">@MyAnno  
2. public class UserModel{  
3. } </span>  

3、为注解添加成员 

[java]  view plain copy print ?

1. <span style="font-size:14px;">//定义  
2. public @interface MyAnno {  
3.   public String schoolName();  
4. }</span>  

[java]  view plain copy print ?

1. <span style="font-size:14px;">//使用  
2. @MyAnno(schoolName="中华人民共和国")  
3. public class UserModel{  
4. } </span>  

4、设置默认值 

[java]  view plain copy print ?

1. <span style="font-size:14px;">//定义  
2. public @interface MyAnno {  
3.   public String schoolName() default "中华人民共和国";  
4. }</span>  

[java]  view plain copy print ?

1. <span style="font-size:14px;">//使用1  
2. @MyAnno  
3. public class UserModel{  
4. }</span>  

[java]  view plain copy print ?

1. <span style="font-size:14px;">//使用2  
2. @MyAnno(schoolName="Java高手")  
3. public class UserModel{  
4. }</span>  

五、对注解的注解

☆指定目标 Target

在了解如何使用Target 之前，需要认识另一个类，该类被称为ElementType (通过API详细学习) ，它实际上是一个枚举。这个枚举定义了注释类型可应用的不同程序元素。 

[java]  view plain copy print ?

1. <span style="font-size:14px;">@Target({ ElementType.TYPE, ElementType.METHOD}) </span>  

☆设置保持性 Retention

 RetentionPolicy (通过API详细学习)枚举类中定义了3种注解保持性，分别决定了Java 编译器以何种方式处理注解。 

[java]  view plain copy print ?

1. @Retention(RetentionPolicy.SOURCE)   

☆添加公共文档 Documented

在默认的情况下在使用javadoc自动生成文档时，注解将被忽略掉。如果想在文档中也包含注解，必须使用Documented为文档注解。

[java]  view plain copy print ?

1. @Documented   

☆设置继承 Inherited 

在默认的情况下，父类的注解并不会被子类继承。如果要继承，就必须加上Inherited注解。

[java]  view plain copy print ?

1. @Inherited   

[java]  view plain copy print ?

1. package annotation;  
2.   
3. import java.lang.annotation.Documented;  
4. import java.lang.annotation.ElementType;  
5. import java.lang.annotation.Inherited;  
6. import java.lang.annotation.Retention;  
7. import java.lang.annotation.RetentionPolicy;  
8. import java.lang.annotation.Target;  
9.   
10. @Inherited  
11. @Documented  
12. @Retention(RetentionPolicy.RUNTIME)  
13. @Target({ElementType.METHOD , ElementType.TYPE} )  
14. public @interface MyAnno {  
15.     public String schoolName() default "哈哈大学";  
16. }  

六、如何读取注解

 要读取注解的内容，就需要使用反射的技术。   注意：要想使用反射得到注释信息，须用@Retention(RetentionPolicy.RUNTIME)进行注解。

[java]  view plain copy print ?

1. import java.lang.reflect.*;  
2. public class TestMyAnno {  
3.   public static void main(String[] args)throws Exception {  
4.     Class c = Class.forName(“anno.UserModel");  
5.     boolean flag = c.isAnnotationPresent(MyAnno.class);  
6.     System.out.println(flag);  
7.     if(flag){  
8.       MyAnno ma = (MyAnno)c.getAnnotation(MyAnno.class);  
9.       System.out.println("学校名称：=="+ma.schoolName());  
10.       //获取到了这些数据过后，下面就可以开始你的处理了  
11.     }  
12.   }  
13. }  

类加载器

Java虚拟机中可以安装多个类加载器，系统默认三个主要类加载器，每个类负责加载特定位置的类：BootStrap,  ExtClassLoader,  AppClassLoader

类加载器也是Java类，因为其他是java类的类加载器本身也要被类加载器加载，显然必须有第一个类加载器不是java类，这正是BootStrap

Java虚拟机中的所有类装载器采用具有父子关系的树形结构进行组织，在实例化每个类装载器对象时，需要为其指定一个父级类装载器对象或者默认采用系统类装载器为其父级类

加载。

一、类加载器之间的父子关系和管辖范围图

二、类加载器的委托机制（通过API认识ClassLoader类）

当Java虚拟机要加载一个类时，到底派出哪个类加载器去加载呢？

首先当前线程的类加载器去加载线程中的第一个类。如果类A中引用了类B，Java虚拟机将使用加载类A的类装载器来加载类B。

还可以直接调用ClassLoader.loadClass()方法来指定某个类加载器去加载某个类。

每个类加载器加载类时，又先委托给其上级类加载器。当所有祖宗类加载器没有加载到类，回到发起者类加载器，还加载不了，则抛ClassNotFoundException，不是再去找发起者类加

载器的儿子，因为没有getChild方法，即使有，那有多个儿子，找哪一个呢？

对着类加载器的层次结构图和委托加载原理，解释先前将ClassLoaderTest输出成jre/lib/ext目录下的itcast.jar包中后，运行结果为ExtClassLoader的原因。

[java]  view plain copy print ?

1. package loader;  
2.   
3. import org.junit.Test;  
4.   
5. public class Demo {  
6.   
7.     @Test  //查看类加载器  
8.     public void testLoader0() throws Exception {  
9.         Class c = Class.forName("loader.Person");  
10.         ClassLoader loader = c.getClassLoader(); //AppClassLoader--java  
11.         System.out.println(loader);  
12.           
13.         loader = loader.getParent(); //ExtClassLoader --java  
14.         System.out.println(loader);  
15.           
16.         loader = loader.getParent(); //null  BootStrap --C  
17.         System.out.println(loader);  
18.           
19.     }  
20.       
21.     @Test  //类加载器  
22.     public void testLoader1() throws Exception {  
23.         //AppClassLoader只能加载项目当中的类  
24.         Class c = Class.forName("loader.Person");  
25.         Object obj = c.newInstance();  
26.         System.out.println("obj:"+obj);  
27.           
28.         Class c2 = Class.forName("d:/ex/UserModel.class");//这个是项目外的类，所以会报错  
29.         Object obj2 = c2.newInstance();  
30.         System.out.println("obj2:"+obj2);  
31.     }  
32.   
33.     @Test  
34.     public void testLoader2() throws Exception{  
35.         Hello h = new Hello();  
36.         System.out.println(h);  
37.         System.out.println(h.getClass().getClassLoader());  
38.     }  
39.       
40. }  

练习

一、做自己的类加载器

虚拟机的核心是通过类加载器来加载.class文件，然后进行相应的解析执行。那么我们可以自己做类加载器，手动加载需要的.class以进行解析执行，从而扩展虚拟机的功能。

以下内容摘自API文档：应用程序需要实现 ClassLoader 的子类，以扩展 Java 虚拟机动态加载类的方式。

网络类加载器子类必须定义方法 findClass 和 loadClassData，以实现从网络加载类。下载组成该类的字节后，它应该使用方法 defineClass 来创建类实例。

myClassLoader.java

[java]  view plain copy print ?

1. package loader.myClassLoader;  
2.   
3. import java.io.ByteArrayOutputStream;  
4. import java.io.FileInputStream;  
5. import java.io.IOException;  
6. import java.io.InputStream;  
7.   
8. public class MyClassLoader extends ClassLoader{  
9.     public Class findClass(String name) {  
10.         byte[] b=null;  
11.         try {  
12.             b = loadClassData(name);  
13.         } catch (IOException e) {  
14.             e.printStackTrace();  
15.         }  
16.         return defineClass(null, b, 0, b.length);  
17.     }  
18.       
19.     private byte[] loadClassData(String fileName) throws IOException {  
20.         InputStream in = new FileInputStream(fileName);  
21.         byte[] b = new byte[1024];  
22.         ByteArrayOutputStream out = new ByteArrayOutputStream();  
23.         int len=0;  
24.         while((len=in.read(b))!=-1){  
25.             out.write(b,0,len);  
26.         }  
27.         out.close();  
28.         b = out.toByteArray();  
29.         return b;  
30.     }  
31. }  

TestMyClassLoader.java

[java]  view plain copy print ?

1. package loader.myClassLoader;  
2. import java.lang.reflect.Method;  
3. import loader.Hello;  
4. import org.junit.Test;  
5. public class TestMyClassLoader {  
6.     /* 
7.      * 演示用我们自己做的类加载器 来加载项目外面的类，并且可以查看到该类的加载器就是我们自己的 
8.      */  
9.     @Test  
10.     public void testLoader() throws Exception{  
11.         MyClassLoader loader = new MyClassLoader();  
12.         Class clazz = loader.findClass("d:/ex/Hello.class");  
13.         //Class clazz = loader.findClass("d:/ex/UserModel.class");  
14.         Object obj = clazz.newInstance();  
15.         System.out.println(obj);  
16.         System.out.println(obj.getClass().getClassLoader()); //loader.myClassLoader.MyClassLoader  
17.     }//loader.myClassLoader.MyClassLoader@48f0c0d3  
18.       
19.     @Test  
20.     public void testLoader2() throws Exception{  
21.         MyClassLoader loader = new MyClassLoader();  
22.         Class clazz = loader.findClass("E:\\MyEclipse 10\\paragraph2\\bin\\loader\\Hello.class");  
23.         Object obj = clazz.newInstance();  
24.         System.out.println(obj);  
25.         //System.out.println(obj.getClass().getClassLoader());  
26.         Method m = clazz.getMethod("call", null);  
27.         m.invoke(obj, null);  
28.           
29.         System.out.println("-------");  
30.           
31.         Hello h = new Hello();  
32.         System.out.println(h);  
33.         h.call();  
34.           
35.         //既然上面两个对象是一样的，那么能不能相互转换呢？※※不能，因为空间不一样。不同类加载器所加载的类模板(字节码对象)在不同的内存空间  这里会挂掉  
36.         Hello h2 = (Hello)obj;  
37.         System.out.println(h2);  
38.           
39.     }  
40. }  

运行结果：

 

二、作自己的测试工具MyJUnit

（注解与反射共同使用的案例 ）

相关说明：1）JUnit用的是@Test注解，我们用@MyTest注解。

2）JUnit已经嵌入到MyEclipse当中，我们自己的MyJUnit只要能独立运行就可以(不嵌入)，同时这样我们也不方便在MyJUnit中以参数方式接收到被测试类的类名与方法名，只能以键盘输

入的方式接收。

3）JUnit能实现指定单个方法来调用执行，由于不能利用MyEclipse传参，因此我们在MyJUnit程序中遍历所有的方法并通过判断是否声明@MyTest注解来决定是否调用执行该方法。

MyTest.java

[java]  view plain copy print ?

1. package loader.myJunit;  
2.   
3. import java.lang.annotation.ElementType;  
4. import java.lang.annotation.Retention;  
5. import java.lang.annotation.RetentionPolicy;  
6. import java.lang.annotation.Target;  
7.   
8. @Retention(RetentionPolicy.RUNTIME)  
9. @Target(ElementType.METHOD)  
10. public @interface MyTest {  
11. }  

MyTestDemo.java

[java]  view plain copy print ?

1. package loader.myJunit;  
2.   
3. public class MyTestDemo {  
4.     public void aa(){  
5.         System.out.println("AAA");  
6.     }  
7.     @MyTest  
8.     public void bb(){  
9.         System.out.println("BBB");  
10.     }  
11.       
12.     @MyTest  
13.     public void cc(){  
14.         System.out.println("CCC");  
15.     }  
16.       
17. }  

MyJUnit.java

[java]  view plain copy print ?

1. package loader.myJunit;  
2.   
3. import java.lang.reflect.Method;  
4. import java.util.Scanner;  
5.   
6. import loader.myClassLoader.MyClassLoader;  
7.   
8. public class MyJUnit {  
9.   
10.     public static void main(String[] args) throws Exception {  
11.         System.out.println("请输入要被测试的类：");  
12.         Scanner sc = new Scanner(System.in);  
13.         String className = sc.nextLine();  
14.           
15. //      Class clazz = Class.forName(className);//必须是完整类名(带包名)  
16. //      Object obj = clazz.newInstance();  
17.         MyClassLoader loader = new MyClassLoader();  
18.         Class clazz = loader.findClass(className);  
19.         Object obj = clazz.newInstance();  
20.           
21.         Method ms[] = clazz.getDeclaredMethods();  
22.         for(Method m: ms){  
23.             boolean boo = m.isAnnotationPresent(MyTest.class);  
24.             if(boo){  
25.                 m.invoke(obj, null);  
26.             }  
27.         }  
28.     }  
29. }  

运行结果：