反射如何进行实战与优化
上一篇文章我们简单介绍了反射的设计初衷，作用和基本的功能。
1.在工作中如何使用反射
反射的主要作用就是运行过程中创建类的对象，在通常情况下，我们使用new关键字已经够用了。但是当工作中某一些处理或者其他功能的类特别多时，我们通常会采用工厂模式进行处理到map中，通过code定义的key 去获取我们的处理调用。但是随着我们的业务的改变增加时，我们再一个一个的去new就显得特别复杂。那么我们就会想，可以根据他们的共同特征去查找出所有的这些类，然后循环去创建他们的实例。
第一种方式：需要创建的类是一个父类的子类
比如protobuf等消息类的处理，我们在创建protobuf消息时，需要创建每个消息的builder.而我们的消息总是随着业务，增加的.手动的增加消息的builder显然是不合适的，开发者很容易忘记添加新的消息到工厂类。那么我们就可以采用反射代替。
public static void init() {
//利用反射获取游戏消息下的所有子类
//getDeclaredClasses 获取改类下的所有子类 返回calss数组
Class<?>[] declaredClasses = GameMsgProtocol.class.getDeclaredClasses();
for (Class<?> declaredClass : declaredClasses) {
//isAssignableFrom 判断是否是calss的子类，包括这个类自身
if (!GeneratedMessageV3.class.isAssignableFrom(declaredClass)){
continue;
}
GameMsgProtocol.MsgCode[] values = GameMsgProtocol.MsgCode.values();
//getSimpleName 获取简单类名
String className = declaredClass.getSimpleName().toLowerCase();
for (GameMsgProtocol.MsgCode msgCode : values) {
if (!msgCode.name().replaceAll("_","").toLowerCase().startsWith(className)){
continue;
}
try {
//通过执行该calss的getDefaultInstance 方法（method）获取该类的实例
//invoke method通过反射执行方法
GeneratedMessageV3 getDefaultInstance =( GeneratedMessageV3) declaredClass.getDeclaredMethod("getDefaultInstance").invoke(declaredClass);
msgCodeBuilderMap.put(msgCode.getNumber(),getDefaultInstance);
msgClassMap.put(declaredClass,msgCode.getNumber());
} catch (Exception e) {
e.printStackTrace();
logger.error(e.getMessage(),e);
}
}
}
}
第二种方式：需要创建的类统一实现了某个接口
由于calss信息并不能包含他的子类或者实现类的信息，所以我们只能通过扫描某个包下所有的类进行判断处理是否是某个接口的实现类。
/**
* 初始化消息处理器到map中
*/
public static void init() {
log.info("初始化消息处理器：");
Set<Class<?>> classes = PackageUtil.listSubClazz(CmdHandlerFactory.class.getPackage().getName(), false, CmdHandler.class);
for (Class<?> clazz : classes) {
//判断是否是抽象类
if ((clazz.getModifiers() & Modifier.ABSTRACT) != 0) {
continue;
}
//获取类的所有的方法
Method[] methods = clazz.getMethods();
for (Method method : methods) {
//获取方法名称
if (!method.getName().equalsIgnoreCase("handle")) {
continue;
}
//获取方法的参数类型。参数可能是多个所以是数组
Class<?>[] parameterTypes = method.getParameterTypes();
for (Class<?> parameterType : parameterTypes) {
//判断方法中参数是否是消息子类，并不属于消息父类，是的话加入map,因为一个消息器只能处理一种类型的消息，所以直接跳出参数循环
if (GeneratedMessageV3.class.isAssignableFrom(parameterType) && parameterType != GeneratedMessageV3.class) {
try {
Object newInstance = clazz.newInstance();
CMD_HADLER.put(parameterType, (CmdHandler) newInstance);
log.info("消息处理器：{}<==>{}",parameterType,newInstance.getClass().getSimpleName());
} catch (Exception e) {
e.printStackTrace();
}
break;
}
}
}
}
}
这里将扫描包下的calss文件的工具类一并贴出。
package com.sunwhite.herostore.util;
import java.io.File;
import java.io.FileInputStream;
import java.net.URL;
import java.util.*;
import java.util.jar.JarEntry;
import java.util.jar.JarInputStream;
/**
* 名称空间实用工具
*/
public final class PackageUtil {
/**
* 类默认构造器
*/
private PackageUtil() {
}
/**
* 列表指定包中的所有子类
*
* @param packageName 包名称
* @param recursive 是否递归查找
* @param superClazz 父类的类型
* @return 子类集合
*/
static public Set<Class<?>> listSubClazz(
String packageName,
boolean recursive,
Class<?> superClazz) {
if (superClazz == null) {
return Collections.emptySet();
} else {
return listClazz(packageName, recursive, superClazz::isAssignableFrom);
}
}
/**
* 列表指定包中的所有类
*
* @param packageName 包名称
* @param recursive 是否递归查找?
* @param filter 过滤器
* @return 符合条件的类集合
*/
static public Set<Class<?>> listClazz(
String packageName, boolean recursive, IClazzFilter filter) {
if (packageName == null ||
packageName.isEmpty()) {
return null;
}
// 将点转换成斜杠
final String packagePath = packageName.replace('.', '/');
// 获取类加载器
ClassLoader cl = Thread.currentThread().getContextClassLoader();
// 结果集合
Set<Class<?>> resultSet = new HashSet<>();
try {
// 获取 URL 枚举
Enumeration<URL> urlEnum = cl.getResources(packagePath);
while (urlEnum.hasMoreElements()) {
// 获取当前 URL
URL currUrl = urlEnum.nextElement();
// 获取协议文本
final String protocol = currUrl.getProtocol();
// 定义临时集合
Set<Class<?>> tmpSet = null;
if ("FILE".equalsIgnoreCase(protocol)) {
// 从文件系统中加载类
tmpSet = listClazzFromDir(
new File(currUrl.getFile()), packageName, recursive, filter
);
} else if ("JAR".equalsIgnoreCase(protocol)) {
// 获取文件字符串
String fileStr = currUrl.getFile();
if (fileStr.startsWith("file:")) {
// 如果是以 "file:" 开头的,
// 则去除这个开头
fileStr = fileStr.substring(5);
}
if (fileStr.lastIndexOf('!') > 0) {
// 如果有 '!' 字符,
// 则截断 '!' 字符之后的所有字符
fileStr = fileStr.substring(0, fileStr.lastIndexOf('!'));
}
// 从 JAR 文件中加载类
tmpSet = listClazzFromJar(
new File(fileStr), packageName, recursive, filter
);
}
if (tmpSet != null) {
// 如果类集合不为空,
// 则添加到结果中
resultSet.addAll(tmpSet);
}
}
} catch (Exception ex) {
// 抛出异常!
throw new RuntimeException(ex);
}
return resultSet;
}
/**
* 从目录中获取类列表
*
* @param dirFile 目录
* @param packageName 包名称
* @param recursive 是否递归查询子包
* @param filter 类过滤器
* @return 符合条件的类集合
*/
static private Set<Class<?>> listClazzFromDir(
final File dirFile, final String packageName, final boolean recursive, IClazzFilter filter) {
if (!dirFile.exists() ||
!dirFile.isDirectory()) {
// 如果参数对象为空,
// 则直接退出!
return null;
}
// 获取子文件列表
File[] subFileArr = dirFile.listFiles();
if (subFileArr == null ||
subFileArr.length <= 0) {
return null;
}
// 文件队列, 将子文件列表添加到队列
Queue<File> fileQ = new LinkedList<>(Arrays.asList(subFileArr));
// 结果对象
Set<Class<?>> resultSet = new HashSet<>();
while (!fileQ.isEmpty()) {
// 从队列中获取文件
File currFile = fileQ.poll();
if (currFile.isDirectory() &&
recursive) {
// 如果当前文件是目录,
// 并且是执行递归操作时,
// 获取子文件列表
subFileArr = currFile.listFiles();
if (subFileArr != null &&
subFileArr.length > 0) {
// 添加文件到队列
fileQ.addAll(Arrays.asList(subFileArr));
}
continue;
}
if (!currFile.isFile() ||
!currFile.getName().endsWith(".class")) {
// 如果当前文件不是文件,
// 或者文件名不是以 .class 结尾,
// 则直接跳过
continue;
}
// 类名称
String clazzName;
// 设置类名称
clazzName = currFile.getAbsolutePath();
// 清除最后的 .class 结尾
clazzName = clazzName.substring(dirFile.getAbsolutePath().length(), clazzName.lastIndexOf('.'));
// 转换目录斜杠
clazzName = clazzName.replace('\\', '/');
// 清除开头的 /
clazzName = trimLeft(clazzName, "/");
// 将所有的 / 修改为 .
clazzName = join(clazzName.split("/"), ".");
// 包名 + 类名
clazzName = packageName + "." + clazzName;
try {
// 加载类定义
Class<?> clazzObj = Class.forName(clazzName);
if (null != filter &&
!filter.accept(clazzObj)) {
// 如果过滤器不为空,
// 且过滤器不接受当前类,
// 则直接跳过!
continue;
}
// 添加类定义到集合
resultSet.add(clazzObj);
} catch (Exception ex) {
// 抛出异常
throw new RuntimeException(ex);
}
}
return resultSet;
}
/**
* 从 .jar 文件中获取类列表
*
* @param jarFilePath .jar 文件路径
* @param recursive 是否递归查询子包
* @param filter 类过滤器
* @return 符合条件的类集合
*/
static private Set<Class<?>> listClazzFromJar(
final File jarFilePath, final String packageName, final boolean recursive, IClazzFilter filter) {
if (jarFilePath == null ||
jarFilePath.isDirectory()) {
// 如果参数对象为空,
// 则直接退出!
return null;
}
// 结果对象
Set<Class<?>> resultSet = new HashSet<>();
try {
// 创建 .jar 文件读入流
JarInputStream jarIn = new JarInputStream(new FileInputStream(jarFilePath));
// 进入点
JarEntry entry;
while ((entry = jarIn.getNextJarEntry()) != null) {
if (entry.isDirectory()) {
continue;
}
// 获取进入点名称
String entryName = entry.getName();
if (!entryName.endsWith(".class")) {
// 如果不是以 .class 结尾,
// 则说明不是 JAVA 类文件, 直接跳过!
continue;
}
if (!recursive) {
//
// 如果没有开启递归模式,
// 那么就需要判断当前 .class 文件是否在指定目录下?
//
// 获取目录名称
String tmpStr = entryName.substring(0, entryName.lastIndexOf('/'));
// 将目录中的 "/" 全部替换成 "."
tmpStr = join(tmpStr.split("/"), ".");
if (!packageName.equals(tmpStr)) {
// 如果包名和目录名不相等,
// 则直接跳过!
continue;
}
}
String clazzName;
// 清除最后的 .class 结尾
clazzName = entryName.substring(0, entryName.lastIndexOf('.'));
// 将所有的 / 修改为 .
clazzName = join(clazzName.split("/"), ".");
// 加载类定义
Class<?> clazzObj = Class.forName(clazzName);
if (null != filter &&
!filter.accept(clazzObj)) {
// 如果过滤器不为空,
// 且过滤器不接受当前类,
// 则直接跳过!
continue;
}
// 添加类定义到集合
resultSet.add(clazzObj);
}
// 关闭 jar 输入流
jarIn.close();
} catch (Exception ex) {
// 抛出异常
throw new RuntimeException(ex);
}
return resultSet;
}
/**
* 类名称过滤器
*
* @author hjj2019
*/
@FunctionalInterface
static public interface IClazzFilter {
/**
* 是否接受当前类?
*
* @param clazz 被筛选的类
* @return 是否符合条件
*/
boolean accept(Class<?> clazz);
}
/**
* 使用连接符连接字符串数组
*
* @param strArr 字符串数组
* @param conn 连接符
* @return 连接后的字符串
*/
static private String join(String[] strArr, String conn) {
if (null == strArr ||
strArr.length <= 0) {
return "";
}
StringBuilder sb = new StringBuilder();
for (int i = 0; i < strArr.length; i++) {
if (i > 0) {
// 添加连接符
sb.append(conn);
}
// 添加字符串
sb.append(strArr[i]);
}
return sb.toString();
}
/**
* 清除源字符串左边的字符串
*
* @param src 原字符串
* @param trimStr 需要被清除的字符串
* @return 清除后的字符串
*/
static private String trimLeft(String src, String trimStr) {
if (null == src ||
src.isEmpty()) {
return "";
}
if (null == trimStr ||
trimStr.isEmpty()) {
return src;
}
if (src.equals(trimStr)) {
return "";
}
while (src.startsWith(trimStr)) {
src = src.substring(trimStr.length());
}
return src;
}
}
2.使用反射如何进行优化
我们都知道，使用反射进行类的创建效率远远不如我们直接创建类，或者调用方法执行。因为使用反射我们需要去查找需要执行的类和方法。因此，如果某些时候我们我们需要频繁的使用的反射的方法创建类时，我们可以想办法，通过反射的方法创建出我们需要的类文件，然后把它存储起来，下移调用的时候直接调用calss文件来提成代码的执行效率。
比如，我们的将jdbc的ResultSet获取的值转换成相应实体类的entity。
动态创建类的calss文件我们是通过javassist来实现的。maven依赖去下。
<dependency>
<groupId>javassist</groupId>
<artifactId>javassist</artifactId>
<version>3.12.1.GA</version>
</dependency>
动态创建类的calss操作如下：
原理:使用stringbuf 将我们需要动态化的内容，拼接一个Class类的源代码,然后通过javassiat生成该类的calss文件进行调用。
public static AbstractEntityHelper getEntityHelper(Class<?> entityClazz) throws Exception {
// 这里需要全新设计,
// 接下来就该请出 javassist 了!
// 判断是否为空
if(null==entityClazz){
return null;
}
AbstractEntityHelper entityHelper=entiyHelperFactory.get(entityClazz);
if (null!=entityHelper){
return entityHelper;
}
//使用javassist生成entityHelper
//获取类池
ClassPool classPool = ClassPool.getDefault();
ClassPath classPath = classPool.appendSystemPath();
//导入相关类，生成entityHelper的代码
classPool.importPackage(ResultSet.class.getName());
classPool.importPackage(entityClazz.getName());
//抽象助手类
CtClass abstractEntityHelperClazz = classPool.getCtClass(AbstractEntityHelper.class.getName());
//助手实现类的名称
String entityHelperClazzName = entityClazz.getName() + "_Helper";
//创建助手类，会生成以下代码
CtClass entityHelperClazz = classPool.makeClass(entityHelperClazzName, abstractEntityHelperClazz);
//创建默认的构造器
CtConstructor ctConstructor = new CtConstructor(new CtClass[0], entityHelperClazz);
//创建默认构造器的方法体
ctConstructor.setBody("{}");
entityHelperClazz.addConstructor(ctConstructor);
//用户创建方法字符串
StringBuffer sb = new StringBuffer();
sb.append("public Object create(java.sql.ResultSet rs) throws Exception{\n");
sb.append(entityClazz.getName()).append(" obj =new ").append(entityClazz.getName()).append("();\n");
//通过反射的方式获取实体类的字段数组并拼接成字符串放入需要创建的类中
Field[] declaredFields = entityClazz.getDeclaredFields();
for (Field field : declaredFields) {
Column column = field.getAnnotation(Column.class);
if (column==null){
continue;
}
String columnName = column.name();
if (field.getType() == Integer.TYPE) {
// 生成如下代码 :
// obj._userId = rs.getInt("user_id");
sb.append("obj.")
.append(field.getName())
.append(" = rs.getInt(\"")
.append(columnName)
.append("\");\n");
} else if (field.getType().equals(String.class)) {
// 生成如下代码 :
// obj._userName = rs.getString("user_name");
sb.append("obj.")
.append(field.getName())
.append(" = rs.getString(\"")
.append(columnName)
.append("\");\n");
} else {
// 不支持的类型...
}
}
sb.append("return obj;\n");
sb.append("}");
//创建解析方法
CtMethod ctMethod = CtNewMethod.make(sb.toString(), entityHelperClazz);
entityHelperClazz.addMethod(ctMethod);
Class<?> javaClazz = entityHelperClazz.toClass();
//创建对象帮助实例
AbstractEntityHelper abstractEntityHelper = (AbstractEntityHelper) javaClazz.newInstance();
entiyHelperFactory.put(entityClazz,abstractEntityHelper);
return abstractEntityHelper;
}
感谢阅读，致力于成为CV工程师的词典！