SpringBoot如何结合Neo4j自定义cypherSql
发表于：2024-11-26 作者：千家信息网编辑
千家信息网最后更新 2024年11月26日，这篇文章主要为大家展示了"SpringBoot如何结合Neo4j自定义cypherSql"，内容简而易懂，条理清晰，希望能够帮助大家解决疑惑，下面让小编带领大家一起研究并学习一下"SpringBoot
千家信息网最后更新 2024年11月26日SpringBoot如何结合Neo4j自定义cypherSql
这篇文章主要为大家展示了"SpringBoot如何结合Neo4j自定义cypherSql"，内容简而易懂，条理清晰，希望能够帮助大家解决疑惑，下面让小编带领大家一起研究并学习一下"SpringBoot如何结合Neo4j自定义cypherSql"这篇文章吧。
前言
SpringBoot引入neo4j
org.springframework.boot spring-boot-starter-data-neo4j
2.2.11.RELEASE
大多数时候Neo4j结合springboot都是按照实体类的映射，进行对象形式的创建节点，导致了节点属性的不可配性。结合这种问题，结合目前开发经验，可以使用neo4j 框架的session 进行原生cypherSql的执行。所以结合使用session进行动态可配等思路，建立一个Neo4jUtil..
Neo4jUtil作用
SpringBoot结合neo4j,自定义封装cypherSql进行操作。实际就是使用neo4j的Session.执行一些cypherSql操作，然后封装了一些方法供大家在既可以使用springboot的对象化操作方式的前提创建节点或者关系，也可以自定义继续封装一些特殊需求的方法，避免大家造轮子。
相关代码
application.yml
spring: data: neo4j: uri: bolt://127.0.0.1:7688 username: neo4j password: neo4j
config
package com.troy.keeper.modules.desk.config;import org.neo4j.ogm.session.SessionFactory;import org.springframework.beans.factory.annotation.Value;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;import org.springframework.data.neo4j.repository.config.EnableNeo4jRepositories;import org.springframework.data.neo4j.transaction.Neo4jTransactionManager;@Configuration@EnableNeo4jRepositories("com.troy.keeper.desc.repository") // 声明neo4j repository存放地址public class Neo4jConfig { @Value("${spring.data.neo4j.uri}") private String uri; @Value("${spring.data.neo4j.username}") private String userName; @Value("${spring.data.neo4j.password}") private String password; @Bean public org.neo4j.ogm.config.Configuration getConfiguration() { org.neo4j.ogm.config.Configuration configuration = new org.neo4j.ogm.config.Configuration.Builder().uri(uri).connectionPoolSize(100).credentials(userName, password).withBasePackages("com.troy.keeper.desc.repository").build(); return configuration; } @Bean public SessionFactory sessionFactory() { return new SessionFactory(getConfiguration()); } @Bean("neo4jTransaction") public Neo4jTransactionManager neo4jTransactionManager(SessionFactory sessionFactory) { return new Neo4jTransactionManager(sessionFactory); }}Entity
Neo4jBasicNode
//节点实体类package com.troy.keeper.modules.desk.entity.neo4j;import lombok.Data;import java.io.Serializable;import java.util.List;import java.util.Map;/** * neo4j 节点实体类 * @author YangBM */@Datapublic class Neo4jBasicNode implements Serializable { private static final long serialVersionUID = 1L; /** * id */ private Long id; /** * 标签 */ private List labels; /** * 标签属性 */ private Map property;} Neo4jBaiscRelation
//关系实体类package com.troy.keeper.modules.desk.entity.neo4j;import lombok.Data;import java.io.Serializable;import java.util.Map;/** * 关系 */@Datapublic class Neo4jBaiscRelation implements Serializable { private static final long serialVersionUID = 1L; /** * id */ private Long id; /** * 标签 */ private String type; /** * 标签属性 */ private Map property;} Neo4jQueryRelation
//查询关系的时候返回的对象封装的实体类package com.troy.keeper.modules.desk.entity.neo4j;import lombok.Data;import java.io.Serializable;import java.util.Map;/** * 关系 * @author YangBM */@Datapublic class Neo4jQueryRelation implements Serializable { private static final long serialVersionUID = 1L; /** * 开始节点id */ private Long start; /** * 结束节点id */ private Long end; /** * 关系类型 */ private String type; /** * id */ private Long id; /** * 标签属性 */ private Map property;} VO
Neo4jBasicRelationReturnVO
package com.troy.keeper.modules.desk.vo.neo4j;import com.troy.keeper.modules.desk.entity.neo4j.Neo4jBasicNode;import com.troy.keeper.modules.desk.entity.neo4j.Neo4jQueryRelation;import lombok.Data;import java.io.Serializable;/** * 基础返回关系VO * 关系 * @author YangBM */@Datapublic class Neo4jBasicRelationReturnVO implements Serializable { private static final long serialVersionUID = 1L; private Neo4jBasicNode start; private Neo4jQueryRelation relationship; private Neo4jBasicNode end;}RelationVO
package com.troy.keeper.modules.desk.vo.neo4j;import lombok.Data;/** * 将关系的实体类，转换换成cypherSql需要字符串类型的vo * Util里面会用到 * @author YangBM */@Datapublic class RelationVO { /** * 关系名称 */ private String relationLabelName; /** * 开始标签名称 */ private String startLabelName; /** * 开始节点条件 */ private String startNodeProperties; /** * 关系的属性 */ private String relationProperties; /** * 结束节点条件 */ private String endNodeProperties; /** * 结束标签名称 */ private String endLabelName; /** * 查询层级 */ private String level;}Util
Neo4jUtil
package com.troy.keeper.modules.desk.util;import com.fasterxml.jackson.core.JsonGenerator;import com.fasterxml.jackson.databind.ObjectMapper;import com.troy.keeper.core.tool.utils.BeanUtil;import com.troy.keeper.core.tool.utils.Func;import com.troy.keeper.modules.desk.dto.neo4j.Neo4jSaveRelationDTO;import com.troy.keeper.modules.desk.dto.neo4j.RelationDTO;import com.troy.keeper.modules.desk.entity.neo4j.Neo4jBaiscRelation;import com.troy.keeper.modules.desk.entity.neo4j.Neo4jBasicNode;import com.troy.keeper.modules.desk.entity.neo4j.Neo4jQueryRelation;import com.troy.keeper.modules.desk.vo.neo4j.Neo4jBasicRelationReturnVO;import com.troy.keeper.modules.desk.vo.neo4j.RelationVO;import lombok.SneakyThrows;import org.apache.commons.collections.IteratorUtils;import org.apache.commons.lang3.StringUtils;import org.neo4j.driver.internal.InternalPath;import org.neo4j.driver.types.Node;import org.neo4j.driver.types.Relationship;import org.neo4j.ogm.model.Property;import org.neo4j.ogm.model.Result;import org.neo4j.ogm.response.model.NodeModel;import org.neo4j.ogm.session.Session;import org.springframework.stereotype.Component;import javax.annotation.Resource;import java.util.*;/** * @author YangBM * Neo4J工具类 */@Componentpublic class Neo4jUtil { /** * init map序列号 */ private static final ObjectMapper mapper = new ObjectMapper(); static { mapper.configure(JsonGenerator.Feature.QUOTE_FIELD_NAMES, false); } @SneakyThrows public static String propertiesMapToPropertiesStr(Map map) { map.entrySet().removeIf(entry -> Func.isEmpty(entry.getValue())); return mapper.writeValueAsString(map); } @Resource private Session session; public Session getSession() { return this.session; } /** * 获取所有的标签名称 * * @return */ public List getAllLabelName() { String cypherSql = "match (n) return distinct labels(n) as name"; Result query = session.query(cypherSql, new HashMap<>()); ArrayList labelNames = new ArrayList<>(); for (Map map : query.queryResults()) { String[] names = (String[]) map.get("name"); for (String name : names) { labelNames.add(name); } } return labelNames; } /** * 获取所有的关系名称 * * @return */ public List getAllRelationName() { String cypherSql = "MATCH ()-[r]-() RETURN distinct type(r) as name"; Result query = session.query(cypherSql, new HashMap<>()); ArrayList relationNames = new ArrayList<>(); for (Map map : query.queryResults()) { relationNames.add(map.get("name").toString()); } return relationNames; } /** * 按条件查询节点 * * @param node * @return 返回节点集合 */ public List queryNode(Neo4jBasicNode node) { String cypherSql = ""; if (Func.isNotEmpty(node.getId())) { cypherSql = String.format("MATCH (n) where id(n)=%s return n", node.getId()); } else { String labels = ""; if (Func.isNotEmpty(node.getLabels())) { labels = ":`" + String.join("`:`", node.getLabels()) + "`"; } String property = ""; if (Func.isNotEmpty(node.getProperty())) { property = Neo4jUtil.propertiesMapToPropertiesStr(node.getProperty()); } cypherSql = String.format("match(n%s%s) return n", labels, property); } Result query = session.query(cypherSql, new HashMap<>()); ArrayList nodeList = new ArrayList<>(); Iterable> maps = query.queryResults(); for (Map map : maps) { NodeModel queryNode = (NodeModel) map.get("n"); Neo4jBasicNode startNodeVo = new Neo4jBasicNode(); startNodeVo.setId(queryNode.getId()); startNodeVo.setLabels(Arrays.asList(queryNode.getLabels())); List> propertyList = queryNode.getPropertyList(); HashMap proMap = new HashMap<>(); for (Property stringObjectProperty : propertyList) { if (proMap.containsKey(stringObjectProperty.getKey())) { throw new RuntimeException("数据重复"); } proMap.put(stringObjectProperty.getKey(), stringObjectProperty.getValue()); } startNodeVo.setProperty(proMap); nodeList.add(startNodeVo); } session.clear(); return nodeList; } /** * 创建节点 * * @param node 节点 * @param nodup 是否去重。 true去重 false不去重 * @return */ public boolean createNode(Neo4jBasicNode node, Boolean nodup) { String labels = ""; if (Func.isNotEmpty(node.getLabels())) { labels = ":`" + String.join("`:`", node.getLabels()) + "`"; } String property = ""; if (Func.isNotEmpty(node.getProperty())) { property = Neo4jUtil.propertiesMapToPropertiesStr(node.getProperty()); } String cypherSql = String.format("%s(%s%s)", nodup ? "MERGE" : "create", labels, property); Result query = session.query(cypherSql, new HashMap<>()); session.clear(); return query.queryStatistics().getNodesCreated() > 0; } /** * 创建节点(不去重) * * @param node 节点 * @param * @return */ public boolean createNode(Neo4jBasicNode node) { return this.createNode(node, false); } /** * 创建节点，（去重增强型） * 创建节点，如果节点存在，先把它删除，在重新创建 * 这个方法的目的是因为 createNode方法所谓的去重，是指如果 ，已有节点A,需要创建的节点B,如果A的属性个数大于B的属性且属性对应的值一模一样，就会创建一个新的A。所以现在的方式是对B新增A中B缺少的属性 * @param node * @return */ public boolean recreateNode(Neo4jBasicNode node){ List saveLabels = node.getLabels(); Map saveProperty = node.getProperty(); Set savePropertyKeySet = saveProperty.keySet(); //查询用属性查询节点是不是存在。 //存在比较标签的lable1是不是一样。不一样就这个查询到的节点（少了就新增标签，多了就删除标签） Neo4jBasicNode queryNode= BeanUtil.copy(node,Neo4jBasicNode.class); queryNode.setLabels(null); List queryNodeList = this.queryNode(queryNode); if (queryNodeList.isEmpty()){ return createNode(node,true); } for (Neo4jBasicNode neo4jBasicNode : queryNodeList) { //处理标签 List queryLabels = neo4jBasicNode.getLabels(); ArrayList addLabels = new ArrayList<>(); for (String saveLabel : saveLabels) { if (!queryLabels.contains(saveLabel)){ //新增标签 addLabels.add(saveLabel); } } String addLabelStr=addLabels.isEmpty()?"":("e:"+String.join(":",addLabels)); //处理属性 Map queryProperty = neo4jBasicNode.getProperty(); Set queryPropertyKeySet = queryProperty.keySet(); HashMap addPropertyMap = new HashMap<>(); for (String savePropertyKey: savePropertyKeySet) { if (!queryPropertyKeySet.contains(savePropertyKey)){ addPropertyMap.put(savePropertyKey,saveProperty.get(savePropertyKey)); } } String addPropertyStr=addPropertyMap.isEmpty()?"":(",e+="+ Neo4jUtil.propertiesMapToPropertiesStr(addPropertyMap)); if(StringUtils.isAllEmpty(addPropertyStr,addPropertyStr)){ return true; } String addLabelCypherSql =String.format("MERGE (e) with e where id(e)=%s set %s %s return count(e) as count",neo4jBasicNode.getId(),addLabelStr,addPropertyStr); Result query = session.query(addLabelCypherSql, new HashMap<>()); System.out.println("跟新了："+neo4jBasicNode.getId()); session.clear(); } //创建不重复节点 return true; }; /** * 批量创建节点(存在的节点将会被重复创建) * * @param nodeList 节点的list集合 * @return 创建成功条数 * */ public Long batchCreateNode(List nodeList) { return this.batchCreateNode(nodeList, false); } /** * 批量创建节点 * * @param nodeList 节点的list集合 * @param nodup 是否去重。 true去重（存在的节点将不会被创建） false不去重 * @return 创建成功条数 */ public Long batchCreateNode(List nodeList, Boolean nodup) { ArrayList addNode = new ArrayList<>(); //验证 for (Neo4jBasicNode neo4jBasicNode : nodeList) { if ((!nodup) || this.queryNode(neo4jBasicNode).size() == 0) { addNode.add(neo4jBasicNode); } } String cypherSql = "create"; ArrayList content = new ArrayList<>(); for (Neo4jBasicNode node : addNode) { String labels = ""; if (Func.isNotEmpty(node.getLabels())) { labels = ":`" + String.join("`:`", node.getLabels()) + "`"; } String property = ""; if (Func.isNotEmpty(node.getProperty())) { property = Neo4jUtil.propertiesMapToPropertiesStr(node.getProperty()); } content.add(String.format("(%s%s)", labels, property)); } cypherSql += String.join(",", content); if (content.size() == 0) { return 0L; } Result query = session.query(cypherSql, new HashMap<>()); session.clear(); return Long.valueOf(query.queryStatistics().getNodesCreated()); } /** * 删除节点和相关关系 * * @param node 节点条件 * @param delRelation true 删除节点相关的关系；false 只删除不存在关系的，存在关系的节点将不会被删除关系 * @return */ public Integer delNode(Neo4jBasicNode node, boolean delRelation) { String cypherSql = ""; if (Func.isNotEmpty(node.getId())) { cypherSql = String.format("MATCH (n) where id(n)=%s ", node.getId()); } else { String labels = ""; if (Func.isNotEmpty(node.getLabels())) { labels = ":`" + String.join("`:`", node.getLabels()) + "`"; } String property = ""; if (Func.isNotEmpty(node.getProperty())) { property = Neo4jUtil.propertiesMapToPropertiesStr(node.getProperty()); } cypherSql = String.format("match(n%s%s) ", labels, property); } if (delRelation) { cypherSql += "DETACH DELETE n"; } else { //删除不存在关系的节点 cypherSql += " where not exists((n)-[]-()) DELETE n"; } Result query = session.query(cypherSql, new HashMap<>()); session.clear(); return query.queryStatistics().getNodesDeleted(); } /** * 删除节点和相关关系 * 只删除不存在关系的，存在关系的节点将不会被删除关系 * * @param node 节点条件 有关系的节点不会删除 * @return */ public Integer delNode(Neo4jBasicNode node) { return this.delNode(node, false); } public int queryNodeCreateRelation(Neo4jBasicNode start, Neo4jBasicNode end, Neo4jBaiscRelation relation) { Neo4jSaveRelationDTO dto = new Neo4jSaveRelationDTO(); dto.setStart(start); dto.setEnd(end); dto.setRelationship(relation); return queryNodeCreateRelation(dto); } /** * 查询节点然后创建关系 * 创建关系(查询开始节点和结束节点然后创造关系) * 注意：开始节点和结束节点以及创建的关系参数一定要存在！ * 关系如果存在，不会重复创建 * 因为需要返回创建条数 当前方法未做条件判断 * * @param saveRelation 关系构造类 * @return 返回创建关系的个数 */ public int queryNodeCreateRelation(Neo4jSaveRelationDTO saveRelation) { //开始节点和结束节点验证 String cypherSql = ""; String startLable = ""; if (Func.isNotEmpty(saveRelation.getStart().getLabels())) { startLable = ":`" + String.join("`:`", saveRelation.getStart().getLabels()) + "`"; } String startProperty = ""; if (Func.isNotEmpty(saveRelation.getStart().getProperty())) { startProperty = Neo4jUtil.propertiesMapToPropertiesStr(saveRelation.getStart().getProperty()); } String endLable = ""; if (Func.isNotEmpty(saveRelation.getEnd().getLabels())) { endLable = ":`" + String.join("`:`", saveRelation.getEnd().getLabels()) + "`"; } String endProperty = ""; if (Func.isNotEmpty(saveRelation.getEnd().getProperty())) { endProperty = Neo4jUtil.propertiesMapToPropertiesStr(saveRelation.getEnd().getProperty()); } String startWhere = ""; if (Func.isNotEmpty(saveRelation.getStart().getId())) { startWhere += " where id(start)=" + saveRelation.getStart().getId(); startLable = ""; startProperty = ""; } String endWhere = ""; if (Func.isNotEmpty(saveRelation.getEnd().getId())) { endWhere += " where id(end)=" + saveRelation.getEnd().getId(); endLable = ""; endProperty = ""; } String relationType = ""; if (Func.isNotEmpty(saveRelation.getRelationship().getType())) { relationType = ":`" + saveRelation.getRelationship().getType() + "`"; } if (Func.isEmpty(relationType)) { throw new RuntimeException("关系名称不能为空！"); } String relationProperty = ""; if (Func.isNotEmpty(saveRelation.getRelationship().getProperty())) { relationProperty = Neo4jUtil.propertiesMapToPropertiesStr(saveRelation.getRelationship().getProperty()); } cypherSql = String.format("MATCH (start%s%s) %s with start MATCH (end%s%s) %s MERGE (start)-[rep%s%s]->(end)", startLable, startProperty, startWhere, endLable, endProperty, endWhere, relationType, relationProperty); Result query = session.query(cypherSql, new HashMap<>()); session.clear(); return query.queryStatistics().getRelationshipsCreated(); } /** * 创建节点同时创建关系 * 重复的不会被创建 * * @param saveRelation * @return */ public boolean creteNodeAndRelation(Neo4jSaveRelationDTO saveRelation) { String cypherSql = ""; String startLable = ""; if (Func.isNotEmpty(saveRelation.getStart().getLabels())) { startLable = ":`" + String.join("`:`", saveRelation.getStart().getLabels()) + "`"; } String startProperty = ""; if (Func.isNotEmpty(saveRelation.getStart().getProperty())) { startProperty = Neo4jUtil.propertiesMapToPropertiesStr(saveRelation.getStart().getProperty()); } String endLable = ""; if (Func.isNotEmpty(saveRelation.getEnd().getLabels())) { endLable = ":`" + String.join("`:`", saveRelation.getEnd().getLabels()) + "`"; } String endProperty = ""; if (Func.isNotEmpty(saveRelation.getEnd().getProperty())) { endProperty = Neo4jUtil.propertiesMapToPropertiesStr(saveRelation.getEnd().getProperty()); } String relationType = ""; if (Func.isNotEmpty(saveRelation.getRelationship().getType())) { relationType = ":`" + saveRelation.getRelationship().getType() + "`"; } if (Func.isEmpty(relationType)) { throw new RuntimeException("关系名称不能为空！"); } String relationProperty = ""; if (Func.isNotEmpty(saveRelation.getRelationship().getProperty())) { relationProperty = Neo4jUtil.propertiesMapToPropertiesStr(saveRelation.getRelationship().getProperty()); } cypherSql = String.format("MERGE (start%s%s)-[rep%s%s]->(end%s%s)", startLable, startProperty, relationType, relationProperty, endLable, endProperty); Result query = session.query(cypherSql, new HashMap<>()); session.clear(); return query.queryStatistics().getRelationshipsCreated() > 0; } /** * 查询关系 * * @param relationDTO * @return */ public List queryRelation(RelationDTO relationDTO) { RelationVO relationVO = formatRelation(relationDTO); //拼接sql String cypherSql = String.format("MATCH p=(a%s%s)-[r%s%s]->(b%s%s)-[*0..%s]->() RETURN p", relationVO.getStartLabelName(), relationVO.getStartNodeProperties(), relationVO.getRelationLabelName(), relationVO.getRelationProperties(), relationVO.getEndLabelName(), relationVO.getEndNodeProperties(), relationVO.getLevel()); System.out.println(cypherSql); long startTime = System.currentTimeMillis(); Result query = session.query(cypherSql, new HashMap<>()); System.out.println(String.format("耗时%d秒", System.currentTimeMillis() - startTime)); Iterable> maps = query.queryResults(); ArrayList returnList = new ArrayList<>(); for (Map map : maps) { InternalPath.SelfContainedSegment[] ps = (InternalPath.SelfContainedSegment[]) map.get("p"); for (InternalPath.SelfContainedSegment p : ps) { returnList.add(changeToNeo4jBasicRelationReturnVO(p)); } } session.clear(); return returnList; } /** * 格式化 * * @param relationDTO * @return */ public RelationVO formatRelation(RelationDTO relationDTO) { RelationVO relationVO = new RelationVO(); //验证 if (Func.isNotEmpty(relationDTO.getRelationLabelName())) { relationVO.setRelationLabelName(":`" + relationDTO.getRelationLabelName()+"`"); } else { relationVO.setRelationLabelName(""); } if (Func.isNotEmpty(relationDTO.getStartLabelName())) { relationVO.setStartLabelName(":`" + relationDTO.getStartLabelName()+"`"); } else { relationVO.setStartLabelName(""); } if (Func.isNotEmpty(relationDTO.getEndLabelName())) { relationVO.setEndLabelName(":`" + relationDTO.getEndLabelName()+"`"); } else { relationVO.setEndLabelName(""); } if (Func.isNotEmpty(relationDTO.getStartNodeProperties())) { relationVO.setStartNodeProperties(Neo4jUtil.propertiesMapToPropertiesStr(relationDTO.getStartNodeProperties())); } else { relationVO.setStartNodeProperties(""); } if (Func.isNotEmpty(relationDTO.getRelationProperties())) { relationVO.setRelationProperties(Neo4jUtil.propertiesMapToPropertiesStr(relationDTO.getRelationProperties())); } else { relationVO.setRelationProperties(""); } if (Func.isNotEmpty(relationDTO.getEndNodeProperties())) { relationVO.setEndNodeProperties(Neo4jUtil.propertiesMapToPropertiesStr(relationDTO.getEndNodeProperties())); } else { relationVO.setEndNodeProperties(""); } if (Func.isNotEmpty(relationDTO.getLevel())) { relationVO.setLevel(relationDTO.getLevel().toString()); } else { relationVO.setLevel(""); } return relationVO; } /** * 转化neo4j默认查询的参数为自定返回类型 * * @param selfContainedSegment * @return Neo4jBasicRelationReturn */ public Neo4jBasicRelationReturnVO changeToNeo4jBasicRelationReturnVO(InternalPath.SelfContainedSegment selfContainedSegment) { Neo4jBasicRelationReturnVO neo4JBasicRelationReturnVO = new Neo4jBasicRelationReturnVO(); //start Node start = selfContainedSegment.start(); Neo4jBasicNode startNodeVo = new Neo4jBasicNode(); startNodeVo.setId(start.id()); startNodeVo.setLabels(IteratorUtils.toList(start.labels().iterator())); startNodeVo.setProperty(start.asMap()); neo4JBasicRelationReturnVO.setStart(startNodeVo); //end Node end = selfContainedSegment.end(); Neo4jBasicNode endNodeVo = new Neo4jBasicNode(); endNodeVo.setId(end.id()); endNodeVo.setLabels(IteratorUtils.toList(end.labels().iterator())); endNodeVo.setProperty(end.asMap()); neo4JBasicRelationReturnVO.setEnd(endNodeVo); //relationship Neo4jQueryRelation neo4JQueryRelation = new Neo4jQueryRelation(); Relationship relationship = selfContainedSegment.relationship(); neo4JQueryRelation.setStart(relationship.startNodeId()); neo4JQueryRelation.setEnd(relationship.endNodeId()); neo4JQueryRelation.setId(relationship.id()); neo4JQueryRelation.setType(relationship.type()); neo4JQueryRelation.setProperty(relationship.asMap()); neo4JBasicRelationReturnVO.setRelationship(neo4JQueryRelation); return neo4JBasicRelationReturnVO; }} 以上是"SpringBoot如何结合Neo4j自定义cypherSql"这篇文章的所有内容，感谢各位的阅读！相信大家都有了一定的了解，希望分享的内容对大家有所帮助，如果还想学习更多知识，欢迎关注行业资讯频道！
节点
标签
属性
查询
名称
实体
条件
方法
封装
内容
对象
篇文章
类型
验证
成功
个数
参数
方式
时候
处理
数据库的安全要保护哪些东西
数据库安全各自的含义是什么
生产安全数据库录入
数据库的安全性及管理
数据库安全策略包含哪些
海淀数据库安全审计系统
建立农村房屋安全信息数据库
易用的数据库客户端支持安全管理
连接数据库失败ssl安全错误
数据库的锁怎样保障安全
网络安全大战图片
小学生网络安全知识手抄报简单
p2p网络技术原理pdf
软件开发和程序设计区别
昆山java软件开发培训
软件开发如何能接到私活
ubuntu的软件开发
软件开发公司注册费用
延庆区咨询软件开发大概费用
金州区软件开发
临海库存软件开发定制价格
网络安全素养课程
用户对数据库中的数据进行每一次
吴江区便宜服务器货源充足
360分拆网络安全
蜀山传奇数据库
网络安全文化包括哪些内容
火的语音对讲软件开发
公司网络技术员绩效表
软件开发难还是需求分析难
前端中怎么做软件开发
公安网络安全保密纪律
添加access数据库
大学生参军网络安全
网络安全体和网络交会模型
网络安全素养课程
江西pdu服务器专用电源费用
山西网络安全会议
杭州市网络技术监督管理局
网络安全学校多少分
