Isi

SiklusHidupBeanSpring:................................................................................................................................................2
BagaimanaAplikasiSpringBootBekerjasecaraInternal?...............................................................................................................3

ApaitucontextLoaderListener?........................................................................................................................................6
Apasajakonteksyangberbeda(Menghadapikonteks):.........................................................................................................6
Konteks Servlet:........................................................................................................................................................6
Konteks Aplikasi:................................................................................................................................................7
RuangLingkupBean....................................................................................................................................................................8

Anotasi:..................................................................................................................................................................... 9
FiltervsInterceptor:..........................................................................................................................................................9
InjeksiKacang:..............................................................................................................................................................10
Beanberskopprototipedalambeanberskopsingleton......................................................................................................12

....................................................................................................................................................................................... 13
AnotasiStereotip.................................................................................................................................................16
Siklus Hidup Bean Spring :

Setiap objek yang berada di bawah kendali Spring's ApplicationContext dalam hal
penciptaan, orkestra, dan penghancuran disebut Spring Bean.

Cara paling umum untuk mendefinisikan bean Spring adalah dengan menggunakan
anjuran @Component

Antarmuka Sadar
Spring menyediakan beberapa antarmuka yang sadar. Ini digunakan untuk mengakses infrastruktur Kerangka Kerja Spring.
Antarmuka yang sadar sebagian besar digunakan dalam kerangka kerja dan jarang digunakan oleh pemrogram Spring.

Anda sebagai pemrogram Spring harus akrab dengan tiga antarmuka aware berikut.
 BeanNameAware: ThesetBeanName()callback dari antarmuka ini menyediakan nama dari bean.
BeanFactoryAwareMenyediakansetBeanFactory(), callback yang menyediakan pabrik pemilik untuk bean
instance.
ApplicationContextAware: ThesetApplicationContext()metode dari antarmuka ini menyediakan
theKonteksAplikasiobjek dari kacang ini.

Pengolahan Pasca Kacang

Musim semi menyediakanPengolahBeanPostProcessorantarmuka yang memberi Anda sarana untuk mengakses konteks Spring
siklus hidup dan berinteraksi dengan bean saat mereka diproses.

BagaimanaAplikasiSpringBootBekerjasecarainternal?
Mari kita memahami bagaimana autokonfigurasi bekerja

Kami menyebutkan starter pom dalam [Link] dan itu secara otomatis mengunduh semua jar yang bergantung.
Di dalam jar tersebut, konfigurasi jalur berikut ada, apa dan kapan untuk menginisialisasi.

Di dalam [Link] disebutkan apa yang harus diaktifkan dan apa yang harus dinonaktifkan berdasarkan
@Anotasi Kondisional dan @Anotasi Konfigurasi.
@Conditonal diperkenalkan di spring 4+ sebelumnya solusinya adalah profiler.
Mari kita ambil contoh satu ketergantungan pemula dari Spring Boot Starter JPA
<ketergantungan>
<groupId>[Link]</groupId>
spring-boot-starter-data-jpa
</dependency>

Ini akan mengunduh jar bergantung berikut

Dari [Link] mari kita buka pengaturan otomatis JpaRespositories

Jika Anda melihat anotasi yang digunakan, itu telah menggunakan @ConditionalOnBean dan @ConditionalOnClass.
Jika kita menggunakan atau membuat kelas apa pun dengan ketergantungan DataSource dan Jpa Repository, maka kelas ini akan
konfigurasi repositori JPA untuk kami tanpa menyebutkan apa pun dari AS
Beberapa penjelasan mengenai kondisi diberikan di bawah ini

Sekarang kita akan memahami bagaimana aplikasi Spring Boot akan memulai Aplikasi kita
Konteks.
 @Konfigurasi: Ini annotaton adalah bagian dari kerangka kerja inti musim semi. Anotasi Konfigurasi Musim Semi
menunjukkan bahwa kelas memiliki metode definisi @Bean. Jadi wadah Spring dapat memproses kelas dan
hasilkan Spring Bean untuk digunakan dalam aplikasi.

@EnableAutoConfiguration : Seperti yang dibahas sebelumnya iini akan memungkinkan dan mengonfigurasi beberapa Komponen
berdasarkan kondisi

Pemindaian Komponen :Bagian ini"memberitahu Musim Semi di mana untuk mencari" disebut sebagai ComponentScan.

Spring adalah kerangka kerja injeksi ketergantungan. Ini semua tentang bean dan menghubungkan ketergantungan.

Langkah pertama dalam mendefinisikan Spring Beans adalah dengan menambahkan anotasi yang tepat - @Component atau @Service atau
@Repositori.

Namun, Spring tidak tahu tentang bean kecuali ia tahu di mana mencarinya.

Tautan Penjelasan Terperinci :htInvalid URL [Link]/spring-boot-dan-komponent-pindai

Sekarang apa yang dilakukan [Link]

1. Ini membuat konteks aplikasi

2. Periksa jenis aplikasi (Reactve, Servlet, dan Tidak ada)
3. Daftarkan kelas yang dianotasi dengan konteks
4. Membuat instansi TomcatEmbeddedServletContainer dan menambahkan konteks.

htps://[Link]/watch?v=qlygg_H1M20

Apa itu contextLoaderListener?

ContextLoaderListenermembaca file konfigurasi Spring (dengan nilai yang diberikan pada terhadaplokasiKonfigurasiKonteks
[Link]),menganalisis dan memuat singleton bean yang didefinisikan dalam file konfigurasi itu. Demikian pula ketika kita ingin
muat prototipe bean, kami akan menggunakan konteks webaplikasi yang sama untuk memuatnya.

Hal lain yang nyaman tentangContextLoaderListenerapakah itu menciptakan

aWebApplicationContextdanWebApplicationContextmemberikan akses kepada
yangServletContextlewatServletContextAwarekacang dangetServletContextmetode.
Apa saja konteks yang berbeda (Menghadapi konteks):

Konteks Servlet:

Ini diinisialisasi ketika aplikasi Servlet dikerahkan. Konten Servlet menyimpan semua konfigurasi
(param-init, param-konteks, dll.) dari seluruh aplikasi servlet.

WebApplicationContext adalah konteks aplikasi yang menyadari web yaitu memiliki informasi konteks servlet. A
Aplikasi web tunggal dapat memiliki beberapa WebApplicationContext dan setiap servlet Dispatcher
(yang merupakan pengendali depan dari arsitektur Spring MVC) terkait dengan sebuah
WebApplicationContext. File konfigurasi webApplicationContext *-[Link] adalah khusus untuk sebuah
DispatcherServlet. Dan karena aplikasi web dapat memiliki lebih dari satu servlet dispatcher
dikonfigurasi untuk melayani beberapa permintaan, bisa ada lebih dari satu file webApplicationContext per
aplikasi web.

Konteks Aplikasi:

Ini adalah hal khusus Spring. Ini diinisialisasi oleh Spring. Ini menyimpan semua definisi bean dan siklus hidupnya.
dari biji yang didefinisikan di dalam file konfigurasi spring. Servlet-Context tidak tahu
tentang hal ini.

Setiap aplikasi web Spring MVC memiliki file [Link] yang dikonfigurasi sebagai
akar konfigurasi konteks. Spring memuat file ini dan membuat applicationContext untuk seluruh
aplikasi. File ini dimuat oleh ContextLoaderListener yang dikonfigurasi sebagai konteks
param dalam file [Link]. Dan hanya akan ada satu applicationContext per aplikasi web.
Ada dua jenis konteks di Spring

[Link] Induk Spring (Konteks Aplikasi / Konteks Root)

<pendengar>
<listener-lass>
[Link]
</kelas-dengar>
</pendengar>
context-param
lokasiKonfigurasiKonteks
param-value
/WEB-INF/[Link]
/WEB-INF/[Link]
/WEB-INF/[Link]
/WEB-INF/[Link]
/WEB-INF/[Link]
</nilai-param>
</context-param>

Ketika container spring dimulai, ia membaca semua definisi bean dari file konfigurasi.
dan menciptakan objek bean serta mengelola siklus hidup objek bean tersebut. Konfigurasi ini
sepenuhnya opsional.

2. Kontes Anak Musim Semi (WebApplicationContext / Kontes Anak)

<servlet>
aplikasiWebSaya
<kelas-servlet>
[Link]
</kelas-servlet>
1
</servlet>
<pemetaan-servlet>
<servlet-name>aplikasiWebSaya</servlet-name>
<url-pattern>/app/*</url-pattern>
</penataan-servlet>

Saat aplikasi web spring mulai, ia akan mencari file konfigurasi bean spring.
[Link]. Ini akan membaca semua definisi bean dan membuat serta mengelolanya.
siklus hidup objek bean. Jika konteks spring induk tersedia, itu akan menggabungkan konteks spring anak
dengan konteks induk spring. Jika tidak ada konteks induk Spring yang tersedia, aplikasi akan
hanya memiliki konteks musim semi anak.

Penjelasan Rinci :[Link]

Lingkup Bean
1. Lingkup dari bean mendefinisikan siklus hidup dan visibilitas bean tersebut dalam konteks.
2. Ada 6 jenis cakupan bean, itu dapat didefinisikan menggunakan anotasi @Scope
singleton
b. prototipe
c. permintaan
d. sesi
e. aplikasi
f. websocket
Empat ruang lingkup terakhir yang disebutkan, permintaan, sesi, aplikasi, dan websocket hanya tersedia di
aplikasi yang sadar web.

Lingkup Deskripsi

singleton(default
Instans objek tunggal per kontainer IoC spring
)

Berlawanan dengan singleton, ini menghasilkan instance baru setiap kali sebuah bean diminta.

Anda harus tahu bahwa kehancuranmetode siklus hidup beantidak

prototipe dipanggilprototipebean yang dibatasi, hanya metode callback inisialisasi yang dipanggil. Jadi
sebagai pengembang, Anda bertanggung jawab untuk membersihkan instance bean yang terikat pada prototipe dan
ada sumber daya yang ada di sana.

Sebuah instance tunggal akan dibuat dan tersedia selama seluruh siklus hidup permintaan HTTP.
Hanya berlaku di ApplicationContext Spring yang sadar web.
permintaan
Instansi ini dihancurkan segera setelah permintaan selesai.

sesi Sebuah instance tunggal akan dibuat dan tersedia selama seluruh siklus hidup dari sesinya HTTP.
 Hanya berlaku di Spring ApplicationContext yang menyadari web.

Sebuah instance tunggal akan dibuat dan tersedia selama seluruh siklus hidup ServletContext.
Hanya berlaku di dalam ApplicationContext Spring yang menyadari web.

Dalam lingkup aplikasi, kontainer membuat satu instance per runtime aplikasi web. Ini hampir
mirip dengan lingkup singleton, dengan hanya dua perbedaan yaitu
aplikasi [Link] terikat adalah singleton perServletContext,
sedangkansingletonbean terikat adalah singleton
perKonteksAplikasiHarap dicatat bahwa mungkin ada beberapa
konteks aplikasi untuk aplikasi tunggal.

Sebuah instansi tunggal akan dibuat dan tersedia selama siklus hidup WebSocket.
websocket
Hanya berlaku di Spring ApplicationContext yang sadar web.

Annotasi :

Filtervs Interceptor:
Interceptor berjalan di antara permintaan.
Interceptor adalah konsep spesifik Spring dan Filter adalah API servlet.

Filter digunakan dalam konteks web dan tidak dapat dijalankan di luar konteks web.
Interceptor dapat digunakan di mana saja.

Filter dapat digunakan untuk otentikasi Halaman Web

Untuk lapisan keamanan dalam logika bisnis atau penyela pencatatan dapat digunakan.

Membuat Interceptor dalam Aplikasi Spring Boot

Memperluas HandlerInterceptorAdaptor untuk membuat kelas interceptor
Buat kelas registerer yang akan mengimplementasikan WebMvcConfigurer

Kelas ini akan mendaftarkan semua interceptor yang akan kita gunakan sebagai interceptor.

Kelas Interceptor
 Filter hanya berfungsi di aplikasi web J2EE, Anda tidak dapat menggunakannya di luar aplikasi
server, Interceptor dapat bekerja di berbagai komponen dan tidak tergantung pada lapisan web, di
interceptor ringkasan memiliki ruang lingkup yang lebih luas daripada filter. Jika Anda berencana untuk memindahkan beberapa komponen
di luar kontainer, Anda harus mempertimbangkan untuk menggunakan interceptor.

Filter bekerja lebih banyak dalam domain permintaan/respons, di sisi lain intersepsi bertindak lebih dalam
domain eksekusi metode.

Jika Anda perlu melakukan sesuatu yang dapat mempengaruhi permintaan atau tanggapan terhadap aplikasi Anda seperti
pencatatan, keamanan, audit, atau Anda akan memengaruhi data yang masuk ke dalamnya, pilihan Anda adalah menyaring, jangan lupa
kemampuan plug yang disediakan oleh itu.

Injeksi Bean :

1. Penyuntikan konstruktor —baik, andal, dan tidak dapat diubah, disuntik melalui salah satu dari

konstruktor. Mungkin untuk mengonfigurasi dalam: XML, XML+Anotasi, Java, Java + Anotasi.

2. Penyuntikan setter — objek yang lebih fleksibel dan dapat diubah, penyuntikan melalui setter. Mungkin untuk

konfigurasi dalam: XML, XML+Anotasi, Java, Java + Anotasi.

3. Injeksi bidang - cepat dan nyaman, pengikatan dengan kontainer IoC. Memungkinkan untuk dikonfigurasi

dalam XML+Annotation, Java + Annotation.

4. Metode Lookup injection —sangat berbeda dari yang lain, digunakan untuk injeksi

ketergantungan dengan lingkup lebih kecil. Bisa dikonfigurasi dalam: XML, XML+Anotasi, Java, Java

+ Anotasi.
 SETTER DI KONSTRUKTOR DI

Keterbacaan yang buruk karena menambah banyak boiler.

kode pelat dalam aplikasi. Keterbacaan yang baik karena tersaji secara terpisah dalam kode.

Kelas bean harus mendeklarasikan konstruktor yang cocok dengan

Bean harus termasuk getter dan setter argumen. Jika tidak, BeanCreationException akan menjadi

metode untuk sifat-sifat. dilempar.

Memerlukan penambahan @Autowired Terbaik dalam hal pengikatan longgar dengan kontainer DI karena itu

anotasi, di atas setter dalam kode tidak bahkan diperlukan untuk menambahkan anotasi @Autowired di dalam

dan karenanya, itu meningkatkan keterkaitan kode.( Injeksi konstruktor implisit untuk konstruktor tunggal

antara kelas dan wadah DI. skenario setelah musim semi 4.0)

Ketergantungan melingkar atau parcial

hasil ketergantungan dengan Setter DI

karena pembuatan objek terjadi sebelum Tidak ada ruang untuk ketergantungan sirkular atau parsial karena

suntikan. ketergantungan diselesaikan sebelum pembuatan objek itu sendiri.

Opsi yang diutamakan ketika properti pada biji lebih dan

Pilihan yang disukai ketika properti kurang objek tidak dapat diubah (misalnya: proses keuangan) adalah penting

dan objek yang dapat diubah dapat dibuat. untuk aplikasi.

Beandengancakupanprototipedalambeandengancakupansingleton.
Karena singleton dibuat (dan kemudian disuntikkan) selama pembuatan konteks, itu adalah satu-satunya waktu Spring
konteks diakses dan demikian bean yang memiliki lingkup prototipe hanya disuntikkan sekali, sehingga mengalahkan tujuan mereka

tujuan.
Masalah :

Sekarang di dalam layanan singleton, kami telah menyuntikkan layanan prototipe.

Sekarang prototipe akan mengembalikan tanggal dan waktu saat ini ketika objek diinisialisasi.

Sekarang jika Anda melihat output di atas, tanggalnya mengembalikan output yang sama. Itu berarti hanya satu objek yang dibuat.

Ini berfungsi sebagai singleton.

Solusi 1 : Menggunakan Konteks Aplikasi

Sekarang jika Anda melihat kode di atas, maka kami telah menggunakan konteks aplikasi untuk mendapatkan bean setiap saat, jadi

solusi ini akan melanggar prinsip IOC dan baik untuk digunakan dalam kelas proxy.

Sekarang jika Anda melihatnya, telah menghasilkan dua objek sebagaimana diminta.

Solusi 2: Menggunakan Penyuntikan Metode yaitu @Lookup

Kami telah menggunakan anotasi lookup, kami telah mengembalikan null tetapi itu tidak akan masalah karena spring akan menimpa

metode ini pada saat runtime dan menggunakan proxy untuk memberikan objek baru setiap kali.

Solusi 3 : Menggunakan Penyedia Injex

Solusi 4: Menggunakan Pabrik Objek

Anotasi Stereotip:
Spring @Komponen, @Repositori, @Layanan dan @Kontroler

Anotasi |
+------------+-----------------------------------------------------+
| @Komponenstereotip generik untuk setiap komponen yang dikelola oleh Spring
| @Repository| stereotip untuk lapisan ketahanan |
|@Layanan | stereotip untuk lapisan layanan |
| @Pengendali stereotip untuk lapisan presentasi (spring-mvc) |