使用反射获取类的字段,方法信息

最新推荐文章于 2021-08-12 12:06:30 发布
最新推荐文章于 2021-08-12 12:06:30 发布
阅读量112 收藏
点赞数
分类专栏： Java反射 文章标签： java reflection
今天在查看javax.mail包中相关类的信息时,想了解一下每一个类的属性,行为概要信息,以及它们之间的关联关系,本来eUML2可以看的,无奈试用过期了,又不想花银子,等找到好的Eclipse插件再说吧. 


package com.pa.reflection;

import java.io.*;
import java.lang.reflect.*;

@SuppressWarnings("rawtypes")
public class ClassReflection {

	private static final String BLANK = " ";

	private static final String LEFT_BRACKET = "(";

	private static final String RIGHT_BRACKET = ")";

	private static final String THROWS = "throws";

	private static final String SEPARATE = ";";

	private static final String NEW_LINE = "\r\n";

	private static final String COMMA = ",";

	private static final String ARG = "arg";

	public static void getClassInfo(Class<?> clazz, Writer writer) {
		try {

			//获取构造函数信息
			StringBuffer constructorsResult = getConstructors(clazz);

			//获取字段信息
			StringBuffer fieldsResult = getFields(clazz);

			//获取方法信息
			StringBuffer methodsResult = getMethods(clazz);

			//最终结果
			StringBuffer finalResult = new StringBuffer();

			finalResult.append(constructorsResult).append(NEW_LINE);

			finalResult.append(fieldsResult).append(NEW_LINE);

			finalResult.append(methodsResult).append(NEW_LINE);

			//输出结果
			writer.write(finalResult.toString());

		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if (writer != null)
				try {
					writer.close();
				} catch (Exception e) {
					e.printStackTrace();
				}
		}

	}

	private static StringBuffer getMethods(Class<?> clazz) {

		Method[] methods = clazz.getDeclaredMethods();
		beforeGetClassMethods(clazz,methods);
		StringBuffer methodsResult = new StringBuffer();
		if (methods != null && methods.length > 0) {
			for (Method method : methods) {
				methodsResult.append(addSuffixBlank(Modifier.toString(method.getModifiers())));
				methodsResult.append(addSuffixBlank(method.getReturnType().getCanonicalName()));
				methodsResult.append(method.getName());

				Class[] parameterTypes = method.getParameterTypes();

				getParameters(methodsResult, parameterTypes);

				Class[] exceptionTypes = method.getExceptionTypes();
				getExceptions(methodsResult, exceptionTypes);

				methodsResult.append(SEPARATE);
				methodsResult.append(NEW_LINE);
			}
		}
		afterGetClassMethods(clazz,methods);
		return methodsResult;
	}

	private static void afterGetClassMethods(Class<?> clazz,Method[] methods) {

	}

	private static void beforeGetClassMethods(Class<?> clazz,Method[] methods) {
		System.out.println("get "+clazz.getCanonicalName()+" methods,totoal size: "+methods.length);
	}

	/**
	 * 获取方法异常信息
	 * @param methodsResult
	 * @param exceptionTypes
	 */
	private static void getExceptions(StringBuffer methodsResult,Class[] exceptionTypes) {
		if (exceptionTypes != null && exceptionTypes.length > 0) {
			methodsResult.append(addSuffixBlank(THROWS));
			for (int j = 0; j < exceptionTypes.length; j++) {
				Class exceptionType = exceptionTypes[j];
				methodsResult.append(exceptionType.getCanonicalName());
				if (j != exceptionTypes.length - 1) {
					methodsResult.append(COMMA);
				} 
			}
		}
	}

	/**
	 * 获取方法参数信息
	 * @param methodsResult
	 * @param parameterTypes
	 */
	private static void getParameters(StringBuffer methodsResult,Class[] parameterTypes) {
		methodsResult.append(LEFT_BRACKET);
		if (parameterTypes != null && parameterTypes.length > 0) {
			for (int i = 0; i < parameterTypes.length; i++) {
				Class parameterType = parameterTypes[i];
				methodsResult.append(addSuffixBlank(parameterType.getCanonicalName())).append(ARG + (i + 1));
				if (i != parameterTypes.length - 1) {
					methodsResult.append(COMMA);
				} 
			}

		}
		methodsResult.append(RIGHT_BRACKET);
	}

	private static StringBuffer getFields(Class<?> clazz) {

		Field[] fields = clazz.getDeclaredFields();
		beforeGetClassFields(clazz,fields);
		StringBuffer fieldsResult = new StringBuffer();
		if (fields != null && fields.length > 0) {
			for (Field field : fields) {
				fieldsResult.append(addSuffixBlank(Modifier.toString((field.getModifiers()))));
				fieldsResult.append(addSuffixBlank(field.getType().getCanonicalName()));
				fieldsResult.append(field.getName());
				fieldsResult.append(SEPARATE);
				fieldsResult.append(NEW_LINE);
			}
		}
		afterGetClassFields(clazz,fields);
		return fieldsResult;
	}


	private static void afterGetClassFields(Class<?> clazz,Field[] fields) {

	}

	private static void beforeGetClassFields(Class<?> clazz,Field[] fields) {
		System.out.println("get "+clazz.getCanonicalName()+" fieds,totoal size: "+fields.length);
	}

	private static StringBuffer getConstructors(Class<?> clazz) {
		Constructor[] constructors = clazz.getDeclaredConstructors();
		beforeGetClassContructors(clazz,constructors);
		StringBuffer constructorsResult = new StringBuffer();
		if (constructors != null && constructors.length > 0) {
			for (Constructor constructor : constructors) {
				constructorsResult.append(addSuffixBlank(Modifier.toString(constructor.getModifiers())));
				constructorsResult.append(addSuffixBlank(constructor.getName()));

				Class[] parameterTypes = constructor.getParameterTypes();
				getParameters(constructorsResult, parameterTypes);

				Class[] exceptionTypes = constructor.getExceptionTypes();
				getExceptions(constructorsResult, exceptionTypes);

				constructorsResult.append(SEPARATE);
				constructorsResult.append(NEW_LINE);
			}
		}
		afterGetClassContructors(clazz,constructors);
		return constructorsResult;
	}

	private static void afterGetClassContructors(Class<?> clazz,Constructor[] constructors) {

	}

	private static void beforeGetClassContructors(Class<?> clazz,Constructor[] constructors) {
		System.out.println("get "+clazz.getCanonicalName()+" constructors,totoal size: "+constructors.length);
	}

	public static String addPrefix(String str, String prefix) {
		return prefix + str;
	}

	public static String addSuffix(String str, String suffix) {
		return str + suffix;
	}

	public static String addPrefixAndSuffix(String str, String prefix,
			String suffix) {
		return prefix + str + suffix;
	}

	public static String addSuffixBlank(String str) {
		return addSuffix(str, BLANK);
	}

	public static void main(String[] args) throws IOException {
		Writer writer = new PrintWriter(System.out);
		System.out.println("请输入你要反射的类(输入'exit'则退出):");
		BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
		String destClass = null;
	    while(true){
	    	destClass = reader.readLine();
	    	if(destClass.equalsIgnoreCase("exit")){
	    		break;
	    	}
			try {
				Class clazz = Class.forName(destClass);
				getClassInfo(clazz, writer);
			} catch (ClassNotFoundException e) {
				e.printStackTrace();
			}
	    }


	}
}


输出结果如下: 

get javax.mail.Part constructors,totoal size: 0
get javax.mail.Part fieds,totoal size: 2
get javax.mail.Part methods,totoal size: 25

public static final java.lang.String ATTACHMENT;
public static final java.lang.String INLINE;

public abstract int getSize()throws javax.mail.MessagingException;
public abstract java.lang.String getFileName()throws javax.mail.MessagingException;
public abstract java.lang.Object getContent()throws java.io.IOException,javax.mail.MessagingException;
public abstract java.io.InputStream getInputStream()throws java.io.IOException,javax.mail.MessagingException;
public abstract java.lang.String getContentType()throws javax.mail.MessagingException;
public abstract void writeTo(java.io.OutputStream arg1)throws java.io.IOException,javax.mail.MessagingException;
public abstract void setText(java.lang.String arg1)throws javax.mail.MessagingException;
public abstract int getLineCount()throws javax.mail.MessagingException;
public abstract boolean isMimeType(java.lang.String arg1)throws javax.mail.MessagingException;
public abstract java.lang.String getDisposition()throws javax.mail.MessagingException;
public abstract void setDisposition(java.lang.String arg1)throws javax.mail.MessagingException;
public abstract java.lang.String getDescription()throws javax.mail.MessagingException;
public abstract void setDescription(java.lang.String arg1)throws javax.mail.MessagingException;
public abstract void setFileName(java.lang.String arg1)throws javax.mail.MessagingException;
public abstract javax.activation.DataHandler getDataHandler()throws javax.mail.MessagingException;
public abstract void setDataHandler(javax.activation.DataHandler arg1)throws javax.mail.MessagingException;
public abstract void setContent(javax.mail.Multipart arg1)throws javax.mail.MessagingException;
public abstract void setContent(java.lang.Object arg1,java.lang.String arg2)throws javax.mail.MessagingException;
public abstract java.lang.String[] getHeader(java.lang.String arg1)throws javax.mail.MessagingException;
public abstract void setHeader(java.lang.String arg1,java.lang.String arg2)throws javax.mail.MessagingException;
public abstract void addHeader(java.lang.String arg1,java.lang.String arg2)throws javax.mail.MessagingException;
public abstract void removeHeader(java.lang.String arg1)throws javax.mail.MessagingException;
public abstract java.util.Enumeration getAllHeaders()throws javax.mail.MessagingException;
public abstract java.util.Enumeration getMatchingHeaders(java.lang.String[] arg1)throws javax.mail.MessagingException;
public abstract java.util.Enumeration getNonMatchingHeaders(java.lang.String[] arg1)throws javax.mail.MessagingException;
huiwen_82132000
关注
专栏目录
Java自定义注解使用反射获取字段注解
10-31
这里，`@Retention(RetentionPolicy.RUNTIME)` 表示该注解会在运行时保留，以便于反射获取；`@Target(ElementType.FIELD)` 指定注解可以应用于字段。 接下来，我们可以创建一个类并使用自定义注解标记某个字段： `...
Java反射 Field类详解
ajax项目中的应用案例
12-01 955
Field 提供有关类或接口的单个字段的信息，以及对它的动态访问权限。反射的字段可能是一个类（静态）字段或实例字段。 Field 成员变量的介绍 每个成员变量有类型和值。 java.lang.reflect.Field 为我们提供了获取当前对象的成员变量的类型，和重新设值的方法。 获取变量的类型 类中的变量分为两种类型：基本类型和引用类型： 基本类型（ 8 种）  整数：byte,...
java getconstructor_java反射机制的 getConstructor(Class... parameterTypes)
weixin_30579759的博客
02-12 609
try{Class tmpClass = Class.forName("Constructor1"); //class name, 如果有package,也需要添加上. i.e. com.abc.Constructor1;Class[] paramtersList = {String.class,Integer.TYPE}; // 构造method的参数(class)类型列表java.lan...
C# 获取类的名,构造方法信息,字段信息,方法信息
mxw_133的博客
02-13 1891
（1）使用Assembly定义和加载程序集，加载在程序集清单中列出模块，以及从此程序集中查找类型并创建该类型的实例。（2）使用Module了解包含模块的程序集以及模块中的类等，还可以获取在模块上定义的所有全局方法或其他特定的非全局方法。（3）使用ConstructorInfo了解构造函数的名称、参数、访问修饰符（如pulic 或private）和实现详细信息（如abstract或virtual）等...
[反射初探]根据反射获取类中参数类型及参数名和参数值
wriar的专栏
05-26 983
public String getMyDeclaredMethods(T t) { Class c = t.getClass(); Method m[] = c.getDeclaredMethods(); String text = ""; String n = c.getCanonicalName(); for (int i = 0; i < m.length; i++) {
Java获取函数参数名称的几种方法
wenl
12-01 2万+
Java获取函数参数名称的几种方法
C#实现利用反射简化给类字段赋值的方法
09-03
这个过程的关键在于通过`Type.GetField()`方法获取字段信息，然后使用`FieldInfo.SetValue()`方法设置字段的值。这样，即使在运行时不知道确切的字段名，也可以根据数据库查询结果动态地进行赋值。 利用反射，我们...
java反射之获取类的信息方法(推荐)
08-30
Java 反射之获取类的信息方法 Java 反射机制是 Java 语言中一种非常强大的机制，它可以在运行时检查和修改类的结构。今天，我们将探索如何使用 Java 反射机制来获取类的信息，包括成员函数、成员变量和构造函数信息...
Java 反射获取类详细信息的常用方法总结
09-05
本文将详细介绍如何使用Java反射获取类的详细信息。 首先，我们需要导入java.lang.reflect包中的相关类，如Class、Field、Constructor和Method，这些类是反射操作的核心。以下是一些常用的反射方法： 1. 获取类...
go语言通过反射获取和设置结构体字段值的方法
09-22
不过需要注意的是，当通过反射获取到的是结构体本身的值时，我们需要使用`Elem()`方法来获取指针指向的实际对象，然后才能修改其字段值。 下面是一个设置结构体字段值的示例： ```go func main() { n := MyStruct...
类的属性、字段和方法
黑色伤
01-11 2178
Visual Basic 语言概念 类的属性、字段和方法一般情况下，字段和属性表示对象的信息，而方法表示对象可以采取的操作。下面的主题描述向类中添加属性、字段和方法的机制及处理与这些项关联的问题。本节内容向类添加字段和属性 提供关于声明字段和属性的信息。 属性和属性过程 解释 Property 过程如何工作以及如何实现公共属性类型。
gettype获取类名_从反射中获取字段的类名
weixin_29898529的博客
12-31 222
Im going round in circles on this.I have a class Person, egpublic class Person {String name = "";}Now, I would like to introspect this class instance & figure out what Class is name declared as.So...
Java反射技术——字段的获取
专注、专心、专业
04-24 9013
关于获取类的字段有两种方式：getFields()和getDeclaredFields()。我们先来看看这两者的区别吧： getFields()：获得某个类的所有的公共（public）的字段，包括父类中的字段。 getDeclaredFields()：获得某个类的所有声明的字段，即包括public、private和proteced，但是不包括父类的申明字段。 同样类似的还有getCons
JAVA的反射机制与动态代理
十年饮冰，难凉热血
11-16 2946
JAVA的反射机制与动态代理    运行时类型信息（RunTime  Type  Information，RTTI）使得你在程序运行时发现和使用类型 信息。RTTI主要用来运行时获取向上转型之后的对象到底是什么具体的类型。    1.Class对象：  JAVA使用Class对象来执行RTTI。每个类都有一个Class对象，它用来创建这个类的所有 对象，反过来说，每个类的所有对象都会
根据类的字段名取出字段值
u012497072的博客
08-02 1502
public static String getObjectFieldName(Object obj, String fieldName) { Field[] fields = obj.getClass().getDeclaredFields(); for (int j = 0; j < fields.length; j++) { fields[j].setAccessible(true)...
java反射字段6_Java反射实践
weixin_42499067的博客
03-01 134
一、概述Java的反射机制是Java语言动态性的一种体现。反射机制是通过反射API来实现的，它允许程序在运行过程中(runtime)取得任何一个已知名称类的内部信息，包括其中的构造方法、声明的字段和定义的方法等。这不得不说是一个很强大的能力。二、基本方法说到反射的用法不得不提java.lang.Class类，通过该类的对象就的方法可以获取到该类中的构造方法、域和方法。对应的方法分别是getCons...
Java反射之Method Class.getMethod(String name, Class<?>... parameterTypes)
热门推荐
Handsome_fan的博客
02-03 3万+
Method Class.getMethod(String name, Class... parameterTypes)的作用是获得对象所声明的公开方法 该方法的第一个参数name是要获得方法的名字，第二个参数parameterTypes是按声明顺序标识该方法形参类型。 person.getClass().getMethod("Speak", null); //获得person对象的Sp
利用反射处理map 与 实体类的值映射
懒得不想说话
02-09 582
可能有点不完善。不过经测试，能满足大部分需求。 直接上干货！   public class DataHelper { public static void putDataIntoEntity(Map&lt;String, Object&gt; map, Object entity) throws SecurityException, ClassNotFoundException...
java获取子类继承的泛型接口方法上具体的参数类型
Brucelwl的博客
08-12 2767
假设有个泛型接口或类，方法上的参数是一个泛型，或者返回值是泛型。然后子类实现了泛型接口，或继承了泛型类。子类指定了具体的泛型类型。在子类没有重写父类方法的情况下，我们通过Method对象是无法反射拿到具体的方法参数或者返回值的，那么如何才能获取到呢？
如何使用反射获取类的信息和调用方法？
最新发布
07-13
要使用反射获取类的信息和调用方法，可以按照以下步骤进行操作： 1. 获取类的信息： - 使用 `Class.forName("类名")` 方法获取类的 `Class` 对象，例如：`Class<?> cls = Class.forName("com.example.MyClass")`。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值