java反射的两个Demo（反射属性，属性名，反射调用方法，内省）

java反射的两个Demo（反射属性，属性名，反射调用方法，内省）

1 demo的功能类

public class InvokeDemo {

  private static Logger log = LoggerFactory.getLogger(InvokeDemo.class);

  private static Student student;

  public static Student buildStudent() {
    student = new Student();
    student.setStudentName("zhangsan");
    student.setAge(11);
    student.setLike("football");
    student.setPhoneNo("12312312123");
    student.setStudentNo("110");
    return student;
  }

  //1 通过反射将一个实体类的入参属性转为map
  public Map<String, Object> convertStudent(Student student) {
    if (student == null) {
      return null;
    }
    Map<String, Object> studentMap = new HashMap<String, Object>();
    try {
      /* 通过三种方式获取类的类对象
         Class<?> c=Student.class;
         Class<?> c1=new Student().getClass();
         Class<?> c2=Class.forName("Student");
       */
      /*
      内省访问JavaBean属性的两种方式：
       1 通过PropertyDescriptor类操作Bean的属性
       2 通过Introspector类获得Bean对象的 BeanInfo，
        然后通过 BeanInfo 来获取属性的描述器（PropertyDescriptor ），
        通过这个属性描述器就可以获取某个属性对应的 getter/setter 方法，
        然后通过反射机制来调用这些方法
       */
      BeanInfo beanInfo = Introspector.getBeanInfo(student.getClass());
      PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
      for (PropertyDescriptor property : propertyDescriptors) {
        String key = property.getName().toUpperCase();
        // 过滤class属性
        if (!key.equals("CLASS")) {
          // 得到property对应的getter方法
          Method getter = property.getReadMethod();
          Object value = getter.invoke(student);
          studentMap.put(key, value);
        }
      }
    } catch (Exception e) {
      log.info("convertStudent Error " + e);
    }
    return studentMap;
  }

  //2 通过反射给制定路径类里的方法传参数并获取结果
  public boolean isChildren(Integer age)
      throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
    boolean isChildren = false;
    if (age != null) {
      //调用对应的订阅关系处理类
      String studentClassPosition = "com.xxx.entity.Student";
      Class studentClass = Class.forName(studentClassPosition);
      Object studentClassObj = studentClass.newInstance();
      Method method = studentClass.getMethod("isChild", Integer.class);
      isChildren = (boolean) method.invoke(studentClassObj, age);
    } else {
      isChildren = false;
    }
    return isChildren;
  }

 //main方法
  public static void main(String[] args) {
    InvokeDemo invokeDemo = new InvokeDemo();
    Student student = invokeDemo.buildStudent();
    //1  通过反射将一个实体类的入参属性转为map
    Map<String, Object> studentMap = invokeDemo.convertStudent(student);
    System.out.println(studentMap.toString());

    //2  通过反射给制定路径类里的方法传参数并获取结果
    Integer age = student.getAge();
    try {
      System.out.println(invokeDemo.isChildren(age));
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
}

2 demo实体类

public class Student {

  private String studentName;

  private Integer age;

  private String studentNo;

  private String like;

  private String phoneNo;

  public boolean isChild(Integer age) {
    if (age < 18) {
      return true;
    } else {
      return false;
    }
  }

  public String getStudentName() {
    return studentName;
  }

  public void setStudentName(String studentName) {
    this.studentName = studentName;
  }

  public Integer getAge() {
    return age;
  }

  public void setAge(Integer age) {
    this.age = age;
  }

  public String getStudentNo() {
    return studentNo;
  }

  public void setStudentNo(String studentNo) {
    this.studentNo = studentNo;
  }

  public String getLike() {
    return like;
  }

  public void setLike(String like) {
    this.like = like;
  }

  public String getPhoneNo() {
    return phoneNo;
  }

  public void setPhoneNo(String phoneNo) {
    this.phoneNo = phoneNo;
  }
}