Flutter Mobile Development · Урок

Генерация кода с riverpod_generator и @riverpod

Используйте аннотации riverpod_generator для создания типобезопасных провайдеров без шаблонного кода.

Урок 2 из 413 шагов

«Генерация кода с riverpod_generator и @riverpod» — бесплатный урок Flutter Mobile Development на CoddyKit. Это урок 2 из 4. Ты можешь прочитать весь урок бесплатно ниже — а потом практиковать его прямо в браузере с встроенным редактором кода и ИИ-репетитором 24/7. Это часть пути обучения Flutter Mobile Development, и твой прогресс синхронизируется между веб-версией и приложением CoddyKit. Курс Flutter Mobile Development содержит 4 уроков всего.

Части этого урока еще не переведены и отображаются на английском.

Why Code Generation?

Before Riverpod 2.0, you picked the right provider type by hand: Provider, StateProvider, FutureProvider, StreamProvider, NotifierProvider, and so on. Choosing wrong meant rewrites.

The riverpod_generator package flips this around. You write a plain function or class and add the @riverpod annotation. The generator inspects your return type and produces the correct, fully type-safe provider for you.

Less boilerplate — no manual provider declarations.
Type-safe parameters — pass arguments without .family gymnastics.
Auto-disposed by default — generated providers behave like autoDispose.

Adding the Dependencies

Code generation needs both runtime and dev-time packages. riverpod_annotation ships the @riverpod annotation you use in source. riverpod_generator and build_runner run the build step that emits the .g.dart files.

A typical pubspec.yaml for a Flutter app looks like this.

dependencies:
  flutter:
    sdk: flutter
  flutter_riverpod: ^2.5.1
  riverpod_annotation: ^2.3.5

dev_dependencies:
  build_runner: ^2.4.11
  riverpod_generator: ^2.4.0
  custom_lint: ^0.6.4
  riverpod_lint: ^2.3.10

Your First Generated Provider

The smallest generated provider is a top-level function annotated with @riverpod. The first parameter is always a Ref object; the return type decides everything.

Because this function returns a plain String synchronously, the generator emits a read-only provider exposing that value. You consume it via ref.watch(helloWorldProvider) exactly like a hand-written Provider<String>.

Note the two required pieces: the part directive and the // ignore_for_file comment is optional — but the part 'file.g.dart'; is mandatory.

import 'package:riverpod_annotation/riverpod_annotation.dart';

part 'hello.g.dart';

@riverpod
String helloWorld(Ref ref) {
  return 'Hello, Riverpod 2.0';
}

Running the Generator

The annotation alone does nothing until build_runner generates the companion .g.dart file. Run it from the project root.

One-off build: generates once and exits. --delete-conflicting-outputs clears stale generated files.
Watch mode: regenerates automatically every time you save a source file — ideal during active development.

After it finishes, the helloWorldProvider symbol becomes available for import.

# Generate once
dart run build_runner build --delete-conflicting-outputs

# Or watch and rebuild on save
dart run build_runner watch --delete-conflicting-outputs

Return Type Drives the Provider

The generator reads your return type and silently picks the matching provider kind. This is the core convenience of code generation: you never name a provider type again.

Return T → synchronous provider (like Provider<T>).
Return Future<T> → async provider exposing AsyncValue<T> (like FutureProvider).
Return Stream<T> → stream provider exposing AsyncValue<T> (like StreamProvider).

Below, simply changing the signature to Future turns it into an async provider — no other change needed.

import 'package:riverpod_annotation/riverpod_annotation.dart';

part 'user.g.dart';

@riverpod
Future<String> userName(Ref ref) async {
  await Future<void>.delayed(const Duration(seconds: 1));
  return 'Ada Lovelace';
}

Passing Parameters (No More .family)

With hand-written providers, parameterizing meant .family and a tuple-like single argument. The generator lets you add normal function parameters after ref, and they become strongly typed provider arguments.

Here messageProvider takes an int id. You call it as ref.watch(messageProvider(42)). Multiple parameters and named/optional parameters all work.

import 'package:riverpod_annotation/riverpod_annotation.dart';

part 'message.g.dart';

@riverpod
Future<String> message(Ref ref, int id) async {
  final repo = ref.watch(messageRepositoryProvider);
  return repo.fetchById(id);
}

// Usage in a widget:
// final msg = ref.watch(messageProvider(42));

Stateful Logic: The Notifier Class

For mutable state with methods, annotate a class that extends the generated base class _$ClassName. You override build() to return the initial state; the generator wires up a NotifierProvider for you.

Inside methods you mutate state, and listeners rebuild automatically. This replaces the old Notifier + manual NotifierProvider declaration with a single annotated class.

import 'package:riverpod_annotation/riverpod_annotation.dart';

part 'counter.g.dart';

@riverpod
class Counter extends _$Counter {
  @override
  int build() => 0;

  void increment() => state++;
  void reset() => state = 0;
}

Async Notifiers

If your build() returns a Future, the generator produces an AsyncNotifier. The exposed state is an AsyncValue<T> that automatically tracks loading, data, and error states.

To update state after an async action, assign AsyncValue.guard(...) to state — it runs your async code and captures success or error without manual try/catch.

import 'package:riverpod_annotation/riverpod_annotation.dart';

part 'todos.g.dart';

@riverpod
class Todos extends _$Todos {
  @override
  Future<List<String>> build() async {
    return ref.watch(todoRepositoryProvider).fetchAll();
  }

  Future<void> add(String title) async {
    state = const AsyncLoading();
    state = await AsyncValue.guard(() async {
      await ref.read(todoRepositoryProvider).create(title);
      return ref.read(todoRepositoryProvider).fetchAll();
    });
  }
}

Consuming Generated Providers

Generated providers are consumed exactly like manual ones — the generated symbol is <name>Provider for functions, or <ClassName>Provider for Notifier classes.

ref.watch(counterProvider) → the current state value.
ref.read(counterProvider.notifier) → the Notifier instance, to call methods like increment().
For async providers, watch returns an AsyncValue you handle with .when(...).

class CounterView extends ConsumerWidget {
  const CounterView({super.key});

  @override
  Widget build(BuildContext context, WidgetRef ref) {
    final count = ref.watch(counterProvider);
    return Column(
      children: [
        Text('Count: $count'),
        ElevatedButton(
          onPressed: () => ref.read(counterProvider.notifier).increment(),
          child: const Text('Add'),
        ),
      ],
    );
  }
}

Keep-Alive and Dependencies

Generated providers are auto-disposed by default — they drop their state when no longer watched. Two annotation options give you control:

@Riverpod(keepAlive: true) — keeps the provider alive even with no listeners (use for app-wide singletons like a Dio client).
@Riverpod(dependencies: [...]) — declares scoped overrides for provider scoping. Most apps don't need this.

The capitalized @Riverpod(...) form is just the configurable version of the lowercase @riverpod shorthand.

import 'package:dio/dio.dart';
import 'package:riverpod_annotation/riverpod_annotation.dart';

part 'http.g.dart';

@Riverpod(keepAlive: true)
Dio dio(Ref ref) {
  return Dio(BaseOptions(baseUrl: 'https://api.example.com'));
}

Pure Dart: Why the Logic Is Testable

A big payoff of code generation is that your provider bodies are plain Dart functions and classes — easy to reason about and unit test. Below is a standalone illustration of the same state++ mutation logic a generated Notifier would run, with no Flutter or Riverpod imports needed.

This kind of pure logic is exactly what you keep inside a generated @riverpod class so it stays trivial to test.

class Counter {
  int state = 0;
  void increment() => state++;
  void reset() => state = 0;
}

void main() {
  final counter = Counter();
  counter.increment();
  counter.increment();
  counter.increment();
  print('After 3 increments: ${counter.state}');
  counter.reset();
  print('After reset: ${counter.state}');
}

Quick Check

You annotate a function that returns Future<List<Product>> with @riverpod. What kind of provider does riverpod_generator emit, and how do you consume it in a widget?

Ответь в интерактивном уроке

Recap

You learned how riverpod_generator removes provider boilerplate:

Add riverpod_annotation (runtime) plus riverpod_generator and build_runner (dev), and a part '<file>.g.dart'; directive.
Annotate a function for read-only/derived values, or a class extending _$Name for stateful Notifiers.
The return type chooses the provider: T → sync, Future<T> → async (AsyncValue), Stream<T> → stream.
Add normal parameters after ref instead of .family.
Run dart run build_runner watch to regenerate on save.
Providers are auto-disposed by default; use @Riverpod(keepAlive: true) for app-wide singletons.

Можно начать бесплатно

Изучай Dart с ИИ-репетитором — бесплатно

Пиши и запускай код прямо в браузере, получай мгновенную помощь от ИИ-репетитора 24/7 и продолжи учиться на сайте или в приложении.

Курсы: 22
Уроки: 88

Начать учиться бесплатно Посмотреть полный курс

Часто задаваемые вопросы

Урок «Генерация кода с riverpod_generator и @riverpod» бесплатный?

Да — полный текст урока «Генерация кода с riverpod_generator и @riverpod» бесплатно доступен здесь в веб-версии. Чтобы практиковать его интерактивно (встроенный редактор кода и ИИ-репетитор 24/7) и разблокировать остальной курс Flutter Mobile Development, подпишись на CoddyKit PRO. Курс Flutter Mobile Development содержит 4 уроков всего.

Чему я научусь в уроке «Генерация кода с riverpod_generator и @riverpod»?

Используйте аннотации riverpod_generator для создания типобезопасных провайдеров без шаблонного кода. Ты практикуешь Flutter Mobile Development с помощью реального кода, который запускаешь прямо в браузере, и ИИ-репетитор 24/7 отвечает на твои вопросы во время урока.

Нужен ли мне опыт, чтобы начать Flutter Mobile Development?

Предыдущий опыт не требуется. Flutter Mobile Development на CoddyKit структурирован для всех уровней — от новичков до продвинутых, поэтому ты можешь начать отсюда или с самого начала и учиться в своем темпе. Это урок 2 из 4.

Сколько времени занимает урок «Генерация кода с riverpod_generator и @riverpod»?

Большинство уроков CoddyKit занимают около 5–10 минут. Каждый из них компактный и интерактивный, поэтому ты постоянно делаешь прогресс и продолжаешь с того же места в веб-версии и приложении.

Можно ли писать и запускать код в этом уроке Flutter Mobile Development?

Да. Каждый урок Flutter Mobile Development включает встроенный редактор кода, поэтому ты пишешь и запускаешь реальный код прямо в браузере и получаешь моментальную обратную связь от AI — локальная установка не требуется.

Все уроки этого курса

От Provider к Riverpod: миграция устаревшего состояния
Генерация кода с riverpod_generator и @riverpod
Конвейеры данных AsyncNotifier и FutureProvider
Области действия, переопределения и ProviderObserver

← Назад к Flutter Mobile Development