比如从前端获得了一个对象person,想让其属性输入map中:
package com.zg.reflactiontest;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.extern.slf4j.Slf4j;
/**
* @Auther: zhaoss
* @Date: 2022/10/8 - 10 - 08 - 11:26
* @Description: com.zg.reflactiontest
* @version: 1.0
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
@Slf4j
public class Person {
private String name;
private String gender;
private Integer age;
}
package com.zg.reflactiontest;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import java.lang.reflect.Field;
import java.util.Map;
import java.util.TreeMap;
@SpringBootTest
class ReflactiontestApplicationTests {
@Test
void contextLoads() throws IllegalAccessException {
Person person = new Person("张三","男",18);
Map<String,Object> map = new TreeMap<>();
Field[] fields = person.getClass().getDeclaredFields();
for (Field f:fields
) {
f.setAccessible(true);
map.put(f.getName(), f.get(person));
System.out.println(map.get(f.getName()));
}
}
}
结果:
张三
男
18
@Test
public void Test9() throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchFieldException, NoSuchMethodException, InvocationTargetException {
//获取类对应的字节码的对象(三种)
/*
1, 由对象获取全类名:
*/
Emp emp = new Emp();
Class clazz1 = emp.getClass();
System.out.println(clazz1);
System.out.println("========");
/*
结果:class com.zg.myssm.entities.Emp
*/
/*
2, 通过全类名获取字节码对象,实例化
*/
Class clazz2 = Class.forName("com.zg.myssm.entities.Emp");
System.out.println(clazz2.toString());
Object o = clazz1.newInstance();
System.out.println(o.toString());
System.out.println("==========");
/*
结果:
class com.zg.myssm.entities.Emp
Emp(empId=null, empName=null, age=null, gender=null, dept=null)
*/
/*
3,调用类的class属性 获取字节码对象 必须要导入包,局限性
*/
Class clazz3 = Emp.class;
System.out.println(clazz3);
System.out.println("==========");
/*
结果:class com.zg.myssm.entities.Emp
*/
/*
4,获取包名常用方法:
*/
System.out.println(clazz1.getPackage());
System.out.println("============");
/*
结果:
package com.zg.myssm.entities
*/
System.out.println(clazz1.getPackage().getName());
System.out.println("============");
/*
结果:
com.zg.myssm.entities
*/
/*
5,获取类名
*/
String simpleName = clazz1.getSimpleName();
System.out.println(simpleName);
System.out.println("============");
/*
结果:
Emp
*/
/*
6,获取完整类名
*/
String name = clazz1.getName();
System.out.println(name);
System.out.println("============");
/*
结果:com.zg.myssm.entities.Emp
*/
/*
7,获取全部字段,公开字段:
*/
Field[] declaredFields = clazz1.getDeclaredFields();
Field[] fields = clazz1.getFields();
//全是私有字段,不显示
Arrays.asList(fields).forEach(System.out::println);
System.out.println("============");
//解除检查setAccessible
for (Field f: declaredFields
) {
f.setAccessible(true);
System.out.println(f);
}
/*
结果:
private java.lang.Integer com.zg.myssm.entities.Emp.empId
private java.lang.String com.zg.myssm.entities.Emp.empName
private java.lang.Integer com.zg.myssm.entities.Emp.age
private java.lang.String com.zg.myssm.entities.Emp.gender
private com.zg.myssm.entities.Dept com.zg.myssm.entities.Emp.dept
*/
//获取单一字段:
System.out.println("============");
Field empName = clazz2.getDeclaredField("empName");
empName.setAccessible(true);
System.out.println(empName);
System.out.println("============");
/*
结果:
private java.lang.String com.zg.myssm.entities.Emp.empName
*/
/*
8,获取构造方法
*/
//获取单个构造方法
Constructor constructor = clazz1.getConstructor(null); //参数类型
System.out.println(constructor);
System.out.println("+++++++++++++++++++");
/*
结果:
public com.zg.myssm.entities.Emp()
*/
//获取全部公开构造方法
Constructor[] constructors = clazz1.getConstructors();
for (Constructor ctor: constructors
) {
System.out.println(ctor);
}
System.out.println("+++++++++++++++++++");
//结果:
/*
public com.zg.myssm.entities.Emp()
public com.zg.myssm.entities.Emp(java.lang.Integer,java.lang.String,java.lang.Integer,java.lang.String,com.zg.myssm.entities.Dept)
*/
/*
获取所有:
getDeclaredConstructors()//获取所有的构造方法,包括私有
getDeclaredConstructor(int.class,String.class)
*/
Constructor ctor2 = clazz1.getDeclaredConstructor(Integer.class, String.class, Integer.class, String.class,Dept.class);
System.out.println(ctor2);
System.out.println("-------------------------");
/*
结果:
public com.zg.myssm.entities.Emp(java.lang.Integer,java.lang.String,java.lang.Integer,java.lang.String,com.zg.myssm.entities.Dept)
*/
/*
9,获取方法
*/
Class clazz5 = Class.forName("com.zg.myssm.entities.Demon");
//获取所有方法
Method[] methods = clazz5.getDeclaredMethods();
for (Method m: methods
) {
m.setAccessible(true);
System.out.println(m);
}
System.out.println("-==============-");
//结果:
/*
public void com.zg.myssm.entities.Demon.runFunc(com.zg.myssm.entities.TestFuncPoint)
*/
/*
Demon:
public class Demon {
public void runFunc(TestFuncPoint funcPoint){
System.out.println(funcPoint.run("通过funcPoint.run()传入的参数"));
}
}
*/
//获取指定方法: 方法名,参数类型
Method runFunc = clazz5.getDeclaredMethod("runFunc", TestFuncPoint.class);
//TestFuncPoint 函数式接口,保证入参和返回值类型,
// s在Demon中通过funcPoint.run(String str)传入过了。
//定义有参数,有返回值函数指针
TestFuncPoint fp = (String s)->{
return s+"myStr";
};
//运行函数: 对象,参数数据
runFunc.invoke(clazz5.newInstance(), fp);
//结果:通过funcPoint.run()传入的参数myStr
System.out.println("========+==============");
//定义无参数,无返回值函数指针
TestFuncPointVoid fpVoid = ()->{
System.out.println("SBSBSBSB");
};
Class clazz6 = Class.forName("com.zg.myssm.entities.TestFuncPointImpl");
/*
public class TestFuncPointImpl {
public void runFunc(TestFuncPointVoid funcPoint){
funcPoint.run();
}
}
*/
//获取指定方法: 方法名,参数类型
Method mypointVoid = clazz6.getDeclaredMethod("runFunc", TestFuncPointVoid.class);
System.out.println(mypointVoid);
/*
结果:
public void com.zg.myssm.entities.
TestFuncPointImpl.runFunc(com.zg.myssm.entities.TestFuncPointVoid)
*/
System.out.println("========+-+==============");
TestFuncPointVoid p = ()->{
System.out.println("Test 函数指针&函数式编程");
};
p.run();
/*
结果:
Test 函数指针&函数式编程
*/
System.out.println("========+-+-+==============");
//运行函数: 对象,参数数据, Impl中自带了run方法
mypointVoid.invoke(clazz6.newInstance(),p);
/*
结果:Test 函数指针&函数式编程
*/
}
用到的类:
package com.zg.myssm.entities;
/**
* @Auther: Zg
* @Date: 2022/10/24 - 10 - 24 - 20:14
* @Description: com.zg.myssm.entities
* @version: 1.0
*/
// Java中 接口只有一个函数,可以用接口指定函数类型,实现函数指针,委托
public interface TestFuncPoint {
String run(String str);
}
package com.zg.myssm.entities;
/**
* @Auther: Zg
* @Date: 2022/10/24 - 10 - 24 - 20:16
* @Description: com.zg.myssm.entities
* @version: 1.0
*/
public class Demon {
public void runFunc(TestFuncPoint funcPoint){
System.out.println(funcPoint.run("通过funcPoint.run()传入的参数"));
}
}
package com.zg.myssm.entities;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* @Auther: Zg
* @Date: 2022/10/16 - 10 - 16 - 20:39
* @Description: com.zg.myssm.entities
* @version: 1.0
*/
@Builder
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Emp {
@TableId(type = IdType.AUTO)
private Integer empId;
private String empName;
private Integer age;
private String gender;
@TableField(exist = false)
private Dept dept;
}
package com.zg.myssm.entities;
import com.fasterxml.jackson.databind.util.ClassUtil;
import javax.lang.model.element.VariableElement;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
/**
* @Auther: Zg
* @Date: 2022/10/24 - 10 - 24 - 21:07
* @Description: com.zg.myssm.entities
* @version: 1.0
*/
public class DemonReflaction {
Map funcMap = new HashMap<String,String >();
public DemonReflaction() {
myinit();
}
private void myinit() {
funcMap.put("猩猩","callLebrown");
funcMap.put("Goat", "callGinnis");
funcMap.put("Hunter","callCurry");
}
public void call(String funcName) throws ClassNotFoundException {
Object methodName = funcMap.get(funcName);
if (methodName != null){
try {
Method method = DemonReflaction.class.getMethod((String) methodName);
Class<?> clazz = Class.forName("com.zg.myssm.entities.DemonReflaction");
//method.invoke(this,null); //对象名,参数数据
method.invoke(clazz.newInstance(),null);
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException | InstantiationException e) {
e.printStackTrace();
}
}
}
public void callLebrown() {
System.out.println("I am Lebrown!");
}
public void callGinnis() {
System.out.println("I am Giannis!");
}
public void callCurry() {
System.out.println("I am Hunter!");
}
}
package com.zg.myssm.entities;
import java.util.HashMap;
import java.util.Map;
/**
* @Auther: Zg
* @Date: 2022/10/24 - 10 - 24 - 23:33
* @Description: com.zg.myssm.entities
* @version: 1.0
*/
public class DemonVoid {
Map<String, TestFuncPointVoid> funcMap = new HashMap<>();
public DemonVoid(){
myInit();
}
private void myInit() {
funcMap.put("猩猩", this::callCurry);
funcMap.put("Goat", this::callGinnis);
funcMap.put("Hunter",this::callLebrown);
}
public void callLebrown(){
System.out.println("我是Lebrown!!!");
}
public void callGinnis(){
System.out.println("我是Lebrown!!!");
}
public void callCurry(){
System.out.println("我是Lebrown!!!");
}
public void call(String funcName){
TestFuncPointVoid method = funcMap.get(funcName);
if (method != null){
method.run();
}
}
}
函数式编程:
@Test
public void Test10() throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {
Class clazz = Class.forName("com.zg.myssm.entities.Demon");
//获取方法 方法名,参数类型
Method runFunc = clazz.getMethod("runFunc", TestFuncPoint.class);//方法名,参数类型
runFunc.setAccessible(true);
TestFuncPoint p = (String str) -> {
return str;
};
//对象,参数数据
runFunc.invoke(clazz.newInstance(), p);
System.out.println(runFunc);
}
@Test
public void Test11(){
// printNum_(new IntPredicate() {
// @Override
// public boolean test(int value) {
// return value%2==0;
// }
// });
// 结果:2,4,6,8
printNum_((int value)->{
return value%2==0;
});
}
public void printNum(IntPredicate predicate){
int[] arr = {1,2,3,4,5,6,7,8,9};
Arrays.asList(arr).forEach(a->{
System.out.println(a);
});
}
public void printNum_(IntPredicate predicate){
Integer[] arr = {1,2,3,4,5,6,7,8,9};
//List<Integer> ints = Arrays.asList(arr);
//调用了test方法,返回bool
Arrays.asList(arr).forEach(a->{
if (predicate.test(a))
System.out.println(a);
});
}