Pengkodean

Mengenal Arsitektur Flutter Clean dengan BLoC

Daftar Isi sembunyikan 1 Arsitektur Bersih biasanya terdiri dari lapisan berikut: 2 Berikut adalah contoh struktur proyek Flutter berikut...

Ditulis oleh Ashok Kumar · 7 min baca >
kinerja desktop bergetar

Memilih arsitek yang bersih berarti aplikasi yang memiliki koneksi rendah, fleksibel, dan dapat dipelihara menggunakan prinsip arsitektur yang bersih. Ideal untuk pengembang Flutter, pendekatan ini menekankan pada pembuatan batasan arsitektural, membuat komponen dapat diuji secara intrinsik. 

Itu sebabnya arsitektur flutter-clean telah menjadi tren baru di kalangan pengembang. Dalam artikel ini, kita akan menjelajahi arsitektur ini dan mempelajari lebih lanjut tentang manfaatnya dalam mengelola interaksi pelanggan atau memanfaatkan kemampuan Flutter/Dart. Proyek ini adalah jalur Anda untuk menguasai arsitektur bersih dalam pengembangan aplikasi.

Arsitektur Bersih biasanya terdiri dari lapisan berikut:

Ide utama di balik Arsitektur Bersih adalah membagi aplikasi menjadi tiga lapisan: lapisan data, lapisan presentasi, dan lapisan topik.

  1. Entitas: Mewakili logika bisnis dan entitas data aplikasi.
  2. Kasus Penggunaan (Interaktor): Berisi aturan bisnis khusus aplikasi dan mengatur aliran data antara entitas dan lapisan luar.
  3. Repositori: Antarmuka untuk akses data, memungkinkan kasus penggunaan mengambil dan menyimpan data tanpa memperhatikan sumber data sebenarnya.
  4. Kerangka Kerja dan Driver: Lapisan terluar, tempat UI, kerangka kerja eksternal, dan sistem eksternal terintegrasi.

Berikut adalah contoh struktur proyek Flutter mengikuti Arsitektur Bersih:

/lib
|-- core
|   |-- entities
|   |-- usecases
|-- data
|   |-- repositories
|-- presentation
|   |-- screens
|   |-- widgets
|-- main.dart

Sekarang mari kita berikan contoh sederhana dengan cuplikan kode.

// lib/core/entities/user.dart

class User {
  final String id;
  final String name;

  User({required this.id, required this.name});
}

entitas

// lib/core/entities/user.dart

class User {
  final String id;
  final String name;

  User({required this.id, required this.name});
}

Gunakan Kasus:

// lib/core/usecases/get_user_usecase.dart

import 'package:your_project/core/entities/user.dart';
import 'package:your_project/data/repositories/user_repository.dart';

class GetUserUseCase {
  final UserRepository userRepository;

  GetUserUseCase({required this.userRepository});

  Future<User> execute(String userId) async {
    return await userRepository.getUser(userId);
  }
}

Repositori

// lib/data/repositories/user_repository.dart

import 'package:your_project/core/entities/user.dart';

abstract class UserRepository {
  Future<User> getUser(String userId);
}

Kerangka Kerja dan Driver:

// lib/presentation/screens/user_screen.dart

import 'package:flutter/material.dart';
import 'package:your_project/core/usecases/get_user_usecase.dart';

class UserScreen extends StatelessWidget {
  final GetUserUseCase getUserUseCase;

  UserScreen({required this.getUserUseCase});

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text('User Screen'),
      ),
      body: FutureBuilder(
        future: getUserUseCase.execute('user123'),
        builder: (context, snapshot) {
          if (snapshot.connectionState == ConnectionState.waiting) {
            return CircularProgressIndicator();
          } else if (snapshot.hasError) {
            return Text('Error: ${snapshot.error}');
          } else {
            final user = snapshot.data as User;
            return Text('User Name: ${user.name}');
          }
        },
      ),
    );
  }
}

Dalam contoh ini, UserScreen adalah komponen yang dimiliki lapisan luar. Ini menggunakan GetUserUseCase untuk mengambil pengguna dari repositori. Repositori bertugas mendapatkan data pengguna dari sumber data sebenarnya, yang bisa berupa a Database, API, atau yang serupa.

Apa yang digunakan untuk Arsitektur Flutter Clean?

Dalam skenario dunia nyata, kode di atas adalah injeksi ketergantungan yang umum digunakan, seperti paket penyedia, untuk menghubungkan dependensi Anda. Ini hanyalah contoh sederhana untuk mengilustrasikan konsep tersebut. Selain itu, akan sangat membantu untuk meningkatkan cara pengelolaan status kesalahan dan memastikan bahwa penanganan kesalahan yang tepat diterapkan dalam kasus penggunaan dan repositori.

Ada banyak kasus penggunaan, tetapi pengembang telah membaginya menjadi dua kategori. Yang pertama adalah pelanggan dan yang kedua adalah prospek. 

Pelanggan: – Dalam kategori ini, arsitektur bersih bekerja di sisi pelanggan. 

  • Buat Pelanggan: Tambahkan pelanggan baru.
  • Dapatkan Semua Pelanggan: Melihat daftar semua pelanggan.
  • Perbarui Informasi Pelanggan: Ubah detail pelanggan.
  • Jadikan Pelanggan Aktif/Tidak Aktif: Mengubah status pelanggan.
  • Hapus Pelanggan: Hapus profil pelanggan.

Prospek (Pelanggan Potensial): – Dalam kategori ini, arsitektur bersih bekerja di sisi pelanggan. 

  • Buat Prospek: Masukkan detail pelanggan potensial baru.
  • Dapatkan Semua Prospek: Lihat daftar semua prospek.
  • Ubah Prospek menjadi Pelanggan: Ubah prospek menjadi pelanggan terdaftar.
  • Perbarui Informasi Prospek: Edit detail prospek.
  • Buat Tugas Pelanggan: Tetapkan tugas yang terkait dengan pelanggan.
  • Dapatkan Semua Aktivitas untuk Pelanggan: Lihat semua tugas dan aktivitas untuk pelanggan tertentu.
  • Kasus penggunaan ini fokus pada pelanggan yang efisien dan manajemen memimpin, memastikan aplikasi CRM ramah pengguna dan mudah beradaptasi.

Penjelasan Flutter Arsitektur Bloc Clean

BLoC (Business Logic Component) adalah pola yang digunakan untuk mengelola status dalam aplikasi Flutter. Jika Anda menggabungkannya dengan prinsip Arsitektur Bersih, ini membantu Anda mengatur dan memisahkan berbagai masalah dengan lebih baik dalam proyek Flutter. Anda dapat mengintegrasikan lapisan Arsitektur Bersih (Entitas, Kasus Penggunaan, Repositori, dan Kerangka/Driver) dengan pola BLoC.

Mari kita buat contoh sederhana menggunakan BLoC dan Clean Architecture:

// lib/core/entities/user.dart

class User {
  final String id;
  final String name;

  User({required this.id, required this.name});
}

entitas

// lib/core/entities/user.dart

class User {
  final String id;
  final String name;

  User({required this.id, required this.name});
}

Gunakan Kasus:

// lib/core/usecases/get_user_usecase.dart

import 'package:your_project/core/entities/user.dart';
import 'package:your_project/data/repositories/user_repository.dart';

class GetUserUseCase {
  final UserRepository userRepository;

  GetUserUseCase({required this.userRepository});

  Future<User> execute(String userId) async {
    return await userRepository.getUser(userId);
  }
}

Repositori

// lib/data/repositories/user_repository.dart

import 'package:your_project/core/entities/user.dart';

abstract class UserRepository {
  Future<User> getUser(String userId);
}

Blok

// lib/presentation/bloc/user_bloc.dart

import 'dart:async';
import 'package:bloc/bloc.dart';
import 'package:your_project/core/entities/user.dart';
import 'package:your_project/core/usecases/get_user_usecase.dart';
import 'package:equatable/equatable.dart';

part 'user_event.dart';
part 'user_state.dart';

class UserBloc extends Bloc<UserEvent, UserState> {
  final GetUserUseCase getUserUseCase;

  UserBloc({required this.getUserUseCase}) : super(UserInitial());

  @override
  Stream<UserState> mapEventToState(
    UserEvent event,
  ) async* {
    if (event is GetUserEvent) {
      yield UserLoading();
      try {
        final user = await getUserUseCase.execute(event.userId);
        yield UserLoaded(user: user);
      } catch (e) {
        yield UserError(error: e.toString());
      }
    }
  }
}

Acara dan Status:

// lib/presentation/bloc/user_event.dart

part of 'user_bloc.dart';

abstract class UserEvent extends Equatable {
  const UserEvent();

  @override
  List<Object> get props => [];
}

class GetUserEvent extends UserEvent {
  final String userId;

  GetUserEvent({required this.userId});

  @override
  List<Object> get props => [userId];
}
// lib/presentation/bloc/user_state.dart

part of 'user_bloc.dart';

abstract class UserState extends Equatable {
  const UserState();

  @override
  List<Object> get props => [];
}

class UserInitial extends UserState {}

class UserLoading extends UserState {}

class UserLoaded extends UserState {
  final User user;

  UserLoaded({required this.user});

  @override
  List<Object> get props => [user];
}

class UserError extends UserState {
  final String error;

  UserError({required this.error});

  @override
  List<Object> get props => [error];
}

UI (Lapisan Presentasi)

// lib/presentation/screens/user_screen.dart

import 'package:flutter/material.dart';
import 'package:flutter_bloc/flutter_bloc.dart';
import 'package:your_project/presentation/bloc/user_bloc.dart';

class UserScreen extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    final userBloc = BlocProvider.of<UserBloc>(context);

    return Scaffold(
      appBar: AppBar(
        title: Text('User Screen'),
      ),
      body: BlocBuilder<UserBloc, UserState>(
        builder: (context, state) {
          if (state is UserLoading) {
            return CircularProgressIndicator();
          } else if (state is UserLoaded) {
            return Text('User Name: ${state.user.name}');
          } else if (state is UserError) {
            return Text('Error: ${state.error}');
          } else {
            return Text('No data');
          }
        },
      ),
      floatingActionButton: FloatingActionButton(
        onPressed: () {
          userBloc.add(GetUserEvent(userId: 'user123'));
        },
        child: Icon(Icons.refresh),
      ),
    );
  }
}

Dalam contoh ini, widget UserScreen menangani antarmuka pengguna. Ia menggunakan UserBloc untuk menangani status dan berkomunikasi dengan GetUserUseCase dari lapisan inti. Pola BLoC berguna untuk menjaga UI, logika bisnis, dan lapisan akses data tetap terpisah dan terorganisir.

Pastikan untuk menyertakan dependensi yang diperlukan di file pubspec.yaml File:

dependencies:
  flutter:
    sdk: flutter
  equatable: ^2.0.3
  bloc: ^7.0.0
  flutter_bloc: ^7.0.0

Apa yang Membuat Arsitektur Bersih Menonjol? 

Mari kita periksa ini! 

Opsi Luar Biasa untuk Situs Anda: Anda akan merekomendasikan strategi untuk mengubah rencana Anda menjadi penerapan yang efektif.

Keahlian dalam Arsitektur Bersih: Anda akan memiliki perusahaan dengan pengetahuan khusus yang menghasilkan konten informatif dan menarik, sehingga memberi Anda keunggulan dalam pengembangan. 

Pendekatan Proyek yang Berpusat pada Pengguna: Berfokus pada pemahaman kebutuhan pengguna akan solusi yang relevan, yang berarti tidak perlu fokus pada konten yang mengganggu. 

Pembaruan dan Komitmen Reguler: Pengembang memiliki lebih banyak fleksibilitas dalam memberikan informasi kepada klien tentang kemajuan secara konsisten.

Desain Kreatif: Mempekerjakan desainer artistik untuk membuat antarmuka berkualitas tinggi.

Beralih ke Pemasaran Online Pakar: Ini menekankan pentingnya pemasaran online profesional untuk promosi yang efektif.

Layanan Bernilai Tambah untuk Pertumbuhan: Layanan pemasaran online memainkan peran penting dalam pengembangan organisasi.

Mengatasi Tantangan Ritel Online: Ini mengatasi masalah dalam ritel online dengan strategi pemasaran khusus industri.

Prinsip Sistem Ritel yang Efektif: Arsitektur yang bersih juga membantu pengembang memanfaatkan prinsip-prinsip efektif untuk sistem ritel dan pembayaran yang aman dan berisiko rendah.

Mengapa Menguasai Flutter dengan Arsitektur Bersih yang Kreatif dan Efektif?

Jika Anda mempelajari alat Flutter online, Anda akan menemukan semua jenis fitur untuk menjaga proyek Anda tetap mutakhir dan memeriksa hasilnya sangatlah mudah. Selain itu, jika Anda memainkan kartu Anda dengan benar dengan arsitektur Flutter yang bersih ini, situs web Anda benar-benar dapat menempatkannya di posisi teratas di semua mesin pencari.

Selain itu, ini memudahkan untuk menentukan peringkat situs web lintas batas. Selain itu, Anda memiliki banyak fitur yang menjanjikan untuk membuat situs Anda terlihat mengagumkan. Tapi ingat, Anda harus memilih kru yang tidak hanya mementingkan penampilan tetapi juga mengetahui bidangnya. Tim-tim ini biasanya memiliki beberapa desainer grafis yang andal, ahli UI, dan pemikiran kreatif untuk mewujudkan visi Anda.

Setelah Anda memahami arsitekturnya, Anda selalu dapat melakukan penyesuaian pada situs web Anda, meningkatkan aliran dan tampilannya. Setelah sedikit penyesuaian di sana-sini, mereka akan memberi Anda tampilan akhir melalui beberapa mock-up atau tata letak yang keren.

Manfaat Arsitektur Flutter Clean

Menyelami Arsitektur Bersih untuk proyek Flutter Anda bukan hanya tentang kode yang baik. Sebaliknya, ini adalah langkah strategis yang membawa banyak manfaat. Jika Anda mengharapkan perjalanan pengembangan Anda berjalan lancar, maka di sinilah Anda harus memulainya. Meskipun menawarkan banyak keuntungan, mari kita bahas beberapa di antaranya. 

Testabilitas

Arsitektur yang bersih mengubah aplikasi Anda menjadi kumpulan lapisan yang tertata rapi, masing-masing memiliki tugasnya sendiri. Pemisahan ini memudahkan pengujian bagi pemula hingga pengembang berpengalaman. Anda dapat memperbesar dan menguji setiap lapisan secara terpisah, sehingga melakukan penyesuaian di satu tempat tidak akan mengacaukan pengujian Anda di tempat lain. Ini seperti memiliki kotak perkakas yang terkotak-kotak rapi di mana setiap perkakas dapat diasah secara terpisah.

Kualitas dan Independensi Kode

Arsitektur Bersih di Flutter seperti memiliki mesin yang diminyaki dengan baik; setiap bagian bekerja secara independen namun bersama-sama dengan mulus. Penyiapan ini tidak hanya membuat kode Anda lebih mudah dibaca dan dipahami, tetapi juga meningkatkan kegunaannya kembali. Anda mendapatkan basis kode yang tidak hanya berkualitas tinggi tetapi juga serbaguna, mudah beradaptasi, dan siap untuk apa pun yang Anda lakukan.

Skalabilitas

Seiring berkembangnya aplikasi Flutter Anda, ini seperti menambahkan lebih banyak ruangan ke sebuah rumah. Arsitektur Bersih adalah arsitek ahli Anda. Ini memastikan bahwa setiap tambahan baru cocok dengan sempurna tanpa kekacauan. Pendekatan terorganisir ini menjaga perluasan aplikasi Anda tetap lancar dan mudah dikelola, menghindari kesulitan yang biasa terjadi dalam pengembangan aplikasi.

Keterbacaan dan Perawatan Lebih Mudah

Basis kode di mana setiap bagian kode mengetahui tempatnya. Itulah yang Anda dapatkan dengan Arsitektur Bersih. Sangat mudah bagi pengembang untuk menavigasi, menghilangkan bug, dan menambahkan fitur baru yang keren. Kejelasan ini memangkas waktu dan upaya yang diperlukan dalam tahap pemeliharaan. Itu membuat hidup lebih mudah bagi semua orang yang terlibat.

Efisiensi Jangka Panjang

Tentu saja, menyiapkan Arsitektur Bersih mungkin terasa seperti pekerjaan ekstra pada awalnya. Tapi anggap saja itu sebagai investasi. Dalam jangka panjang, Anda menyiapkan proyek Anda untuk sukses. Ini sangat berguna untuk proyek-proyek besar dengan banyak bagian yang bergerak dan integrasi. Waktu penyiapan awal lebih kecil dibandingkan efisiensi dan peningkatan yang akan Anda alami nantinya.

Membungkus!

Jadi, itu saja tentang arsitektur Flutter yang bersih. Kami harap Anda mendapat gambaran tentang manfaatnya bagi pengembang dan beberapa kemunduran yang terkait dengannya. Oleh karena itu, terima kasih telah membaca panduan ini. 

Ditulis oleh Ashok Kumar
CEO, Pendiri, Kepala Pemasaran di Make An App Like. Saya Penulis di OutlookIndia.com, KhaleejTimes, DeccanHerald. Hubungi saya untuk mempublikasikan konten Anda. Profil
source_code_example-removebg-pratinjau

Untuk Apa MongoDB Digunakan?

Ashok Kumar in Pengkodean
  ·   3 min baca

Tinggalkan Balasan

Translate »