java反射

[代码] [Java]代码

001

/**

002	* @Title: 反射方式调用构造方法

003	* @return void

004

*/

005	public void invokeConstructor() throws Exception {

006

007	String className = "XXXXX";

008	// 创建一个Class对象，用于描述Person类

009	Class<?> clazz = Class.forName(className);

010

011

/**

012	* 调用有参的构造方法

013

*/

014	// 指明所要调用的构造方法的形参

015	Class<?>[] argTypes = { String.class, Integer.class };

016	// 获取指定参数的构造方法

017	Constructor<?> constructor = clazz.getConstructor(argTypes);

018	// 通过给定的实参，创建一个对象，它的返回值即新建对象的句柄

019	Object obj = constructor.newInstance("ddd", 333);

020

021

/**

022	* 调用无参构造方法

023

*

024	* @see 也可以使用下面的两种方式，获取无参的构造方法

025	* @see constructor = clazz.getConstructor(new Class[0])

026	* @see constructor = clazz.getConstructor(null)

027	* @see 另外也可以使用obj = clazz.newInstance()创建无参构造方法的一个对象

028

*/

029	// 获取无参的构造方法，并使用其创建一个对象

030	obj = clazz.getConstructor().newInstance();

031

032

}

033

034

/**

035

*

036	* @Title: 反射方式调用单例

037	* @param @throws Exception

038	* @return void

039

* @throws

040

*/

041	public void invokeSingleton() throws Exception {

042

043	String className = "XXXXX";

044	// 反射调用单例(无参)

045	Class c = Class.forName(className);

046

047	Method m = c.getDeclaredMethod("getInstance");

048

049	// 若调用private方法，设置此属性，即可访问

050	// m1.setAccessible(true);

051

052	Object obj = m.invoke(c);

053

054	// 反射调用单例(有参)

055	Class c1 = Class.forName(className);

056

057	// Class<?>[] cc = {String.class};

058	// Method m =c.getDeclaredMethod("getInstance",cc);

059	Method m1 = c1.getDeclaredMethod("getInstance", String.class);

060

061	// 若调用private方法，设置此属性，即可访问

062	// m1.setAccessible(true);

063

064	Object obj1 = m1.invoke(c, "我是参数字符串");

065

066

}

067

068

/**

069

*

070	* @Title: 得到某个对象的属性

071	* @param owner

072	* @param fieldName

073	* @return Object

074

* @throws

075

*/

076	public Object getProperty(Object owner, String fieldName) throws Exception {

077

078	Class ownerClass = owner.getClass();

079

080	Field field = ownerClass.getField(fieldName);

081

082	Object property = field.get(owner);

083

084	return property;

085

}

086

087

/**

088

*

089	* @Title: 得到某个类的静态属性

090	* @param className

091	* @param fieldName

092	* @return Object

093

* @throws

094

*/

095	public Object getStaticProperty(String className, String fieldName)

096	throws Exception {

097

098	Class ownerClass = Class.forName(className);

099

100	Field field = ownerClass.getField(fieldName);

101

102	Object property = field.get(ownerClass);

103

104	return property;

105

}

106

107

/**

108

*

109	* @Title: 执行某对象的方法

110	* @param owner

111	* @param methodName

112	* @param args

113	* @return Object

114

*/

115	public Object invokeMethod(Object owner, String methodName, Object[] args)

116	throws Exception {

117

118	Class ownerClass = owner.getClass();

119

// 参数类型

120	Class[] argsClass = new Class[args.length];

121	for (int i = 0, j = args.length; i < j; i++) {

122	argsClass[i] = args[i].getClass();

123

}

124	Method method = ownerClass.getMethod(methodName, argsClass);

125	return method.invoke(owner, args);

126

}

127

128

/**

129

*

130	* @Title: 执行某个类的静态方法

131	* @param className

132	* @param methodName

133	* @param args

134	* @return Object

135

* @throws

136

*/

137	public Object invokeStaticMethod(String className, String methodName,

138	Object[] args) throws Exception {

139

140	Class ownerClass = Class.forName(className);

141

142	Class[] argsClass = new Class[args.length];

143

144	for (int i = 0, j = args.length; i < j; i++) {

145	argsClass[i] = args[i].getClass();

146

}

147

148	Method method = ownerClass.getMethod(methodName, argsClass);

149

150	return method.invoke(null, args);

151

}