AI 助理
文档备案控制台
开发者社区 开发与运维 文章 正文

【案例实战】Java整合hudi-client 0.11.1

2023-05-22 1217
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 【案例实战】Java整合hudi-client 0.11.1

1.Linux部署hudi环境

（1）安装maven-3.5.4、jdk1.8环境

# 解压maven，重命名
tar -xf apache-maven-3.5.4-bin.tar.gz -C /usr/local/
mv apache-maven-3.5.4 maven
# 解压jdk，重命名
tar -xf jdk-8u212-linux-x64.tar.gz -C /usr/local/
mv jdk1.8.0_212 jdk
# 配置环境变量
vi /etc/profile
# 添加如下配置：
# JAVA HOME
JAVA_HOME=/usr/local/jdk
export JAVA_HOME
CLASSPATH=.:$JAVA_HOME/lib
export CLASSPATH
PATH=$PATH:$JAVA_HOME/bin:$CLASSPATH
export PATH
# MAVEN HOME
MAVEN_HOME=/usr/local/maven
export MAVEN_HOME
PATH=$PATH:$MAVEN_HOME/bin
export PATH
# 刷新配置
source /etc/profile

# 验证环境配置
java -version
mvn -version



260b4b448e4b4205b036ad56383f04b0.jpg

（2）下载Hudi源码包

wget https://archive.apache.org/dist/hudi/0.9.0/hudi-0.9.0.src.tgz

（3）配置Maven镜像，在maven包下conf目录下setting.xml文件

<mirror>
    <id>alimaven</id>
    <name>aliyun maven</name>
    <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
    <mirrorOf>central</mirrorOf>
</mirror>
<mirror>
    <id>aliyunmaven</id>
    <mirrorOf>*</mirrorOf>
    <name>阿里云spring插件仓库</name>
    <url>https://maven.aliyun.com/repository/spring-plugin</url>
</mirror>
<mirror>
    <id>repo2</id>
    <name>Mirror from Maven Repo2</name>
    <url>https://repo.spring.io/plugins-release/</url>
    <mirrorOf>central</mirrorOf>
</mirror>
<mirror>
    <id>UK</id>
    <name>UK Central</name>
    <url>http://uk.maven.org/maven2</url>
    <mirrorOf>central</mirrorOf>
</mirror>
<mirror>
    <id>jboss-public-repository-group</id>
    <name>JBoss Public Repository Group</name>
    <url>http://repository.jboss.org/nexus/content/groups/public</url>
    <mirrorOf>central</mirrorOf>
</mirror>
<mirror>
    <id>CN</id>
    <name>OSChina Central</name>
    <url>http://maven.oschina.net/content/groups/public/</url>
    <mirrorOf>central</mirrorOf>
</mirror>
<mirror>
    <id>google-maven-central</id>
    <name>GCS Maven Central mirror Asia Pacific</name>
    <url>https://maven-central-asia.storage-download.googleapis.com/maven2/</url>
    <mirrorOf>central</mirrorOf>
</mirror>
<mirror>
    <id>confluent</id>
    <name>confluent maven</name>
    <url>http://packages.confluent.io/maven/</url>
    <mirrorOf>confluent</mirrorOf>
</mirror>

（4）编译hudi源码包

# 将下载好的hudi解压
tar -xf hudi-0.9.0.src.tgz -C /usr/local/
cd /usr/local/hudi-0.9.0
# 执行命令
mvn clean install -DskipTests -DskipITs -Dscala-2.12 -Dspark3

（5）编译成功后，进入hudi-cli，执行./hudi-cli.sh目录测试

./hudi-cli.sh



f2cc4926b28842aa8fff2afea43945aa.jpg

（6）安装HDFS

# 解压hadoop安装包
tar -zxf hadoop-2.7.3.tar.gz -C /usr/local/
cd /usr/local/
# 创建软连接
ln -s hadoop-2.7.3 hadoop
# 配置环境变量
vi /etc/profile
# HADOOP HOME
export HADOOP_HOME=/usr/local/hadoop
export HADOOP_CONF_DIR=$HADOOP_HOME/etc/hadoop
export HADOOP_COMMON_HOME=$HADOOP_HOME
export HADOOP_HDFS_HOME=$HADOOP_HOME
export HADOOP_YARN_HOME=$HADOOP_HOME
export HADOOP_MAPRED_HOME=$HADOOP_HOME
export PATH=$PATH:$HADOOP_HOME/bin:$HADOOP_HOME/sbin
source /etc/profile
# 在Hadoop环境变量脚本配置JDK和HADOOP安装目录
vi /usr/local/hadoop/etc/hadoop/hadoop-env.sh
# 添加如下内容
export JAVA_HOME=/usr/local/jdk
export HADOOP_HOME=/usr/local/hadoop
# 配置Hadoop Common模块公共属性，编辑core-site.xml文件
  <property>
    <name>fs.defaultFS</name>
    <!-- 以自己的ip地址为准 -->
    <value>hdfs://192.168.139.100:8020</value>
  </property>
  <property>
    <name>hadoop.tmp.dir</name>
    <value>/hadoop/datas</value>
  </property>
  <property>
    <name>hadoop.http.staticuser.user</name>
    <value>root</value>
  </property>
# 配置HDFS分布式文件系统相关属性，hdfs-site.xml
<property>
    <name>dfs.namenode.name.dir</name>
    <value>/hadoop/datas/dfs/nn</value>
  </property>
  <property>
    <name>dfs.datanode.data.dir</name>
    <value>/hadoop/datas/dfs/dn</value>
  </property>
  <property>
    <name>dfs.replication</name>
    <value>1</value>
  </property>
  <property>
    <name>dfs.permissions.enabled</name>
    <value>false</value>
  </property>
  <property>
    <name>dfs.datanode.data.dir.perm</name>
    <value>750</value>
  </property>

# 创建HDFS所需的目录
mkdir -p /hadoop/datas/dfs/nn
mkdir -p /hadoop/datas/dfs/dn
mkdir -p /hadoop/datas

# 配置HDFS集群中从节点DataNode所运行机器
vi /usr/local/hadoop/etc/hadoop/workers
# 增加配置：
192.168.139.100

# 格式化HDFS
 hdfs namenode -format
# 启动HDFS集群
hadoop-daemon.sh start namenode
hadoop-daemon.sh start datanode
# 访问HDFS UI 
http://192.168.139.100:50070/


0704cfae0f7c4b96805863c416eb6324.jpg

（7）安装Spark 3.x

# 解压软件包
tar -zxf /usr/local/software/spark-3.0.0-bin-hadoop2.7.tgz -C /usr/local/
cd /usr/local/
# 创建软链接
ln -s /usr/local/spark-3.0.0-bin-hadoop2.7 /usr/local/spark
# 安装scala
tar -zxf /usr/local/softwares/scala-2.12.10.tgz -C /usr/local/
ln -s /usr/local/scala-2.12.10 /usr/local/scala
# 设置环境变量
vi /etc/profile
# SCALA_HOME
export SCALA_HOME=/usr/local/scala
export PATH=$PATH:$SCALA_HOME/bin
source /etc/profile

# 修改配置spark名称
cd /usr/local/spark/conf
# 修改配置文件名称
cp -p spark-env.sh.template spark-env.sh.template.bak
mv spark-env.sh.template spark-env.sh
# 编辑文件
vi spark-env.sh
# 修改配置文件内容
JAVA_HOME=/usr/local/jdk
SCALA_HOME=/usr/local/scala
HADOOP_CONF_DIR=/usr/local/hadoop/etc/hadoop

# 本地模式启动spark-shell
cd /usr/local/spark
bin/spark-shell --master local[2]

f2454459fa8b4142bd9e9a8694c01c60.jpg

2.java整合hudi

（1）创建maven工程添加依赖

    <dependency>
            <groupId>org.apache.hudi</groupId>
            <artifactId>hudi-java-client</artifactId>
            <version>0.11.1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.hudi</groupId>
            <artifactId>hudi-examples</artifactId>
            <version>0.11.1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.hudi</groupId>
            <artifactId>hudi-examples-common</artifactId>
            <version>0.11.1</version>
        </dependency>
        <!--JSON-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.83</version>
        </dependency>
        <dependency>
            <groupId>org.apache.parquet</groupId>
            <artifactId>parquet-avro</artifactId>
            <version>1.10.1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.avro</groupId>
            <artifactId>avro</artifactId>
            <version>1.10.1</version>
        </dependency>

（2）封装HoodieClient类，提供对Hoodie的增删改

/**
 * @description hudi-client增删改查
 * @author lixiang
 */
public class HoodieClient {
    private HoodieJavaWriteClient<HoodieAvroPayload> client;
    private String tableFormat;
    /**
     * HDFS 路径
     */
    private final static String DEFAULT_HDFS_PATH = "hdfs://192.168.139.100:8020";
    /**
     * 默认HDFS 存放的路径
     */
    private final static String DEFAULT_HDFS_DIR = "usr/hudi/warehouse";
    // ==============================构造方法开始==============================
    public HoodieClient(String hdfsPath, String hdfsDir, String tableName, String tableFormat,HoodieTableType tableType) {
        this.tableFormat = tableFormat;
        initHuDiClient(hdfsPath,hdfsDir,tableName,tableFormat,tableType);
    }
  //指定tableName、tableFormat和表类型，指定hdfs路径
    public HoodieClient(String hdfsDir, String tableName, String tableFormat,HoodieTableType tableType) {
        this(DEFAULT_HDFS_PATH,hdfsDir,tableName,tableFormat,tableType);
    }
  //指定tableName、tableFormat和指定hdfs路径，COPY_ON_WRITE类型表
    public HoodieClient(String hdfsDir, String tableName, String tableFormat) {
        this(DEFAULT_HDFS_PATH,hdfsDir,tableName,tableFormat,HoodieTableType.COPY_ON_WRITE);
    }
  //指定tableName、tableFormat和表类型，默认hdfs路径
    public HoodieClient(String tableName, String tableFormat,HoodieTableType tableType) {
        this(DEFAULT_HDFS_PATH,DEFAULT_HDFS_DIR,tableName,tableFormat,tableType);
    }
  //指定tableName和tableFormat，默认hdfs路径，COPY_ON_WRITE类型表
    public HoodieClient(String tableName, String tableFormat) {
        this(DEFAULT_HDFS_PATH,DEFAULT_HDFS_DIR,tableName,tableFormat,HoodieTableType.COPY_ON_WRITE);
    }
    // ==============================构造方法结束==============================
    /**
     * 初始化HoodieJavaWriteClient
     * @param hdfsPath
     * @param hdfsDir
     * @param tableName
     * @param tableFormat
     * @param tableType
     */
    private void initHuDiClient(String hdfsPath,String hdfsDir, String tableName, String tableFormat,HoodieTableType tableType){
        // 初始化Hoodie表
        String tablePath = hdfsPath+"/"+hdfsDir+"/"+tableName;
        // 创建HDFS路径
        Configuration hadoopConf = new Configuration();
        Path path = new Path(tablePath);
        FileSystem fileSystem = FSUtils.getFs(tablePath, hadoopConf);
        try {
            // 检查路径是否存在
            if (!fileSystem.exists(path)) {
                // 初始化Hoodie Table 创建Hoodie表的tablePath，写入初始化元数据信息
                HoodieTableMetaClient.withPropertyBuilder()
                        .setTableType(tableType.name())
                        .setTableName(tableName)
                        .setPayloadClassName(HoodieAvroPayload.class.getName())
                        .initTable(hadoopConf, tablePath);
            }
        } catch (IOException e) {
            throw new RuntimeException("初始化表Hoodie表异常,"+tableName);
        }
        // 创建write client conf
        HoodieWriteConfig huDiWriteConf = HoodieWriteConfig.newBuilder()
                // 数据schema
                .withSchema(tableFormat)
                // 数据插入更新并行度
                .withParallelism(2, 2)
                // 数据删除并行度
                .withDeleteParallelism(2)
                // HuDi表索引类型，BLOOM
                .withIndexConfig(HoodieIndexConfig.newBuilder().withIndexType(HoodieIndex.IndexType.BLOOM).build())
                // 合并
                .withCompactionConfig(HoodieCompactionConfig.newBuilder().archiveCommitsWith(20, 30).build())
                //.withEmbeddedTimelineServerEnabled(false)
                .withPath(tablePath)
                .forTable(tableName)
                .build();
        /*huDiWriteConf.getProps().setProperty(KeyGeneratorOptions.PARTITIONPATH_FIELD_NAME.key(),"table_name");
        huDiWriteConf.getProps().setProperty(KeyGeneratorOptions.RECORDKEY_FIELD_NAME.key(),"uuid");*/
        // 获得HuDi write client
        this.client = new HoodieJavaWriteClient<>(new HoodieJavaEngineContext(hadoopConf), huDiWriteConf);
    }
    /**
     * 单条插入Hoodie数据
     * @param jsonObject
     */
    public void upsertOne(JSONObject insertObject){
        upsert(Arrays.asList(insertObject));
    }
    /**
     * 批量插入Hoodie数据
     * @param jsonObject
     */
    public void upsertBatch(List<JSONObject> insertObjects){
        upsert(insertObjects);
    }
    public void deleteOne(String primaryKey,String tableName){
        delete(Arrays.asList(primaryKey),tableName);
    }
    public void deleteBatch(List<String> primaryKeys,String tableName){
        delete(primaryKeys,tableName);
    }
    /**
     * 删除逻辑
     * @param primaryKeys
     * @param tableName
     */
    private void delete(List<String> primaryKeys,String tableName){
        String newCommitTime = client.startCommit();
        List<HoodieKey> deleteKeys = primaryKeys.stream().map(key -> new HoodieKey(key,tableName)).collect(Collectors.toList());
        client.delete(deleteKeys, newCommitTime);
    }
    /**
     * 新增修改公用操作
     * @param insertObjects
     * @param primaryKey
     */
    private void upsert(List<JSONObject> insertObjects){
        String newCommitTime = client.startCommit();
        Schema avroSchema = new Schema.Parser().parse(tableFormat);
        List<HoodieRecord<HoodieAvroPayload>> hoodieRecords = insertObjects.stream().map(obj -> {
            String tableName = obj.getString("table_name");
            String uuid = obj.getString("uuid");
            GenericRecord genericRecord = new GenericData.Record(avroSchema);
            obj.forEach(genericRecord::put);
            HoodieKey hoodieKey = new HoodieKey(uuid, tableName);
            HoodieAvroPayload payload = new HoodieAvroPayload(Option.of(genericRecord));
            return (HoodieRecord<HoodieAvroPayload>) new HoodieAvroRecord<>(hoodieKey, payload);
        }).collect(Collectors.toList());
        // 获取upsertStatus
        client.upsert(hoodieRecords, newCommitTime);
    }
    /**
     * 客户端关闭方法
     */
    public void close(){
        client.close();
    }
}

（3）创建Schema，自定义表结构的JSON数据

  //根据自己的表结构进行编写
  private static String getTableFormat(String tableName){
        JSONObject field1 = new JSONObject();
        field1.put("name","uuid");
        field1.put("type","string");
        JSONObject field2 = new JSONObject();
        field2.put("name","table_name");
        field2.put("type","string");
        JSONObject field3 = new JSONObject();
        field3.put("name","date");
        field3.put("type","string");
        JSONArray fields = new JSONArray();
        fields.add(field1);
        fields.add(field2);
        fields.add(field3);
        JSONObject schema = new JSONObject();
        schema.put("type","record");
        schema.put("name",tableName);
        schema.put("fields",fields);
        return schema.toJSONString();
    }
    public static void main(String[] args) {
        String tableName = "data_raw_cow";
        // 获取表的JSON结构
        String tableFormat = getTableFormat(tableName);
        System.out.println(tableFormat);
    }

运行结果：
{
    "name":"data_raw_cow",
    "type":"record",
    "fields":[
        {
            "name":"uuid",
            "type":"string"
        },
        {
            "name":"table_name",
            "type":"string"
        },
        {
            "name":"date",
            "type":"string"
        }
    ]
}

（4）随机获取表名方法（测试）

  private static List<String> tableNames;
    static{
        tableNames = Arrays.asList("table_name1","table_name2","table_name3","table_name4","table_name5","table_name6");
    }
    private static String getTableName(){
        Random random = new Random();
        return tableNames.get(random.nextInt(tableNames.size()));
    }

（5）测试新增10条数据

 public static void main(String[] args) {
        String tableName = "data_raw_cow";
        // 获取表的JSON结构
        String tableFormat = getTableFormat(tableName);
        System.out.println(tableFormat);
        List<JSONObject> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            JSONObject json = new JSONObject();
            json.put("uuid",UUID.randomUUID().toString());
            json.put("table_name",getTableName());
            json.put("date", String.valueOf(LocalDateTime.now()));
            list.add(json);
        }
        HoodieClient client = new HoodieClient(tableName,tableFormat);
        client.upsertBatch(list);
        client.close();
    }

072ddeb8e7f24edea3e4147164dc16a9.jpg

（6）修改一条数据


09b9fe3df9904f33b29be716ef6542fe.jpg

  /**
     * 修改测试数据,修改uuid为1dd87dd5-8e14-4562-9234-51247264968d，table_name为table_name6的数据，将日期改成xxxxxxxxxx
     * @return
     */
    private static JSONObject getUpdateOneData(){
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("uuid","1dd87dd5-8e14-4562-9234-51247264968d");
        jsonObject.put("table_name","table_name6");
        jsonObject.put("date","xxxxxxxxxx");
        return jsonObject;
    }
    public static void main(String[] args) {
        String tableName = "data_raw_cow";
        // 获取表的JSON结构
        String tableFormat = getTableFormat(tableName);
        JSONObject updateOneData = getUpdateOneData();
        HoodieClient client = new HoodieClient(tableName,tableFormat);
        client.upsertOne(updateOneData);
        client.close();
    }


cc91293ac51e42c1b09c219b74257f97.jpg

（7）测试删除数据，删除数据主要是拼接主键，按照HoodieKey去删除数据

public static void main(String[] args) {
        String tableName = "data_raw_cow";
        // 获取表的JSON结构
        String tableFormat = getTableFormat(tableName);
        HoodieClient client = new HoodieClient(tableName,tableFormat);
        client.deleteOne("1dd87dd5-8e14-4562-9234-51247264968d","table_name6");
        client.close();
    }

dd15600b8e524bf1a6f153094a0a6fef.jpg


3.Spark整合hudi

Spark整合hudi这块主要是上述查询验证用到，也可以在Spark命令行去执行查看hudi数据

  • idea怎末运行scala代码配置：

（1）创建maven工程，引入依赖，采用scala语言,下面是pom.xml文件内容

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.lixiang</groupId>
    <artifactId>hudi_scala</artifactId>
    <version>1.0-SNAPSHOT</version>
    <repositories>
        <repository>
            <id>aliyun</id>
            <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
        </repository>
        <repository>
            <id>cloudera</id>
            <url>https://repository.cloudera.com/artifactory/cloudera-repos/</url>
        </repository>
        <repository>
            <id>jboss</id>
            <url>http://repository.jboss.com/nexus/content/groups/public</url>
        </repository>
    </repositories>
    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <scala.version>2.12.10</scala.version>
        <scala.binary.version>2.12</scala.binary.version>
        <spark.version>3.0.0</spark.version>
        <hadoop.version>2.7.3</hadoop.version>
        <hudi.version>0.9.0</hudi.version>
    </properties>
    <dependencies>
        <!-- 依赖Scala语言 -->
        <dependency>
            <groupId>org.scala-lang</groupId>
            <artifactId>scala-library</artifactId>
            <version>${scala.version}</version>
        </dependency>
        <!-- Spark Core 依赖 -->
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-core_${scala.binary.version}</artifactId>
            <version>${spark.version}</version>
        </dependency>
        <!-- Spark SQL 依赖 -->
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-sql_${scala.binary.version}</artifactId>
            <version>${spark.version}</version>
        </dependency>
        <!-- Hadoop Client 依赖 -->
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-client</artifactId>
            <version>${hadoop.version}</version>
        </dependency>
        <!-- hudi-spark3 -->
        <dependency>
            <groupId>org.apache.hudi</groupId>
            <artifactId>hudi-spark3-bundle_2.12</artifactId>
            <version>${hudi.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-avro_2.12</artifactId>
            <version>${spark.version}</version>
        </dependency>
    </dependencies>
    <build>
        <outputDirectory>target/classes</outputDirectory>
        <testOutputDirectory>target/test-classes</testOutputDirectory>
        <resources>
            <resource>
                <directory>${project.basedir}/src/main/resources</directory>
            </resource>
        </resources>
        <!-- Maven 编译的插件 -->
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.0</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>net.alchim31.maven</groupId>
                <artifactId>scala-maven-plugin</artifactId>
                <version>3.2.0</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>compile</goal>
                            <goal>testCompile</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

（2）编写scala代码

import org.apache.spark.sql.{DataFrame, SparkSession}
object HuDiClientTest {
  def main(args: Array[String]): Unit = {
    //创建SparkSession实例对象，设置属性
    val spark: SparkSession = {
      SparkSession.builder()
        .appName(this.getClass.getSimpleName.stripSuffix("$"))
        .master("local[2]")
        //设置序列化方式：Kryo
        .config("spark.serializer", "org.apache.spark.serializer.KryoSerializer")
        .getOrCreate()
    }
    val tableName: String = "data_raw_cow"
    val tablePath: String = "/usr/hudi/warehouse/" + tableName
    //查询数据，才采用Snapshot快照方式从Hudi表中查询数据
    queryData(spark,tablePath)
  }
  /**
   * 查询hudi数据
   * @param spark
   * @param tablePath
   */
  def queryData(spark: SparkSession, tablePath: String): Unit = {
    spark.read.format("hudi").load(tablePath).createOrReplaceTempView("hudi_table")
    spark.sql("select * from hudi_table").show(false)
  }
}


文章标签：
云消息队列 Kafka 版
Java
分布式计算
Spark
Maven
Scala
数据格式
JSON
关键词：
Java实战
Java案例
实战Java
案例Java
互联网小阿祥
目录
相关文章
aliyun4145988376
|
7月前
|
存储 人工智能 算法
从零掌握贪心算法Java版：LeetCode 10题实战解析（上）
在算法世界里，有一种思想如同生活中的"见好就收"——每次做出当前看来最优的选择，寄希望于通过局部最优达成全局最优。这种思想就是贪心算法，它以其简洁高效的特点，成为解决最优问题的利器。今天我们就来系统学习贪心算法的核心思想，并通过10道LeetCode经典题目实战演练，带你掌握这种"步步为营"的解题思维。
aliyun4145988376
418 0
代码bug生产队
|
7月前
|
安全 Java 开发者
告别NullPointerException：Java Optional实战指南
告别NullPointerException：Java Optional实战指南
代码bug生产队
339 119
JJLIN距离
|
8月前
|
人工智能 Java API
Java AI智能体实战：使用LangChain4j构建能使用工具的AI助手
随着AI技术的发展，AI智能体（Agent）能够通过使用工具来执行复杂任务，从而大幅扩展其能力边界。本文介绍如何在Java中使用LangChain4j框架构建一个能够使用外部工具的AI智能体。我们将通过一个具体示例——一个能获取天气信息和执行数学计算的AI助手，详细讲解如何定义工具、创建智能体并处理执行流程。本文包含完整的代码示例和架构说明，帮助Java开发者快速上手AI智能体的开发。
JJLIN距离
3001 8
JJLIN距离
|
8月前
|
人工智能 Java API
Java与大模型集成实战：构建智能Java应用的新范式
随着大型语言模型（LLM）的API化，将其强大的自然语言处理能力集成到现有Java应用中已成为提升应用智能水平的关键路径。本文旨在为Java开发者提供一份实用的集成指南。我们将深入探讨如何使用Spring Boot 3框架，通过HTTP客户端与OpenAI GPT（或兼容API）进行高效、安全的交互。内容涵盖项目依赖配置、异步非阻塞的API调用、请求与响应的结构化处理、异常管理以及一些面向生产环境的最佳实践，并附带完整的代码示例，助您快速将AI能力融入Java生态。
JJLIN距离
1278 12
一缕微风绕指柔
|
8月前
|
Java 开发者
Java并发编程：CountDownLatch实战解析
Java并发编程：CountDownLatch实战解析
一缕微风绕指柔
572 100
啦啦啦191
|
8月前
|
存储 前端开发 Java
【JAVA】Java 项目实战之 Java Web 在线商城项目开发实战指南
本文介绍基于Java Web的在线商城技术方案与实现，涵盖三层架构设计、MySQL数据库建模及核心功能开发。通过Spring MVC + MyBatis + Thymeleaf实现商品展示、购物车等模块，提供完整代码示例，助力掌握Java Web项目实战技能。（238字）
啦啦啦191
937 0
爱专研的技术土狗
|
9月前
|
数据采集 JSON Java
Java爬虫获取1688店铺所有商品接口数据实战指南
本文介绍如何使用Java爬虫技术高效获取1688店铺商品信息，涵盖环境搭建、API调用、签名生成及数据抓取全流程，并附完整代码示例，助力市场分析与选品决策。
爱专研的技术土狗
480 0
艾伦~耶格尔
|
9月前
|
算法 Java 开发者
Java流程控制：条件与循环结构实战
本文深入讲解编程中的流程控制结构，涵盖条件语句（if-else、switch）、循环结构（for、while、do-while）及循环控制关键字（break、continue）的使用技巧与实战案例，帮助开发者写出更清晰、高效的代码。
艾伦~耶格尔
253 0
啦啦啦191
|
9月前
|
Java API Maven
2025 Java 零基础到实战最新技术实操全攻略与学习指南
本教程涵盖Java从零基础到实战的全流程，基于2025年最新技术栈，包括JDK 21、IntelliJ IDEA 2025.1、Spring Boot 3.x、Maven 4及Docker容器化部署，帮助开发者快速掌握现代Java开发技能。
啦啦啦191
1680 1
啦啦啦191
|
9月前
|
Java 关系型数据库 数据库
Java 项目实战教程从基础到进阶实战案例分析详解
本文介绍了多个Java项目实战案例，涵盖企业级管理系统、电商平台、在线书店及新手小项目，结合Spring Boot、Spring Cloud、MyBatis等主流技术，通过实际应用场景帮助开发者掌握Java项目开发的核心技能，适合从基础到进阶的学习与实践。
啦啦啦191
1265 4