Grundlegende Verwendung und Vorsichtsmaßnahmen für Junit-Einheitentests

Grundlegende Verwendung von Junit-Unit-Tests:
1. Fügen Sie eine Annotation @Test
zur auszuführenden Methode hinzu. 2. Die Annotation meldet einen Fehler und die Lösung ist Strg+1, Junit hinzufügen
3 . Wählen Sie die auszuführende Methode aus. Klicken Sie mit der rechten Maustaste auf die Methode und führen Sie sie aus als --> Junit-Test 🎜>
Hinweise zum Junit-Unit-Testen:
1. Methoden ohne die @Test-Annotation können nicht mit Junit ausgeführt werden
2. Junit kann nur leere Parametermethoden mit dem Modifikator public und dem Rückgabewerttyp void

Anmerkungen im Zusammenhang mit Unit-Tests

@Test: Unit-Test, Sie können eine Methode separat ausführen
@Before: Wird vor dem Unit-Test ausgeführt. @Test kann verwendet werden, um einige Ressourcen abzurufen
@After: Wird nach dem Unit-Test @Test ausgeführt. Kann zur Nutzung einiger Ressourcen verwendet werden
Hinweis: @Before und @After können nicht separat ausgeführt werden, um @Test auszuführen, sie werden automatisch ausgeführt

Nach JDK1.5 bereitgestellte Anmerkungen
@Deprecated: Zeigt an, dass es veraltet ist
@Deprecated: Es kann zum Ändern von Klassen verwendet werden, um veraltete Klassen darzustellen, und es kann auch zum Ändern von Methoden verwendet werden, um veraltete Methoden darzustellen
Veraltete Klassen und Methoden können verwendet werden, dies wird jedoch nicht empfohlen, da sie möglicherweise Mängel aufweisen oder besser sind. Die Methode ersetzt die Anmerkungen

, die nach JDK1.5 bereitgestellt wurden.
@Override: Eine Methode zum Testen, ob Die Methode wird überschrieben.
In JDK1.5 kann @Override nur die Klassenvererbung und das Umschreiben von Klassen erkennen. Methode
In JDK1.6 und höher kann @Override sowohl die Methode zum Umschreiben der Klassenvererbung als auch das Umschreiben der Klassenimplementierungsschnittstelle erkennen Methode

Nach JDK1.5 bereitgestellte Anmerkungen
@SuppressWarnings: Zeigt die Unterdrückung von Warnungen an (Anzeige von Warnungen nicht zulassen)
@SuppressWarnings: Bei der Verwendung müssen Sie sich darüber im Klaren sein, welche Warnung Sie möchten zu unterdrücken
@SuppressWarnings (Parameter): Der Parameter ist ein String-Array
Wenn Sie nur einen Parameter schreiben, kann {} ignoriert werden. Wenn mehrere Parameter vorhanden sind, muss {} verwendet werden, um mehrere Parameter durch Kommas zu trennen 🎜> String[] a = {"ac","ds"}
Warnungen, die unterdrückt werden können, sind:
Rohtypen, Typsicherheit ignorieren
deaktiviert, Sicherheitsprüfung ignorieren
unbenutzt, unbenutzt ignorieren
Veraltung ignorieren obsolet
null ignorieren Nullzeiger
seriell ignorieren Seriennummer
alle ignorieren alle
Annotationen Geltungsbereich: kann in der Klassenmethode oder im Code definiert werden
Dieselbe Annotation kann nur einmal verwendet werden am selben Ort


Benutzerdefinierte Annotation: Verwenden Sie das Schlüsselwort @interface
, um die Klasse zu definieren: class
Definieren Sie die Schnittstelle: interface
Definieren Sie die Aufzählung: enum (elimination)
Definieren Sie die Annotation: @interface
Definieren Sie das Format der Annotation:
Modifikator @interface Annotation name {
Annotated Attributes; (kann vorhanden sein oder nicht)
Definieren Sie Annotationen mit Attributen:
Attribute entsprechen Mitgliedsvariablen und Mitgliedsmethoden in Klassen
Definitionsformat von Attributen:
Modifikator-Rückgabewerttyp (Datentyp) Attributname () [Standardattributwert]
Modifikator: festes Format (ähnlich der Schnittstelle ) öffentliche Zusammenfassung Es wird empfohlen, erweiterte Lesezeilen zu schreiben, unabhängig davon, ob sie geschrieben werden sollen oder nicht
Rückgabewerttyp: Basisdatentyp (8 Typen in 4 Kategorien) )String-Typ Klassentyp-Aufzählungsanmerkung Eindimensionales Array des oben genannten Typs
[Standardattributwert]: [] Optionale Attribute können einen Standardwert angeben oder keinen Standardwert angeben
int a; int a = 10 ;




Definieren eine Annotation mit Attributen

Diese Annotation hat nur ein Attribut mit dem Namen value

 1 public @interface MyAnnotation02 { 2     //基本数据类型(4类8种) 3     public abstract int a() default 10; 4     //String类型 5     public abstract String s(); 6     //Class类型 7     public abstract Class clazz(); 8     //枚举 9     public abstract Color c();10     //注解11     public abstract MyAnnotation01 myanno01();12     //以上类型的一维数组13     public abstract String[] arr();14 }15 16 enum Color{17     GREEN,18     RED19     /*20      * public static final Color GREEN = new Color();21      * public static final Color RED = new Color();22      */23 }

Meta-Annotation: Wird zum Ändern benutzerdefinierter Annotationen verwendet. Die vom JDK bereitgestellte Annotation

@Retention wird verwendet, um den Deklarationszeitraum der geänderten Anmerkungen zu bestimmen benutzerdefinierte Annotation

Das Attribut der Retention-Annotation ist eine Aufzählung RetentionPolicy (die Aufzählung hat 3 Attribute SOURCE, CLASS, RUNTIME)
Funktion: Gibt an, wie lange die Annotation des Annotationstyps aufbewahrt werden soll
Falls vorhanden Keine Aufbewahrungsanmerkung in der Annotationstypdeklaration, die Aufbewahrungsrichtlinie ist standardmäßig RetentionPolicy.CLASS
RetentionPolicy.SOURCE. Geänderte Annotationen können nur im Quellcode vorhanden sein, Bytecode-Klassen nicht. Zweck: Wird dem Compiler bereitgestellt.
RetentionPolicy.CLASS geänderte Annotationen können nur im Quellcode und Bytecode vorhanden sein, nicht im Laufzeitspeicher. Zweck: Die virtuelle JVM-Java-Maschine verwendet
RetentionPolicy.RUNTIME. Die geänderte Annotation ist im Quellcode, Bytecode und im Speicher (Laufzeit) vorhanden. Zweck: XML-Konfiguration ersetzen
@Target wird verwendet, um den Verwendungsort der geänderten benutzerdefinierten Annotation zu bestimmen
Das Attribut der Target-Annotation ist ein Aufzählungselementtyp (häufig verwendete Attribute TYPE, CONSTRUCTOR ...)
Funktion: Gibt die Art des Programmelements an, für das der Anmerkungstyp gilt.
Wenn in der Annotationstypdeklaration keine Target-Meta-Annotation vorhanden ist, kann der deklarierte Typ für jedes Programmelement verwendet werden.
ElementType.TYPE geänderte Klasse, Schnittstelle
ElementType.CONSTRUCTOR geänderte Struktur
ElementType.METHOD geänderte Methode
ElementType.FIELD geändertes Feld

使用自定义注解:
 格式:@自定义注解的名字(属性名= 属性值 ,属性名=属性值)
 注意:
 1.自定义注解没有属性,可以直接使用-->@自定义注解的名字
 2.自定义注解有属性 使用的时候 必须使用键值对的方式 给所有属性赋值 才能使用 有默认值的属性可以不用赋值
 3.如果注释的属性是一个数组 赋值的时候只有一个值可以省略{} 赋值多个必须写出{}
 4.注解的使用范围  可以用来修饰类 方法 构造方法 变量
 5.使用自定义注解 如果只有一个属性 名字叫value 赋值的时候value可以省略不写
 6.一个对象上(修饰类, 方法,构造方法,变量)注解只能使用一次 不能重复使用

自定义注解的解析:使用自定义注解 获取自定义注解的属性值
 和解析有关的接口:
 java.lang.reflect.AnnotatedElement接口
 所有已知实现类:AccessibleObject Class Constructor Field Method Package
 接口中的方法:
  boolean isAnnotationPresent(Class annotationClass)
  如果指定类型的注释存在于此元素上，则返回 true，否则返回 false。
  判断(Constructor, Field, Method...)有没有指定的注解
  参数:注解的class文件对象,可以传递MyAnnotation03.class(String.class,int.class)
  T getAnnotation(Class annotationClass)
  如果存在该元素的指定类型的注释，则返回这些注释，否则返回 null。
  获取(Constructor, Field, Method...)上的注解,参数传递的是哪个注解的class文件对象,就获取哪个注解
  参数:注解的class文件对象,可以传递MyAnnotation03.class


 使用步骤:
  1.定义一个方法,使用自定义注解
  2.使用反射技术获取本类的class文件对象
  3.使用反射技术获取类中所有的方法
  4.遍历包含所有方法的数组,获取每一个方法
  5.使用isAnnotationPresent判断该方法上是否包含传递参数的注解
  6.如果方法上包含注解,使用getAnnotation获取方法上的注解
  7.使用属性的名字,获取属性值

 1 public class UseMyAnnotation02 { 2     //1.定义一个方法,使用自定义注解 3     @MyAnnotation03(value=10) 4     public void method(){ 5          6     } 7      8     @Test 9     public void test(){10         //2.使用反射技术获取本类的class文件对象11         Class clazz = UseMyAnnotation02.class;12         //3.使用反射技术获取类中所有的方法13         Method[] methods = clazz.getMethods();14         //4.遍历包含所有方法的数组,获取每一个方法15         for (Method method : methods) {16             String methodName = method.getName();17             //5.使用isAnnotationPresent判断该方法上是否包含传递参数的注解18             boolean b = method.isAnnotationPresent(MyAnnotation03.class);19             if(b){20                 System.out.println(methodName+":"+b);21                 //6.如果方法上包含注解,使用getAnnotation获取方法上的注解22                 MyAnnotation03 myAnno = method.getAnnotation(MyAnnotation03.class);23                 //7.使用属性的名字,获取属性值24                 int v = myAnno.value();25                 System.out.println(v);26             }27         }28     }29 }

类加载器:把class文件加载到内存中 并生成一个class文件对象

加载器的组成:
Bootstrap ClassLoader 引导(根)类加载器
 也被称为引导类加载器 负责java核心类的加载
 Extension ClassLoader 扩展类加载器
 负责人JRE的扩展目录中的jar包的加载
 在JDK中JRE的lib目录下井ext目录
 AppClassLoader 应用类加载器
  负责在JVM启动时加载来自java命令的class文件 以及classpath环境变量
  所指定的jar包和类路径
  自定义的类型Person; commons-io-2.4.jar
类加载器的继承关系:
AppClassLoader extends ExtClassLoader extends Bootstrap ClassLoader extends ClassLoader
和类加载器有关的方法:
Class类中的方法:
ClassLoader getClassLoader() 返回该类的类加载器。
ClassLoader类中的方法:
ClassLoader getParent() 返回委托的父类加载器。

 1 public class DemoClassLoader { 2     @Test 3     public void show01(){ 4         //获取应用类加载器 5         ClassLoader loader = DemoClassLoader.class.getClassLoader(); 6         System.out.println(loader);//sun.misc.Launcher$AppClassLoader@5fcf29 7          8         loader = loader.getParent(); 9         System.out.println(loader);//sun.misc.Launcher$ExtClassLoader@5fcf2910         11         loader = loader.getParent();12         System.out.println(loader);//根类加载器由c/c++编写,没有相关的类描述,返回null13     }14     15     @Test16     public void app(){17         //获取应用类加载器18         ClassLoader loader = DemoClassLoader.class.getClassLoader();19         System.out.println(loader);//sun.misc.Launcher$AppClassLoader@5fcf2920     }21     22     @Test23     public void ext(){24         //获取扩展类加载器25         /*26          * 扩展包中的类,不支持使用27          * 想使用必须设置访问权限28          * sun/**29          */30         ClassLoader loader = SunEC.class.getClassLoader();31         System.out.println(loader);//sun.misc.Launcher$ExtClassLoader@19b1de32     }33     34     @Test35     public void boot(){36         ClassLoader loader = String.class.getClassLoader();37         System.out.println(loader);//null38     }39 }

JDK动态代理:只能代理接口
 java.util.collections集合的工具类
 Collections集合的工具类的静态方法
 static List unmodifiableList(List list)
 返回指定列表的不可修改视图
 传递一个List集合返回一个被代理的List集合
 unmodifiableList方法就是一个代理方法,代理List集合
 如果调用size get方法 没有对集合进行修改 则允许执行
 如果调用add remove set 对集合进行了修改,则抛出异常不让方法执行
  会抛出UnsupportedOperationException:不支持操作异常

 1 public class Demo01Proxy { 2     @Test 3     public void show(){ 4         List<String> list = new ArrayList<String>(); 5         list.add("a"); 6         list.add("b"); 7          8         //调用Collections中的方法unmodifiableList 9         list = Collections.unmodifiableList(list);10         String s = list.get(0);11         System.out.println(s);12         13         System.out.println(list.size());14         15         //list.add("c");16         //list.remove(0);17     }18 }

创建接口InvocationHandler的实现类
 重写接口中的方法invoke 对集合的方法进行判断
 如果调用size get方法 没有对集合进行修改 则允许执行
 如果调用add remove set 对集合进行了修改 则抛出异常不让方法执行
 Object invoke(Object proxy,Method method,Object[] args)在代理实例上处理方法调用并返回结果
 参数:
  Object proxy:内部会使用反射创建一个代理人对象,和我们无关
Method method:内部会使用反射获取到执行List集合的方法(size,get,....)
  Object[] args:内部会使用反射获取到调用集合方法的参数
  返回值:
  Object:调用List集合的方法的返回值

  注意事项:
  代理的是List集合,必须把被代理的集合传递到实现类中,为了保证代理的始终是同一个List集合
  在成员位置创建一个List集合
  使用带参数构造给集合赋值

 1 public class InvocationHandlerImpl implements InvocationHandler{ 2     private List<String> list;   
 public InvocationHandlerImpl(List<String> list) { 5         
 this.list = list; 6     } 7  8     @Override 9     
 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {10         
 //获取方法的名字11         String mehtodName = method.getName();12         
 //对方法的名字进行判断,如果是add,remove,set就抛出异常13         
 if("add".equals(mehtodName)){14             throw new UnsupportedOperationException("add no run");15         }   
 if("remove".equals(mehtodName)){18             throw new UnsupportedOperationException("remove no run");19         }     
 if("set".equals(mehtodName)){22             throw new UnsupportedOperationException("set no run");23         }        
 //如果是size,get执行方法25         Object obj = method.invoke(list, args);26         return obj;27     }
 }

 1 /* 2  * 动态代理综合案例: 3  * 需求: 4  *     模拟Collections.unmodifiableList(list); 5  *         传递List,返回List 6  *         调用List方法的时候,通过我的代理类中的方法 invoke, 7  *         如果调用size,get方法,没有对集合进行修改,则允许执行 8  *         如果调用add,remove,set,对集合进行了修改,则抛出异常不让方法执行 9  *             会抛出UnsupportedOperationException:不支持操作异常10  * 实现步骤:11  *     1.模拟unmodifiableList方法,定义一个代理的方法proxyList,参数传递List集合,返回被代理后的List集合12  *     2.在proxyList方法内部实现动态代理13  *         java.lang.reflect.Proxy:提供了和动态代理有关的方法14  *         static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) 
15  *             返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序。 
16  *         参数:17  *             ClassLoader loader:传递类加载器,加载类到内存中,创建class文件对象;可以传递本类的类加载器18  *             Class<?>[] interfaces:传递ArrayList实现的接口List/Collection的Class文件对象19  *             InvocationHandler h:创建一个InvocationHandler的实现类,重写接口中的方法invoke,对集合的方法进行判断20  *                 如果调用size,get方法,没有对集合进行修改,则允许执行21  *                 如果调用add,remove,set,对集合进行了修改,则抛出异常不让方法执行22  *         返回值类型:23  *             Object:返回被代理后的List集合24  
*/25 @SuppressWarnings("all")26 public class Demo02Proxy {27     /*28      * 1.模拟unmodifiableList方法,定义一个代理的方法proxyList,参数传递List集合,返回被代理后的List集合29      */30     public static List<String> proxyList(List<String> list){31         //2.在proxyList方法内部实现动态代理,调用Proxy类中的方法newProxyInstance32         List<String> proxyList = (List<String>) Proxy.newProxyInstance(Demo02Proxy.class.getClassLoader(),33                 list.getClass().getInterfaces(), new InvocationHandlerImpl(list));34         return proxyList;35     }   
/*      * 1.模拟unmodifiableList方法,定义一个代理的方法proxyList,参数传递List集合,返回被代理后的List集合39      */40     public static List<String> proxyList02(final List<String> list){41         //2.在proxyList方法内部实现动态代理,调用Proxy类中的方法newProxyInstance42         List<String> proxyList = (List<String>) Proxy.newProxyInstance(Demo02Proxy.class.getClassLoader(),43                 list.getClass().getInterfaces(), new InvocationHandler() {44                     @Override45                     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {46                         
//获取方法的名字47                         
String mehtodName = method.getName();48                         //对方法的名字进行判断,如果是add,remove,set就抛出异常49                         if("add".equals(mehtodName)){50                             throw new UnsupportedOperationException("add no run");51                         }52                         53                         if("remove".equals(mehtodName)){54                             throw new UnsupportedOperationException("remove no run");55                         
}   
if("set".equals(mehtodName)){58                             throw new UnsupportedOperationException("set no run");59                         }60                         //如果是size,get执行方法61                         Object obj = method.invoke(list, args);62                         return obj;63                     }64                 });65         return proxyList;66     }67     68     @Test69     public void test(){70         List<String> list = new ArrayList<String>();71         list.add("a");72         list.add("b");73         //调用代理方法proxyList传递list集合74         
//list = Collections.unmodifiableList(list);75         
list = Demo02Proxy.proxyList(list);76         System.out.println(list.size());77         System.out.println(list.get(0));78         //list.add("c");//UnsupportedOperationException:add no run79         //list.remove(0);//UnsupportedOperationException:remove no run80         list.set(0, "c");//UnsupportedOperationException:set no run81     }82 }

 

Das obige ist der detaillierte Inhalt vonGrundlegende Verwendung und Vorsichtsmaßnahmen für Junit-Einheitentests. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!