SpringBoot该怎么使用Neo4j - 优化篇

🕗 发布于 2024-12-11 02:38 spring boot neo4j 后端

文章目录

前言
实体工具
使用

前言

上一篇中，我们的Cypher都用的是字符串，字符串拼接简单，但存在写错的风险，对于一些比较懒的开发者，甚至觉得之间写字符串还更自在快速，也确实，但如果在后期需要修改，如更高字段名或者一些级联的变动，会导致维护难，所以，这里这里我们模仿Mybatis-Plus写一个实体字段工具之间替换哪些字符串，以提高项目可维护性。
如需要了解上篇，位置：SpringBoot该怎么使用Neo4j

实体工具

我们以这篇的工具为基础进行下面的开发：Lambda表达式提取字段名-CSDN博客

然后我们再增加对于与Neo4j的实体工具：

实体缓存对象信息，保存实体必要信息

public class EntityCache {

    private String className;

    private List<String> labels;

    private Map<String, String> fieldNameMap;

    public String getClassName() {
        return className;
    }

    public void setClassName(String className) {
        this.className = className;
    }

    public List<String> getLabels() {
        return labels;
    }

    public void setLabels(List<String> labels) {
        this.labels = labels;
    }

    public Map<String, String> getFieldNameMap() {
        return fieldNameMap;
    }

    public void setFieldNameMap(Map<String, String> fieldNameMap) {
        this.fieldNameMap = fieldNameMap;
    }
}

解析工具，也就是反射解析

public class EntityUtil {

    /**
     * 实体缓存
     */
    private static final Map<String, EntityCache> ENTITY_MAP = new ConcurrentHashMap<>();

    public static void main(String[] args) {
        Job job = new Job();
        String column = column(Job::getName);
        System.out.println(column);
        System.out.println(label(Job.class));
    }

    /**
     * 从lambda转换出字段名
     */
    public static <T, R> String column(CusFunction<T, R> column) {
        SerializedLambda resolve = LambdaUtils.resolve(column);
        return getColumn(LambdaUtils.getClass(resolve), LambdaUtils.getMethodName(resolve) , true);
    }

    /**
     * 从实体class解析出标签
     */
    public static <T> String label(Class<T> clazz) {
        EntityCache info = ENTITY_MAP.putIfAbsent(clazz.getTypeName(), resolve(clazz));
        return info.getLabels().get(0);
    }

    /**
     * 根据类型和方法名解析字段名
     * @param aClass 类型
     * @param methodName 方法名
     * @param dbField 是否数据库字段
     * @return 字段名
     */
    private static String getColumn(Class<?> aClass, String methodName, boolean dbField) {
        String fieldName = PropertyNamer.methodToProperty(methodName);
        if (!dbField) {
            return fieldName;
        }
        EntityCache info = resolve(aClass);
        if (!StringUtils.hasLength(fieldName)) {
            throw new RuntimeException(String.format("找不到实体对应的字段-[%s.%s]", aClass.getTypeName(), methodName));
        }
        Map<String, String> map = info.getFieldNameMap();
        return map.get(fieldName);
    }

    /**
     * 解析实体
     * @param clazz 类型
     * @return 实体缓存对象
     */
    public static <T> EntityCache resolve(Class<T> clazz) {
        String typeName = clazz.getTypeName();
        EntityCache info = ENTITY_MAP.get(typeName);
        if (info != null) {
            return info;
        }
        Field[] declaredFields = clazz.getDeclaredFields();
        Map<String, String> fieldNameMap = new HashMap<>();
        for (Field declaredField : declaredFields) {
            declaredField.setAccessible(true);
            String fieldName = declaredField.getName();
            String dbFieldName = fieldName;
            Property property = declaredField.getAnnotation(Property.class);
            if (property != null) {
                if (StringUtils.hasLength(property.name())) {
                    dbFieldName = property.name();
                }
                if (StringUtils.hasLength(property.value())) {
                    dbFieldName = property.value();
                }
            }
            fieldNameMap.put(fieldName, dbFieldName);
        }
        List<String> labelList = resolveLabel(clazz);
        info = new EntityCache();
        info.setLabels(labelList);
        info.setClassName(typeName);
        info.setFieldNameMap(fieldNameMap);
        ENTITY_MAP.put(typeName, info);
        return info;
    }

    /**
     * 解析标签
     * @param clazz 类型
     * @return 标签列表
     */
    private static <T> List<String> resolveLabel(Class<T> clazz) {
        Node node = clazz.getAnnotation(Node.class);
        if (node == null) {
            throw new RuntimeException("非数据库实体对象实体！");
        }
        String[] value = node.value();
        String[] labels = node.labels();
        List<String> result = new ArrayList<>();
        result.addAll(Arrays.asList(value));
        result.addAll(Arrays.asList(labels));
        if (result.isEmpty()) {
            result.add(clazz.getSimpleName());
        }
        return result;
    }
}

测试：

    @Test
    public void testEntity() {
        String column = EntityUtil.column(Job::getName);
        EntityUtil.label(Job.class);
        String column1 = EntityUtil.column(Job::getJobName);
        System.out.println(column +"  " + column1);
    }

使用

实际开发中，就可以将字符串进行替换，如下面：

查询标签Job，name='liry'，并通过id顺序排序，取第一个的cypher构建

// match(a:Job) where a.name='liry' return a order by a.id  limit 1

Node temp = Cypher.node("Job").named("a");
ResultStatement statement = Cypher.match(temp)
                                          .where(temp.property("name").isEqualTo(Cypher.anonParameter(job.getName())))
                                          .returning(temp.getRequiredSymbolicName())
                                          .orderBy(temp.property("id"))
                                          .limit(1)
                                          .build();

进行替换

// match(a:Job) where a.name='liry' return a order by a.id  limit 1

// 字符串 Job  -> EntityUtil.label(Job.class)
// 字符串 name -> EntityUtil.column(Job::getName)
// 字符串 id -> EntityUtil.column(Job::getId)
Node temp = Cypher.node(EntityUtil.label(Job.class)).named("a");
ResultStatement statement = Cypher.match(temp)
                                          .where(temp.property(EntityUtil.column(Job::getName)).isEqualTo(Cypher.anonParameter(job.getName())))
                                          .returning(temp.getRequiredSymbolicName())
                                          .orderBy(temp.property(EntityUtil.column(Job::getId)))
                                          .limit(1)
                                          .build();

创建一个节点：

create (a:Job{name:'liry',jobName:'liry-job'}) return a;

可以看到调试中构建的Cypher是正确的。

原文地址：https://blog.csdn.net/qq_28911061/article/details/144246948

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：MMPano 部署笔记
下一篇：go 集成nacos注册中心、配置中心

.NET(C#) 如何配置用户首选项及保存用户设置
.NET(C#) 如何配置用户首选项及保存用户设置
阅读更多2024-12-14
【最新】北大数字普惠金融指数数据集-省市县（2011-2023年）
郭峰,王靖一,王芳,孔涛,张勋,程志云.测度中国数字普惠金融发展:指数编制与空间特征[J].经济学(季刊),2020,19(04):1401-1418.时间跨度：省级和城市级指数时间跨度为2011-2
阅读更多2024-12-14
GESP202412 四级【Recamán】题解（AC）
a11ak−1−kkakak−1−kak−1k小杨想知道 Recamán 数列的前n项从小到大排序后的结果。手动计算非常困难，小杨希望你能帮他解决这个问题。
阅读更多2024-12-14
IDEA遇到EasyConnect中的网络资源无法访问的问题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。原文链接：https://blog.csdn.net/wanshanyu_/article/de
阅读更多2024-12-14
双目摄像头标定方法
此时已经完成标定，左下角为反投影误差，右边为外参可视化。将双目左右目拍的图像上传（左右目最好不少于20张）此时回到主页面，即可看到成功导出。把这些误差大的删除即可。
阅读更多2024-12-14
Servlet、omcat服务器架构与工作原理
Servlet是运行在服务器端的Java程序，它的主要职责之一是接收并处理来自客户端（如浏览器）的HTTP请求。当客户端发送一个请求到服务器时，Servlet可以解析请求中的信息，例如请求的URL路径
阅读更多2024-12-14
Vue生命周期钩子函数：深入解析与实践
作为高级Vue前端开发人员，对Vue组件的生命周期钩子函数有着深刻的理解是至关重要的。生命周期钩子函数是指在Vue组件的创建、更新、销毁等过程中，Vue自动调用的一系列方法。通过这些钩子函数，我们可以
阅读更多2024-12-14
安卓开发--使用android studio发布APP
app发布
阅读更多2024-12-14
数据结构与算法学习笔记----拓扑排序
@ author: 明月清了个风。
阅读更多2024-12-14
python 将数据保存到现有的Excel文件的新工作表
out_file = ‘query.xlsx’df1 = pd.DataFrame(out_data)若直接写入：df1.to_excel(out_file, index=False, sheet_n
阅读更多2024-12-14

SpringBoot该怎么使用Neo4j - 优化篇

文章目录

前言

实体工具

使用

相关文章