java操作hugegraph图数据库

已于 2023-09-08 16:51:13 修改
阅读量1.5k 收藏 8
点赞数 3
分类专栏： 知识图谱 图数据库hugegraph java 文章标签： java 知识图谱 数据库
于 2022-10-14 16:58:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41060647/article/details/127322861
版权

记录使用java调用hugegraph图数据库过程中出现的一些问题及整体流程。（代码示例贴在最下边）
官方网址:https://hugegraph.apache.org/docs/clients/restful-api/propertykey/
java可以通过两种方式调用
1、一种是官方提供的API接口，可以直接调用restful接口;
在这里插入图片描述
下面是postman调用示例：注意需要验证图数据库（hugegraph）账号密码；
在这里插入图片描述
2、可以通过hugegraph提供的java客户端工具调用：并且官网提供了调用示例；
在这里插入图片描述
过程中遇到的问题：
1、hugegraph引用的jar包与fastJSon jar包冲突问题，可以降低fastJSon版本到1.1.x处理；如果不想修改jar包版本可以加入代码，将autoDiscover 设置为false：
private static final com.alibaba.fastjson.support.jaxrs.FastJsonAutoDiscoverable FastJsonAutoDiscoverable = null;
static {
FastJsonAutoDiscoverable.autoDiscover = false;
}
2、 hugegraph很多情况会返回异常信息字符串，无法解析返回的信息。
解决方法：自定义异常信息类ReturnErrorJsonHandler，重新message信息。

整体代码demo贴在下边：

1、HugeGraphUtils（图数据库接口API）

package net.beidousky.web.app.utils;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.JSONPath;
import net.beidousky.web.app.domain.Result;
import net.beidousky.web.app.entity.HugeClientVo;
import org.springframework.core.io.ClassPathResource;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.Properties;

/**
 * 图数据库接口API(hugegraph)
 */
public class HugeGraphUtils {

    //解决fastJSon与Jersey冲突问题
    private static final com.alibaba.fastjson.support.jaxrs.FastJsonAutoDiscoverable FastJsonAutoDiscoverable = null;
    static {
        FastJsonAutoDiscoverable.autoDiscover = false;
    }

    /**
     * 获取hugeGraph客户端操作对象
     * @param key
     * @return
     * @throws IOException
     */
    private static HugeClientVo getHugeGraph(String key) throws IOException {
        //读取配置文件hugeGraph连接信息
        ClassPathResource classPathResource = new ClassPathResource("hugeGraph.properties");
        Properties properties = new Properties();
        properties.load(classPathResource.getInputStream());
        //读取配置文件中key对应的value值
        String json = new String (properties.getProperty(key).getBytes(StandardCharsets.UTF_8), StandardCharsets.UTF_8) ;
        HugeClientVo hugeClientVo =JSON.parseObject(json,HugeClientVo.class);
        return hugeClientVo;
    }

    /**
     * 属性操作--创建属性
     * @param falg
     * @return
     * @throws IOException
     */
    public static Result createPropertyKey(String falg,String json) throws IOException{
         HugeClientVo hugeClientVo = getHugeGraph(falg);
         String ip = hugeClientVo.getIp();
         String userName =hugeClientVo.getUserName();
         String password =hugeClientVo.getPassword();
         String url = ip+ "/graphs/hugegraph/schema/propertykeys" ;
        String res = "";
         try{
              res =  RestTemplateUtil.hugeGraphRest(json,url,userName,password);
         }catch(Exception e){
             String message = JSONPath.read(e.getMessage(),"$.message",String.class);
             Result result =  Result.success(message);
             return result;
         }
         int id = JSONPath.read(res,"$.id",int.class);
         JSONObject jsonObject = new JSONObject();
         jsonObject.put("id",id);
         Result result = new Result(10000,"属性创建成功",jsonObject);
         return result;
    }


    /**
     * 属性操作--检查属性信息是否存在
     * @param falg
     * @return
     * @throws IOException
     */
    public static Result getPropertyKey(String falg,String name) throws IOException{
        HugeClientVo hugeClientVo = getHugeGraph(falg);
        String ip = hugeClientVo.getIp();
        String userName =hugeClientVo.getUserName();
        String password =hugeClientVo.getPassword();
        String url = ip+ "/graphs/hugegraph/schema/propertykeys/"+name;
        String res =  RestTemplateUtil.hugeGraphGet(url,userName,password);
        int id = JSONPath.read(res,"$.id",int.class);
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("id",id);
        Result result = new Result(10000,"属性创建成功",jsonObject);
        return result;
    }



    /**
     * 获取所有顶点标签
     * @param falg
     * @return
     * @throws IOException
     */
 /*   public static String getAllLabel(String falg) throws IOException, SQLException, JSONException {
        HugeClient hugeClient = getHugeClient(falg);
        GremlinManager gremlin = hugeClient.gremlin();
        ResultSet resultSet = gremlin.gremlin("g.V()").execute();
        List<Object> list = resultSet.data();
        System.out.print(resultSet);
        JSONArray jsonarray = JSONArray.fromObject(list);
        return jsonarray.toString();
    }
*/


}

2、HugeClientUtils（java操作图数据库客户端）

package net.beidousky.web.app.utils;

import com.alibaba.fastjson.JSON;
import com.baidu.hugegraph.driver.GremlinManager;
import com.baidu.hugegraph.driver.HugeClient;
import com.baidu.hugegraph.driver.SchemaManager;
import com.baidu.hugegraph.structure.gremlin.ResultSet;
import com.baidu.hugegraph.structure.schema.PropertyKey;
import net.beidousky.web.app.entity.HugeClientVo;
import net.beidousky.web.app.entity.hugegraph.Property;
import net.sf.json.JSONArray;
import org.json.JSONException;
import org.springframework.core.io.ClassPathResource;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.sql.SQLException;
import java.util.List;
import java.util.Properties;

/**
 * java操作图数据库(hugeGraph)
 */
public class HugeClientUtils {

    //解决fastJSon与Jersey冲突问题
    private static final com.alibaba.fastjson.support.jaxrs.FastJsonAutoDiscoverable FastJsonAutoDiscoverable = null;
    static {
        FastJsonAutoDiscoverable.autoDiscover = false;
    }

    /**
     * 获取hugeGraph客户端操作对象
     * @param key
     * @return
     * @throws IOException
     */
    private static HugeClient getHugeClient(String key) throws IOException {
        //读取配置文件hugeGraph连接信息
        ClassPathResource classPathResource = new ClassPathResource("hugeGraph.properties");
        Properties properties = new Properties();
        properties.load(classPathResource.getInputStream());
        //读取配置文件中key对应的value值
        String json = new String (properties.getProperty(key).getBytes(StandardCharsets.UTF_8), StandardCharsets.UTF_8) ;
        HugeClientVo hugeClientVo =JSON.parseObject(json,HugeClientVo.class);
        HugeClient hugeClient = null;
        if(hugeClientVo!=null){
            //获取操作客户端
            System.out.print("ip:"+hugeClientVo.getIp()+",name:"+hugeClientVo.getHugegraphGraphName()+",username:"+hugeClientVo.getUserName()+",password:"+hugeClientVo.getPassword());
            hugeClient = HugeClient.builder(hugeClientVo.getIp(),hugeClientVo.getHugegraphGraphName())
                    .configUser(hugeClientVo.getUserName(),hugeClientVo.getPassword())
                    .build();
        }
        return hugeClient;
    }

    /**
     * 属性操作--创建属性
     * @param falg
     * @return
     * @throws IOException
     */
    public static String createPropertyKey(String falg, Property property) throws IOException, SQLException, JSONException {
        HugeClient hugeClient = getHugeClient(falg);
        SchemaManager schema = hugeClient.schema();
        PropertyKey res = null;
        switch (property.getData_type()){
            case "STRING" :
                switch (property.getCardinality()){
                    case "SINGLE" :
                        res =  schema.propertyKey(property.getName()).asText().valueSingle().ifNotExist().create();
                    case "LIST" :
                        res =  schema.propertyKey(property.getName()).asText().valueList().ifNotExist().create();
                    case "SET" :
                        res =  schema.propertyKey(property.getName()).asText().valueSet().ifNotExist().create();
                }
                break;
            case "INT" :
                switch (property.getCardinality()){
                    case "SINGLE" :
                        res =  schema.propertyKey(property.getName()).asInt().valueSingle().ifNotExist().create();
                    case "LIST" :
                        res =  schema.propertyKey(property.getName()).asInt().valueList().ifNotExist().create();
                    case "SET" :
                        res =  schema.propertyKey(property.getName()).asInt().valueSet().ifNotExist().create();
                }
                break;
            case "FLOAT" :
                switch (property.getCardinality()){
                    case "SINGLE" :
                        res =  schema.propertyKey(property.getName()).asFloat().valueSingle().ifNotExist().create();
                    case "LIST" :
                        res =  schema.propertyKey(property.getName()).asFloat().valueList().ifNotExist().create();
                    case "SET" :
                        res =  schema.propertyKey(property.getName()).asFloat().valueSet().ifNotExist().create();
                }
                break;
            case "DATE" :
                switch (property.getCardinality()){
                    case "SINGLE" :
                        res =  schema.propertyKey(property.getName()).asDate().valueSingle().ifNotExist().create();
                    case "LIST" :
                        res =  schema.propertyKey(property.getName()).asDate().valueList().ifNotExist().create();
                    case "SET" :
                        res =  schema.propertyKey(property.getName()).asDate().valueSet().ifNotExist().create();
                }
                break;
            case "BOOLEAN" :
                switch (property.getCardinality()){
                    case "SINGLE" :
                        res =  schema.propertyKey(property.getName()).asBoolean().valueSingle().ifNotExist().create();
                    case "LIST" :
                        res =  schema.propertyKey(property.getName()).asBoolean().valueList().ifNotExist().create();
                    case "SET" :
                        res =  schema.propertyKey(property.getName()).asBoolean().valueSet().ifNotExist().create();
                }
                break;
            case "BLOB" :
                switch (property.getCardinality()){
                    case "SINGLE" :
                        res =  schema.propertyKey(property.getName()).asBlob().valueSingle().ifNotExist().create();
                    case "LIST" :
                        res =  schema.propertyKey(property.getName()).asBlob().valueList().ifNotExist().create();
                    case "SET" :
                        res =  schema.propertyKey(property.getName()).asBlob().valueSet().ifNotExist().create();
                }
            case "Double" :
                switch (property.getCardinality()){
                    case "SINGLE" :
                        res =  schema.propertyKey(property.getName()).asDouble().valueSingle().ifNotExist().create();
                    case "LIST" :
                        res =  schema.propertyKey(property.getName()).asDouble().valueList().ifNotExist().create();
                    case "SET" :
                        res =  schema.propertyKey(property.getName()).asDouble().valueSet().ifNotExist().create();
                }
                break;
        }
         return res.toString();
    }

    /**
     * 获取所有顶点标签
     * @param falg
     * @return
     * @throws IOException
     */
    public static String getAllLabel(String falg) throws IOException{
        HugeClient hugeClient = getHugeClient(falg);
        GremlinManager gremlin = hugeClient.gremlin();
        ResultSet resultSet = gremlin.gremlin("g.V()").execute();
        List<Object> list = resultSet.data();
        System.out.print(resultSet);
        JSONArray jsonarray = JSONArray.fromObject(list);
        return jsonarray.toString();
    }



}

3、RestTemplateUtil （接口调用工具类）

package net.beidousky.web.app.utils;
import net.beidousky.web.app.component.ReturnErrorJsonHandler;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.web.client.RestTemplate;
import java.util.*;

/**
 * 接口工具类
 *
 * @author jwb
 */
public class RestTemplateUtil {



    /**
     * 图数据库调用post方法
     * @param json
     * @param url
     * @return
     */
    public static String hugeGraphRest(String json, String url, String userName, String password) {
        RestTemplate template =new RestTemplate();
        //自定义异常处理用于解决调用hugeGraph返回异常结果读取message信息
        template.setErrorHandler(new ReturnErrorJsonHandler());
        HttpHeaders headers = new HttpHeaders();
        MediaType type = MediaType.parseMediaType("application/json; charset=UTF-8");
        headers.setContentType(type);
        //添加账号密码验证
        headers.add("Authorization", "Basic " + Base64.getUrlEncoder().encodeToString((userName + ":" + password).getBytes()));
        headers.add("Accept", MediaType.APPLICATION_JSON.toString());
        HttpEntity<String> formEntity = new HttpEntity<String>(json, headers);
        String  result= template.postForEntity(url,formEntity,String.class).getBody();
        return result;
    }

    /**
     * 图数据库调用get方法
     * @param
     * @param url
     * @return
     */
    public static String hugeGraphGet(String url, String userName, String password) {
        RestTemplate template =new RestTemplate();
        //自定义异常处理用于解决调用hugeGraph返回异常结果读取message信息
        template.setErrorHandler(new ReturnErrorJsonHandler());
        HttpHeaders headers = new HttpHeaders();
        MediaType type = MediaType.parseMediaType("application/json; charset=UTF-8");
        headers.setContentType(type);
        //添加账号密码验证
        headers.add("Authorization", "Basic " + Base64.getUrlEncoder().encodeToString((userName + ":" + password).getBytes()));
        headers.add("Accept", MediaType.APPLICATION_JSON.toString());
        String  result= template.getForEntity(url,String.class,headers).getBody();
        return result;
    }

}

4、ReturnErrorJsonHandler（自定义异常处理用于解决调用hugeGraph返回异常结果读取message信息）

package net.beidousky.web.app.component;

import org.apache.commons.lang3.ObjectUtils;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.client.ClientHttpResponse;
import org.springframework.lang.Nullable;
import org.springframework.web.client.DefaultResponseErrorHandler;
import org.springframework.web.client.HttpClientErrorException;
import org.springframework.web.client.HttpServerErrorException;
import org.springframework.web.client.UnknownHttpStatusCodeException;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.Reader;
import java.nio.CharBuffer;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 自定义异常处理用于解决调用hugeGraph返回异常结果读取message信息
 */
public class ReturnErrorJsonHandler extends DefaultResponseErrorHandler {

    //调用父类方法就行
    public boolean hasError(ClientHttpResponse response) throws IOException {
        return super.hasError(response);
    }

    //重写该方法调用重写的getErrorMessage方法
    public void handleError(ClientHttpResponse response) throws IOException {
        HttpStatus statusCode = HttpStatus.resolve(response.getRawStatusCode());
        if (statusCode == null) {
            byte[] body = this.getResponseBody(response);
            String message = this.getErrorMessage( body, this.getCharset(response));
            throw new UnknownHttpStatusCodeException(message, response.getRawStatusCode(), response.getStatusText(), response.getHeaders(), body, this.getCharset(response));
        } else {
            this.handleError(response, statusCode);
        }
    }

    //重写该方法，让它返回我们要的格式
    private String getErrorMessage(@Nullable byte[] responseBody, @Nullable Charset charset) {
        if (ObjectUtils.isEmpty(responseBody)) {
            return "[no body]";
        } else {
            charset = charset == null ? StandardCharsets.UTF_8 : charset;
            int maxChars = 200;
            if (responseBody.length < maxChars * 2) {
                //主要是这里
                String message=  new String(responseBody, charset);
                //Unicode 转换为汉字
                return UnicodeToString(message);
            } else {
                try {
                    Reader reader = new InputStreamReader(new ByteArrayInputStream(responseBody), charset);
                    CharBuffer buffer = CharBuffer.allocate(maxChars);
                    reader.read(buffer);
                    reader.close();
                    buffer.flip();
                    return buffer.toString() + "... (" + responseBody.length + " bytes)";
                } catch (IOException var9) {
                    throw new IllegalStateException(var9);
                }
            }
        }
    }
    /**
     * 将 Unicode 转换为汉字
     * */
    public String UnicodeToString(String str) {
        Pattern pattern = Pattern.compile("(\\\\u(\\p{XDigit}{4}))");
        Matcher matcher = pattern.matcher(str);
        char ch;
        while (matcher.find()) {
            ch = (char) Integer.parseInt(matcher.group(2), 16);
            str = str.replace(matcher.group(1), ch + "");
        }
        return str;
    }
    //重写该方法调用重写的getErrorMessage方法
    protected void handleError(ClientHttpResponse response, HttpStatus statusCode) throws IOException {
        String statusText = response.getStatusText();
        HttpHeaders headers = response.getHeaders();
        byte[] body = this.getResponseBody(response);
        Charset charset = this.getCharset(response);
        String message = this.getErrorMessage(body, charset);
        switch(statusCode.series()) {
            case CLIENT_ERROR:
                throw HttpClientErrorException.create(message, statusCode, statusText, headers, body, charset);
            case SERVER_ERROR:
                throw HttpServerErrorException.create(message, statusCode, statusText, headers, body, charset);
            default:
                throw new UnknownHttpStatusCodeException(message, statusCode.value(), statusText, headers, body, charset);
        }
    }
}

5、hugeGraph.properties（配置文件，由于业务需要，配置的是多个图数据库，所以配置文件中会有多个配置图数据库连接信息，动态读取）

NINTH = {"ip":"http://ip:端口","hugegraph_graph_name":"图数据库名称","userName":"账号","password":"密码"}
SECOND = {"ip":"http://ip:端口2","hugegraph_graph_name":"图数据库名称","userName":"账号","password":"密码"}

6、HugegraphTest（测试类）

package net.beidousky.web.app.controller;
import com.alibaba.fastjson.JSON;
import net.beidousky.web.app.domain.Result;
import net.beidousky.web.app.entity.hugegraph.Property;
import net.beidousky.web.app.utils.HugeGraphUtils;
import java.io.IOException;

public class HugegraphTest {

    /**
     * 属性操作--创建属性
     * @throws IOException
     */
        @org.junit.jupiter.api.Test
        public void createPropertyKey() throws IOException{
            Property property = new Property();
            property.setName("测试7");
            property.setData_type("TEXT");
            property.setCardinality("SINGLE");
            String json = JSON.toJSONString(property);
            Result resultSet =  HugeGraphUtils.createPropertyKey("NINTH",json);
            String jsons = JSON.toJSONString(resultSet);
            System.out.print(jsons);
        }
}

7、HugeClientVo（图数据库连接实体）

package net.beidousky.web.app.entity;
import lombok.Data;

/**
 * hugegraph连接实体
 */
@Data
public class HugeClientVo {

    //hugegraph连接地址
    private String ip;
    //hugegraph名称
    private String hugegraphGraphName;
    //hugegraph用户名
    private String userName;
    //hugegraph密码
    private String password;


}

8、Property （属性参数实体）
package net.beidousky.web.app.entity.hugegraph;

import lombok.Data;

@Data
public class Property {

//属性名称
private String name;
//属性类型只支持–STRING|INT|FLOAT|DATE|BOOLEAN|BLOB
private String data_type;
//属性基数
private String cardinality;

}

最后贴一下代码目录
在这里插入图片描述
在这里插入图片描述
创作不易，大家帮忙关注一下公众号，感谢。
在这里插入图片描述

JWB.
关注
  • 3
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于HugeGraph图数据库的知识图谱培训.pptx
08-17
本培训文档主要介绍图数据库、知识图谱、HugeGraph图数据库，以及基于HugeGraph图数据库构建知识图谱实例，重点介绍了图数据库和知识图谱的基本业务知识和应用场景。
【图数据库实战】HugeGraph架构
xqdd的专栏
11-17 967
作为一款通用的图数据库产品，HugeGraph需具备图数据的基本功能，如下图所示。HugeGraph包括三个层次的功能，分别是存储层、计算层和用户接口层。HugeGraph支持OLTP和OLAP两种图计算类型，其中OLTP实现了框架，并支持Gremlin查询语言。OLAP计算是基于SparkGraphX实现。
Java中的图数据库应用：Neo4j入门
宋小黑的博客
03-02 1647
不管是哪个操作系统，安装完成后咱们都需要进行一些基本的配置。最重要的就是关于安全性的配置，特别是设置数据库的用户名和密码。Neo4j在首次启动时会要求设置这些信息，确保你的数据库不会被未授权的人访问。此外，还可以通过修改文件来进行更多高级配置，比如调整内存设置、配置日志文件的位置等。对于大多数初学者来说，刚开始使用默认配置就已经足够了。随着咱们对Neo4j的了解加深，再根据实际需要进行相应的调整。安装并配置好Neo4j之后，咱们就可以开始探索图数据库的强大功能了。
Hugegraph环境配置及查询接口
zheng_wei_的博客
01-22 1219
hugegraph图数据库的环境配置和部分配置文件的详解，以及基于springboot的的查询接口
JAVA拓展新的数据库_HugeGraph - 一个开源快速，高度可扩展的图数据库
weixin_42356349的博客
02-25 262
HugeGraph HugeGraph is a fast-speed and highly-scalable graph database. Billions of vertices and edges can be easily stored into and queried from HugeGraph due to its excellent OLTP ability. As comp...
hugegraph-server和HugeGraph-Hubble超详细安装部署教程（主要idea和linux压缩文件安装）
技术分享，共同成长
11-25 2292
hugegraph-server和HugeGraph-Hubble超详细安装部署教程（主要idea和linux压缩文件安装），hugegraph-server的详细安装配置，heHugeGraph-Hubble的安装配置
图数据库HugeGraph简介与快速入门
热门推荐
家辉自留地
02-11 2万+
  图数据库HugeGraph简介与快速入门 作者：胡佳辉(家辉)，日期：2019年2月10日 CSDN博客：https://blog.csdn.net/gobitan   1. HugeGraph简介 1.1 HugeGraph概述 HugeGraph是一款由百度开源的图数据库(Graph Database)系统，可以存储海量的顶点(Vertex)和边(Edge)， 基于Apache...
HugeGraph安装与使用
qq_41060647的博客
11-21 824
components核心，服务端，图数据到后端的存储。支持的后端包括：Memory，Cassandra，ScyllaDB， RocksDB，HBase，MySQL和PostgreSQLWeb可视化管理平台，一站式可视化分析平台。平台覆盖从数据建模，到数据快速导入，再到数据线上线下分析、图统一管理的全流程;客户端，用于连接到 HugeGraph-Server。目前，仅实现Java版本。其他语言的用户可以自己实现;数据导入工具，它将普通文本数据转换为图形顶点和边缘，并插入图形数据库;
图数据库hugegraph如何快速导入10亿+数据
penriver的博客
03-23 2400
随着社交、电商、金融、零售、物联网等行业的快速发展，现实社会织起了了一张庞大而复杂的关系网，亟需一种支持海量复杂数据关系运算的数据库即图数据库。本系列文章是学习知识图谱以及图数据库相关的知识梳理与总结 本文会包含如下内容： 如何快速导入10亿+数据到图数据库 本篇文章适合人群：架构师、技术专家、对知识图谱与图数据库感兴趣的高级工程师 1. hugegraph环境 hugegraph server版本0.11.2，后端存储使用的是RocksDB，单机版本。 服务器版本是：CPU: 2 *Inte...
【图数据库实战】HugeGraph简介
xqdd的专栏
11-15 305
HugeGraph是一款易用、高效、通用的开源图数据库系统（Graph Database，）， 实现了框架及完全兼容查询语言， 具备完善的工具链组件，助力用户轻松构建基于图数据库之上的应用和产品。HugeGraph支持百亿以上的顶点和边快速导入，并提供毫秒级的关联关系查询能力（OLTP）， 并支持大规模分布式图分析（OLAP）。
百度地图开发java源码-hugegraph-doc:HugeGraph数据库用户文档
06-06
HugeGraph是一款易用、高效、通用的开源图数据库系统（Graph Database，）， 实现了框架及完全兼容查询语言， 具备完善的工具链组件，助力用户轻松构建基于图数据库之上的应用和产品。HugeGraph支持百亿以上的顶点...
JAVA使用DBUtils操作数据库
08-18
主要介绍了JAVA使用DBUtils操作数据库的相关资料，文中示例代码非常详细，帮助大家学习JAVA，感兴趣的朋友可以了解下
java操作oracle数据库示例
09-04
主要介绍了java操作oracle数据库示例,需要的朋友可以参考下
java数据库操作java数据库操作.ppt
06-07
java数据库操作java数据库操作
java 数据库操作，事务回滚
04-06
java 应用程序操作数据库实例，若出现sql异常则事务回滚。
java方法重写（重点讲），方法重载
weixin_46281068的博客
04-27 929
一、方法重载定义：一个类中，出现多个方法的名称相同，但是它们的形参列表是不同的，那么这些方法就称为方法重载了。注意：一个类中，只要一些方法的名称相同、形参列表不同，那么它们就是方法重载了，其它的都不管（如:修饰符，返回值类型是否一样都无所谓）。形参列表不同指的是:形参的个数、类型、顺序不同，不关心形参的名称。应用场景：开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的。
Day25-Java基础之常用类1
m0_46053885的博客
04-27 880
同时我们发现Math类中的方法都是静态的，因此在使用的时候我们可以直接通过类名去调用。对于计算机而言，其实是没有数据类型的概念的，都是0101010101，数据类型是编程语言自己规定的，所以在实际存储的时候，先把具体的数字变成二进制，每32个bit为一组，存储在数组中。比较内存地址值一般情况下是没有意义的，我们希望比较的是对象的属性，如果两个对象的属性相同，我们认为就是同一个对象；如果我们的数据是一个浮点类型的数据，有的时候计算机并不会将这个数据完全转换成一个二进制数据，而是将这个将其转换成一个无限的。
链表刷题集
最新发布
yajunjiao的专栏
04-30 278
本文主要列举了一些刷的题，不多，有那么几道，也建议各位去建立自己的刷题集。积少成多。
hugegraph的计算逻辑
06-09
HugeGraph 的计算逻辑主要包括以下几个方面： 1. 定义图模式和属性：首先，用户需要定义图的模式和属性，包括图中的节点和边类型，每种类型的属性及其数据类型等。 2. 存储数据：HugeGraph 使用 Apache Cassandra 作为底层存储引擎，将图中的节点和边数据存储在 Cassandra 中。 3. 执行图查询：HugeGraph 提供了 Gremlin 查询语言，用户可以通过编写 Gremlin 语句来查询图中的数据。HugeGraph 还支持使用 Spark 进行图计算。 4. 执行图算法：HugeGraph 提供了多种常用的图算法，例如 PageRank、连通性、最短路径等，用户可以通过调用 API 或编写 Gremlin 语句来执行这些算法。 5. 支持分布式计算：HugeGraph 是一个分布式系统，可以在多个节点上进行计算。HugeGraph 支持数据分片和分布式计算，可以处理大规模的图数据集。 总的来说，HugeGraph 的计算逻辑是基于图模型的，通过定义图模式和属性、存储数据、执行查询和算法等步骤来实现图数据的管理和分析。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值