- Strona główna
- Przewodnik
- JSONL w Rust: serde_json, BufReader i abstrakcje o zerowym koszcie
JSONL w Rust: serde_json, BufReader i abstrakcje o zerowym koszcie
Kompletny przewodnik po pracy z plikami JSONL (JSON Lines) w Rust. Dowiesz się, jak odczytywać, zapisywać, parsować i przetwarzać strumieniowo dane JSONL z użyciem serde_json i BufReader, a także jak korzystać z rayon do przetwarzania równoległego oraz tokio do asynchronicznego I/O.
Dlaczego warto przetwarzać JSONL w Rust?
Rust świetnie sprawdza się w przetwarzaniu JSONL, gdy liczą się wydajność, bezpieczeństwo pamięci i poprawność. Jego model własności eliminuje wyścigi danych już na etapie kompilacji, a abstrakcje o zerowym koszcie pozwalają pisać łańcuchy iteratorów na wysokim poziomie abstrakcji, które kompilator zamienia w wydajne pętle. Z kolei serde_json należy do najszybszych parserów JSON niezależnie od języka programowania. Jeśli budujesz potok przetwarzania danych, który musi obsługiwać miliony rekordów JSONL na sekundę, Rust daje Ci kontrolę potrzebną do osiągnięcia takiej wydajności bez rezygnacji z bezpieczeństwa.
JSONL (JSON Lines) przechowuje po jednym obiekcie JSON w każdej linii, dzięki czemu idealnie nadaje się do przetwarzania strumieniowego, logów, do których tylko dopisuje się nowe wpisy, oraz przetwarzania dużych zbiorów danych. BufReader w Rust odczytuje pliki linia po linii bez wczytywania całego pliku do pamięci, a model iteratorów doskonale pasuje do struktury JSONL opartej na liniach. W tym przewodniku nauczysz się odczytywać i zapisywać JSONL z użyciem BufReader, parsować rekordy do struktur o ściśle określonych typach za pomocą serde, przetwarzać rekordy równolegle z rayon, obsługiwać asynchroniczne I/O z tokio oraz tworzyć niezawodną obsługę błędów z użyciem Result i operatora ?.
Odczyt plików JSONL z użyciem BufReader
Biblioteka standardowa Rust udostępnia BufReader do wydajnego, buforowanego odczytu plików. W połączeniu z iteratorem lines() pozwala odczytywać pliki JSONL linia po linii przy minimalnym zużyciu pamięci. Każda linia jest parsowana niezależnie, więc to podejście sprawdza się przy plikach dowolnej wielkości.
Najprościej jest opakować File w BufReader, przejść po liniach zwracanych przez lines() i sparsować każdą z nich za pomocą serde_json. W ten sposób w pamięci znajduje się naraz tylko jedna linia, niezależnie od wielkości pliku.
use std::fs::File;
use std::io::{BufRead, BufReader};
use serde_json::Value;
fn read_jsonl(path: &str) -> std::io::Result<Vec<Value>> {
let file = File::open(path)?;
let reader = BufReader::new(file);
let mut records = Vec::new();
for (line_num, line) in reader.lines().enumerate() {
let line = line?;
let trimmed = line.trim();
if trimmed.is_empty() {
continue; // Pomin puste linie
}
match serde_json::from_str::<Value>(trimmed) {
Ok(value) => records.push(value),
Err(e) => {
eprintln!("Pomijanie nieprawidlowego JSON w linii {}: {}", line_num + 1, e);
}
}
}
Ok(records)
}
fn main() -> std::io::Result<()> {
let records = read_jsonl("data.jsonl")?;
println!("Zaladowano {} rekordow", records.len());
if let Some(first) = records.first() {
println!("Pierwszy rekord: {}", first);
}
Ok(())
}Dodaj serde i serde_json do pliku Cargo.toml. Opcja derive udostępnia makra derive Serialize i Deserialize, które pozwalają definiować struktury o określonych typach pól.
[dependencies]
serde = { version = "1", features = ["derive"] }
serde_json = "1"
# Opcjonalnie: do rownoleglego przetwarzania
rayon = "1.10"
# Opcjonalnie: do asynchronicznego I/O
tokio = { version = "1", features = ["full"] }Parsowanie z kontrolą typów za pomocą serde_json
Jedną z największych zalet Rust przy przetwarzaniu JSONL są makra derive biblioteki serde. Pozwalają one deserializować każdą linię JSON bezpośrednio do struktury o ściśle określonych typach pól. Kompilator sprawdza, czy Twój kod poprawnie obsługuje dane, i wykrywa niezgodności typów, brakujące pola oraz błędy struktury już podczas kompilacji, a nie dopiero podczas działania programu.
Zdefiniuj strukturę z Deserialize i użyj serde_json::from_str, aby parsować do niej każdą linię JSONL. Brakujące lub niepoprawne pola skutkują czytelnymi komunikatami o błędach już podczas parsowania, zamiast powodować panikę na późniejszym etapie działania programu.
use serde::Deserialize;
use std::fs::File;
use std::io::{BufRead, BufReader};
#[derive(Debug, Deserialize)]
struct LogEntry {
timestamp: String,
level: String,
message: String,
#[serde(default)]
metadata: Option<serde_json::Value>,
}
fn read_typed_jsonl(path: &str) -> anyhow::Result<Vec<LogEntry>> {
let file = File::open(path)?;
let reader = BufReader::new(file);
let mut entries = Vec::new();
for line in reader.lines() {
let line = line?;
let trimmed = line.trim();
if trimmed.is_empty() {
continue;
}
let entry: LogEntry = serde_json::from_str(trimmed)?;
entries.push(entry);
}
Ok(entries)
}
fn main() -> anyhow::Result<()> {
let entries = read_typed_jsonl("logs.jsonl")?;
for entry in &entries {
println!("[{}] {}: {}", entry.level, entry.timestamp, entry.message);
}
Ok(())
}Jeśli rekordy JSONL mają różne schematy, użyj serde_json::Value, aby uzyskać elastyczny dostęp do danych. Do wartości możesz odwoływać się za pomocą nawiasów kwadratowych, a do bezpiecznej konwersji typów używać metod as_str(), as_i64().
use serde_json::Value;
use std::fs::File;
use std::io::{BufRead, BufReader};
fn process_dynamic_jsonl(path: &str) -> anyhow::Result<()> {
let file = File::open(path)?;
let reader = BufReader::new(file);
for line in reader.lines() {
let line = line?;
let trimmed = line.trim();
if trimmed.is_empty() {
continue;
}
let value: Value = serde_json::from_str(trimmed)?;
// Dostep do pol dynamicznie
if let Some(name) = value.get("name").and_then(Value::as_str) {
println!("Imie: {}", name);
}
if let Some(age) = value.get("age").and_then(Value::as_i64) {
println!("Wiek: {}", age);
}
// Sprawdz czy pole istnieje
if value.get("email").is_some() {
println!("Posiada pole email");
}
}
Ok(())
}Zapis plików JSONL w Rust
Zapis JSONL to odwrotność odczytu: serializujesz każdy rekord do ciągu znaków JSON, dodajesz znak nowej linii i zapisujesz całość do pliku. BufWriter i serde_json::to_string zapewniają zarówno poprawność, jak i wydajność.
Serializuj każdą strukturę za pomocą serde_json::to_string() i zapisuj ją wraz z końcowym znakiem nowej linii. Makro derive Serialize automatycznie konwertuje typy Rust na JSON.
use serde::Serialize;
use std::fs::File;
use std::io::Write;
#[derive(Serialize)]
struct Record {
id: u64,
name: String,
score: f64,
}
fn write_jsonl(path: &str, records: &[Record]) -> std::io::Result<()> {
let mut file = File::create(path)?;
for record in records {
let json = serde_json::to_string(record)
.map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e))?;
writeln!(file, "{}", json)?;
}
Ok(())
}
fn main() -> std::io::Result<()> {
let records = vec![
Record { id: 1, name: "Alice".into(), score: 95.5 },
Record { id: 2, name: "Bob".into(), score: 87.3 },
Record { id: 3, name: "Charlie".into(), score: 92.1 },
];
write_jsonl("output.jsonl", &records)?;
println!("Zapisano {} rekordow", records.len());
Ok(())
}Przy zapisie dużych plików JSONL opakuj File w BufWriter, aby ograniczyć liczbę wywołań systemowych. Bufor łączy wiele małych zapisów w większe porcje, które są zapisywane przy jego opróżnianiu, co znacznie zwiększa przepustowość.
use serde::Serialize;
use std::fs::File;
use std::io::{BufWriter, Write};
#[derive(Serialize)]
struct Event {
timestamp: u64,
event_type: String,
payload: serde_json::Value,
}
fn write_buffered_jsonl(path: &str, events: &[Event]) -> std::io::Result<()> {
let file = File::create(path)?;
let mut writer = BufWriter::new(file);
for event in events {
serde_json::to_writer(&mut writer, event)
.map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e))?;
writer.write_all(b"\n")?;
}
writer.flush()?;
Ok(())
}Przetwarzanie równoległe z rayon
Biblioteka rayon pozwala przetwarzać dane równolegle w Rust przy minimalnych zmianach w kodzie. Wystarczy wywołać par_iter() zamiast iter(), a rayon automatycznie rozdzieli pracę między wszystkie rdzenie procesora, korzystając z puli wątków z mechanizmem work stealing. Sprawdza się to szczególnie dobrze przy transformacjach JSONL obciążających procesor, w których parsowanie i przetwarzanie zajmują więcej czasu niż operacje I/O.
use rayon::prelude::*;
use serde::{Deserialize, Serialize};
use std::fs::File;
use std::io::{BufRead, BufReader, BufWriter, Write};
#[derive(Debug, Deserialize, Serialize)]
struct Record {
id: u64,
text: String,
#[serde(default)]
word_count: Option<usize>,
}
fn parallel_process_jsonl(
input_path: &str,
output_path: &str,
) -> anyhow::Result<usize> {
// Krok 1: Wczytaj wszystkie linie do pamieci
let file = File::open(input_path)?;
let reader = BufReader::new(file);
let lines: Vec<String> = reader.lines().collect::<Result<_, _>>()?;
// Krok 2: Parsuj i transformuj rownolegle
let processed: Vec<Record> = lines
.par_iter()
.filter(|line| !line.trim().is_empty())
.filter_map(|line| {
serde_json::from_str::<Record>(line.trim()).ok()
})
.map(|mut record| {
record.word_count = Some(record.text.split_whitespace().count());
record
})
.collect();
// Krok 3: Zapisz wyniki
let file = File::create(output_path)?;
let mut writer = BufWriter::new(file);
let count = processed.len();
for record in &processed {
serde_json::to_writer(&mut writer, record)?;
writer.write_all(b"\n")?;
}
writer.flush()?;
Ok(count)
}
fn main() -> anyhow::Result<()> {
let count = parallel_process_jsonl("input.jsonl", "output.jsonl")?;
println!("Przetworzono {} rekordow rownolegle", count);
Ok(())
}W tym podejściu najpierw odczytujesz wszystkie linie, następnie przetwarzasz je równolegle za pomocą par_iter() z rayon, a na koniec zapisujesz wyniki sekwencyjnie. Parsowanie i transformacja odbywają się równolegle na wszystkich dostępnych rdzeniach procesora. W przypadku plików mieszczących się w pamięci przyspieszenie może rosnąć niemal liniowo wraz z liczbą rdzeni. Przy bardzo dużych plikach rozważ podział danych wejściowych na porcje, aby pogodzić zużycie pamięci z przetwarzaniem równoległym.
Asynchroniczne I/O z tokio
Jeśli przetwarzanie JSONL obejmuje sieciowe I/O, na przykład odczyt z endpointów HTTP lub zapis do zdalnego magazynu danych, środowisko wykonawcze tokio pozwala prowadzić obliczenia w czasie oczekiwania na operacje I/O. Trait tokio::io::AsyncBufReadExt udostępnia asynchroniczną metodę lines(), która odpowiada synchronicznemu API BufReader.
use tokio::fs::File;
use tokio::io::{AsyncBufReadExt, BufReader};
use serde::Deserialize;
#[derive(Debug, Deserialize)]
struct ApiRecord {
id: u64,
url: String,
status: String,
}
async fn read_jsonl_async(path: &str) -> anyhow::Result<Vec<ApiRecord>> {
let file = File::open(path).await?;
let reader = BufReader::new(file);
let mut lines = reader.lines();
let mut records = Vec::new();
while let Some(line) = lines.next_line().await? {
let trimmed = line.trim().to_string();
if trimmed.is_empty() {
continue;
}
let record: ApiRecord = serde_json::from_str(&trimmed)?;
records.push(record);
}
Ok(records)
}
async fn write_jsonl_async(
path: &str,
records: &[ApiRecord],
) -> anyhow::Result<()> {
use tokio::io::AsyncWriteExt;
let mut file = File::create(path).await?;
for record in records {
let json = serde_json::to_string(record)?;
file.write_all(json.as_bytes()).await?;
file.write_all(b"\n").await?;
}
file.flush().await?;
Ok(())
}
#[tokio::main]
async fn main() -> anyhow::Result<()> {
let records = read_jsonl_async("api_logs.jsonl").await?;
println!("Odczytano {} rekordow asynchronicznie", records.len());
write_jsonl_async("output.jsonl", &records).await?;
Ok(())
}Podejście asynchroniczne daje największe korzyści w połączeniu z operacjami sieciowymi. Przy samym odczycie i zapisie plików na lokalnym dysku synchroniczny BufReader jest często szybszy, ponieważ obsługa async wiąże się z narzutem związanym z planowaniem zadań. Użyj tokio, gdy odczytujesz JSONL ze strumieni HTTP, bucketów S3 lub innych źródeł sieciowych, gdzie większość czasu zajmuje oczekiwanie na I/O.
Obsługa błędów: Result i operator ?
Typ Result i operator ? w Rust pozwalają czytelnie obsługiwać błędy przy przetwarzaniu JSONL i łatwo łączyć operacje, które mogą się nie powieść. Zamiast bloków try-catch każda taka operacja zwraca Result. Błąd możesz przekazać dalej operatorem ? albo obsłużyć lokalnie za pomocą match. Dzięki temu ścieżki obsługi błędów są jawne i nie da się ich przypadkowo zignorować.
use serde::Deserialize;
use std::fs::File;
use std::io::{BufRead, BufReader};
use thiserror::Error;
#[derive(Error, Debug)]
enum JsonlError {
#[error("Blad I/O: {0}")]
Io(#[from] std::io::Error),
#[error("Blad parsowania JSON w linii {line}: {source}")]
Parse {
line: usize,
source: serde_json::Error,
},
#[error("Blad walidacji w linii {line}: {message}")]
Validation {
line: usize,
message: String,
},
}
#[derive(Debug, Deserialize)]
struct Record {
id: u64,
name: String,
value: f64,
}
fn validate_record(record: &Record, line: usize) -> Result<(), JsonlError> {
if record.name.is_empty() {
return Err(JsonlError::Validation {
line,
message: "nazwa nie moze byc pusta".into(),
});
}
if record.value < 0.0 {
return Err(JsonlError::Validation {
line,
message: format!("wartosc musi byc nieujemna, otrzymano {}", record.value),
});
}
Ok(())
}
fn process_jsonl_with_errors(
path: &str,
) -> Result<Vec<Record>, JsonlError> {
let file = File::open(path)?; // Blad Io konwertowany automatycznie przez #[from]
let reader = BufReader::new(file);
let mut records = Vec::new();
for (idx, line) in reader.lines().enumerate() {
let line_num = idx + 1;
let line = line?; // Propagacja bledow I/O
let trimmed = line.trim();
if trimmed.is_empty() {
continue;
}
let record: Record = serde_json::from_str(trimmed)
.map_err(|e| JsonlError::Parse { line: line_num, source: e })?;
validate_record(&record, line_num)?;
records.push(record);
}
Ok(records)
}
fn main() {
match process_jsonl_with_errors("data.jsonl") {
Ok(records) => println!("Pomyslnie przetworzono {} rekordow", records.len()),
Err(JsonlError::Io(e)) => eprintln!("Blad pliku: {}", e),
Err(JsonlError::Parse { line, source }) => {
eprintln!("Blad JSON w linii {}: {}", line, source);
}
Err(JsonlError::Validation { line, message }) => {
eprintln!("Blad walidacji w linii {}: {}", line, message);
}
}
}W tym przykładzie biblioteka thiserror służy do zdefiniowania własnego typu wyliczeniowego błędów, który obejmuje wszystkie rodzaje niepowodzeń: błędy I/O, błędy parsowania JSON z numerami linii oraz błędy walidacji wynikające z reguł domenowych. Atrybut #[from] umożliwia automatyczną konwersję z std::io::Error, a operator ? przekazuje błędy w górę stosu wywołań. Każdy wariant błędu zawiera dość informacji, by utworzyć czytelny komunikat diagnostyczny i precyzyjnie wskazać linię, która spowodowała problem.
Biblioteki Rust do przetwarzania JSON
W ekosystemie Rust znajdziesz kilka bibliotek do parsowania JSON, które różnią się wydajnością. Standardowym wyborem jest serde_json, natomiast simd-json i sonic-rs wykorzystują instrukcje SIMD, aby osiągać jeszcze lepsze wyniki.
serde_json
StandardDe facto standard obsługi JSON w Rust. Dzięki ścisłej integracji z makrami derive biblioteki serde umożliwia serializację bez pisania powtarzalnego kodu. Świetnie sprawdza się w większości zadań związanych z JSONL: zapewnia ścisłą kontrolę typów, szczegółowe komunikaty o błędach i szerokie wsparcie w ekosystemie.
simd-json
NajszybszyPort simdjson do Rust, który wykorzystuje instrukcje SIMD do parsowania JSON z szybkością wielu gigabajtów na sekundę. Wymaga modyfikowalnych buforów wejściowych i ma inne API niż serde_json, ale w zadaniach zdominowanych przez parsowanie może być 2-4x szybszy. Najlepiej sprawdza się w potokach przetwarzania o dużej przepustowości.
sonic-rs
SIMD + serdeBiblioteka do obsługi JSON przyspieszana instrukcjami SIMD, z API zgodnym z serde. Jej celem jest połączenie szybkości simd-json z wygodą korzystania z serde_json. Obsługuje zarówno parsowanie leniwe, jak i natychmiastowe, dlatego warto ją rozważyć, gdy potrzebujesz wydajności bez przepisywania kodu.
Wypróbuj nasze darmowe narzędzia do JSONL
Nie chcesz pisać kodu? Skorzystaj z naszych darmowych narzędzi online, aby przeglądać, walidować i konwertować pliki JSONL bezpośrednio w przeglądarce.
Sposoby przetwarzania gigabajtów danych JSONL: odczyt strumieniowy, zarządzanie pamięcią, dzielenie plików, kompresja i narzędzia online.
Dowiedz się, jak używać JSONL jako formatu wymiany danych w pipeline’ach ETL. Poznaj przetwarzanie strumieniowe w Apache Kafka, DAG-i w Airflow, ładowanie danych do Snowflake i BigQuery oraz projektowanie pipeline’ów odpornych na awarie.
Poznaj dobre praktyki pracy z JSONL: formatowanie, spójność schematu, obsługę błędów, optymalizację wydajności i organizację plików. Praktyczne przykłady pomogą Ci uniknąć typowych pułapek.
Waliduj pliki JSONL linia po linii. Od razu wykrywaj błędy składni, problemy z kodowaniem i niezgodności z formatem.
Pełny przewodnik po pracy z plikami JSONL w Go. Poznaj bufio.Scanner, json.Decoder, wzorce współbieżności z użyciem goroutines, obsługę błędów i budowanie wydajnych pipeline’ów danych.