Java进阶示例

使用DataFrame和SQL查询处理数据

在Spark中，DataFrame是一种以结构化方式处理数据的强大工具，它允许用户以类似于SQL的方式操作数据，提供了比RDD更高的抽象层次和更好的性能。下面的示例将展示如何使用Spark SQL的DataFrame API来读取CSV数据，执行查询，并保存结果。

Java代码示例：

import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.SparkSession;

public class SparkSQLDataFrameExample {

    public static void main(String[] args) {
        // 创建SparkSession
        SparkSession spark = SparkSession
                .builder()
                .appName("Spark SQL DataFrame Example")
                .master("local") // 使用本地模式运行，实际部署时可修改为集群模式
                .getOrCreate();

        // 加载CSV文件到DataFrame
        Dataset<Row> df = spark.read()
                .option("header", "true") // 表示第一行为列名
                .option("inferSchema", "true") // 自动推断每列的数据类型
                .csv("path/to/your/csv/file.csv");

        // 显示DataFrame的前几行数据
        df.show(5);

        // 执行SQL查询
        Dataset<Row> sqlDF = spark.sql("SELECT * FROM df WHERE column_name > 100"); 
        // 注意：直接使用表名df可能不起作用，Spark可能要求先注册DataFrame为临时视图
        df.createOrReplaceTempView("data_view");
        sqlDF = spark.sql("SELECT * FROM data_view WHERE column_name > 100");

        // 显示查询结果
        sqlDF.show();

        // 将结果保存为新的CSV文件
        sqlDF.write()
            .format("csv")
            .option("header", "true")
            .save("path/to/save/new/csv");

        // 停止SparkSession
        spark.stop();
    }
}

在这个示例中，我们首先创建了一个SparkSession，这是使用Spark SQL的入口点。接着，我们使用read()方法加载了一个CSV文件，并通过选项指定了文件的第一行包含列名，并让Spark自动推断每列的数据类型。然后，我们展示了如何查看DataFrame的部分内容，并通过SQL查询筛选出满足特定条件的记录。最后，我们将查询结果保存为了一个新的CSV文件。

请注意，实际应用中需要将"path/to/your/csv/file.csv"和"path/to/save/new/csv"替换为实际的文件路径。此外，根据你的具体需求，可能还需要调整option参数和SQL查询语句。

实时数据流处理

Apache Flink 是一个用于处理无界和有界数据流的开源流处理框架，支持高吞吐、低延迟的实时处理。下面的示例将展示如何使用Flink的Java API来实现一个简单的实时数据流处理任务，即计算一个文本数据流中每个单词出现的次数。

Java代码示例：

首先，确保你已安装并配置了Apache Flink环境。

import org.apache.flink.api.common.functions.FlatMapFunction;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.util.Collector;

public class FlinkWordCount {

    public static void main(String[] args) throws Exception {

        // 设置执行环境
        final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        // 创建数据流，这里假设从标准输入读取数据（例如通过命令行输入或nc命令发送）
        DataStream<String> text = env.socketTextStream("localhost", 9999);

        // 定义转换操作
        DataStream<Tuple2<String, Integer>> counts =
                // 将文本行切分为单词
                text.flatMap(new Tokenizer())
                        // 分组并计数
                        .keyBy(0)
                        .sum(1);

        // 打印结果到控制台，并设置并行度为1以简化输出
        counts.print().setParallelism(1);

        // 执行任务
        env.execute("Flink WordCount Example");
    }

    // 实现FlatMapFunction接口，用于将文本行切分为单词
    public static final class Tokenizer implements FlatMapFunction<String, Tuple2<String, Integer>> {
        @Override
        public void flatMap(String value, Collector<Tuple2<String, Integer>> out) {
            // 将每一行切分为单词，并为每个单词生成一个（单词，1）的Tuple
            for (String word : value.split("\\W+")) {
                if (!word.isEmpty()) {
                    out.collect(new Tuple2<>(word, 1));
                }
            }
        }
    }
}

此示例展示了如何使用Flink创建一个流处理作业，从网络套接字（例如通过nc -lk 9999命令发送文本数据到本地9999端口）读取文本数据流，对文本行中的单词进行计数，并将结果打印到控制台。Tokenizer类实现了FlatMapFunction，负责将输入的文本行切分成单词并生成对应的键值对，之后通过keyBy操作对相同的单词进行分组，并使用sum聚合函数计算每个单词的总数。

请确保在运行此示例之前启动了一个向指定端口发送数据的服务，或者根据实际情况调整数据源。

Spring Boot RESTful API 示例

接下来，我们将创建一个简单的Spring Boot应用程序，该程序提供一个RESTful API来管理书籍信息，包括书籍的增删改查功能。这将展示Spring Boot框架在快速构建Web服务方面的强大能力。

Java代码示例：

首先，确保你的开发环境已经配置了Spring Boot，可以使用Spring Initializr来快速启动项目，选择Web依赖。

1. 创建Book实体类 (src/main/java/com/example/demo/model/Book.java)

package com.example.demo.model;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Book {

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;
    private String title;
    private String author;

    // 省略getter和setter方法
}

2. 创建BookRepository接口 (src/main/java/com/example/demo/repository/BookRepository.java)

package com.example.demo.repository;

import com.example.demo.model.Book;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface BookRepository extends JpaRepository<Book, Long> {
}

3. 创建BookService类 (src/main/java/com/example/demo/service/BookService.java)

package com.example.demo.service;

import com.example.demo.model.Book;
import com.example.demo.repository.BookRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Optional;

@Service
public class BookService {

    private final BookRepository bookRepository;

    @Autowired
    public BookService(BookRepository bookRepository) {
        this.bookRepository = bookRepository;
    }

    public List<Book> findAll() {
        return bookRepository.findAll();
    }

    public Optional<Book> findById(Long id) {
        return bookRepository.findById(id);
    }

    public Book save(Book book) {
        return bookRepository.save(book);
    }

    public void deleteById(Long id) {
        bookRepository.deleteById(id);
    }
}

4. 创建BookController类 (src/main/java/com/example/demo/controller/BookController.java)

package com.example.demo.controller;

import com.example.demo.model.Book;
import com.example.demo.service.BookService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/api/books")
public class BookController {

    private final BookService bookService;

    @Autowired
    public BookController(BookService bookService) {
        this.bookService = bookService;
    }

    @GetMapping
    public ResponseEntity<List<Book>> getAllBooks() {
        List<Book> books = bookService.findAll();
        return ResponseEntity.ok(books);
    }

    @GetMapping("/{id}")
    public ResponseEntity<Book> getBookById(@PathVariable Long id) {
        return bookService.findById(id)
                .map(ResponseEntity::ok)
                .orElse(ResponseEntity.notFound().build());
    }

    @PostMapping
    public ResponseEntity<Book> createBook(@RequestBody Book book) {
        Book savedBook = bookService.save(book);
        return ResponseEntity.ok(savedBook);
    }

    @PutMapping("/{id}")
    public ResponseEntity<Book> updateBook(@PathVariable Long id, @RequestBody Book book) {
        if (!bookService.existsById(id)) {
            return ResponseEntity.notFound().build();
        }
        book.setId(id);
        Book updatedBook = bookService.save(book);
        return ResponseEntity.ok(updatedBook);
    }

    @DeleteMapping("/{id}")
    public ResponseEntity<Void> deleteBook(@PathVariable Long id) {
        if (!bookService.existsById(id)) {
            return ResponseEntity.notFound().build();
        }
        bookService.deleteById(id);
        return ResponseEntity.noContent().build();
    }
}

这个示例中，我们定义了一个简单的书籍模型Book，使用Spring Data JPA的BookRepository来处理数据库交互，通过BookService层封装业务逻辑，最后在BookController中定义了与书籍相关的HTTP端点，实现了CRUD操作。要运行这个应用，只需启动主类（通常包含@SpringBootApplication注解），然后你可以通过Postman或类似工具来测试这些API端点。