我要评论java反射是一种强大的机制，允许程序在运行时检查和操作类、接口、字段和方法。
尽管它提供了极大的灵活性，但反射也是一把双刃剑——使用不当会导致性能下降、安全漏洞和难以调试的代码。
本文总结了20个关于java反射的经验。
基础最佳实践
1. 缓存反射对象
反射操作获取class、method、field、constructor等对象是昂贵的，应当尽可能缓存这些对象，特别是在循环或热点代码路径中。
// 不推荐: 每次调用都获取方法对象
public object invoke(object obj, string methodname, object... args) throws exception {
method method = obj.getclass().getdeclaredmethod(methodname, getparametertypes(args));
return method.invoke(obj, args);
}
// 推荐: 使用缓存
private static final concurrenthashmap<class<?>, map<string, method>> method_cache = new concurrenthashmap<>();
public object invoke(object obj, string methodname, object... args) throws exception {
class<?> clazz = obj.getclass();
map<string, method> methods = method_cache.computeifabsent(clazz,
k -> arrays.stream(k.getdeclaredmethods())
.collect(collectors.tomap(method::getname, m -> m, (m1, m2) -> m1)));
method method = methods.get(methodname);
return method.invoke(obj, args);
}2. 区分getmethods()和getdeclaredmethods()
getmethods()返回所有公共方法，包括继承的方法getdeclaredmethods()返回所有方法（包括私有、保护、默认和公共），但不包括继承的方法
// 获取所有公共方法（包括从父类继承的） method[] publicmethods = myclass.class.getmethods(); // 获取所有声明的方法（包括私有方法，但不包括继承方法） method[] declaredmethods = myclass.class.getdeclaredmethods();
选择正确的方法可以提高性能并避免意外访问不应访问的方法。
3. 正确处理invocationtargetexception
使用反射调用方法时，原始异常会被包装在invocationtargetexception中，应当提取并处理原始异常。
try {
method.invoke(obj, args);
} catch (invocationtargetexception e) {
// 获取并处理目标方法抛出的实际异常
throwable targetexception = e.gettargetexception();
log.error("method {} threw an exception: {}", method.getname(), targetexception.getmessage());
throw targetexception; // 或者适当处理
} catch (illegalaccessexception e) {
// 处理访问权限问题
log.error("access denied to method {}: {}", method.getname(), e.getmessage());
}4. 合理使用setaccessible(true)
使用setaccessible(true)可以绕过访问检查，访问私有成员，但应谨慎使用。
field privatefield = myclass.class.getdeclaredfield("privatefield");
privatefield.setaccessible(true); // 允许访问私有字段
privatefield.set(instance, newvalue);在生产环境中，应当考虑这种操作的必要性和安全影响。
5. 使用泛型增强类型安全
泛型可以减少类型转换，使反射代码更安全。
// 类型不安全的反射
object result = method.invoke(obj, args);
string strresult = (string) result; // 可能的classcastexception
// 使用泛型增强类型安全
public <t> t invokemethod(object obj, method method, object... args) throws exception {
@suppresswarnings("unchecked")
t result = (t) method.invoke(obj, args);
return result;
}性能优化技巧
6. 避免反射热点路径
在性能关键的代码路径上避免使用反射。如果必须使用，考虑以下替代方案：
- 使用工厂模式或依赖注入
- 预先生成访问器代码
- 使用接口而非反射
// 不推荐: 频繁调用的代码中使用反射
for (int i = 0; i < 1000000; i++) {
method.invoke(obj, i);
}
// 推荐: 将反射封装到工厂中，一次性创建调用器
interface processor {
void process(int i);
}
processor processor = createprocessor(obj, method);
for (int i = 0; i < 1000000; i++) {
processor.process(i);
}7. 考虑使用methodhandle而非反射
java 7引入的methodhandle通常比传统反射更高效，特别是在重复调用同一方法时。
// 使用methodhandle
methodtype methodtype = methodtype.methodtype(string.class, int.class);
methodhandles.lookup lookup = methodhandles.lookup();
methodhandle handle = lookup.findvirtual(string.class, "substring", methodtype);
// 调用方法（性能更好的热点路径）
string result = (string) handle.invoke("hello world", 6);8. 利用lambdametafactory创建高效函数接口
对于简单的getter和setter方法，可以使用lambdametafactory创建函数接口，性能接近直接调用。
public static <t, r> function<t, r> creategetter(class<t> clazz, string propertyname) throws exception {
method method = clazz.getdeclaredmethod("get" + capitalize(propertyname));
methodhandles.lookup lookup = methodhandles.lookup();
callsite site = lambdametafactory.metafactory(
lookup,
"apply",
methodtype.methodtype(function.class),
methodtype.methodtype(object.class, object.class),
lookup.unreflect(method),
methodtype.methodtype(method.getreturntype(), clazz));
return (function<t, r>) site.gettarget().invokeexact();
}
// 使用生成的函数
function<person, string> namegetter = creategetter(person.class, "name");
string name = namegetter.apply(person); // 性能接近直接调用person.getname()9. 使用第三方库优化反射
某些情况下，可以考虑使用专门针对反射优化的库：
- bytebuddy
- reflectasm
- cglib
// 使用bytebuddy优化反射调用
getter<person, string> namegetter = methodhandles.lookup()
.in(person.class)
.getter(person.class.getdeclaredfield("name"))
.bindto(bytebuddy.install(methodhandles.lookup()));
string name = namegetter.get(person);10. 谨慎传递大型数组或复杂对象
当通过反射传递参数或返回值时，大型数组或复杂对象可能导致性能问题。考虑使用更简单的数据类型或流式处理。
// 不推荐: 通过反射传递大数组
object[] largearray = new object[10000];
method.invoke(obj, (object) largearray);
// 推荐: 使用更小的批次或流处理
stream.of(largearray)
.collect(collectors.groupingby(i -> i % 100))
.foreach((batch, items) -> {
try {
method.invoke(obj, (object) items.toarray());
} catch (exception e) {
// 处理异常
}
});安全性考虑
11. 避免通过反射修改final字段
虽然技术上可行，但修改final字段可能导致线程安全问题和不可预测的行为。
// 危险操作: 修改final字段
field field = myclass.class.getdeclaredfield("constant");
field.setaccessible(true);
field modifiersfield = field.class.getdeclaredfield("modifiers");
modifiersfield.setaccessible(true);
modifiersfield.setint(field, field.getmodifiers() & ~modifier.final);
field.set(null, newvalue); // 可能引起严重问题这种操作在java 9后变得更加困难，并且在理论上可能导致jvm优化假设失效。
12. 访问控制检查
在框架或api中，要实施适当的访问控制检查，防止恶意使用反射。
public void invokemethod(object target, string methodname, object... args) {
// 检查调用者是否有权限执行此操作
securitymanager sm = system.getsecuritymanager();
if (sm != null) {
sm.checkpermission(new reflectpermission("suppressaccesschecks"));
}
// 检查目标方法是否在允许调用的白名单中
if (!allowed_methods.contains(methodname)) {
throw new securityexception("method not in allowed list: " + methodname);
}
// 执行反射操作
// ...
}13. 注意jdk版本差异
不同jdk版本对反射的限制不同，java 9以后的模块系统对反射访问增加了更多限制。
// java 9+ 访问非导出模块的类
try {
// 尝试使用反射访问
class<?> clazz = class.forname("jdk.internal.misc.unsafe");
// 这会抛出异常，除非使用--add-opens参数启动jvm
} catch (exception e) {
// 处理访问限制异常
}java 11+中，推荐在启动参数中明确指定需要开放的模块：
--add-opens java.base/jdk.internal.misc=all-unnamed
14. 处理动态代理的安全问题
使用反射和动态代理时，确保代理类不会被滥用。
// 安全的代理创建
invocationhandler handler = new myinvocationhandler();
myinterface proxy = (myinterface) proxy.newproxyinstance(
myinterface.class.getclassloader(),
new class<?>[] { myinterface.class },
(proxy, method, args) -> {
// 检查是否允许调用此方法
if (method.getdeclaringclass() == object.class) {
return method.invoke(handler, args); // 允许object方法
}
if (!allowed_methods.contains(method.getname())) {
throw new securityexception("method not allowed: " + method.getname());
}
return method.invoke(target, args);
});15. 避免反射调用序列化/反序列化方法
不要使用反射调用readobject、writeobject等序列化方法，这可能导致严重安全漏洞。
// 危险操作
method readobject = targetclass.getdeclaredmethod("readobject", objectinputstream.class);
readobject.setaccessible(true);
readobject.invoke(instance, inputstream); // 可能导致反序列化漏洞应当使用java标准序列化机制或安全的序列化库。
高级技巧与实践
16. 结合注解实现声明式编程
反射和注解结合可以实现强大的声明式编程模型，类似spring和jpa的实现方式。
// 自定义注解
@retention(retentionpolicy.runtime)
@target(elementtype.method)
public @interface transactional {
boolean readonly() default false;
}
// 使用反射处理注解
public void processclass(class<?> clazz) {
for (method method : clazz.getdeclaredmethods()) {
transactional annotation = method.getannotation(transactional.class);
if (annotation != null) {
boolean readonly = annotation.readonly();
// 创建事务代理...
}
}
}17. 获取泛型信息
尽管java有类型擦除，但可以通过反射api获取泛型信息。
public class genericexample<t> {
private list<string> stringlist;
private map<integer, t> genericmap;
// 获取字段泛型类型
public static void main(string[] args) throws exception {
field stringlistfield = genericexample.class.getdeclaredfield("stringlist");
parameterizedtype stringlisttype = (parameterizedtype) stringlistfield.getgenerictype();
class<?> stringlistclass = (class<?>) stringlisttype.getactualtypearguments()[0];
system.out.println(stringlistclass); // 输出: class java.lang.string
field genericmapfield = genericexample.class.getdeclaredfield("genericmap");
parameterizedtype genericmaptype = (parameterizedtype) genericmapfield.getgenerictype();
type keytype = genericmaptype.getactualtypearguments()[0]; // integer
type valuetype = genericmaptype.getactualtypearguments()[1]; // t (typevariable)
system.out.println(keytype + ", " + valuetype);
}
}18. 实现插件系统和spi机制
反射是实现插件系统和服务提供者接口(spi)的关键技术。
public class pluginloader {
public static list<plugin> loadplugins(string packagename) {
list<plugin> plugins = new arraylist<>();
// 扫描包中的类
reflections reflections = new reflections(packagename);
set<class<? extends plugin>> pluginclasses =
reflections.getsubtypesof(plugin.class);
// 实例化插件
for (class<? extends plugin> pluginclass : pluginclasses) {
try {
// 查找@plugininfo注解
plugininfo info = pluginclass.getannotation(plugininfo.class);
if (info != null && info.enabled()) {
// 使用反射创建插件实例
plugin plugin = pluginclass.getdeclaredconstructor().newinstance();
plugins.add(plugin);
}
} catch (exception e) {
// 处理异常
}
}
return plugins;
}
}19. 避免反射创建原生类型数组
创建原生类型数组需要特别注意，不能直接使用array.newinstance()。
// 错误: 尝试通过反射创建int[] object array = array.newinstance(int.class, 10); // 正确 object array = array.newinstance(integer.type, 10); // 也正确 // 错误: 尝试通过反射设置值 array.set(array, 0, 42); // 抛出illegalargumentexception // 正确方式 array.setint(array, 0, 42);
20. 使用反射模拟依赖注入
可以使用反射实现简单的依赖注入框架，类似spring的核心功能。
public class simpledi {
private map<class<?>, object> container = new hashmap<>();
public void register(class<?> type, object instance) {
container.put(type, instance);
}
public <t> t getinstance(class<t> type) throws exception {
// 检查容器中是否已有实例
if (container.containskey(type)) {
return type.cast(container.get(type));
}
// 创建新实例
constructor<t> constructor = type.getdeclaredconstructor();
t instance = constructor.newinstance();
// 注入字段
for (field field : type.getdeclaredfields()) {
if (field.isannotationpresent(inject.class)) {
field.setaccessible(true);
class<?> fieldtype = field.gettype();
object dependency = getinstance(fieldtype); // 递归解析依赖
field.set(instance, dependency);
}
}
container.put(type, instance);
return instance;
}
}总结
在实际应用中，应当权衡反射带来的灵活性与潜在的性能、安全和可维护性问题。
大多数情况下，如果有不使用反射的替代方案，应优先考虑。
最后，优秀的框架设计应该尽量将反射细节封装起来，为最终用户提供清晰、类型安全的api，只在必要的内部实现中使用反射。
以上就是java中反射的20个使用技巧分享的详细内容，更多关于java反射技巧的资料请关注代码网其它相关文章！
发表评论