آموزش نوشتن فایل پیکربندی اطلاعات مبتنی بر جاوا
در درس های قبل ، به نحوه تنظیم Spring beans به وسیله فایل های پیکربندی مبتنی بر XML آشنا شدید . اگر با نوشتن کدهای پیکربندی اطلاعات به زبان XML مشکلی ندارید ، به نظر من نیازی نیست تا روش نوشتن این فایل را به زبان جاوا را نیزیاد بگیرید . زیرا در هر دو روش به نتیجه یکسانی رسیده و
فایل پیکربندی اطلاعات مبتنی بر XML یا مبتنی بر جاوا خروجی یکسانی دارند .
گزینه نوشتن دستورات فایل پیکربندی اطلاعات برنامه برپایه جاوا ، شما را قادر می سازد بیشتر کدهای تنظیم Spring را بدون نیاز به XML و به وسیله annotation های مبتنی بر جاوا که در بخش های بعدی ، تشریح می کنیم ، بنویسید .
المنت های @Bean Annotation و @Configuration
Annotating یک کلاس به وسیله المنت @Configuration مشخص می کند که آن کلاس می تواند توسط Spring IOC Container به عنوان یک منبع جهت تعیین و تنظیم Bean ها به کار رود .
از طرف دیگر @Bean annotation به Spring اعلام می کند که یک متد مشخص شده به وسیله @Bean ، یک object ای را به برنامه باز می گرداند که بایستی در محتوی برنامه Spring ، به عنوان یک Bean در نظر گرفته شود .
ساده ترین حالت یک کلاس @Configuration ، می تواند به صورت زیر باشد :
package com.tahlildadeh ;
import org.springframework.context.annotation.*;
@Configuration
public class HelloWorldConfig {
@Bean
public HelloWorld helloWorld(){
return new HelloWorld();
}
}
کد کلاس فوق ، معادل کد فایل پیکربندی XML زیر خواهد بود :
id="helloWorld" class="com.tahlildadeh .HelloWorld" />
در اینجا ، نام متدی که به وسیله @Bean در کد annotation شده ، به عنوان یک bean ID عمل کرده و bean واقعی را ایجاد نموده و به برنامه باز می گرداند . کلاس Configuration شما می تواند بیش از اعلان برای @Bean داشته باشد .
پس از اینکه کلاس های Configuration شما تعیین شدند ، می توانید آنها را به وسیله AnnotationConfigApplicationContext برای
Spring Container فراهم کرده و لود نمایید ، به صورت زیر :
public static void main(String[] args) {
ApplicationContext ctx =
new AnnotationConfigApplicationContext(HelloWorldConfig.class);
HelloWorld helloWorld = ctx.getBean(HelloWorld.class);
helloWorld.setMessage("Hello World!");
helloWorld.getMessage();
}
همچنین می توانید چندین کلاس Configuration را به وسیله زیر برای برنامه لود کنید :
public static void main(String[] args) {
AnnotationConfigApplicationContext ctx =
new AnnotationConfigApplicationContext();
ctx.register(AppConfig.class, OtherConfig.class);
ctx.register(AdditionalConfig.class);
ctx.refresh();
MyService myService = ctx.getBean(MyService.class);
myService.doStuff();
}
مثال عملی :
برای درک ، یک مثال عملی جهت مطالب ارایه شده در محیط Eclipse اجرا می کنیم . برای این منظور مراحل زیر را انجام دهید :
- یک پروژه جدید با نام SpringExample ایجاد کرده و یک پکیج با نام com.tahlildadeh را به پوشه src پروژه اضافه کنید .
- همانطور که در درس آموزش ایجاد اولین برنامه Spring نشان دادیم ، کتابخانه های لازم جهت برنامه خود را به وسیله دکمه Add External JARs به پروژه اضافه کنید .
- در زیر مجموعه پکیج com.tahlildadeh ، کلاس های جاوا HelloWorldConfig ، MainApp و HelloWorld را ایجاد نمایید .
- در پوشه Src ، فایل پیکربندی اطلاعات Beans Configuration را با نام Beans.Xml ایجاد نمایید .
- در مرحله آخر نیز ، محتویات مورد نظر جهت فایل های جاوا ، فایل پیکربندی اطلاعات و سایر فایل ها را برای اجرای برنامه ایجاد نمایید .
کد زیر ، محتویات فایل HelloWorldConfig.java را نشان می دهد :
package com.tutorialspoint;
import org.springframework.context.annotation.*;
@Configuration
public class HelloWorldConfig {
@Bean
public HelloWorld helloWorld(){
return new HelloWorld();
}
}
همچنین کد زیر مربوط به فایل HelloWorld.java می باشد :
package com.tutorialspoint;
public class HelloWorld {
private String message;
public void setMessage(String message){
this.message = message;
}
public void getMessage(){
System.out.println("Your Message : " + message);
}
}
در نهایت نیز کد فایل MainApp.java بایستی به صورت زیر باشد :
package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.*;
public class MainApp {
public static void main(String[] args) {
ApplicationContext ctx =
new AnnotationConfigApplicationContext(HelloWorldConfig.class);
HelloWorld helloWorld = ctx.getBean(HelloWorld.class);
helloWorld.setMessage("Hello World!");
helloWorld.getMessage();
}
}
پس از اینکه کلید فایل های اصلی برنامه را ایجاد کرده و کتابخانه های مورد نیاز را نیز به پروژه اضافه کردید ، آن را اجرا خواهیم کرد . در این مثال بایستی توجه داشته باشید که دیگر نیازی به فایل پیکربندی اطلاعات Configuration ، نخواهیم داشت .
اگر همه چیز در برنامه درست بوده باشد ، خروجی زیر را تولید خواهد شد :
Your Message : Hello World!
تزریق Bean Dependencies
وقتی که یک @Bean ، وایستگی هایی ( dependencies ) به یک Bean دیگر دارد ، تشریح این وابستگی بسیار ساده خواهد بود . برای این منظور کدی همانند مثال زیر می نویسیم که در آن یک bean method ، شی bean دیگری را فراخوانی می کند :
package com.tutorialspoint;
import org.springframework.context.annotation.*;
@Configuration
public class AppConfig {
@Bean
public Foo foo() {
return new Foo(bar());
}
@Bean
public Bar bar() {
return new Bar();
}
}
در کد مثال فوق ، شی foo bean یک refrence را از طریق تزریق آرگومان سازنده ( Constructor ) دریافت می کند . برای مثال درک بهتر مطلب ، یک مثال عملی نیز در ادامه ارایه می دهیم .
مثال عملی :
- یک پروژه جدید با نام SpringExample ایجاد کرده و یک پکیج با نام com.tahlildadeh را به پوشه src پروژه اضافه کنید .
- همانطور که در درس آموزش ایجاد اولین برنامه Spring نشان دادیم ، کتابخانه های لازم جهت برنامه خود را به وسیله دکمه Add External JARs به پروژه اضافه کنید .
- در زیر مجموعه پکیج com.tahlildadeh ، کلاس های جاوا TextEditorConfig ، TextEditor ، SpellChecker و MainApp را ایجاد نمایید .
- در پوشه Src ، فایل پیکربندی اطلاعات Beans Configuration را با نام Beans.Xml ایجاد نمایید .
- در مرحله آخر نیز ، محتویات مورد نظر جهت فایل های جاوا ، فایل پیکربندی اطلاعات و سایر فایل ها را برای اجرای برنامه ایجاد نمایید .
کد زیر ، محتویات فایل TexEditorConfig.java را نشان می دهد :
package com.tutorialspoint;
import org.springframework.context.annotation.*;
@Configuration
public class TextEditorConfig {
@Bean
public TextEditor textEditor(){
return new TextEditor( spellChecker() );
}
@Bean
public SpellChecker spellChecker(){
return new SpellChecker( );
}
}
همچنین کد زیر مربوز به فایل TexEditor.java است :
package com.tutorialspoint;
public class TextEditor {
private SpellChecker spellChecker;
public TextEditor(SpellChecker spellChecker){
System.out.println("Inside TextEditor constructor." );
this.spellChecker = spellChecker;
}
public void spellCheck(){
spellChecker.checkSpelling();
}
}
کد زیر نیز ، محتویات یک کلاس وابسته ( dependent class ) دیگر برنامه به نام SpellChecker.java را نشان می دهد :
package com.tutorialspoint;
public class SpellChecker {
public SpellChecker(){
System.out.println("Inside SpellChecker constructor." );
}
public void checkSpelling(){
System.out.println("Inside checkSpelling." );
}
}
در نهایت نیز کد فایل Main App.java به صورت زیر است :
package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.*;
public class MainApp {
public static void main(String[] args) {
ApplicationContext ctx =
new AnnotationConfigApplicationContext(TextEditorConfig.class);
TextEditor te = ctx.getBean(TextEditor.class);
te.spellCheck();
}
}
پس از اینکه فایل های اصلی برنامه و کتابخانه های لازم آن را اضافه کردید ، می توانید پروژه را اجرا کنید . در این مثال هم توجه داشته باشید که نیازی به فایل پیکربندی اطلاعات مبتنی بر XML نخواهیم داشت . اگر همه چیز برنامه درست باشد ، بایستی خروجی زیر تولید شود :
Inside SpellChecker constructor. Inside TextEditor constructor. Inside checkSpelling.
آموزش @Inport Annotation
@Inport Annotation به ما امکان میدهد تا @Bean Definitions ( توضیحات یک Bean ) را از یک کلاس Configuration دیگر لود و فراخوانی کنیم . فرض کنید که کد کلاس ConfigA به صورت زیر باشد :
@Configuration
public class ConfigA {
@Bean
public A a() {
return new A();
}
}
شما می توانید کد تشریح یک Bean را در تعریف یک Bean دیگر به صورت زیر وارد کنید :
@Configuration
@Import(ConfigA.class)
public class ConfigB {
@Bean
public B a() {
return new A();
}
}
اکنون ، وقتی که می خواهیم کد برنامه را بنویسیم ، به جای اینکه نیاز باشد کد هر دو کلاس ConfigA.class و ConfigB.class را تشریح کنیم ، فقط نیاز است کلاس ConfigB را همانند زیر اعلام کنیم :
public static void main(String[] args) {
ApplicationContext ctx =
new AnnotationConfigApplicationContext(ConfigB.class);
// now both beans A and B will be available...
A a = ctx.getBean(A.class);
B b = ctx.getBean(B.class);
}
آموزش Lifecycle Callbacks
@Bean annotation امکان تعریف متد های callback تعریف اولیه و تخریب شی Bean را همانند آنچه در توابع init-method و destroy-method کدنویسی Spring XML داشتیم را به ما میدهد . نحوه انجام کار به صورت زیر است :
public class Foo {
public void init() {
// initialization logic
}
public void cleanup() {
// destruction logic
}
}
@Configuration
public class AppConfig {
@Bean(initMethod = "init", destroyMethod = "cleanup" )
public Foo foo() {
return new Foo();
}
}
تعیین محدوده شی Bean یا Bean Scope
Scope پیش فرض یک Bean ، مقدار Singleton است . اما می توانید به وسیله المنت @Scope ، آن را به صورت زیر تغییر دهید :
@Configuration
public class AppConfig {
@Bean
@Scope("prototype")
public Foo foo() {
return new Foo();
}
}