【读Ngbatis源码记】当启动Ngbatis时，发生了什么
站长
· 阅读数 23
点进这篇文章的同学可能不了解Ngbatis，但是说起mybatis应该不陌生。
Ngbatis是为NebulaGraph图数据库量身定制一款ORM框架，它允许开发者通过XML映射或Java注解来编写NebulaGraph查询语言（nGQL），实现与图数据库的交互。它借鉴了MyBatis的使用习惯进行开发，并包含了一些类似于mybatis-plus的单表操作，同时还包括了图数据库特有的实体-关系基本操作。
这里先贴上仓库地址：github.com/nebula-cont…，欢迎来玩~
这篇文章的主要目的是帮助自己更好地熟悉ngbatis源码，做的一些笔记。
先贴个ngbatis启动时初始化过程的时序图，来源于ngbatis官网，地址贴到最后了
从启动类出发：NgbatisContextInitializer
NgbatisContextInitializer方法主要作用是为了初始化一些配置信息。包括NebulaPoolConfig连接池初始化、NgbatisConfigNgbatis的配置信息初始化、NebulaJdbcProperties连接配置初始化等。并在初始化时加入了NgbatisBeanFactoryPostProcessor前置处理器。
1.执行initialize方法，从配置文件中读取配置信息
@Override
public void initialize(ConfigurableApplicationContext context) {
//确保 Env 能够使用Spring管理的类加载器
Env.classLoader = context.getClassLoader();
//获取Spring应用上下文的可配置环境对象
ConfigurableEnvironment environment = context.getEnvironment();
//①调用NgbatisContextInitializer.getNebulaPoolConfig方法，实例化一个nebula数据库连接池，且加载自定义配置
NebulaPoolConfig nebulaPool = getNebulaPoolConfig(environment);
//②调用NgbatisContextInitializer.getNebulaNgbatisConfig方法，加载yaml中关于ngbatis的自定义配置
NgbatisConfig ngbatisConfig = getNebulaNgbatisConfig(environment);
//③调用NgbatisContextInitializer.getNebulaJdbcProperties方法读取并应用 Nebula 数据库连接的配置信息
if (environment.getProperty("nebula.hosts") != null) {
NebulaJdbcProperties nebulaJdbcProperties =
getNebulaJdbcProperties(environment)
.setPoolConfig(nebulaPool)
.setNgbatis(ngbatisConfig);
ParseCfgProps parseCfgProps = readParseCfgProps(environment);
//注册一个新的 NgbatisBeanFactoryPostProcessor
context.addBeanFactoryPostProcessor(
new NgbatisBeanFactoryPostProcessor(nebulaJdbcProperties, parseCfgProps, context)
);
}
}
Env类是ngbatis框架存储全局环境信息的地方，具体如下：
public class Env {
//类加载器
public static ClassLoader classLoader;
// 使用 fastjson 安全模式，规避任意代码执行风险
static {
ParserConfig.getGlobalInstance().setSafeMode(true);
}
private Logger log = LoggerFactory.getLogger(Env.class);
// 模板引擎 默认 beetl
private TextResolver textResolver;
// 结果集路由
private ResultResolver resultResolver;
// 参数解析器
private ArgsResolver argsResolver;
// 参数名格式化器
private ArgNameFormatter argNameFormatter;
// 解析的参数配置
private ParseCfgProps cfgProps;
// 应用上下文
private ApplicationContext context;
// 用户名
private String username;
// 密码
private String password;
// 连接是否支持重连
private boolean reconnect = false;
// 图空间
private String space;
// 主键生成器
private PkGenerator pkGenerator;
// 本地会话调度器
private SessionDispatcher dispatcher;
// xml 中标签所声明的信息或方法类
private MapperContext mapperContext;
...构造器
/**
* 获取 Nebula SessionPool
* @return SessionPool
*/
public SessionPool getSessionPool(String spaceName) {
return mapperContext.getNebulaSessionPoolMap().get(spaceName);
}
/**
* <p>获取nebula graph的会话。</p>
* @return session
*/
public Session openSession() {
try {
return mapperContext.getNebulaPool().getSession(username, password, reconnect);
} catch (Throwable e) {
throw new RuntimeException(e);
}
}
...get和set方法
}
① 调用本类的getNebulaPoolConfig方法如下：
private NebulaPoolConfig getNebulaPoolConfig(ConfigurableEnvironment environment) {
NebulaPoolConfig nebulaPoolConfig = new NebulaPoolConfig()
.setMinConnSize(
environment.getProperty("nebula.pool-config.min-conns-size", Integer.class, 0))
.setMaxConnSize(
environment.getProperty("nebula.pool-config.max-conns-size", Integer.class, 10))
.setTimeout(environment.getProperty("nebula.pool-config.timeout", Integer.class, 0))
.setIdleTime(environment.getProperty("nebula.pool-config.idle-time", Integer.class, 0))
.setIntervalIdle(
environment.getProperty("nebula.pool-config.interval-idle", Integer.class, -1))
.setWaitTime(environment.getProperty("nebula.pool-config.wait-time", Integer.class, 0));
return nebulaPoolConfig;
}
application.yaml文件中关于库的配置如下：
nebula:
pool-config:
min-conns-size: 0
max-conns-size: 10
timeout: 6000
idle-time: 0
interval-idle: -1
wait-time: 6000
min-cluster-health-rate: 1.0
enable-ssl: false
问题：为什么可以从environment直接获取yaml中关于数据库的配置？
Spring Boot 在启动时会自动加载
application.yml或application.properties文件中的配置，并将其放入环境中。
问题：这些关于连接池的配置项是什么意思？
- min-conns-size: 最小连接数。这是连接池始终维持的最小空闲连接数。即使没有活动数据库操作，连接池也至少会有这么多连接已经建立并等待被使用。
- max-conns-size: 最大连接数。这是连接池允许的最大连接数。超过这个数量的连接请求将被排队，直到有可用的连接。
- timeout: 超时时间。这是数据库操作的超时时间，单位通常是秒或毫秒。如果一个数据库操作超过这个时间限制还没有完成，它将抛出一个超时异常。
- idle-time: 空闲时间。这是连接在被关闭之前可以在池中保持空闲状态的最长时间。超过这个时间限制的空闲连接将被回收。
- interval-idle: 空闲间隔。这个配置可能用于设置检测并回收空闲连接的时间间隔。在每个间隔之后，连接池可能会检查并关闭一些空闲时间超过
idle-time的连接。- wait-time: 等待时间。这是当连接池中没有可用连接时，连接请求必须等待的最长时间。如果在这个时间内没有可用的连接返回到池中，请求可能会失败或抛出异常。
② 调用本类的getNebulaNgbatisConfig方法如下：
private NgbatisConfig getNebulaNgbatisConfig(ConfigurableEnvironment environment) {
return new NgbatisConfig()
.setSessionLifeLength(
//
environment.getProperty("nebula.ngbatis.session-life-length", Long.class)
)
.setCheckFixedRate(
environment.getProperty("nebula.ngbatis.check-fixed-rate", Long.class)
)
.setUseSessionPool(
environment.getProperty("nebula.ngbatis.use-session-pool", Boolean.class)
);
}
application.yaml文件中关于ngbatis的配置如下：
nebula:
ngbatis:
session-life-length: 300000
check-fixed-rate: 300000
# space name needs to be informed through annotations(@Space) or xml(space="test")
# default false(false: Session pool map will not be initialized)
use-session-pool: false
问题：这些关于ngbatis的配置项是什么意思？
- session-life-length:会话存活有效期，300000毫秒即5分钟。一个会话在没有活动时可以保持打开状态的最长时间。超过这个时间限制后，会话将自动关闭，以释放资源。
- checkFixedRate:会话健康检查的固定间隔时间。
- use-session-pool:是否使用 Nebula-java 的会话池。
③ 调用本类的getNebulaJdbcProperties方法如下：
private NebulaJdbcProperties getNebulaJdbcProperties(ConfigurableEnvironment environment) {
NebulaJdbcProperties nebulaJdbcProperties = new NebulaJdbcProperties();
String hosts = getProperty(environment, "nebula.hosts");
String username = getProperty(environment, "nebula.username");
String password = getProperty(environment, "nebula.password");
String space = getProperty(environment, "nebula.space");
return nebulaJdbcProperties
.setHosts(hosts)
.setUsername(username)
.setPassword(password)
.setSpace(space);
}
再到BeanFactoryPostProcessor类：NgbatisBeanFactoryPostProcessor
这个类是“Ngbatis 创建动态代理的主程”，实现了BeanFactoryPostProcessor类。
Kimi🌓这样说： 在Spring框架中，
BeanFactoryPostProcessor是一个接口，它允许开发者在容器实例化所有的bean之前，对BeanFactory进行自定义的修改或扩展。具体来说，BeanFactoryPostProcessor的目的是：
- 修改Bean定义：在Spring容器创建bean实例之前，可以修改bean的属性值，比如修改bean的scope、lazy-init属性等。
- 添加新的Bean定义：可以在BeanFactory中注册新的bean定义，这些定义在配置文件中没有被显式地定义。
- 删除Bean定义：可以移除BeanFactory中的某些bean定义。
- 修改Bean的创建过程：可以影响bean的创建过程，比如自定义初始化和销毁方法。
BeanFactoryPostProcessor接口定义了两个方法：
postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)：这个方法在BeanFactory标准初始化之后，所有的bean定义已加载但实例化之前调用。开发者可以在这里执行自定义逻辑来修改BeanFactory。
2.执行postProcessBeanFactory方法，创建连接池和全局上下文MapperContext
@Override
public void postProcessBeanFactory(
ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
//创建连接池
NebulaPool nebulaPool = nebulaPool();
//创捷全局上下文
mapperContext(nebulaPool);
}
创建连接池，调用本类的nebulaPool方法如下：
public NebulaPool nebulaPool() {
NebulaPool pool = new NebulaPool();
try {
//⭐调用连接池的init方法
pool.init(
nebulaJdbcProperties.getHostAddresses(),
nebulaJdbcProperties.getPoolConfig()
);
} catch (UnknownHostException e) {
throw new RuntimeException("Can not connect to Nebula Graph");
}
return pool;
}
如图所示，init 方法传入了两个参数，一个是地址集合参数，一个是线程池配置参数。
NebulaGraph 的连接池其实就是基于 apache commons-pool2 对象池框架对连接进行了池化管理。
具体init方法的介绍可参考这篇文章 [Ngbatis源码学习]Ngbatis源码阅读之连接池的创建 - knqiufan - 博客园 (cnblogs.com)
创建全局上下文，调用本类的mapperContext方法如下：
public MapperContext mapperContext(NebulaPool nebulaPool) {
//实例化了一个基础类资源加载器
DaoResourceLoader daoBasicResourceLoader = new DaoResourceLoader(parseCfgProps);
//实例化MapperContext
MapperContext context = MapperContext.newInstance();
context.setResourceRefresh(parseCfgProps.isResourceRefresh());
context.setNgbatisConfig(nebulaJdbcProperties.getNgbatis());
//①调用MapperResourceLoader.load方法读取用户创建的 XXXDao.xml 并解析，存入上下文
Map<String, ClassModel> interfaces = daoBasicResourceLoader.load();
//②调用DaoResourceLoader.loadTpl方法读取 NebulaDaoBasic 的模板文件并解析，存入上下文
Map<String, String> daoBasicTpl = daoBasicResourceLoader.loadTpl();
context.setDaoBasicTpl(daoBasicTpl);
context.setNebulaPool(nebulaPool);
context.setInterfaces(interfaces);
context.setNebulaPoolConfig(nebulaJdbcProperties.getPoolConfig());
//③调用NgbatisBeanFactoryPostProcessor.figureTagTypeMapping方法，将实体类型设置到MapperContext中
figureTagTypeMapping(interfaces.values(), context.getTagTypeMapping());
//④调用本类的setNebulaSessionPool方法，将全局上下文放进SessionPool中
setNebulaSessionPool(context);
//⑤调用本类的registerBean方法，为所有的动态代理类注册Bean到SpringBoot
registerBean(context);
return context;
}
①调用MapperResourceLoader.load方法如下：
👉Mapper资源加载器：MapperResourceLoader
继承了PathMatchingResourcePatternResolver类
Kimi🌓这样说： 继承
PathMatchingResourcePatternResolver后，MapperResourceLoader可以利用 Spring 的资源抽象和模式匹配功能，同时添加自己的特定功能，以满足应用程序的特定需求。这在开发需要处理大量配置文件、映射文件或其他资源的应用程序时非常有用，比如在开发数据库访问层时，可能需要加载和解析大量的 SQL 映射文件。
提供了许多方法：
- load方法：加载resource目录下所有用户自定义的xxxDao.xml文件
- parseClassModel方法：解析每个xxxDao.xml文件
public Map<String, ClassModel> load() {
Map<String, ClassModel> resultClassModel = new HashMap<>();
try {
//获取资源路径 mapperLocations = "mapper/**/*.xml"
Resource[] resources = getResources(parseConfig.getMapperLocations());
for (Resource resource : resources) {
//⭐遍历每个xml文件，调用本类的parseClassModel方法解析，存入结果集中
resultClassModel.putAll(parseClassModel(resource));
}
} catch (IOException | NoSuchMethodException e) {
throw new ResourceLoadException(e);
}
return resultClassModel;
}
public Map<String, ClassModel> parseClassModel(Resource resource)
throws IOException, NoSuchMethodException {
Map<String, ClassModel> result = new HashMap<>();
// 从资源中获取文件信息，IO 读取
Document doc = Jsoup.parse(resource.getInputStream(), "UTF-8", "http://example.com/");
// 传入 xml 解析器，获取 xml 信息
Elements elementsByTag = doc.getElementsByTag(parseConfig.getMapper());
for (Element element : elementsByTag) {
ClassModel cm = new ClassModel();
cm.setResource(resource);
// 调用本身的match方法，获取 namespace 设置到 ClassModel 的 namespace 属性上
match(cm, element, "namespace", parseConfig.getNamespace());
// 与上行代码同理，前提是xml中有设置space
match(cm, element, "space", parseConfig.getSpace());
// 如果没在xml中设置space，则从注解获取 space
if (null == cm.getSpace()) {
//调用自身的setClassModelBySpaceAnnotation方法
setClassModelBySpaceAnnotation(cm);
}
//如果开启了sessionPool会把space的name放进sessionPool中进行初始化
addSpaceToSessionPool(cm.getSpace());
// 获取 子节点
List<Node> nodes = element.childNodes();
// ⭐便历子节点，调用自身的parseMethodModel方法，获取 MethodModel
Map<String, MethodModel> methods = parseMethodModel(cm, nodes);
cm.setMethods(methods);
result.put(cm.getNamespace().getName() + PROXY_SUFFIX, cm);
}
return result;
}
- match方法：通过反射给model赋值
- castValue方法：将value字符串转成type对象
- setClassModelBySpaceAnnotation方法：从注解中获取space的name
private void match(Object model, Node node, String javaAttr, String attr) {
String attrTemp = null;
try {
String attrText = node.attr(attr);
if (isBlank(attrText)) {
return;
}
attrTemp = attrText;
//getDeclaredField方法获取类中声明的与指定名称匹配的 Field 对象
Field field = model.getClass().getDeclaredField(javaAttr);
Class<?> type = field.getType();
//调用本身的castValue方法将 attrText 字符串转为 type 类型的对象
Object value = castValue(attrText, type);
//调用ReflectUtil的setValue方法，利用反射将value设置到model的field属性
ReflectUtil.setValue(model, field, value);
} catch (ClassNotFoundException e) {
throw new ParseException("类型 " + attrTemp + " 未找到");
} catch (Exception e) {
e.printStackTrace();
}
}
private Object castValue(String attrText, Class<?> type) throws ClassNotFoundException {
if (type == Class.class) {
return Class.forName(attrText);
} else if (boolean.class.equals(type)) {
return Boolean.valueOf(attrText);
} else {
return attrText;
}
}
//如果xml中没配置space，则通过这个方法从注解中获取space
private void setClassModelBySpaceAnnotation(ClassModel cm) {
try {
//getGenericInterfaces方法获取该类或接口实现的接口
Type[] genericInterfaces = cm.getNamespace().getGenericInterfaces();
if (genericInterfaces.length == 0) {
return;
}
//获取第一个泛型接口的具体类型，转为ParameterizedType类型
ParameterizedType nebulaDaoBasicType = (ParameterizedType) genericInterfaces[0];
Type[] genericTypes = nebulaDaoBasicType.getActualTypeArguments();
if (genericTypes.length == 0) {
return;
}
String spaceClassName = genericTypes[0].getTypeName();
//使用 Class.forName 加载类名对应的类，并获取该类上的@Space注解
Space annotation = Class.forName(spaceClassName).getAnnotation(Space.class);
if (null != annotation && !annotation.name().equals("")) {
cm.setSpace(annotation.name());
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
- parseMethodModel方法：解析每个xxxDao.xml的多个方法
- getMethodNames方法：过滤出所有 Element 类型的节点，并获取它们的ID，将这些ID收集到一个列表中返回
- parseNgqlModel方法：将xxxDao.xml中的<nGQL>标签的内容打包成NgqlModel
- parseMethodModel(Node node)方法:解析xxxDao.xml中的<mapper>方法打包成MethodModel
- nodesToString方法：获取<mapper>子标签默认插槽内的文本
- checkReturnType方法：检查返回参数
private Map<String, MethodModel> parseMethodModel(ClassModel cm, List<Node> nodes)
throws NoSuchMethodException {
Class namespace = cm.getNamespace();
Map<String, MethodModel> methods = new HashMap<>();
List<String> methodNames = getMethodNames(nodes);
for (Node methodNode : nodes) {
if (methodNode instanceof Element) {
//<nGQL id="include-test">
if (((Element) methodNode).tagName().equalsIgnoreCase("nGQL")) {
if (Objects.isNull(cm.getNgqls())) {
cm.setNgqls(new HashMap<>());
}
//调用自身的parseNgqlModel方法解析xxxDao.xml中的<nGQL>方法
NgqlModel ngqlModel = parseNgqlModel((Element) methodNode);
cm.getNgqls().put(ngqlModel.getId(),ngqlModel);
}
else {
//⭐调用自身的parseMethodModel方法解析xxxDao.xml中的多个<mapper>方法
MethodModel methodModel = parseMethodModel(methodNode);
addSpaceToSessionPool(methodModel.getSpace());
//调用ReflectUtil.getNameUniqueMethod方法根据dao接口和方法名获取唯一方法
Method method = getNameUniqueMethod(namespace, methodModel.getId());
methodModel.setMethod(method);
Assert.notNull(method,
"接口 " + namespace.getName() + " 中，未声明 xml 中的出现的方法：" + methodModel.getId());
//调用自身的checkReturnType方法检查返回参数
checkReturnType(method, namespace);
//⭐调用自身的方法，对需要分页的方法进行支持
pageSupport(method, methodModel, methodNames, methods, namespace);
methods.put(methodModel.getId(), methodModel);
}
}
}
return methods;
}
protected NgqlModel parseNgqlModel(Element ngqlEl) {
return new NgqlModel(ngqlEl.id(),ngqlEl.text());
}
private List<String> getMethodNames(List<Node> nodes) {
return nodes.stream().map(node -> {
if (node instanceof Element) {
return ((Element) node).id();
}
return null;
}).collect(Collectors.toList());
}
protected MethodModel parseMethodModel(Node node) {
MethodModel model = new MethodModel();
match(model, node, "id", parseConfig.getId());
match(model, node, "parameterType", parseConfig.getParameterType());
match(model, node, "resultType", parseConfig.getResultType());
match(model, node, "space", parseConfig.getSpace());
match(model, node, "spaceFromParam", parseConfig.getSpaceFromParam());
List<Node> nodes = node.childNodes();
//调用自身的nodesToString方法，将node的内容转为字符串解码后存入MethodModel
model.setText(nodesToString(nodes));
return model;
}
protected String nodesToString(List<? extends Node> nodes) {
StringBuilder builder = new StringBuilder();
for (Node node : nodes) {
if (node instanceof TextNode) {
builder.append(((TextNode) node).getWholeText());
builder.append("\n");
}
}
String mapperText = builder.toString();
//调用Jsoup库Entities.unescape方法，解码xml特殊符号
String unescape = Entities.unescape(mapperText);
return unescape;
}
//ReturnUtils.getNameUniqueMethod方法：根据方法名，获取唯一的方法
public static Method getNameUniqueMethod(Class<?> daoInterface, String methodName) {
Method[] daoMethods = daoInterface.getMethods();
for (Method method : daoMethods) {
if (nullSafeEquals(method.getName(), methodName)) {
return method;
}
}
return null;
}
private void checkReturnType(Method method, Class namespace) {
Class<?> returnType = method.getReturnType();
if (NEED_SEALING_TYPES.contains(returnType)) {
//对暂未支持的 未封箱基础类型 进行检查并给出友好报错
throw new ResourceLoadException(
"目前不支持返回基本类型，请使用对应的包装类，接口：" + namespace.getName() + "." + method.getName());
}
}
- pageSupport方法：将需要分页的接口，自动追加两个接口，用于生成动态代理
- createPageMethod方法：创建 分页中查询范围条目方法 的模型
- setParamAnnotations方法：给pageMethodModel或者countMethodModel设置上参数列表的参数注解
- getPageParamName方法：得到分页在参数中的下标或者@param注解的内容作为变量名
多参数或者有@Param注解，会把ngql变成这样：
以上两种情况之外：
- createCountMethod方法：创建分页中的 条数统计接口 的方法模型。
//检查分页
private void pageSupport(Method method, MethodModel methodModel, List<String> methodNames,
Map<String, MethodModel> methods, Class<?> namespace) throws NoSuchMethodException {
Class<?>[] parameterTypes = method.getParameterTypes();
List<Class<?>> parameterTypeList = Arrays.asList(parameterTypes);
//检查参数列表中有没有Page类型
if (parameterTypeList.contains(Page.class)) {
//调用自身的 createPageMethod 方法创建一个分页范围的模型
int pageParamIndex = parameterTypeList.indexOf(Page.class);
MethodModel pageMethod =
createPageMethod(
methodModel, methodNames, parameterTypes, pageParamIndex, namespace
);
methods.put(pageMethod.getId(), pageMethod);
//调用自身的 createCountMethod 方法创建一个分页条数的模型
MethodModel countMethod = createCountMethod(
methodModel, methodNames, parameterTypes, namespace
);
methods.put(countMethod.getId(), countMethod);
}
}
private MethodModel createPageMethod(MethodModel methodModel, List<String> methodNames,
Class<?>[] parameterTypes, int pageParamIndex, Class<?> namespace)
throws NoSuchMethodException {
//根据methodName，给分页方法起名字
//例：selectCustomPage -> selectCustomPage$Page
String methodName = methodModel.getId();
String pageMethodName = String.format("%s$Page", methodName);
Assert.isTrue(!methodNames.contains(pageMethodName),
"There is a method name conflicts with " + pageMethodName);
MethodModel pageMethodModel = new MethodModel();
//调用自身的setParamAnnotations方法，获取参数注解数组存入pageMethodModel
Annotation[][] parameterAnnotations = setParamAnnotations(parameterTypes, namespace,
methodName, pageMethodModel);
pageMethodModel.setParameterTypes(parameterTypes);
pageMethodModel.setId(pageMethodName);
pageMethodModel.setSpaceFromParam(methodModel.isSpaceFromParam());
pageMethodModel.setSpace(methodModel.getSpace());
String cql = methodModel.getText();
//调用getPageParamName的到分页变量名
String pageParamName = getPageParamName(parameterAnnotations, pageParamIndex);
if (pageParamName != null) {
String format = "%s\t\tSKIP $%s.startRow LIMIT $%s.pageSize";
cql = String.format(format, cql, pageParamName, pageParamName);
} else {
String format = "%s\t\tSKIP $startRow LIMIT $pageSize";
cql = String.format(format, cql);
}
pageMethodModel.setText(cql);
pageMethodModel.setResultType(methodModel.getResultType());
pageMethodModel.setReturnType(methodModel.getMethod().getReturnType());
return pageMethodModel;
}
private static Annotation[][] setParamAnnotations(Class<?>[] parameterTypes, Class<?> namespace,
String methodName, MethodModel methodModel) throws NoSuchMethodException {
//调用getDeclaredMethod方法根据方法名和参数获取方法
Method declaredMethod = namespace.getDeclaredMethod(methodName, parameterTypes);
//调用getParameterAnnotations方法获取该方法参数的注解数组
Annotation[][] parameterAnnotations = declaredMethod.getParameterAnnotations();
//把参数注解放进methodModel中
methodModel.setParamAnnotations(parameterAnnotations);
return parameterAnnotations;
}
private String getPageParamName(Annotation[][] parameterAnnotations, int pageParamIndex) {
if (parameterAnnotations.length > pageParamIndex) {
Annotation[] parameterAnnotation = parameterAnnotations[pageParamIndex];
for (int i = 0; i < parameterAnnotation.length; i++) {
Annotation ifParam = parameterAnnotation[i];
if (ifParam.annotationType() == Param.class) {
Param param = (Param) ifParam;
String paramName = param.value();
if (isNotBlank(paramName)) {
return paramName;
}
}
}
}
// 多参数，并且没有注解时，使用 pN 的参数格式来表示参数名
if (parameterAnnotations.length > 1) {
return "p" + pageParamIndex;
}
return null;
}
private MethodModel createCountMethod(MethodModel methodModel, List<String> methodNames,
Class<?>[] parameterTypes, Class<?> namespace) throws NoSuchMethodException {
//例：selectCustomPage -> selectCustomPage$Count
String methodName = methodModel.getId();
String countMethodName = String.format("%s$Count", methodName);
Assert.isTrue(!methodNames.contains(countMethodName),
"There is a method name conflicts with " + countMethodName);
MethodModel countMethodModel = new MethodModel();
setParamAnnotations(parameterTypes, namespace, methodName, countMethodModel);
countMethodModel.setParameterTypes(parameterTypes);
countMethodModel.setId(countMethodName);
// Fix: Set the specified space in the original method to the proxy method for paging,
countMethodModel.setSpaceFromParam(methodModel.isSpaceFromParam());
countMethodModel.setSpace(methodModel.getSpace());
String cql = methodModel.getText();
String with = cql.replaceAll("(RETURN)|(return)", "WITH");
cql = String.format("%s\t\tRETURN count(*);", with);
countMethodModel.setText(cql);
countMethodModel.setReturnType(Long.class);
return countMethodModel;
}
②调用DaoResourceLoader.loadTpl方法如下：
👉基础类资源加载器：DaoResourceLoader
继承了MapperResourceLoader类，可以使用MapperResourceLoader类提供的load()和nodesToString()方法。
提供了两个方法：
- loadTpl()：根据NebulaDaoBasic.xml资源路径获取Resource，且调用自身的parse()方法
- parse()：使用Jsoup解析xml文件，返回结果Map(基类接口方法名,nGQL模板)
public class DaoResourceLoader extends MapperResourceLoader {
public DaoResourceLoader(ParseCfgProps parseConfig) {
super(parseConfig);
}
public Map<String, String> loadTpl() {
try {
Resource resource = getResource(parseConfig.getMapperTplLocation());
return parse(resource);
} catch (IOException e) {
throw new ResourceLoadException(e);
}
}
private Map<String, String> parse(Resource resource) throws IOException {
Document doc = Jsoup.parse(resource.getInputStream(), "UTF-8", "http://example.com/");
Map<String, String> result = new HashMap<>();
Method[] methods = NebulaDaoBasic.class.getMethods();
for (Method method : methods) {
String name = method.getName();
Element elementById = doc.getElementById(name);
if (elementById != null) {
List<TextNode> textNodes = elementById.textNodes();
//调用MapperResourceLoader.nodesToString方法将textNode转为nGQL模板字符串
String tpl = nodesToString(textNodes);
result.put(name, tpl);
}
}
return result;
}
}
③调用本类的figureTagTypeMapping方法如下：
private void figureTagTypeMapping(
Collection<ClassModel> classModels,
Map<String, Class<?>> tagTypeMapping) {
for (ClassModel classModel : classModels) {
//调用NebulaDaoBasicExt.entityTypeAndIdType方法获取泛型类型
Class<?>[] entityTypeAndIdType = entityTypeAndIdType(classModel.getNamespace());
if (entityTypeAndIdType != null) {
Class<?> entityType = entityTypeAndIdType[0];
String vertexName = vertexName(entityType);
tagTypeMapping.putIfAbsent(vertexName, entityType);
}
}
}
👉NebulaDaoBasic的扩展类：NebulaDaoBasicExt
提供给NebulaDaoBasic调用的拓展方法。 与具体执行gql的方法分离，避免干扰通用dao的继承。
- entityTypeAndIdType方法：根据dao接口类型，通过它的泛型，取得其管理的实体类型与主键类型
public static Class<?>[] entityTypeAndIdType(Class<?> currentType) {
Class<?>[] result = null;
//调用getGenericInterfaces方法返回由这个类直接实现的接口
Type[] genericInterfaces = currentType.getGenericInterfaces();
for (Type genericInterface : genericInterfaces) {
//调用ReflectUtil.isCurrentTypeOrParentType方法判断参数1是否是参数2子类或者实现类
if (isCurrentTypeOrParentType(genericInterface.getClass(), ParameterizedType.class)) {
//获取泛型参数数组
Type[] actualTypeArguments =
((ParameterizedType) genericInterface).getActualTypeArguments();
result = new Class<?>[]{
(Class<?>) actualTypeArguments[0], // T {@link NebulaDaoBasic }
(Class<?>) actualTypeArguments[1] // ID {@link NebulaDaoBasic }
};
} else if (genericInterface instanceof Class) {
result = entityTypeAndIdType((Class<?>) genericInterface);
}
}
return result;
}
④调用本类的setNebulaSessionPool方法如下：
当开启了sessionPool才会执行
public void setNebulaSessionPool(MapperContext context) {
NgbatisConfig ngbatisConfig = nebulaJdbcProperties.getNgbatis();
if (ngbatisConfig.getUseSessionPool() == null || !ngbatisConfig.getUseSessionPool()) {
return;
}
context.getSpaceNameSet().add(nebulaJdbcProperties.getSpace());
Map<String, SessionPool> nebulaSessionPoolMap = context.getNebulaSessionPoolMap();
for (String spaceName : context.getSpaceNameSet()) {
SessionPool sessionPool = initSessionPool(spaceName);
if (sessionPool == null) {
log.error("{} session pool init failed.", spaceName);
continue;
}
nebulaSessionPoolMap.put(spaceName, sessionPool);
}
}
⑤调用本类的registerBean方法如下：
这里主要做的事是：注册 XXXDao 对象形成由 spring 管理的 bean
private void registerBean(MapperContext context) {
Map<String, ClassModel> interfaces = context.getInterfaces();
for (ClassModel cm : interfaces.values()) {
//调用MapperProxyClassGenerator.setClassCode方法生成代理类
beanFactory.setClassCode(cm);
}
//将代理类加载到 jvm 中，执行方：RAMClassLoader
RamClassLoader ramClassLoader = new RamClassLoader(context.getInterfaces());
for (ClassModel cm : interfaces.values()) {
try {
String className = cm.getNamespace().getName() + PROXY_SUFFIX;
//将加载的类注册成bean，交由spring boot管理
registerBean(cm, ramClassLoader.loadClass(className));
log.info("Bean had been registed (代理类注册成bean): {}", className);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
👉MapperProxyClassGenerator
基于 ASM 对接口进行动态代理，并生成 Bean 代理的实现类
- setClassCode方法：根据 ClassModel 对象中扫描得到的信息，生成代理类，并将字节码设置到 ClassModel 对象中
public byte[] setClassCode(ClassModel cm) {
String fullNameType = getFullNameType(cm);
ClassWriter cw = new ClassWriter(0);
// public class XXX extends Object implement XXX
cw.visit(
V1_8,
ACC_PUBLIC,
fullNameType,
null,
"java/lang/Object",
new String[]{getFullNameType(cm.getNamespace().getName())}
);
// 无参构造
constructor(cw);
// 生成代理方法
methods(cw, cm);
// 完成
cw.visitEnd();
byte[] code = cw.toByteArray();
cm.setClassByte(code);
//将生成的字节码，写入本地文件，形成 .class 文件供调试时使用
writeFile(cm);
return code;
}
visit方法Kimi解释如下：
-
visit方法用于开始定义一个类。参数如下：V1_8：指定生成的字节码版本为Java 8。ASM使用版本号来确保生成的字节码与特定版本的Java虚拟机兼容。ACC_PUBLIC：访问标志，表示这个类是公开的（public）。fullNameType：类名的完全限定名，包括包名。例如，如果类在包com.example中，名为MyClass，则fullNameType将是"com/example/MyClass"。null：签名字段，这里没有使用泛型，所以是null。"java/lang/Object"：超类名称，这里指定所有Java类的默认超类java.lang.Object。new String[]{getFullNameType(cm.getNamespace().getName())}：接口数组，这里调用getFullNameType方法获取接口的完全限定名，并将结果作为字符串数组传递。
- constructor方法：给类生成无参构造器
private void constructor(ClassWriter cw) {
MethodVisitor constructor = cw.visitMethod(ACC_PUBLIC, "<init>", "()V", null, null);
// 将this参数入栈
constructor.visitCode();
constructor.visitVarInsn(ALOAD, 0);
constructor.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
constructor.visitInsn(RETURN);
// 指定局部变量栈的空间大小
constructor.visitMaxs(1, 1);
// 构造方法的结束
constructor.visitEnd();
}
- method方法：生成代理方法
private void methods(ClassWriter cw, ClassModel cm) {
// 读取配置，并根据配置向 class 文件写人代理方法
Map<String, MethodModel> methods = cm.getMethods();
for (Map.Entry<String, MethodModel> entry : methods.entrySet()) {
method(cw, cm, entry);
}
}
private void method(ClassWriter cw, ClassModel cm, Map.Entry<String, MethodModel> mmEntry) {
String methodName = mmEntry.getKey();
MethodModel mm = mmEntry.getValue();
/* return Mapper.invoke( "接口名 namespace", "方法名 method", new Object[]{ arg1, arg2, ... } );
----- start */
Method method = mm.getMethod();
String methodSignature = ReflectUtil.getMethodSignature(mm);
MethodVisitor mapper =
cw.visitMethod(
ACC_PUBLIC,
methodName,
methodSignature,
null,
null
);
mapper.visitCode();
String className = cm.getNamespace().getName();
mapper.visitLdcInsn(className);
mapper.visitLdcInsn(mm.getId());
int parameterCount = addParams(mapper, mm.getParameterCount());
mapper.visitMethodInsn(
INVOKESTATIC,
getFullNameType(MapperProxy.class.getName()),
"invoke",
"(Ljava/lang/String;Ljava/lang/String;[Ljava/lang/Object;)Ljava/lang/Object;",
false
);
/* -------------------------------- end --------------------------------*/
// *2，每多一个方法参数，需要多定义 2 个局部变量，下标变量
// +3： 3 个固定参数位，namespace、methodName、args
mapper.visitMaxs(Integer.MAX_VALUE, Integer.MAX_VALUE);
// 检查类型转换
Class<?> returnType = mm.getReturnType();
mapper.visitTypeInsn(CHECKCAST, getFullNameType(returnType.getTypeName()));
// 基本类型封箱
// sealingReturnType(mapper, returnType ); // FIXME 处理基本类型的封箱
int returnTypeInsn = getReturnTypeInsn(returnType);
mapper.visitInsn(returnTypeInsn);
mapper.visitEnd();
}
参考源码及文章的🔗
- github.com/nebula-cont…
- 关于 NgBatis | NgBatis Docs (graph-cn.github.io)
- Springboot 撞上 NebulaGraph——NGbatis 初体验 (nebula-graph.com.cn)
- [Ngbatis源码学习][SpringBoot] ApplicationContextInitializer接口类的使用和原理解读 - knqiufan - 博客园 (cnblogs.com)
- [Ngbatis源码学习] Ngbatis 源码阅读之 NgbatisContextInitializer - knqiufan - 博客园 (cnblogs.com)
- [Ngbatis源码学习] Ngbatis 源码阅读之 Jsoup 简单使用说明 - knqiufan - 博客园 (cnblogs.com)
转载自:https://juejin.cn/post/7393298241793851443