单元测试、反射、注解、动态代理
单元测试
单元测试概述
单元测试
单元测试就是针对最小的功能单元编写测试代码，Java程序最小的功能单元是方法，因此，单元测试就是针对Java方法的测试，进而检查方法的正确性。
目前测试方法是怎么进行的，存在什么问题
- 只有一个main方法，如果一个方法的测试失败了，其他方法测试会受到影响。
- 无法得到测试的结果报告，需要程序员自己去观察测试是否成功。
- 无法实现自动化测试。
JUnit单元测试框架
- JUnit是使用Java语言实现的单元测试框架，它是开源的，Java开发者都应当学习并使用JUnit编写单元测试。
- 此外，几乎所有的IDE工具都集成了JUnit，这样我们就可以直接在IDE中编写并运行JUnit测试，JUnit目前最新版本是5。
JUnit优点
- JUnit可以灵活的选择执行哪些测试方法，可以一键执行全部测试方法。
- Junit可以生成全部方法的测试报告。
- 单元测试中的某个方法测试失败了，不会影响其他测试方法的测试。
- Junit单元测试是做什么的？
测试类中方法的正确性的。 - Junit单元测试的优点是什么？
JUnit可以选择执行哪些测试方法，可以一键执行全部测试方法的测试。
JUnit可以生测试报告，如果测试良好则是绿色；如果测试失败，则是红色。
单元测试中的某个方法测试失败了，不会影响其他测试方法的测试。
单元测试快速入门
单元测试快速入门
需求：使用单元测试进行业务方法预期结果、正确性测试的快速入门
分析：
将JUnit的jar包导入到项目中
IDEA通常整合好了Junit框架，一般不需要导入。
如果IDEA没有整合好，需要自己手工导入如下2个JUnit的jar包到模块
编写测试方法：该测试方法必须是公共的无参数无返回值的非静态方法。
在测试方法上使用@Test注解：标注该方法是一个测试方法
在测试方法中完成被测试方法的预期正确性测试。
选中测试方法，选择“JUnit运行” ，如果测试良好则是绿色；如果测试失败，则是红色
总结
- JUnit单元测试的实现过程是什么样的？
必须导入Junit框架的jar包。
定义的测试方法必须是无参数无返回值，且公开的方法。
测试方法使用@Test注解标记。 - JUnit测试某个方法，测试全部方法怎么处理？成功的标志是什么
测试某个方法直接右键该方法启动测试。
测试全部方法，可以选择类或者模块启动。
红色失败，绿色通过。
###单元测试常用注解
Junit常用注解(Junit 5.xxxx版本)
| 注解 | 说明 |
|---|---|
| @Test | 测试方法 |
| @BeforeEach | 用来修饰实例方法，该方法会在每一个测试方法执行之前执行一次。 |
| @AfterEach | 用来修饰实例方法，该方法会在每一个测试方法执行之后执行一次。 |
| @BeforeAll | 用来静态修饰方法，该方法会在所有测试方法之前只执行一次。 |
| @AfterAll | 用来静态修饰方法，该方法会在所有测试方法之后只执行一次。 |
- 开始执行的方法:初始化资源。
- 执行完之后的方法:释放资源。
Junit常用注解(Junit 4.xxxx版本)
| 注解 | 说明 |
|---|---|
| @Test | 测试方法 |
| @Before | 用来修饰实例方法，该方法会在每一个测试方法执行之前执行一次。 |
| @After | 用来修饰实例方法，该方法会在每一个测试方法执行之后执行一次。 |
| @BeforeClass | 用来静态修饰方法，该方法会在所有测试方法之前只执行一次。 |
| @AfterClass | 用来静态修饰方法，该方法会在所有测试方法之后只执行一次。 |
package com.itheima.d1_junit;
/**
业务方法
*/
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/0);
System.out.println("查询全部用户名称成功~~");
}
}
package com.itheima.d1_junit;
import org.junit.*;
/**
* 测试类
* 是独立出来的
*/
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执行一次");
}
/**
* 测试方法
* 特点：
* 1.必须是公开的，无参数，无返回值的方法
* 2.测试方法必须需使用@Test标记
*/
@Test
public void testLoginName(){
UserService userService=new UserService();
String rs=userService.loginName("admin","123456");
//预计结果正确性测试：断言。
Assert.assertEquals("您的登录业务可能出现bug","登录成功",rs);
}
@Test
public void testSelectNames(){
UserService userService=new UserService();
userService.selectNames();
}
}
反射
反射概述
反射概述
- 反射是指对于任何一个Class类，在"运行的时候"都可以直接得到这个类全部成分。
- 在运行时,可以直接得到这个类的构造器对象：Constructor
- 在运行时,可以直接得到这个类的成员变量对象：Field
- 在运行时,可以直接得到这个类的成员方法对象：Method
- 这种运行时动态获取类信息以及动态调用类中成分的能力称为Java语言的反射机制。
反射的关键
- 反射的第一步都是先得到编译后的Class类对象，然后就可以得到Class的全部成分。
- 反射的基本作用、关键？
反射是在运行时获取类的字节码文件对象：然后可以解析类中的全部成分。
反射的核心思想和关键就是:得到编译以后的class文件对象。
反射获取类对象
package com.itheima.d2_reflect_class;
/**
* 目标：反射的第一步：获取Class对象
*/
public class Test {
public static void main(String[] args) throws ClassNotFoundException {
//1.Class中的一个静态方法：forName(全限名)
Class c=Class.forName("com.itheima.d2_reflect_class.Student");
System.out.println(c);//Student.class
//2.类名。class
Class c1=Student.class;
System.out.println(c1);
//3.对象.getClass（）获取对象的Class对象
Student s=new Student();
Class c2=s.getClass();
}
}
- 反射的第一步是什么？
获取Class类对象，如此才可以解析类的全部成分 - 获取Class类的对象的三种方式
- 方式一：Class c1 = Class.forName(“全类名”);
- 方式二：Class c2 = 类名.class
- 方式三：Class c3 = 对象.getClass();
反射获取构造器对象
使用反射技术获取构造器对象并使用
- 反射的第一步是先得到类对象，然后从类对象中获取类的成分对象。
- Class类中用于获取构造器的方法
| 方法 | 说明 |
|---|---|
| Constructor<?>[] getConstructors() | 返回所有构造器对象的数组（只能拿public的） |
| Constructor<?>[] getDeclaredConstructors() | 返回所有构造器对象的数组，存在就能拿到 |
| Constructor getConstructor(Class<?>… parameterTypes) | 返回单个构造器对象（只能拿public的） |
| Constructor getDeclaredConstructor(Class<?>… parameterTypes) | 返回单个构造器对象，存在就能拿到 |
- 获取构造器的作用依然是初始化一个对象返回。
Constructor类中用于创建对象的方法
| 符号 | 说明 |
|---|---|
| T newInstance(Object… initargs) | 根据指定的构造器创建对象 |
| public void setAccessible(boolean flag) | 设置为true,表示取消访问检查，进行暴力反射 |
-
利用反射技术获取构造器对象的方式
getDeclaredConstructors()
getDeclaredConstructor (Class<?>… parameterTypes) -
反射得到的构造器可以做什么？
-
依然是创建对象的
public newInstance(Object… initargs)
-
如果是非public的构造器，需要打开权限（暴力反射），然后再创建对象
setAccessible(boolean)
反射可以破坏封装性，私有的也可以执行了。
-
package com.itheima.d3_reflect_constructor;
/**
* @author zhao
*/
public class Student {
private String name;
private int age;
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 +
'}';
}
}
package com.itheima.d3_reflect_constructor;
import org.junit.Test;
import java.lang.reflect.Constructor;
/**
目标：反射_获取Constructor构造器对象.
反射的第一步是先得到Class类对象。（Class文件）
反射中Class类型获取构造器提供了很多的API:
1. Constructor getConstructor(Class... parameterTypes)
根据参数匹配获取某个构造器，只能拿public修饰的构造器，几乎不用！
2. Constructor getDeclaredConstructor(Class... parameterTypes)
根据参数匹配获取某个构造器，只要申明就可以定位，不关心权限修饰符，建议使用！
3. Constructor[] getConstructors()
获取所有的构造器，只能拿public修饰的构造器。几乎不用！！太弱了！
4. Constructor[] getDeclaredConstructors()
获取所有申明的构造器，只要你写我就能拿到，无所谓权限。建议使用！！
小结：
获取类的全部构造器对象： Constructor[] getDeclaredConstructors()
-- 获取所有申明的构造器，只要你写我就能拿到，无所谓权限。建议使用！！
获取类的某个构造器对象：Constructor getDeclaredConstructor(Class... parameterTypes)
-- 根据参数匹配获取某个构造器，只要申明就可以定位，不关心权限修饰符，建议使用！
*/
public class TestStudent01 {
// 1. getConstructors:
// 获取全部的构造器：只能获取public修饰的构造器。
// Constructor[] getConstructors() 只能拿public
@Test
public void getConstructors() {
//a.第一步：获取类对象
Class c = Student.class;
//b.提取类中的全部的构造器
Constructor[] constructors = c.getConstructors();
//c.遍历构造器
for (Constructor constructor : constructors) {
System.out.println(constructor.getName() + "==>" + constructor.getParameterCount());//拿参数个数
}
}
// 2.getDeclaredConstructors():
// 获取全部的构造器：只要你敢写，这里就能拿到，无所谓权限是否可及。（私有公开都可以）
@Test
public void getDeclaredConstructors() {
//a.第一步：获取类对象
Class c = Student.class;
//b.提取类中的全部的构造器
Constructor[] constructors = c.getDeclaredConstructors();
//c.遍历构造器
for (Constructor constructor : constructors) {
System.out.println(constructor.getName() + "==>" + constructor.getParameterCount());//拿参数个数
}
}
// 3.getConstructor(Class... parameterTypes)
// 获取某个构造器：只能拿 public修饰 的某个构造器
@Test
public void getConstructor() throws Exception {
//a.第一步：获取类对象
Class c = Student.class;
//b.定位单个构造器对象(按照参数定位无参数构造器)
Constructor cons = c.getConstructor();
//拿参数个数
System.out.println(cons.getName() + "==>" + cons.getParameterCount());
}
// 4.getConstructor(Class... parameterTypes)
// 获取某个构造器：只要你敢写，这里就能拿到，无所谓权限是否可及。
@Test
public void getDeclaredConstructor() throws Exception {
//a.第一步：获取类对象
Class c = Student.class;
//b.定位单个构造器对象(按照参数定位无参数构造器)
Constructor cons = c.getConstructor();
//拿参数个数
System.out.println(cons.getName() + "==>" + cons.getParameterCount());
//c.定位某个有参构造器
Constructor cons1 = c.getConstructor(String.class,int.class);
//拿参数个数
System.out.println(cons1.getName() + "==>" + cons1.getParameterCount());
}
}
package com.itheima.d3_reflect_constructor;
import org.junit.Test;
import java.lang.reflect.Constructor;
/**
目标: 反射_获取Constructor构造器然后通过这个构造器初始化对象。
反射获取Class中的构造器对象Constructor作用：
也是初始化并得到类的一个对象返回。
Constructor的API:
1. T newInstance(Object... initargs)
创建对象，注入构造器需要的数据。
2. void setAccessible(true)
修改访问权限，true代表暴力攻破权限，false表示保留不可访问权限(暴力反射)
小结：
可以通过定位类的构造器对象。
如果构造器对象没有访问权限可以通过：void setAccessible(true)打开权限
构造器可以通过T newInstance(Object... initargs)调用自己，传入参数！
*/
public class TestStudent02 {
// 1.调用构造器得到一个类的对象返回。
@Test
public void getDeclaredConstructor() throws Exception {
// a.第一步：获取类对象
Class c = Student.class;
// b.定位单个构造器对象 (按照参数定位无参数构造器)
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("-------------------");
// c.定位某个有参构造器
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);
}
}
反射获取成员变量对象
使用反射技术获取成员变量对象并使用
- 反射的第一步是先得到类对象，然后从类对象中获取类的成分对象。
- Class类中用于获取成员变量的方法
| 方法 | 说明 |
|---|---|
| Field[] getFields() | 返回所有成员变量对象的数组（只能拿public的） |
| Field[] getDeclaredFields() | 返回所有成员变量对象的数组，存在就能拿到 |
| Field getField(String name) | 返回单个成员变量对象（只能拿public的） |
| Field getDeclaredField(String name) | 返回单个成员变量对象，存在就能拿到 |
- 获取成员变量的作用依然是在某个对象中取值、赋值
Field类中用于取值、赋值的方法
| 符号 | 说明 |
|---|---|
| void set(Object obj, Object value)： | 赋值 |
| Object get(Object obj) | 获取值。 |
- 利用反射技术获取成员变量的方式
获取类中成员变量对象的方法
getDeclaredFields()
getDeclaredField (String name) - 反射得到成员变量可以做什么？
依然是在某个对象中取值和赋值。
void set(Object obj, Object value)：
Object get(Object obj)
如果某成员变量是非public的，需要打开权限（暴力反射），然后再取值、赋值
setAccessible(boolean)
package com.itheima.d4_reflect_field;
/**
* @author zhao
*/
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 +
'}';
}
}
package com.itheima.d4_reflect_field;
import org.junit.Test;
import java.io.File;
import java.lang.reflect.Field;
/**
目标：反射_获取Field成员变量对象。
反射的第一步是先得到Class类对象。
1、Field getField(String name);
根据成员变量名获得对应Field对象，只能获得public修饰
2.Field getDeclaredField(String name);
根据成员变量名获得对应Field对象，只要申明了就可以得到
3.Field[] getFields();
获得所有的成员变量对应的Field对象，只能获得public的
4.Field[] getDeclaredFields();
获得所有的成员变量对应的Field对象，只要申明了就可以得到
小结：
获取全部成员变量：getDeclaredFields
获取某个成员变量：getDeclaredField
*/
public class FieldDemo01 {
/**
* 1.获取全部的成员变量。
* Field[] getDeclaredFields();
* 获得所有的成员变量对应的Field对象，只要申明了就可以得到
*/
@Test
public void getDeclaredFileds(){
//a.定位Class对象
Class c=Student.class;
Field[] fields=c.getDeclaredFields();
//c.遍历
for (Field field : fields) {
System.out.println(field.getName()+"==》"+field.getType());
}
}
/**
2.获取某个成员变量对象 Field getDeclaredField(String name);
*/
@Test
public void getDeclaredFiled() throws NoSuchFieldException {
//a.定位Class对象
Class c=Student.class;
//b.根据名称定位某个成员变量
Field f=c.getDeclaredField("age");
System.out.println(f.getName()+"==》"+f.getType());
}
}
package com.itheima.d4_reflect_field;
import org.junit.Test;
import java.lang.reflect.Field;
/**
目标：反射获取成员变量: 取值和赋值。
Field的方法：给成员变量赋值和取值
void set(Object obj, Object value)：给对象注入某个成员变量数据
Object get(Object obj):获取对象的成员变量的值。
void setAccessible(true);暴力反射，设置为可以直接访问私有类型的属性。
Class getType(); 获取属性的类型，返回Class对象。
String getName(); 获取属性的名称。
*/
public class FieldDemo02 {
@Test
public void setField() throws Exception {
// a.反射第一步，获取类对象
Class c = Student.class;
// b.提取某个成员变量
Field ageF = c.getDeclaredField("age");
ageF.setAccessible(true);//暴力打开权限
//c.赋值
Student s=new Student();
ageF.set(s,18);//s.setAge(18)
System.out.println(s);
//d.取值
int age= (int) ageF.get(s);
System.out.println(age);
}
}
反射获取方法对象
使用反射技术获取方法对象并使用
- 反射的第一步是先得到类对象，然后从类对象中获取类的成分对象。
- Class类中用于获取成员方法的方法
| 方法 | 说明 |
|---|---|
| Method[] getMethods() | 返回所有成员方法对象的数组（只能拿public的） |
| Method[] getDeclaredMethods() | 返回所有成员方法对象的数组，存在就能拿到 |
| Method getMethod(String name, Class<?>… parameterTypes) | 返回单个成员方法对象（只能拿public的） |
| Method getDeclaredMethod(String name, Class<?>… parameterTypes) | 返回单个成员方法对象，存在就能拿到 |
- 获取成员方法的作用依然是在某个对象中进行执行此方法
Method类中用于触发执行的方法
| 符号 | 说明 |
|---|---|
| Object invoke(Object obj, Object… args) | 运行方法参数一：用obj对象调用该方法参数二：调用方法的传递的参数（如果没有就不写）返回值：方法的返回值（如果没有就不写） |
package com.itheima.d5_reflect_method;
/**
* @author zhao
*/
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;
}
}
package com.itheima.d5_reflect_method;
import org.junit.Test;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
/**
目标：反射——获取Method方法对象
反射获取类的Method方法对象：
1、Method getMethod(String name,Class...args);
根据方法名和参数类型获得对应的方法对象，只能获得public的
2、Method getDeclaredMethod(String name,Class...args);
根据方法名和参数类型获得对应的方法对象，包括private的
3、Method[] getMethods();
获得类中的所有成员方法对象，返回数组，只能获得public修饰的且包含父类的
4、Method[] getDeclaredMethods();
获得类中的所有成员方法对象，返回数组,只获得本类申明的方法。
Method的方法执行：
Object invoke(Object obj, Object... args)
参数一：触发的是哪个对象的方法执行。
参数二： args：调用方法时传递的实际参数
*/
public class MethodDemo01 {
/**
* 1.获得类中的所有成员方法对象
*/
@Test
public void getDeclaredMethods() {
// a.获取类对象
Class c = Dog.class;
// b.提取全部方法；包括私有的
Method[] methods = c.getDeclaredMethods();
//c.遍历全部方法
for (Method method : methods) {
System.out.println(method.getName() + "返回值类型" + method.getReturnType() + "参数个数 " + method.getParameterCount());
}
}
/**
* 2. 获取某个方法对象
*/
@Test
public void getDeclaredMethod() throws Exception {
// a.获取类对象
Class c = Dog.class;
// b.提取单个方法；包括私有的
Method method = c.getDeclaredMethod("eat");
Method method2 = c.getDeclaredMethod("eat", String.class);
// 暴力打开权限了
method.setAccessible(true);
method2.setAccessible(true);
// c.触发方法的执行
Dog d = new Dog();
// 注意：方法如果是没有结果回来的，那么返回的是null.
Object rs = method.invoke(d);
System.out.println(rs);
Object rs1 = method2.invoke(d,"骨头");
System.out.println(rs1);
}
}
- 利用反射技术获取成员方法对象的方式
获取类中成员方法对象
getDeclaredMethods()
getDeclaredMethod (String name, Class<?>… parameterTypes) - 反射得到成员方法可以做什么？
依然是在某个对象中触发该方法执行。
Object invoke(Object obj, Object… args)
如果某成员方法是非public的，需要打开权限（暴力反射），然后再触发执行
setAccessible(boolean)
反射的作用-绕过编译阶段为集合添加数据
反射的作用-绕过编译阶段为集合添加数据
- 反射是作用在运行时的技术，此时集合的泛型将不能产生约束了，此时是可以为集合存入其他任意类型的元素的。
ArrayList<Integer> list = new ArrayList<>();
list.add(100);
// list.add(“黑马"); // 报错
list.add(99);
- 泛型只是在编译阶段可以约束集合只能操作某种数据类型，在编译成Class文件进入运行阶段的时候，其真实类型都是ArrayList了，泛型相当于被擦除了。
package com.itheima.d6_reflect_genericity;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
public class ReflectDemo {
public static void main(String[] args) throws Exception {
// 需求：反射实现泛型擦除后，加入其他类型的元素
ArrayList<String> list1=new ArrayList<>();
ArrayList<Integer> list2=new ArrayList<>();
//方式三获取class对象的方法
System.out.println(list1.getClass());
System.out.println(list2.getClass());
System.out.println(list1.getClass()==list2.getClass());//true ArrayList.class
System.out.println("...........................................");
ArrayList<Integer> list3=new ArrayList<>();
list3.add(23);
list3.add(22);
//list2.add("黑马");
Class c=list3.getClass();//ArryList.class==>public boolean add(E e)
//定位c类中的add方法
Method add=c.getDeclaredMethod("add", Object.class);
boolean rs= (boolean) add.invoke(list3,"黑马");
System.out.println(rs);
System.out.println(list3);
ArrayList list4=list3;
list4.add("白马");
list4.add(false);
System.out.println(list3);
}
}
- 反射为何可以给约定了泛型的集合存入其他类型的元素？
编译成Class文件进入运行阶段的时候，泛型会自动擦除。
反射是作用在运行时的技术，此时已经不存在泛型了。
反射的作用-通用框架的底层原理
反射做通用框架
需求：给你任意一个对象，在不清楚对象字段的情况可以，可以把对象的字段名称和对应值存储到文件中去。
需求
给你任意一个对象，在不清楚对象字段的情况可以，可以把对象的字段名称和对应值存储到文件中去。
分析
定义一个方法，可以接收任意类的对象。
每次收到一个对象后，需要解析这个对象的全部成员变量名称。
这个对象可能是任意的，那么怎么样才可以知道这个对象的全部成员变量名称呢？
使用反射获取对象的Class类对象，然后获取全部成员变量信息。
遍历成员变量信息，然后提取本成员变量在对象中的具体值
存入成员变量名称和值到文件中去即可。
package com.itheima.d7_reflect_framework;
/**
* @author zhao
*/
public class Student {
private String name;
private char sex;
private int age;
private String className;
private String hobby;
public Student(){
}
public Student(String name, char sex, int age, String className, String hobby) {
this.name = name;
this.sex = sex;
this.age = age;
this.className = className;
this.hobby = hobby;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getClassName() {
return className;
}
public void setClassName(String className) {
this.className = className;
}
public String getHobby() {
return hobby;
}
public void setHobby(String hobby) {
this.hobby = hobby;
}
}
package com.itheima.d7_reflect_framework;
/**
* @author zhao
*/
public class Teacher {
private String name;
private char sex;
private double salary;
public Teacher(){
}
public Teacher(String name, char sex, double salary) {
this.name = name;
this.sex = sex;
this.salary = salary;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
}
package com.itheima.d7_reflect_framework;
import java.io.FileOutputStream;
import java.io.PrintStream;
import java.lang.reflect.Field;
/**
* @author zhao
*/
public class MybatisUtil {
/**框架
保存任意类型的对象
* @param obj
*/
public static void save(Object obj) {
try (
PrintStream ps=new PrintStream(new FileOutputStream("D:\\code\\javapro\\javamax\\junit_reflect_annotationproxy-app/src/data.txt"),true);
) {
//1.提取全部成员变量，只有反射可以解决
Class c=obj.getClass();//c.getSimpleName()获取当前类名 c.getName获取全限名：包名+类名
ps.println("====================="+c.getSimpleName()+"============================");
//2.提取全部成员变量
Field[]fields=c.getDeclaredFields();
//3.获取成员变量的信息
for (Field field : fields) {
String name=field.getName();
//提取本成员变量在obj对象中的值（取值）.当前的成员变量追着对象
field.setAccessible(true);
String value=field.get(obj)+"";
ps.println(name+"="+value);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
package com.itheima.d7_reflect_framework;
import java.util.Date;
import java.util.Properties;
/**
目标：提供一个通用框架，支持保存所有对象的具体信息。
* @author zhao
*/
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高级框架
基本上主流框架都会基于反射设计一些通用技术功能。
注解
注解概述
注解概述、作用
- Java 注解（Annotation）又称 Java 标注，是 JDK5.0 引入的一种注释机制。
- Java 语言中的类、构造器、方法、成员变量、参数等都可以被注解进行标注。
注解的作用是什么呢？
- 对Java中类、方法、成员变量做标记，然后进行特殊处理，至于到底做何种处理由业务需求来决定。
- 例如：JUnit框架中，标记了注解@Test的方法就可以被当成测试方法执行，而没有标记的就不能当成测试方法执行。
- 注解的作用
对Java中类、方法、成员变量做标记，然后进行特殊处理。
例如：JUnit框架中，标记了注解@Test的方法就可以被当成测试方法执行，而没有标记的就不能当成测试方法执行
自定义注解
自定义注解 — 格式
- 自定义注解就是自己做一个注解来使用。
public @interface 注解名称 {
public 属性类型 属性名() default 默认值 ;
}
特殊属性
- value属性，如果只有一个value属性的情况下，使用value属性的时候可以省略value名称不写!!
- 但是如果有多个属性, 且多个属性没有默认值，那么value名称是不能省略的。
package com.itheima.d8_annotation;
public @interface Book {
String value();//特殊属性
double pricwe();
//double pricwe() default 9.9;
}
package com.itheima.d8_annotation;
public @interface MyBook {
String name();
String[] authors();
double price();
}
package com.itheima.d8_annotation;
/**
目标：学会自定义注解。掌握其定义格式和语法。
*/
@MyBook(name="《精通JavaSE》",authors = {"黑马", "dlei"} , price = 199.5)
//@Book(value = "/delete")
//@Book("/delete")
@Book(value = "/delete", pricwe = 19.9)
//@Book("/delete")
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: 约束自定义注解只能在哪些地方使用，
@Retention：申明注解的生命周期
@Target中可使用的值定义在ElementType枚举类中，常用值如下
- TYPE，类，接口
- FIELD, 成员变量
- METHOD, 成员方法
- PARAMETER, 方法参数
- CONSTRUCTOR, 构造器
- LOCAL_VARIABLE, 局部变量
@Retention中可使用的值定义在RetentionPolicy枚举类中，常用值如下
- SOURCE： 注解只作用在源码阶段，生成的字节码文件中不存在
- CLASS： 注解作用在源码阶段，字节码文件阶段，运行阶段不存在，默认值.
- RUNTIME：注解作用在源码阶段，字节码文件阶段，运行阶段（开发常用）
package com.itheima.d8_annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target({ElementType.METHOD,ElementType.FIELD})//元注解
@Retention(RetentionPolicy.RUNTIME)//一直活着，在运行阶段这个注解也不消失
public @interface MyTest {
}
package com.itheima.d8_annotation;
/**
* 认识元注解
*/
//@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 |
- 所有的类成分Class, Method , Field , Constructor，都实现了AnnotatedElement接口他们都拥有解析注解的能力：
解析注解的技巧
- 注解在哪个成分上，我们就先拿哪个成分对象。
- 比如注解作用成员方法，则要获得该成员方法对应的Method对象，再来拿上面的注解
- 比如注解作用在类上，则要该类的Class对象，再来拿上面的注解
- 比如注解作用在成员变量上，则要获得该成员变量对应的Field对象，再来拿上面的注解
注解解析的案例
需求：注解解析的案例
分析
定义注解Book，要求如下：
包含属性：String value() 书名 - 包含属性：double price() 价格，默认值为 100
包含属性：String[] authors() 多位作者 - 限制注解使用的位置：类和成员方法上
指定注解的有效范围：RUNTIME
定义BookStore类，在类和成员方法上使用Book注解
定义AnnotationDemo01测试类获取Book注解上的数据
package com.itheima.d8_annotation;
import org.junit.Test;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.util.Arrays;
/**
目标：完成注解的解析
*/
public class AnnotationDemo3 {
@Test
public void parseClass(){
// a.先得到类对象
Class c = BookStore.class;
// b.判断这个类上面是否存在这个注解
//是否陈列注解
if(c.isAnnotationPresent(Bookk.class)){
//c.直接获取该注解对象
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 {
// a.先得到类对象
Class c = BookStore.class;
Method m = c.getDeclaredMethod("test");
// b.判断这个类上面是否存在这个注解
if(m.isAnnotationPresent(Bookk.class)){
//c.直接获取该注解对象
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(){
}
}
package com.itheima.d8_annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Bookk {
String value();
double price() default 100;
String[] author();
}
总结
注解解析的方式
| 方法 |
|---|
| Annotation[] getDeclaredAnnotations() |
| T getDeclaredAnnotation(Class annotationClass) |
| boolean isAnnotationPresent(Class annotationClass) |
注解的应用场景一：junit框架
模拟Junit框架
需求
定义若干个方法，只要加了MyTest注解，就可以在启动时被触发执行
分析
定义一个自定义注解MyTest，只能注解方法，存活范围是一直都在。
定义若干个方法，只要有@MyTest注解的方法就能在启动时被触发执行，没有这个注解的方法不能执行。
package com.itheima.d8_annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target({ElementType.METHOD,ElementType.FIELD})//元注解
@Retention(RetentionPolicy.RUNTIME)//一直活着，在运行阶段这个注解也不消失
public @interface MyTest {
}
package com.itheima.d8_annotation;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class AnnotationDemo4 {
@MyTest
public void test1(){
System.out.println("test1");
}
public void test2(){
System.out.println("test2");
}
@MyTest
public void test3(){
System.out.println("test3");
}
/**
* 启动菜单，有注解的才被调用
* @param args
*/
public static void main(String[] args) throws InvocationTargetException, IllegalAccessException {
AnnotationDemo4 t=new AnnotationDemo4();
//a.获取类对象
Class c=AnnotationDemo4.class;
//b.提取全部方法
Method []methods=c.getDeclaredMethods();
//c.遍历方法看是否有注解MyTest，有就跑它
for (Method method : methods) {
if (method.isAnnotationPresent(MyTest.class)){
//跑它
method.invoke(t);
}
}
}
}
动态代理
准备案例、提出问题
模拟企业业务功能开发，并完成每个功能的性能统计
需求
模拟某企业用户管理业务，需包含用户登录，用户删除，用户查询功能，并要统计每个功能的耗时。
分析
定义一个UserService表示用户业务接口，规定必须完成用户登录，用户删除，用户查询功能。
定义一个实现类UserServiceImpl实现UserService，并完成相关功能，且统计每个功能的耗时。
定义测试类，创建实现类对象，调用方法。
本案例存在的问题？
答：业务对象的的每个方法都要进行性能统计，存在大量重复的代码。
package com.itheima.d10_proxy2;
public class UserServiceImpl implements UserService{
@Override
public String login(String loginName, String passWord) {
String rs="登录名称和密码错误";
if("admin".equals(loginName)&&"123456".equals(passWord)){
rs="登陆成功";
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return rs;
}
@Override
public void deleteUsers() {
try {
System.out.println("您正在删除数据中....");
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
@Override
public String selectUsers() {
String rs="查询了10000个用户数据";
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return rs;
}
}
package com.itheima.d10_proxy2;
public interface UserService {
String login(String loginName,String passWord) throws InterruptedException;
void deleteUsers();
String selectUsers();
}
package com.itheima.d10_proxy2;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class ProxyUtil {
//通过一个静态方法位用户业务对象返回一个代理对象
public static UserService getProxy(UserService obj){
return (UserService) Proxy.newProxyInstance(obj.getClass().getClassLoader(),
obj.getClass().getInterfaces(), new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
long startTime=System.currentTimeMillis();
//真正触发对象的行为执行的
Object rs=method.invoke(obj,args);
long endTime=System.currentTimeMillis();
System.out.println(method.getName()+"方法耗时："+(endTime-startTime)/1000.0+"s");
return rs;
}
});
}
}
package com.itheima.d10_proxy2;
public class Test {
public static void main(String[] args) throws InterruptedException {
//目标：掌握使用动态代理解决问题，理解使用动态代理的优势
UserService userService=ProxyUtil.getProxy(new UserServiceImpl());
System.out.println(userService.login("admin", "123456"));
System.out.println(userService.selectUsers());
userService.deleteUsers();
}}
login方法耗时：1.0s
登陆成功
selectUsers方法耗时：3.002s
查询了10000个用户数据
您正在删除数据中....
deleteUsers方法耗时：2.0s
使用动态代理解决问题
动态代理
- 代理就是被代理者没有能力或者不愿意去完成某件事情，需要找个人代替自己去完成这件事，动态代理就是用来对业务功能（方法）进行代理的。
关键步骤
1.必须有接口，实现类要实现接口（代理通常是基于接口实现的）。
3.创建一个实现类的对象，该对象为业务对象，紧接着为业务对象做一个代理对象。
动态代理的优点
- 非常的灵活，支持任意接口类型的实现类对象做代理，也可以直接为接本身做代理。
- 可以为被代理对象的所有方法做代理。
- 可以在不改变方法源码的情况下，实现对方法功能的增强。
- 不仅简化了编程工作、提高了软件系统的可扩展性，同时也提高了开发效率。
package com.itheima.d9_proxy;
public class Star implements Skill{
private String name;
public Star(String name) {
this.name = name;
}
@Override
public void dance() {
System.out.println(name+"开始跳舞，迷人~");
}
@Override
public void sing() {
System.out.println("开始唱歌，唱得很好听~");
}
}
package com.itheima.d9_proxy;
public interface Skill {
void dance();
void sing();
}
package com.itheima.d9_proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
//代理
public class StarAgentProxy {
/**
* 设计一个方法来返回一个明星对象的代理对象
*/
public static Skill getProxy(Star obj){
//为杨超越这个对象生成一个代理对象
/**
* public static Object newProxyInstance( ClassLoader loader,
* @NotNull Class<?>[] interfaces 对象实现的接口列表,
* @NotNull reflect.InvocationHandler h )
*/
return (Skill) Proxy.newProxyInstance(obj.getClass().getClassLoader(),
obj.getClass().getInterfaces(), new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("收首付款，把杨超越送出去");
//真正让杨超越去唱歌和跳舞
//method正在调用的方法对象 args代表这个方法的参数
method.invoke(obj,args);
Object rs=method.invoke(obj,args);
System.out.println("收尾款，把杨超越接回来");
return rs;
}
});
}
}
package com.itheima.d9_proxy;
/**
* 目标：学习开发出一个代理对象出来，理解动态代理的执行流程。
*/
public class Test {
public static void main(String[] args) {
//1.创建一个对象（杨超越），对象的类必须实现接口
Star s=new Star("杨超越");
//为杨超越对象，生成一个代理对象（经纪人）
Skill s2=StarAgentProxy.getProxy(s);
s2.dance();//走代理的
s2.sing();
}
}
```java
package com.itheima.d9_proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
//代理
public class StarAgentProxy {
/**
* 设计一个方法来返回一个明星对象的代理对象
*/
public static Skill getProxy(Star obj){
//为杨超越这个对象生成一个代理对象
/**
* public static Object newProxyInstance( ClassLoader loader,
* @NotNull Class<?>[] interfaces 对象实现的接口列表,
* @NotNull reflect.InvocationHandler h )
*/
return (Skill) Proxy.newProxyInstance(obj.getClass().getClassLoader(),
obj.getClass().getInterfaces(), new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("收首付款，把杨超越送出去");
//真正让杨超越去唱歌和跳舞
//method正在调用的方法对象 args代表这个方法的参数
method.invoke(obj,args);
Object rs=method.invoke(obj,args);
System.out.println("收尾款，把杨超越接回来");
return rs;
}
});
}
}
package com.itheima.d9_proxy;
/**
* 目标：学习开发出一个代理对象出来，理解动态代理的执行流程。
*/
public class Test {
public static void main(String[] args) {
//1.创建一个对象（杨超越），对象的类必须实现接口
Star s=new Star("杨超越");
//为杨超越对象，生成一个代理对象（经纪人）
Skill s2=StarAgentProxy.getProxy(s);
s2.dance();//走代理的
s2.sing();
}
}
541
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
