单元测试
- Junit单元测试框架
- 优点：
- JUnit可以灵活的选择执行哪些测试方法，可以一键执行全部测试方法。
- Junit可以生成全部方法的测试报告。
- 单元测试中的某个方法测试失败了，不会影响其他测试方法的测试。
- JUnit单元测试的实现过程
- 必须导入Junit框架的jar包。（第一次使用，如果联网了，IDEA会帮助生成jar包）
- 定义的测试方法必须是无参数无返回值，且公开的方法。
- 测试方法使用@Test注解标记。
- JUnit测试某个方法，测试全部方法怎么处理？成功的标志是什么
- 测试某个方法直接右键该方法启动测试。
- 测试全部方法，可以选择类或者模块启动。
- 红色失败，绿色通过，黄色代表没有异常，只是和自己的期待值不同
- Junit常用注解(Junit 4.xxxx版本)
- 开始执行的方法:初始化资源。
- 执行完之后的方法:释放资源。
| 注解 | 说明 |
|---|
| @Test | 测试方法 |
| @Before | 用来修饰实例方法，该方法会在每一个测试方法执行之前执行一次。 |
| @After | 用来修饰实例方法，该方法会在每一个测试方法执行之后执行一次。 |
| @BeforeClass | 用来静态修饰方法，该方法会在所有测试方法之前只执行一次。 |
| @AfterClass | 用来静态修饰方法，该方法会在所有测试方法之后只执行一次。 |
- Junit常用注解(Junit 5.xxxx版本)
| 注解 | 说明 |
|---|
| @Test | 测试方法 |
| @BeforeEach | 用来修饰实例方法，该方法会在每一个测试方法执行之前执行一次。 |
| @AfterEach | 用来修饰实例方法，该方法会在每一个测试方法执行之后执行一次。 |
| @BeforeAll | 用来静态修饰方法，该方法会在所有测试方法之前只执行一次。 |
| @AfterAll | 用来静态修饰方法，该方法会在所有测试方法之后只执行一次。 |
public class UserService {
public String loginName(String loginName , String passWord){
if("admin".equals(loginName) && "123456".equals(passWord)){
return "登录成功";
}else {
return "用户名或者密码有问题";
}
}
public void selectNames(){
System.out.println(10/2);
System.out.println("查询全部用户名称成功~~");
}
}
public class TestUserService {
@Before
public void before(){
System.out.println("===before方法执行一次===");
}
@After
public void after(){
System.out.println("===after方法执行一次===");
}
@BeforeClass
public static void beforeClass(){
System.out.println("===beforeClass方法执行一次===");
}
@AfterClass
public static void afterClass(){
System.out.println("===afterClass方法执行一次===");
}
@Test
public void testLoginName(){
UserService userService = new UserService();
String rs = userService.loginName("admin","123456");
Assert.assertEquals("您的登录业务可能出现问题", "登录成功", rs );
}
@Test
public void testSelectNames(){
UserService userService = new UserService();
userService.selectNames();
}
}
反射
获取Class类的对象的三种方式
- 方式一：Class c1 = Class.forName(“全类名”); 从包名开始写 ，写到类名
- 方式二：Class c2 = 类名.class
- 方式三：Class c3 = 对象.getClass();
public class Student {
}
public class Test {
public static void main(String[] args) throws Exception {
Class c = Class.forName("com.itheima.d2_reflect_class.Student");
System.out.println(c);
Class c1 = Student.class;
System.out.println(c1);
Student s = new Student();
Class c2 = s.getClass();
System.out.println(c2);
}
}
反射获取构造器对象
| 方法 | 说明 |
|---|
| Constructor<?>[] getConstructors() | 返回所有构造器对象的数组（只能拿public的） |
| Constructor<?>[] getDeclaredConstructors() | 返回所有构造器对象的数组，存在就能拿到 |
| Constructor getConstructor(Class<?>… parameterTypes) | 返回单个构造器对象（只能拿public的） |
| Constructor getDeclaredConstructor(Class<?>… parameterTypes) | 返回单个构造器对象，存在就能拿到 |
- Constructor类中用于创建对象的方法（反射可以暴利打开private权限，破坏封装性）
| 符号 | 说明 |
|---|
| T newInstance(Object… initargs) | 根据指定的构造器创建对象 |
| public void setAccessible(boolean flag) | 设置为true,表示取消访问检查，进行暴力反射 |
public class Student {
private String name;
private int age;
private Student(){
System.out.println("无参数构造器执行！");
}
public Student(String name, int age) {
System.out.println("有参数构造器执行！");
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
public class TestStudent01 {
@Test
public void getConstructors(){
Class c = Student.class;
Constructor[] constructors = c.getConstructors();
for (Constructor constructor : constructors) {
System.out.println(constructor.getName() + "===>" + constructor.getParameterCount());
}
}
@Test
public void getDeclaredConstructors(){
Class c = Student.class;
Constructor[] constructors = c.getDeclaredConstructors();
for (Constructor constructor : constructors) {
System.out.println(constructor.getName() + "===>" + constructor.getParameterCount());
}
}
@Test
public void getConstructor() throws Exception {
Class c = Student.class;
Constructor cons = c.getConstructor();
System.out.println(cons.getName() + "===>" + cons.getParameterCount());
}
@Test
public void getDeclaredConstructor() throws Exception {
Class c = Student.class;
Constructor cons = c.getDeclaredConstructor();
System.out.println(cons.getName() + "===>" + cons.getParameterCount());
Constructor cons1 = c.getDeclaredConstructor(String.class, int.class);
System.out.println(cons1.getName() + "===>" + cons1.getParameterCount());
}
}
public class TestStudent02 {
@Test
public void getDeclaredConstructor() throws Exception {
Class c = Student.class;
Constructor cons = c.getDeclaredConstructor();
System.out.println(cons.getName() + "===>" + cons.getParameterCount());
cons.setAccessible(true);
Student s = (Student) cons.newInstance();
System.out.println(s);
System.out.println("-------------------");
Constructor cons1 = c.getDeclaredConstructor(String.class, int.class);
System.out.println(cons1.getName() + "===>" + cons1.getParameterCount());
Student s1 = (Student) cons1.newInstance("孙悟空", 1000);
System.out.println(s1);
}
}
反射获取成员变量对象
| 方法 | 说明 |
|---|
| Field[] getFields() | 返回所有成员变量对象的数组（只能拿public的） |
| Field[] getDeclaredFields() | 返回所有成员变量对象的数组，存在就能拿到 |
| Field getField(String name) | 返回单个成员变量对象（只能拿public的） |
| Field getDeclaredField(String name) | 返回单个成员变量对象，存在就能拿到 |
| 符号 | 说明 |
|---|
| void set(Object obj, Object value)： | 赋值 |
| Object get(Object obj) | 获取值。 |
public class Student {
private String name;
private int age;
public static String schoolName;
public static final String COUNTTRY = "中国";
public Student(){
System.out.println("无参数构造器执行！");
}
public Student(String name, int age) {
System.out.println("有参数构造器执行！");
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
public class FieldDemo01 {
@Test
public void getDeclaredFields(){
Class c = Student.class;
Field[] fields = c.getDeclaredFields();
for (Field field : fields) {
System.out.println(field.getName() + "==>" + field.getType());
}
}
@Test
public void getDeclaredField() throws Exception {
Class c = Student.class;
Field f = c.getDeclaredField("age");
System.out.println(f.getName() +"===>" + f.getType());
}
}
public class FieldDemo02 {
@Test
public void setField() throws Exception {
Class c = Student.class;
Field ageF = c.getDeclaredField("age");
ageF.setAccessible(true);
Student s = new Student();
ageF.set(s , 18);
System.out.println(s);
int age = (int) ageF.get(s);
System.out.println(age);
}
}
反射获取方法对象
| 方法 | 说明 |
|---|
| Method[] getMethods() | 返回所有成员方法对象的数组（只能拿public的） |
| Method[] getDeclaredMethods() | 返回所有成员方法对象的数组，存在就能拿到 |
| Method getMethod(String name, Class<?>… parameterTypes) | 返回单个成员方法对象（只能拿public的） |
| Method getDeclaredMethod(String name, Class<?>… parameterTypes) | 返回单个成员方法对象，存在就能拿到 |
| 符号 | 说明 |
|---|
| Object invoke(Object obj, Object… args) | 运行方法 参数一：用obj对象调用该方法 参数二：调用方法的传递的参数（如果没有就不写） 返回值：方法的返回值（如果没有就不写） |
public class Dog {
private String name ;
public Dog(){
}
public Dog(String name) {
this.name = name;
}
public void run(){
System.out.println("狗跑的贼快~~");
}
private void eat(){
System.out.println("狗吃骨头");
}
private String eat(String name){
System.out.println("狗吃" + name);
return "吃的很开心！";
}
public static void inAddr(){
System.out.println("在黑马学习Java!");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
public class MethodDemo01 {
@Test
public void getDeclaredMethods(){
Class c = Dog.class;
Method[] methods = c.getDeclaredMethods();
for (Method method : methods) {
System.out.println(method.getName() +" 返回值类型：" + method.getReturnType() + " 参数个数：" + method.getParameterCount());
}
}
@Test
public void getDeclardMethod() throws Exception {
Class c = Dog.class;
Method m = c.getDeclaredMethod("eat");
Method m2 = c.getDeclaredMethod("eat", String.class);
m.setAccessible(true);
m2.setAccessible(true);
Dog d = new Dog();
Object result = m.invoke(d);
System.out.println(result);
Object result2 = m2.invoke(d, "骨头");
System.out.println(result2);
}
}
反射的作用
- 绕过编译阶段为集合添加数据
- 反射是作用在运行时的技术，此时集合的泛型将不能产生约束了，此时是可以为集合存入其他任意类型的元素的。
- 泛型只是在编译阶段可以约束集合只能操作某种数据类型，在编译成Class文件进入运行阶段的时候，其真实类型都是ArrayList了，泛型相当于被擦除了。
public class ReflectDemo {
public static void main(String[] args) throws Exception {
ArrayList<String> lists1 = new ArrayList<>();
ArrayList<Integer> lists2 = new ArrayList<>();
System.out.println(lists1.getClass());
System.out.println(lists2.getClass());
System.out.println(lists1.getClass() == lists2.getClass());
System.out.println("---------------------------");
ArrayList<Integer> lists3 = new ArrayList<>();
lists3.add(23);
lists3.add(22);
Class c = lists3.getClass();
Method add = c.getDeclaredMethod("add", Object.class);
boolean rs = (boolean) add.invoke(lists3, "黑马");
System.out.println(rs);
System.out.println(lists3);
ArrayList list4 = lists3;
list4.add("白马");
list4.add(false);
System.out.println(lists3);
}
}
public class Teacher {
private String name;
private char sex;
private double salary;
...
}
public class Student {
private String name;
private char sex;
private int age;
private String className;
private String hobby;
...
}
public class MybatisUtil {
public static void save(Object obj){
try (
PrintStream ps = new PrintStream(new FileOutputStream("junit-reflect-annotation-proxy-app/src/data.txt", true));
){
Class c = obj.getClass();
ps.println("================" + c.getSimpleName() + "================");
Field[] fields = c.getDeclaredFields();
for (Field field : fields) {
String name = field.getName();
field.setAccessible(true);
String value = field.get(obj) + "";
ps.println(name + "=" + value);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
public class ReflectDemo {
public static void main(String[] args) throws Exception {
Student s = new Student();
s.setName("猪八戒");
s.setClassName("西天跑路1班");
s.setAge(1000);
s.setHobby("吃，睡");
s.setSex('男');
MybatisUtil.save(s);
Teacher t = new Teacher();
t.setName("波仔");
t.setSex('男');
t.setSalary(6000);
MybatisUtil.save(t);
}
}
注解
- 注解的作用
- 对Java中类、方法、成员变量做标记，然后进行特殊处理。
- 例如：JUnit框架中，标记了注解@Test的方法就可以被当成测试方法执行，而没有标记的就不能当成测试方法执行
自定义注解
public @interface 注解名称 {
public 属性类型 属性名() default 默认值 ;
}
- 特殊属性
- value属性，如果只有一个value属性的情况下，使用value属性的时候可以省略value名称不写!!
- 但是如果有多个属性, 且多个属性没有默认值，那么value名称是不能省略的。
public @interface MyBook {
String name();
String[] authors();
double price();
}
public @interface Book {
String value();
double price() ;
}
@MyBook(name="《精通JavaSE》",authors = {"黑马", "dlei"} , price = 199.5)
@Book(value = "/delete", price = 23.5)
public class AnnotationDemo1 {
@MyBook(name="《精通JavaSE2》",authors = {"黑马", "dlei"} , price = 199.5)
private AnnotationDemo1(){
}
@MyBook(name="《精通JavaSE1》",authors = {"黑马", "dlei"} , price = 199.5)
public static void main(String[] args) {
@MyBook(name="《精通JavaSE2》",authors = {"黑马", "dlei"} , price = 199.5)
int age = 21;
}
}
元注解
@Target({ElementType.METHOD,ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyTest {
}
public class AnnotationDemo2 {
@MyTest
private String name;
@MyTest
public void test(){
}
public static void main(String[] args) {
}
}
注解解析
- 注解的解析就是判断是否存在注解，存在注解就解析出内容。
- 与注解解析相关的接口
- Annotation: 注解的顶级接口，注解都是Annotation类型的对象
- AnnotatedElement:该接口定义了与注解解析相关的解析方法
| 方法 | 说明 |
|---|
| Annotation[] getDeclaredAnnotations() | 获得当前对象上使用的所有注解，返回注解数组。 |
| T getDeclaredAnnotation(Class annotationClass) | 根据注解类型获得对应注解对象 |
| boolean isAnnotationPresent(Class annotationClass) | 判断当前对象是否使用了指定的注解，如果使用了则返回true，否则false |
- 案例
- 定义注解Bookk，要求如下：
- 包含属性：String value() 书名
- 包含属性：double price() 价格，默认值为 100
- 包含属性：String[] authors() 多位作者
- 限制注解使用的位置：类和成员方法上
- 指定注解的有效范围：RUNTIME
- 定义BookStore类，在类和成员方法上使用Bookk注解
- 定义AnnotationDemo03测试类获取Bookk注解上的数据
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Bookk {
String value();
double price() default 100;
String[] author();
}
public class AnnotationDemo3 {
@Test
public void parseClass(){
Class c = BookStore.class;
if(c.isAnnotationPresent(Bookk.class)){
Bookk book = (Bookk) c.getDeclaredAnnotation(Bookk.class);
System.out.println(book.value());
System.out.println(book.price());
System.out.println(Arrays.toString(book.author()));
}
}
@Test
public void parseMethod() throws NoSuchMethodException {
Class c = BookStore.class;
Method m = c.getDeclaredMethod("test");
if(m.isAnnotationPresent(Bookk.class)){
Bookk book = (Bookk) m.getDeclaredAnnotation(Bookk.class);
System.out.println(book.value());
System.out.println(book.price());
System.out.println(Arrays.toString(book.author()));
}
}
}
@Bookk(value = "《情深深雨濛濛》", price = 99.9, author = {"琼瑶", "dlei"})
class BookStore{
@Bookk(value = "《三少爷的剑》", price = 399.9, author = {"古龙", "熊耀华"})
public void test(){
}
}
- 应用场景：模拟Junit框架
- 需求：定义若干个方法，只要加了MyTest注解，就可以在启动时被触发执行
public class AnnotationDemo4 {
public void test1(){
System.out.println("===test1===");
}
@MyTest
public void test2(){
System.out.println("===test2===");
}
@MyTest
public void test3(){
System.out.println("===test3===");
}
public static void main(String[] args) throws Exception {
AnnotationDemo4 t = new AnnotationDemo4();
Class c = AnnotationDemo4.class;
Method[] methods = c.getDeclaredMethods();
for (Method method : methods) {
if(method.isAnnotationPresent(MyTest.class)){
method.invoke(t);
}
}
}
}
动态代理
- 模拟某企业用户管理业务，需包含用户登录，用户删除，用户查询功能，并要统计每个功能的耗时
- 定义一个UserService表示用户业务接口，规定必须完成用户登录，用户删除，用户查询功能。
- 定义一个实现类UserServiceImpl实现UserService，并完成相关功能，且统计每个功能的耗时。
- 定义测试类，创建实现类对象，调用方法。
public interface UserService {
String login(String loginName , String passWord) ;
void selectUsers();
boolean deleteUsers();
void updateUsers();
}
public class UserServiceImpl implements UserService{
@Override
public String login(String loginName, String passWord) {
try {
Thread.sleep(1000);
} catch (Exception e) {
e.printStackTrace();
}
if("admin".equals(loginName) && "1234".equals(passWord)) {
return "success";
}
return "登录名和密码可能有毛病";
}
@Override
public void selectUsers() {
System.out.println("查询了100个用户数据！");
try {
Thread.sleep(2000);
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public boolean deleteUsers() {
try {
System.out.println("删除100个用户数据！");
Thread.sleep(500);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
@Override
public void updateUsers() {
try {
System.out.println("修改100个用户数据！");
Thread.sleep(2500);
} catch (Exception e) {
e.printStackTrace();
}
}
}
public class ProxyUtil {
public static <T> T getProxy(T obj) {
return (T)Proxy.newProxyInstance(obj.getClass().getClassLoader(),
obj.getClass().getInterfaces(),
new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
long startTimer = System .currentTimeMillis();
Object result = method.invoke(obj, args);
long endTimer = System.currentTimeMillis();
System.out.println(method.getName() + "方法耗时：" + (endTimer - startTimer) / 1000.0 + "s");
return result;
}
});
}
}
public class Test {
public static void main(String[] args) {
UserService userService = ProxyUtil.getProxy(new UserServiceImpl());
System.out.println(userService.login("admin", "1234"));
System.out.println(userService.deleteUsers());
userService.selectUsers();
userService.updateUsers();
}
}
7万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
