Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Optimalkan kinerja aplikasi modern AWS Blu Age Anda
*Vishal Jaswani, Manish Roy, dan Himanshu Sah, Amazon Web Services*
## Ringkasan
Aplikasi mainframe yang dimodernisasi dengan AWS Blu Age memerlukan pengujian fungsional dan kesetaraan kinerja sebelum diterapkan ke produksi. Dalam pengujian kinerja, aplikasi modern dapat bekerja lebih lambat daripada sistem lama, terutama dalam pekerjaan batch yang kompleks. Perbedaan ini ada karena aplikasi mainframe bersifat monolitik, sedangkan aplikasi modern menggunakan arsitektur multitier. Pola ini menyajikan teknik pengoptimalan untuk mengatasi kesenjangan kinerja ini untuk aplikasi yang dimodernisasi dengan menggunakan [refactoring otomatis](https://docs.aws.amazon.com/m2/latest/userguide/refactoring-m2.html) dengan Blu Age. AWS
Pola ini menggunakan kerangka modernisasi AWS Blu Age dengan Java asli dan kemampuan penyetelan basis data untuk mengidentifikasi dan mengatasi kemacetan kinerja. Pola ini menjelaskan bagaimana Anda dapat menggunakan profil dan pemantauan untuk mengidentifikasi masalah kinerja dengan metrik seperti waktu eksekusi SQL, pemanfaatan memori, dan pola. I/O Kemudian menjelaskan bagaimana Anda dapat menerapkan pengoptimalan yang ditargetkan, termasuk restrukturisasi kueri database, caching, dan penyempurnaan logika bisnis.
Peningkatan waktu pemrosesan batch dan pemanfaatan sumber daya sistem membantu Anda mencocokkan tingkat kinerja mainframe dalam sistem modern Anda. Pendekatan ini mempertahankan kesetaraan fungsional selama transisi ke arsitektur berbasis cloud modern.
Untuk menggunakan pola ini, atur sistem Anda dan identifikasi hotspot kinerja dengan mengikuti instruksi di bagian [Epics](#optimize-performance-aws-blu-age-modernized-application-epics), dan terapkan teknik pengoptimalan yang dibahas secara rinci di bagian [Arsitektur](#optimize-performance-aws-blu-age-modernized-application-architecture).
## Prasyarat dan batasan
**Prasyarat**
+ Aplikasi modern AWS Blu Age
+ [JProfiler Lisensi](https://www.ej-technologies.com/store/jprofiler)
+ Hak istimewa administratif untuk menginstal klien database dan alat profil
+ AWS Sertifikasi Blu Age [Level 3](https://bluinsights.aws/certification/)
+ Pemahaman tingkat menengah tentang kerangka AWS Blu Age, struktur kode yang dihasilkan, dan pemrograman Java
**Batasan**
Kemampuan dan fitur pengoptimalan berikut berada di luar cakupan pola ini:
+ Optimalisasi latensi jaringan antara tingkatan aplikasi
+ Pengoptimalan tingkat infrastruktur melalui jenis instans Amazon Elastic Compute Cloud ( EC2Amazon) dan pengoptimalan penyimpanan
+ Pengujian beban pengguna bersamaan dan pengujian stres
**Versi produk**
+ JProfiler versi 13.0 atau yang lebih baru (kami sarankan versi terbaru)
+ pgAdmin versi 8.14 atau yang lebih baru
## Arsitektur
Pola ini mengatur lingkungan pembuatan profil untuk aplikasi AWS Blu Age dengan menggunakan alat seperti dan JProfiler pgAdmin. Ini mendukung optimasi melalui DAOManager dan SQLExecution Builder yang APIs disediakan oleh AWS Blu Age.
Sisa bagian ini memberikan informasi terperinci dan contoh untuk mengidentifikasi hotspot kinerja dan strategi pengoptimalan untuk aplikasi modern Anda. Langkah-langkah di bagian [Epik](#optimize-performance-aws-blu-age-modernized-application-epics) merujuk kembali ke informasi ini untuk panduan lebih lanjut.
**Mengidentifikasi hotspot kinerja dalam aplikasi mainframe modern**
Dalam aplikasi mainframe modern, *hotspot kinerja* adalah area spesifik dalam kode yang menyebabkan perlambatan atau inefisiensi yang signifikan. Hotspot ini sering disebabkan oleh perbedaan arsitektur antara mainframe dan aplikasi modern. Untuk mengidentifikasi kemacetan kinerja ini dan mengoptimalkan kinerja aplikasi modern Anda, Anda dapat menggunakan tiga teknik: SQL logging, rencana kueri, dan analisis. `EXPLAIN` JProfiler
*Teknik identifikasi hotspot: pencatatan SQL*
Aplikasi Java modern, termasuk yang telah dimodernisasi dengan menggunakan AWS Blu Age, memiliki kemampuan bawaan untuk mencatat kueri SQL. Anda dapat mengaktifkan logger tertentu dalam proyek AWS Blu Age untuk melacak dan menganalisis pernyataan SQL yang dijalankan oleh aplikasi Anda. Teknik ini sangat berguna untuk mengidentifikasi pola akses database yang tidak efisien, seperti permintaan individu yang berlebihan atau panggilan database yang tidak terstruktur dengan baik, yang dapat dioptimalkan melalui batching atau penyempurnaan kueri.
Untuk mengimplementasikan logging SQL di aplikasi modern AWS Blu Age Anda, atur level log ke untuk pernyataan SQL dalam `application.properties` file `DEBUG` untuk menangkap detail eksekusi kueri:
```
level.org.springframework.beans.factory.support.DefaultListableBeanFactory : WARN
level.com.netfective.bluage.gapwalk.runtime.sort.internal: WARN
level.org.springframework.jdbc.core.StatementCreatorUtils: DEBUG
level.com.netfective.bluage.gapwalk.rt.blu4iv.dao: DEBUG
level.com.fiserv.signature: DEBUG
level.com.netfective.bluage.gapwalk.database.support.central: DEBUG
level.com.netfective.bluage.gapwalk.rt.db.configuration.DatabaseConfiguration: DEBUG
level.com.netfective.bluage.gapwalk.rt.db.DatabaseInteractionLoggerUtils: DEBUG
level.com.netfective.bluage.gapwalk.database.support.AbstractDatabaseSupport: DEBUG
level.com.netfective.bluage.gapwalk.rt: DEBUG
```
Pantau kueri frekuensi tinggi dan berkinerja lambat dengan menggunakan data yang dicatat untuk mengidentifikasi target pengoptimalan. Fokus pada kueri dalam proses batch karena biasanya memiliki dampak kinerja tertinggi.
*Teknik identifikasi hotspot: Kueri JELASKAN rencana*
Metode ini menggunakan kemampuan perencanaan kueri sistem manajemen database relasional. Anda dapat menggunakan perintah seperti `EXPLAIN` di PostgreSQL atau MySQL, atau di Oracle`EXPLAIN PLAN`, untuk memeriksa bagaimana database Anda bermaksud menjalankan kueri yang diberikan. Output dari perintah ini memberikan wawasan berharga ke dalam strategi eksekusi kueri, termasuk apakah indeks akan digunakan atau pemindaian tabel lengkap akan dilakukan. Informasi ini sangat penting untuk mengoptimalkan kinerja kueri, terutama dalam kasus di mana pengindeksan yang tepat dapat secara signifikan mengurangi waktu eksekusi.
Ekstrak kueri SQL yang paling berulang dari log aplikasi dan analisis jalur eksekusi kueri berkinerja lambat dengan menggunakan `EXPLAIN` perintah yang khusus untuk database Anda. Berikut adalah contoh untuk database PostgreSQL.
Kueri:
```
SELECT * FROM tenk1 WHERE unique1 < 100;
```
`EXPLAIN`perintah:
```
EXPLAIN SELECT * FROM tenk1 where unique1 < 100;
```
Output:
```
Bitmap Heap Scan on tenk1 (cost=5.06..224.98 rows=100 width=244)
Recheck Cond: (unique1 < 100)
-> Bitmap Index Scan on tenk1_unique1 (cost=0.00..5.04 rows=100 width=0)
Index Cond: (unique1 < 100)
```
Anda dapat menafsirkan `EXPLAIN` output sebagai berikut:
+ Baca `EXPLAIN` rencana dari operasi terdalam ke terluar (bawah ke atas).
+ Carilah istilah-istilah kunci. Misalnya, `Seq Scan` menunjukkan pemindaian tabel lengkap dan `Index Scan` menunjukkan penggunaan indeks.
+ Periksa nilai biaya: Angka pertama adalah biaya awal, dan angka kedua adalah total biaya.
+ Lihat `rows` nilai untuk perkiraan jumlah baris output.
Dalam contoh ini, mesin kueri menggunakan pemindaian indeks untuk menemukan baris yang cocok, dan kemudian hanya mengambil baris tersebut (`Bitmap Heap Scan`). Ini lebih efisien daripada memindai seluruh tabel, meskipun biaya akses baris individu lebih tinggi.
Operasi pemindaian tabel dalam output `EXPLAIN` rencana menunjukkan indeks yang hilang. Optimalisasi membutuhkan pembuatan indeks yang sesuai.
*Teknik identifikasi hotspot: analisis JProfiler *
JProfiler adalah alat profil Java komprehensif yang membantu Anda mengatasi kemacetan kinerja dengan mengidentifikasi panggilan database yang lambat dan panggilan intensif CPU. Alat ini sangat efektif dalam mengidentifikasi kueri SQL yang lambat dan penggunaan memori yang tidak efisien.
Contoh analisis untuk kueri:
```
select evt. com.netfective.bluage.gapwalk.rt.blu4iv.dao.Blu4ivTableManager.queryNonTrasactional
```
Tampilan JProfiler Hot Spots memberikan informasi berikut:
+ Kolom **waktu**
+ Menunjukkan total durasi eksekusi (misalnya, 329 detik)
+ Menampilkan persentase total waktu aplikasi (misalnya, 58,7%)
+ Membantu mengidentifikasi operasi yang paling memakan waktu
+ Kolom **Waktu Rata-rata**
+ Menunjukkan durasi per eksekusi (misalnya, 2.692 mikrodetik)
+ Menunjukkan kinerja operasi individu
+ Membantu mendeteksi operasi individu yang lambat
+ Kolom **acara**
+ Menunjukkan jumlah eksekusi (misalnya, 122,387 kali)
+ Menunjukkan frekuensi operasi
+ Membantu mengidentifikasi metode yang sering disebut
Untuk hasil contoh:
+ Frekuensi tinggi: 122.387 eksekusi menunjukkan potensi pengoptimalan
+ Masalah kinerja: 2.692 mikrodetik untuk waktu rata-rata menunjukkan inefisiensi
+ Dampak kritis: 58,7% dari total waktu menunjukkan kemacetan utama
JProfiler dapat menganalisis perilaku runtime aplikasi Anda untuk mengungkapkan hotspot yang mungkin tidak terlihat melalui analisis kode statis atau pencatatan SQL. Metrik ini membantu Anda mengidentifikasi operasi yang memerlukan pengoptimalan dan menentukan strategi pengoptimalan yang paling efektif. Untuk informasi selengkapnya tentang JProfiler fitur, lihat [JProfiler dokumentasi](https://www.ej-technologies.com/resources/jprofiler/help/doc/main/introduction.html).
Bila Anda menggunakan ketiga teknik ini (SQL logging, query `EXPLAIN` plan, dan JProfiler) dalam kombinasi, Anda bisa mendapatkan tampilan holistik dari karakteristik kinerja aplikasi Anda. Dengan mengidentifikasi dan menangani hotspot kinerja yang paling penting, Anda dapat menjembatani kesenjangan kinerja antara aplikasi mainframe asli Anda dan sistem berbasis cloud modern Anda.
Setelah Anda mengidentifikasi hotspot kinerja aplikasi Anda, Anda dapat menerapkan strategi pengoptimalan, yang dijelaskan di bagian berikutnya.
**Strategi optimasi untuk modernisasi mainframe**
Bagian ini menguraikan strategi utama untuk mengoptimalkan aplikasi yang telah dimodernisasi dari sistem mainframe. Ini berfokus pada tiga strategi: menggunakan yang ada APIs, menerapkan caching yang efektif, dan mengoptimalkan logika bisnis.
*Strategi optimasi: Menggunakan yang ada APIs*
AWS Blu Age menyediakan beberapa antarmuka DAO yang kuat APIs yang dapat Anda gunakan untuk mengoptimalkan kinerja. Dua antarmuka utama — DAOManager dan SQLExecution Builder — menawarkan kemampuan untuk meningkatkan kinerja aplikasi.
**DAOManager**
DAOManager berfungsi sebagai antarmuka utama untuk operasi database dalam aplikasi modern. Ini menawarkan beberapa metode untuk meningkatkan operasi database dan meningkatkan kinerja aplikasi, terutama untuk membuat, membaca, memperbarui, dan menghapus (CRUD) operasi langsung dan pemrosesan batch.
+ **Gunakan SetMaxResults.** Di DAOManager API, Anda dapat menggunakan **SetMaxResults**metode ini untuk menentukan jumlah maksimum catatan yang akan diambil dalam satu operasi database. Secara default, hanya DAOManager mengambil 10 catatan sekaligus, yang dapat menyebabkan beberapa panggilan database saat memproses kumpulan data besar. Gunakan pengoptimalan ini ketika aplikasi Anda perlu memproses sejumlah besar catatan dan saat ini membuat beberapa panggilan database untuk mengambilnya. Ini sangat berguna dalam skenario pemrosesan batch di mana Anda melakukan iterasi melalui kumpulan data besar. Dalam contoh berikut, kode di sebelah kiri (sebelum optimasi) menggunakan nilai pengambilan data default dari 10 catatan. Kode di sebelah kanan (setelah optimasi) ditetapkan **setMaxResults**untuk mengambil 100.000 catatan sekaligus.
**catatan**
Pilih ukuran batch yang lebih besar dengan hati-hati dan periksa ukuran objek, karena pengoptimalan ini meningkatkan jejak memori.
+ **Ganti SetOnGreatorOrEqual dengan SetOnEqual.** Optimasi ini melibatkan perubahan metode yang Anda gunakan untuk mengatur kondisi untuk mengambil catatan. **SetOnGreatorOrEqual**Metode ini mengambil catatan yang lebih besar dari atau sama dengan nilai yang ditentukan, sedangkan hanya **SetOnEqual**mengambil catatan yang sama persis dengan nilai yang ditentukan.
Gunakan **SetOnEqual**seperti yang diilustrasikan dalam contoh kode berikut, ketika Anda tahu bahwa Anda memerlukan pencocokan yang tepat dan saat ini Anda menggunakan **SetOnGreatorOrEqual**metode diikuti oleh **readNextEqual()**. Optimalisasi ini mengurangi pengambilan data yang tidak perlu.
+ **Gunakan operasi batch write dan update.** Anda dapat menggunakan operasi batch untuk mengelompokkan beberapa operasi tulis atau pembaruan ke dalam satu transaksi database. Ini mengurangi jumlah panggilan database dan secara signifikan dapat meningkatkan kinerja untuk operasi yang melibatkan beberapa catatan.
Dalam contoh berikut, kode di sebelah kiri melakukan operasi tulis dalam satu lingkaran, yang memperlambat kinerja aplikasi. Anda dapat mengoptimalkan kode ini dengan menggunakan operasi penulisan batch: Selama setiap iterasi `WHILE` loop, Anda menambahkan catatan ke batch hingga ukuran batch mencapai ukuran 100 yang telah ditentukan sebelumnya. Anda kemudian dapat menyiram batch ketika mencapai ukuran batch yang telah ditentukan, dan kemudian flush semua catatan yang tersisa ke database. Ini sangat berguna dalam skenario di mana Anda memproses kumpulan data besar yang memerlukan pembaruan.
+ **Tambahkan indeks.** Menambahkan indeks adalah optimasi tingkat database yang dapat secara signifikan meningkatkan kinerja kueri. Indeks memungkinkan database untuk dengan cepat menemukan baris dengan nilai kolom tertentu tanpa memindai seluruh tabel. Gunakan pengindeksan pada kolom yang sering digunakan dalam `WHERE` klausa, `JOIN` kondisi, atau pernyataan. `ORDER BY` Ini sangat penting untuk tabel besar atau ketika pengambilan data cepat sangat penting.
**SQLExecutionPembangun**
SQLExecutionBuilder adalah API fleksibel yang dapat Anda gunakan untuk mengendalikan kueri SQL yang akan dieksekusi, mengambil kolom tertentu saja, `INSERT` dengan menggunakan`SELECT`, dan menggunakan nama tabel dinamis. Dalam contoh berikut, SQLExecutor Builder menggunakan kueri kustom yang Anda tentukan.
**Memilih antara DAOManager dan SQLExecution Builder**
Pilihan antara ini APIs tergantung pada kasus penggunaan spesifik Anda:
+ Gunakan DAOManager saat Anda ingin AWS Blu Age Runtime untuk menghasilkan kueri SQL alih-alih menulisnya sendiri.
+ Pilih SQLExecution Builder saat Anda perlu menulis kueri SQL untuk memanfaatkan fitur khusus database atau menulis kueri SQL yang optimal.
*Strategi pengoptimalan: Caching*
Dalam aplikasi modern, menerapkan strategi caching yang efektif dapat secara signifikan mengurangi panggilan database dan meningkatkan waktu respons. Ini membantu menjembatani kesenjangan kinerja antara mainframe dan lingkungan cloud.
Dalam aplikasi AWS Blu Age, implementasi caching sederhana menggunakan struktur data internal seperti peta hash atau daftar array, sehingga Anda tidak perlu menyiapkan solusi caching eksternal yang memerlukan biaya dan restrukturisasi kode. Pendekatan ini sangat efektif untuk data yang sering diakses tetapi jarang berubah. Saat Anda menerapkan caching, pertimbangkan batasan memori dan pola pembaruan untuk memastikan bahwa data yang di-cache tetap konsisten dan memberikan manfaat kinerja aktual.
Kunci keberhasilan caching adalah mengidentifikasi data yang tepat untuk cache. Dalam contoh berikut, kode di sebelah kiri selalu membaca data dari tabel, sedangkan kode di sebelah kanan membaca data dari tabel ketika peta hash lokal tidak memiliki nilai untuk kunci yang diberikan. `cacheMap`adalah objek peta hash yang dibuat dalam konteks program dan dihapus dalam metode pembersihan konteks program.
Caching dengan DAOManager:
Caching dengan SQLExecution Builder:
*Strategi optimasi: Optimalisasi logika bisnis*
Optimalisasi logika bisnis berfokus pada restrukturisasi kode yang dihasilkan secara otomatis dari AWS Blu Age agar lebih selaras dengan kemampuan arsitektur modern. Ini menjadi perlu ketika kode yang dihasilkan mempertahankan struktur logika yang sama dengan kode mainframe lama, yang mungkin tidak optimal untuk sistem modern. Tujuannya adalah untuk meningkatkan kinerja sambil mempertahankan kesetaraan fungsional dengan aplikasi asli.
Pendekatan pengoptimalan ini melampaui tweak API sederhana dan strategi caching. Ini melibatkan perubahan bagaimana aplikasi memproses data dan berinteraksi dengan database. Pengoptimalan umum termasuk menghindari operasi baca yang tidak perlu untuk pembaruan sederhana, menghapus panggilan database yang berlebihan, dan merestrukturisasi pola akses data agar lebih selaras dengan arsitektur aplikasi modern. Berikut adalah beberapa contoh:
+ **Memperbarui data secara langsung di database.**Merestrukturisasi logika bisnis Anda dengan menggunakan pembaruan SQL langsung alih-alih beberapa DAOManager operasi dengan loop. Misalnya, kode berikut (sisi kiri) membuat beberapa panggilan database dan menggunakan memori yang berlebihan. Secara khusus, ia menggunakan beberapa operasi baca dan tulis database dalam loop, pembaruan individual alih-alih pemrosesan batch, dan pembuatan objek yang tidak perlu untuk setiap iterasi.
Kode dioptimalkan berikut (sisi kanan) menggunakan operasi pembaruan SQL Langsung tunggal. Secara khusus, ia menggunakan panggilan database tunggal alih-alih beberapa panggilan dan tidak memerlukan loop karena semua pembaruan ditangani dalam satu pernyataan. Optimalisasi ini memberikan kinerja dan pemanfaatan sumber daya yang lebih baik, dan mengurangi kompleksitas. Ini mencegah injeksi SQL, menyediakan caching rencana kueri yang lebih baik, dan membantu meningkatkan keamanan.
**catatan**
Selalu gunakan kueri berparameter untuk mencegah injeksi SQL dan memastikan manajemen transaksi yang tepat.
+ **Mengurangi panggilan database yang berlebihan.** Panggilan database redundan dapat secara signifikan mempengaruhi kinerja aplikasi, terutama ketika mereka terjadi dalam loop. Teknik optimasi yang sederhana namun efektif adalah menghindari pengulangan kueri database yang sama beberapa kali. Perbandingan kode berikut menunjukkan bagaimana memindahkan panggilan `retrieve()` database di luar loop mencegah eksekusi berlebihan dari kueri identik, yang meningkatkan efisiensi.
+ **Mengurangi panggilan database dengan menggunakan `JOIN` **klausa** SQL**. Implementasikan SQLExecution Builder untuk meminimalkan panggilan ke database. SQLExecutionBuilder memberikan kontrol lebih besar atas pembuatan SQL dan sangat berguna untuk kueri kompleks yang DAOManager tidak dapat ditangani secara efisien. Misalnya, kode berikut menggunakan beberapa DAOManager panggilan:
```
List employees = daoManager.readAll();
for(Employee emp : employees) {
Department dept = deptManager.readById(emp.getDeptId()); // Additional call for each employee
Project proj = projManager.readById(emp.getProjId()); // Another call for each employee
processEmployeeData(emp, dept, proj);
}
```
Kode yang dioptimalkan menggunakan satu panggilan database di SQLExecution Builder:
```
SQLExecutionBuilder builder = new SQLExecutionBuilder();
builder.append("SELECT e.*, d.name as dept_name, p.name as proj_name");
builder.append("FROM employee e");
builder.append("JOIN department d ON e.dept_id = d.id");
builder.append("JOIN project p ON e.proj_id = p.id");
builder.append("WHERE e.status = ?", "ACTIVE");
List> results = builder.execute(); // Single database call
for(Map result : results) {
processComplexData(result);
}
```
*Menggunakan strategi optimasi bersama*
Ketiga strategi ini bekerja secara sinergis: APIs menyediakan alat untuk akses data yang efisien, caching mengurangi kebutuhan untuk pengambilan data berulang, dan optimasi logika bisnis memastikan bahwa ini APIs digunakan dengan cara yang paling efektif. Pemantauan dan penyesuaian reguler dari pengoptimalan ini memastikan peningkatan kinerja berkelanjutan sambil mempertahankan keandalan dan fungsionalitas aplikasi yang dimodernisasi. Kunci sukses terletak pada pemahaman kapan dan bagaimana menerapkan setiap strategi berdasarkan karakteristik aplikasi dan tujuan kinerja Anda.
## Alat
+ [JProfiler](https://www.ej-technologies.com/jprofiler)adalah alat profil Java yang dirancang untuk pengembang dan insinyur kinerja. Ini menganalisis aplikasi Java dan membantu mengidentifikasi kemacetan kinerja, kebocoran memori, dan masalah threading. JProfiler menawarkan CPU, memori, dan thread profiling serta database dan Java virtual machine (JVM) monitoring untuk memberikan wawasan tentang perilaku aplikasi.
**catatan**
Sebagai alternatif JProfiler, Anda dapat menggunakan [Java VisualVM](https://visualvm.github.io/). Ini adalah alat profil dan pemantauan kinerja open source gratis untuk aplikasi Java yang menawarkan pemantauan real-time penggunaan CPU, konsumsi memori, manajemen thread, dan statistik pengumpulan sampah. Karena Java VisualVM adalah alat JDK bawaan, ini lebih hemat biaya daripada untuk kebutuhan profil dasar. JProfiler
+ [pgAdmin](https://www.pgadmin.org/) adalah alat administrasi dan pengembangan open source untuk PostgreSQL. Ini menyediakan antarmuka grafis yang membantu Anda membuat, memelihara, dan menggunakan objek database. Anda dapat menggunakan pgAdmin untuk melakukan berbagai tugas, mulai dari menulis kueri SQL sederhana hingga mengembangkan basis data yang kompleks. Fitur-fiturnya termasuk sintaks yang menyoroti editor SQL, editor kode sisi server, agen penjadwalan untuk SQL, shell, dan tugas batch, dan dukungan untuk semua fitur PostgreSQL untuk pengguna PostgreSQL pemula dan berpengalaman.
## Praktik terbaik
Mengidentifikasi hotspot kinerja:
+ Dokumentasikan metrik kinerja dasar sebelum Anda memulai pengoptimalan.
+ Tetapkan target peningkatan kinerja yang jelas berdasarkan persyaratan bisnis.
+ Saat melakukan benchmarking, nonaktifkan logging verbose, karena dapat memengaruhi kinerja.
+ Siapkan rangkaian uji kinerja dan jalankan secara berkala.
+ Gunakan pgAdmin versi terbaru. (Versi lama tidak mendukung paket `EXPLAIN` kueri.)
+ Untuk benchmarking, lepaskan JProfiler setelah pengoptimalan Anda selesai karena menambah latensi.
+ Untuk benchmarking, pastikan untuk menjalankan server dalam mode mulai alih-alih mode debug, karena mode debug menambah latensi.
Strategi optimasi:
+ Konfigurasikan **SetMaxResults**nilai dalam `application.yaml` file, untuk menentukan batch berukuran tepat sesuai dengan spesifikasi sistem Anda.
+ Konfigurasikan **SetMaxResults**nilai berdasarkan volume data dan kendala memori.
+ Ubah **SetOnGreatorOrEqual**menjadi **SetOnEqual**hanya ketika panggilan berikutnya`.readNextEqual()`.
+ Dalam operasi penulisan atau pembaruan batch, tangani batch terakhir secara terpisah, karena mungkin lebih kecil dari ukuran batch yang dikonfigurasi dan dapat dilewatkan oleh operasi tulis atau pembaruan.
Caching:
+ Bidang yang diperkenalkan untuk caching di`processImpl`, yang bermutasi dengan setiap eksekusi, harus selalu didefinisikan dalam konteks itu. `processImpl` Bidang juga harus dibersihkan dengan menggunakan `cleanUp()` metode `doReset()` or.
+ Saat Anda menerapkan cache dalam memori, ukuran cache yang tepat. Cache yang sangat besar yang disimpan dalam memori dapat mengambil semua sumber daya, yang dapat memengaruhi kinerja keseluruhan aplikasi Anda.
SQLExecutionPembangun:
+ Untuk kueri yang Anda rencanakan untuk digunakan di SQLExecution Builder, gunakan nama kunci seperti`PROGRAMNAME_STATEMENTNUMBER`.
+ Saat Anda menggunakan SQLExecution Builder, selalu periksa `Sqlcod` bidangnya. Bidang ini berisi nilai yang menentukan apakah kueri dijalankan dengan benar atau mengalami kesalahan apa pun.
+ Gunakan kueri berparameter untuk mencegah injeksi SQL.
Optimalisasi logika bisnis:
+ Pertahankan kesetaraan fungsional saat merestrukturisasi kode, dan jalankan pengujian regresi dan perbandingan basis data untuk subset program yang relevan.
+ Pertahankan snapshot profil untuk perbandingan.
## Epik
### Instal JProfiler dan pgAdmin
| Tugas | Deskripsi | Keterampilan yang dibutuhkan |
| --- | --- | --- |
| Instal dan konfigurasikan JProfiler. | [See the AWS documentation website for more details](http://docs.aws.amazon.com/id_id/prescriptive-guidance/latest/patterns/optimize-performance-aws-blu-age-modernized-application.html) | Pengembang aplikasi |
| Instal dan konfigurasikan pgAdmin. | Pada langkah ini, Anda menginstal dan mengkonfigurasi klien DB untuk menanyakan database Anda. Pola ini menggunakan database PostgreSQL dan pgAdmin sebagai klien database. Jika Anda menggunakan mesin database lain, ikuti dokumentasi untuk klien DB yang sesuai.[See the AWS documentation website for more details](http://docs.aws.amazon.com/id_id/prescriptive-guidance/latest/patterns/optimize-performance-aws-blu-age-modernized-application.html) | Pengembang aplikasi |
### Identifikasi hotspot
| Tugas | Deskripsi | Keterampilan yang dibutuhkan |
| --- | --- | --- |
| Aktifkan pencatatan kueri SQL di aplikasi AWS Blu Age Anda. | [Aktifkan logger untuk pencatatan kueri SQL di `application.properties` file aplikasi AWS Blu Age Anda, seperti yang dijelaskan di bagian Arsitektur.](#optimize-performance-aws-blu-age-modernized-application-architecture) | Pengembang aplikasi |
| Menghasilkan dan menganalisis `EXPLAIN` rencana kueri untuk mengidentifikasi hotspot kinerja database. | Untuk detailnya, lihat bagian [Arsitektur](#optimize-performance-aws-blu-age-modernized-application-architecture). | Pengembang aplikasi |
| Buat JProfiler snapshot untuk menganalisis kasus uji berkinerja lambat. | [See the AWS documentation website for more details](http://docs.aws.amazon.com/id_id/prescriptive-guidance/latest/patterns/optimize-performance-aws-blu-age-modernized-application.html) | Pengembang aplikasi |
| Analisis JProfiler snapshot untuk mengidentifikasi kemacetan kinerja. | Ikuti langkah-langkah ini untuk menganalisis JProfiler snapshot.[See the AWS documentation website for more details](http://docs.aws.amazon.com/id_id/prescriptive-guidance/latest/patterns/optimize-performance-aws-blu-age-modernized-application.html)
Untuk informasi selengkapnya tentang penggunaan JProfiler, lihat bagian [Arsitektur](#optimize-performance-aws-blu-age-modernized-application-architecture) dan [JProfiler dokumentasi](https://www.ej-technologies.com/jprofiler/docs). | Pengembang aplikasi |
### Tetapkan garis dasar
| Tugas | Deskripsi | Keterampilan yang dibutuhkan |
| --- | --- | --- |
| Tetapkan garis dasar kinerja sebelum Anda menerapkan pengoptimalan. | [See the AWS documentation website for more details](http://docs.aws.amazon.com/id_id/prescriptive-guidance/latest/patterns/optimize-performance-aws-blu-age-modernized-application.html) | Pengembang aplikasi |
### Terapkan strategi pengoptimalan
| Tugas | Deskripsi | Keterampilan yang dibutuhkan |
| --- | --- | --- |
| Optimalkan panggilan baca. | Optimalkan pengambilan data dengan menggunakan DAOManager **SetMaxResults**metode. Untuk informasi lebih lanjut tentang pendekatan ini, lihat bagian [Arsitektur](#optimize-performance-aws-blu-age-modernized-application-architecture). | Pengembang aplikasi, DAOManager |
| Refactor logika bisnis untuk menghindari beberapa panggilan ke database. | Kurangi panggilan database dengan menggunakan `JOIN` klausa SQL. Untuk detail dan contoh, lihat *Optimasi logika bisnis* di bagian [Arsitektur](#optimize-performance-aws-blu-age-modernized-application-architecture). | Pengembang aplikasi, SQLExecution Pembangun |
| Refactor kode untuk menggunakan caching untuk mengurangi latensi panggilan baca. | Untuk informasi tentang teknik ini, lihat *Caching* di bagian [Arsitektur](#optimize-performance-aws-blu-age-modernized-application-architecture). | Pengembang aplikasi |
| Tulis ulang kode yang tidak efisien yang menggunakan beberapa DAOManager operasi untuk operasi pembaruan sederhana. | Untuk informasi selengkapnya tentang memperbarui data secara langsung di database, lihat *Optimasi logika bisnis* di bagian [Arsitektur](#optimize-performance-aws-blu-age-modernized-application-architecture). | Pengembang aplikasi |
### Strategi pengoptimalan uji
| Tugas | Deskripsi | Keterampilan yang dibutuhkan |
| --- | --- | --- |
| Validasi setiap perubahan optimasi secara iteratif sambil mempertahankan kesetaraan fungsional. | [See the AWS documentation website for more details](http://docs.aws.amazon.com/id_id/prescriptive-guidance/latest/patterns/optimize-performance-aws-blu-age-modernized-application.html)Menggunakan metrik dasar sebagai referensi memastikan pengukuran yang akurat dari setiap dampak pengoptimalan sambil mempertahankan keandalan sistem. | Pengembang aplikasi |
## Pemecahan masalah
| Isu | Solusi |
| --- | --- |
| Ketika Anda menjalankan aplikasi modern, Anda melihat pengecualian dengan kesalahan`Query_ID not found`. | Untuk menyelesaikan masalah ini:[See the AWS documentation website for more details](http://docs.aws.amazon.com/id_id/prescriptive-guidance/latest/patterns/optimize-performance-aws-blu-age-modernized-application.html) |
| Anda telah menambahkan indeks, tetapi Anda tidak melihat peningkatan kinerja apa pun. | Ikuti langkah-langkah ini untuk memastikan bahwa mesin kueri menggunakan indeks:[See the AWS documentation website for more details](http://docs.aws.amazon.com/id_id/prescriptive-guidance/latest/patterns/optimize-performance-aws-blu-age-modernized-application.html) |
| Anda menemukan out-of-memory pengecualian. | Verifikasi bahwa kode melepaskan memori yang dipegang oleh struktur data. |
| Operasi penulisan batch menghasilkan catatan yang hilang dalam tabel | Tinjau kode untuk memastikan bahwa operasi penulisan tambahan dilakukan ketika jumlah batch tidak nol. |
| Pencatatan SQL tidak muncul di log aplikasi. | [See the AWS documentation website for more details](http://docs.aws.amazon.com/id_id/prescriptive-guidance/latest/patterns/optimize-performance-aws-blu-age-modernized-application.html) |
## Sumber daya terkait
+ [Aplikasi refactoring secara otomatis dengan AWS Blu Age (Panduan Pengguna](https://docs.aws.amazon.com/m2/latest/userguide/refactoring-m2.html)*)AWS Mainframe Modernization *
+ [Dokumentasi pgAdmin](https://www.pgadmin.org/docs/)
+ [JProfiler dokumentasi](https://www.ej-technologies.com/jprofiler/docs)