نمایش موارد بر اساس برچسب: spring

یکشنبه, 11 مرداد 1394 00:17

Spring IoC Container

Spring IoC Container

در آموزش قبلی یک برنامه بسیار ساده با Spring نوشتیم و دیدیم که ارتباط بین اشیا (wiring)  و استنتاج لازم برای ساخت آبجکت ها توسط خود Spring صورت گرفت.

Spring Container هسته اصلی فریم ورک Spring است و مسئولیت ساخت اشیا ، ایجاد ارتباط بین آن ها (wiring) ، پیکره بندی آن ها (configure) و مدیریت چرخه طول عمر آبجکت ها (lifecycle) را به عهده می گیرد. اگر مستقیماً از JavaSE به محیط های اینچنین وارد شوید این مسائل کمی گیج کننده خواهند بود ولی اگر سابقه کار با مفاهیم Java EE یا فریم ورک هایی مانند Spring را داشته باشید این موضوع برای شما قابل درک خواهد بود.

در محیط های اینچنینی وظیفه مدیریت آبجکت ها بر عهده برنامه نویس نیست ، بلکه برنامه نویس تنها تنظیمات مورد نیاز را مشخص می کند و آن ها را به Container می دهد ما بقی به عهده فریم ورک خواهد بود.

Spring Container از Dependency Injection برای مدیریت کامپوننت ها برای ساخت application استفاده می کند و آبجکت های ایجاد شده در این محیط Spring Bean نامیده می شوند که بعداً در مورد آنها توضیح خواهم داد.

اساس کار Container چندان پیچیده نیست ، در این آموزش شمای کلی عملکرد Container را مورد بررسی قرار می دهیم و در آموزش های آینده به جزئیات بیشتر می پردازیم.

Container تنظیمات مورد نیاز برای پیکره بندی را از طریق configuration metadata دریافت می کند ، metadata می تواند به شکل xml یا annotation (که اخیراً استفاده از annotation بیشتر مورد توجه قرار گرفته است ) یا حتی کد های جاوا باشد.

شکل زیر نحوه عملکرد Container را به صورت کلی نمایش می دهد :

 

Container کلاس هایی را به شکل POJO  و تنظیمات metadata را دریافت می کند ، سپس آبجکت ها را ایجاد و ارتباط بین آن ها را استنتاج می کند و برنامه کامل را ایجاد می کند و مدیریت آبجکت ها را به عهده می گیرد.

دو نوع Container در Spring در اختیار ما قرار دارد :

  • Spring BeanFactory Container
  • Spring ApplicationContext Container

Spring BeanFactory Container :

ساده ترین نوع Container است که Spring در اختیار ما قرار می دهد و از مفاهیم ساده DI پشتیبانی می کند و از طریق org.springframework.beans.factory.BeanFactory  قابل تعریف است.

Spring ApplicationContext Container :

این Container از طریق org.springframework.context.ApplicationContext  قابل تعریف است و امکانات بیشتری را نسبت به BeanFactory در اختیار ما قرار می دهد و در شرایط کلی توصیه می شود از آن به جای BeanFactory استفاده کنیم ، با این وجود در بعضی شرایط  که قصد تولید برنامه های سبک تری را داریم (مثلاً برنامه های موبایل یا Applet) می توانیم از BeanFactory استفاده کنیم.

نکته : همانطور که قبلاً گفتم و باز هم تاکید می کنم Spring یک فریم ورک برای نوشتن انواع مختلف برنامه های جاوایی است و نباید آن را با Spring MVC که برای تولید برنامه های تحت وب به کار می رود اشتباه گرفت ، Spring MVC تنها یک بخش از Spring است.

منتشرشده در Other Languages
برچسب‌ها
یکشنبه, 11 مرداد 1394 00:13

شروع آشنایی با Spring

راه اندازی محیط Spring

قبلاً کمی با Spring ، بخش ها و مفاهیم به کار رفته در آن آشنا شدیم ، در این آموزش کوتاه یاد می گیریم که چگونه از این framework در برنامه های خودمان استفاده کنیم.

در این آموزش از Apache Commons Logging 1.2 و Spring Framework 4.1.5 استفاده می کنیم.

اگر به آدرس http://projects.spring.io/spring-framework مراجعه کنید متوجه می شوید که استفاده از ابزار های dependency management system را توصیه کرده اند و راه حل های مبتنی بر MAVEN و GRADLE را ارائه داده اند ولی ما در این آموزش به شیوه دیگری عمل می کنیم.

دانلود Apache Commons Logging :

ابتدا به آدرس http://commons.apache.org/proper/commons-logging/download_logging.cgi می رویم و از قسمت Binaries فایل فشرده مربوط به Commons Logging را دانلود می کنیم و سپس فایل فشرده را در جایی از  کامپیوتر خودمان از حالت فشرده خارج می کنیم

 

دانلود Spring Framework

در این آموزش ما از maven یا gradle استفاده نمی کنیم بلکه خودمان فایل فشرده Spring framework را دانلود می کنیم. برای اینکار می توانیم به یکی از دو آدرس زیر مراجعه کنیم :

http://maven.springframework.org/release/org/springframework/spring/4.1....

http://repo.spring.io/release/org/springframework/spring/4.1.5.RELEASE

سپس فایل spring-framework-4.1.5.RELEASE-dist.zip را دانلود می کنیم و آن را در جایی از کامپیوتر خودمان از حالت فشرده خارج می کنیم.

 

ساخت اولین پروژه :

یک پروژه جاوایی معمولی ایجاد می کنیم سپس فایل های jar موجود در پوشه commons-logging-1.2 را به کتابخانه های برنامه اضافه می کنیم.

فایل های jar موجود در spring-framework-4.1.5.RELEASE\libs را نیز به کتابخانه های برنامه اضافه می کنیم ، البته در داخل این پوشه فایل های jar بسیاری وجود دارند که به همه آن ها نیاز ندارید ولی در این آموزش همه آن ها را برای راحتی کار به برنامه اضافه می کنیم در ادامه در طی اجرای پروژه های بزرگتر خودتان یاد می گیرید که تنها از jar های مورد نیاز استفاده کنید.

 

نوشتن کد های اولین پروژه :

برای نوشتن اولین پروژه مبتنی بر Spring framework از کد های نمونه http://projects.spring.io/spring-framework استفاده می کنیم. برای اینکار به صورت زیر عمل می کنیم:

یک package دلخواه در داخل پروژه ایجاد می کنیم.

یک interface به نام MessageService به صورت زیر ایجاد می کنیم :


package safecomp.spring;

public interface MessageService {
	String getMessage();
}

این اینترفیس تنها یک متد به نام getMessage را تعریف می کند.

کلاس MessagePrinter  را به صورت زیر تعریف می کنیم :


package safecomp.spring;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;


@Component
public class MessagePrinter {
	final private MessageService service;
	
	@Autowired
	public MessagePrinter(MessageService service){
		this.service=service;
	}
	
	public void printMessage(){
		System.out.println(service.getMessage());
	}
}

متد printMessage نتیجه فراخوانی متد getMessage بر روی نمونه service را چاپ می کند. در این کلاس از دو Annotation استفاده شده است.

Component@ مشخص می کند که کلاس MessagePrinter یک کامپوننت است ، این Annotation از Spring 2.5 به بعد تعریف و اضافه شده است.

کلاس هایی که با این Annotation تعریف شوند به صورت خودکار به عنوان کامپوننت شناسایی می شوند. (اگر درکی از کاربرد این مفاهیم ندارید نگران نباشید در آینده این مفاهیم را بهتر درک خواهید کرد).

 

Autowired@

این Annotation باعث خودکار سازی ایجاد dependecy می شود و ما را از نوشتن تنظیمات XML عجیب و غریب بی نیاز می سازد ، در این مثال این Annotation به ما می فهماند که پارامتر service برای سازنده کلاس MessagePrinter به صورت خودکار توسط Spring Framework از داخل Context استنتاج می شود ، در ادامه  متوجه خواهید شد که چگونه استفاده از Auto Wiring باعث ایجاد Dependecy Injection می شوند

کلاس Application را به صورت زیر تعریف می کنیم :


package safecomp.spring;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;


@Configuration
@ComponentScan
public class Application {
	
	@Bean
    MessageService mockMessageService() {
        return new MessageService() {
            public String getMessage() {
              return "Hello World!";
            }
        };
    }
	
	public static void main(String[] args) {
	      ApplicationContext context = 
	          new AnnotationConfigApplicationContext(Application.class);
	      MessagePrinter printer = context.getBean(MessagePrinter.class);
	      printer.printMessage();
	}
}

اگر قبلاً سابقه برنامه نویسی Java EE یا کار با EJB  و مفاهیم مشابه را داشته باشید درک کد بالا برایتان آسان خواهد شد ، در غیر این صورت کمی این کد عجیب و غریب خواهد بود.

تمام برنامه های Spring ای به مفهومی به نام Context نیاز دارند. در اینجا یک ApplicationContext به نام context  از روی کلاس Application ایجاد می کنیم متد mockMessageService به عنوان متدی که Bean بر می گرداند تعریف شده و در این context تعریف شده است چون عضوی از کلاس Application است.با استفاده از context.getBean می توانیم Bean های دلخواهی را از روی کلاس هایمان ایجاد کنیم در اینجا یک Bean به نام printer از نوع MessagePrinter تعریف می کنیم. متد mockMessageService نیز در context تعریف شده و یک MessageService بر می گرداند.در اینجا پای Auto Wiring به وسط کشیده می شود و پارامتر ورودی سازنده MessagePrinter را به درستی استنتاج می کند (از نتیجه فراخوانی متد mockMessageService به صورت خودکار و بدون دخالت ما استفاده می کند).

هنگامی که برنامه فوق را مانند هر برنامه معمولی جاوایی اجرا کنیم نتیجه زیر چاپ می شود


Hello World!

 

در این آموزش با نحوه راه اندازی محیط Spring Framework آشنا شدیم ، نگران مفاهیم جدید مطرح شده نباشید ، این موضوعات را در مثال های بیشتر بهتر درک خواهید کرد و موضوع مورد بحث این آموزش نبودند و در حال حاضر چندان روی درک آن ها تاکید نداریم ، آنچه در این آموزش می خواستیم به آن برسیم راه اندازی و استفاده از Spring Framework بود.

 

منتشرشده در Other Languages
برچسب‌ها
شنبه, 10 مرداد 1394 23:46

اسپرینگ (Spring) چیست؟

سپرینگ (Spring) یکی از معروف ترین و پرکاربرد ترین framework های جاوایی است .این framework متن باز بوده و اولین بار در سال 2003 ارائه شده است. اسپرینگ از ابتدای ارائه تا الآن تغییرات زیادی داشته و بسیار قدرتمند  معروف شده است.در طی آموزش های مختلف ابتدا اسپرینگ و امکانات آن را معرفی می کنیم سپس با ارائه مثال های بیشتر با امکانات مختلف آن آشنا می شویم.

 

اسپرینگ چیست؟

اسپرینگ framework قدرتمندی است که هدف اصلی آن برنامه های enterprise هستند اگرچه اسپرینگ بیشتر java EE را هدف گرفته است ولی در محیط های غیر از EE نیز می توان از آن استفاده کرد. بر خلاف تصوری که اشتباهاً در بین خیلی ها شکل گرفته است اسپرینگ برای ساخت اپلیکیشن تحت وب نیست بلکه Spring web که مبتنی بر مدل MVC بود و بیشتر به عنوان Spring MVC شناخته می شود تنها بخشی از اسپرینگ است که از آن برای ساخت برنامه های تحت وب استفاده می شود. اسپرینگ ماژولار است و شما بر اساس نیازی که دارید می توانید ماژول های مورد نیاز خودتان را انتخاب کنید و بقیه را کنار بگذارید.اسپرینگ همه چیز را از اول ایجاد نکرده است بلکه نحوه استفاده از تکنولوژی های موجود را ساده تر می کند و بهبود می دهد.اسپرینگ با استفاده از Dependency Injection و Inversion of Control (که بعداً در مورد آنها بیشتر توضیح می دهم) وابستگی بین اشیا در کد را کاهش می دهد و به ما کمک می کند که کد هایی قابل حمل و reusable بنویسیم .اسپرینگ به ما این امکان را می دهد که کد ها را به سادگی تست کنیم.

 

اسپرینگ به برنامه نویسان اجازه می دهد تا برنامه هایشان را به سبک POJO بنویسند و این یک امتیاز عالی برای برنامه نویسان جاواست.

مثال هایی از ساده سازی برنامه نویسی توسط اسپرینگ :

  • به سادگی می توانید با پایگاه داده کار کنید بدون اینکه خود را درگیر پیچیدگی های transaction API کنید.
  • به سادگی می توانید متد هایی را به صورت remote اجرا کنید بدون اینکه نیاز باشد در گیر RMI و ... شوید.
  • می توانید به سادگی متد هایی برای کار با message ها بنویسید بدون اینکه درگیر توابع JMS شوید.
  • و ....

اسپرینگ از حدود 20 ماژول تشکیل شده است که این ماژول ها را می توان به 8 دسته مطابق شکل زیر تقسیم کرد.

 

 

قبل از معرفی ماژول ها بهتر است با سه واژه DI و IoC و AOP آشنا شویم.

IoC :

Inversion of Control یا همان IoC یک واژه کلی است و باید در بستر مناسب خودش تعریف شود. IoC به این معنی نیست که همه چیز برعکس می شود بلکه در IoC باید به این بیاندیشیم که کنترل چه چیزی عوض شده است؟ هدف کلی از IoC این است که وابستگی بین کد ها را کاهش دهد و تیکه کد های کاربردی تا حد امکان مستقل از هم باشند که در این محیط های مختلف به شکل های مختلفی پیاده سازی می شود. یک مثال مشهور در این زمینه برنامه های کنسولی قدیمی است که در آن ها منو به صورت لیستی از اعداد نمایش داده می شد  و سپس کاربر عددی را وارد می کرد و برنامه مبتنی بر عدد کاربر عملی را انجام می داد. به عنوان مثال کد جاوای زیر را در نظر بگیرید :

 

 


import java.util.Scanner;


public class Main {
    
    Scanner in;
    
    int displayMenu(){
        System.out.println("-----");
        System.out.println("1) get Name ...");
        System.out.println("2) print Hello ");
        System.out.println("3) display Random");
        System.out.println("4) exit");
        
        int item=in.nextInt();
        return item;
    }
    
    void logic(){
        
        while(true){
            int menuItem=displayMenu();
            if(menuItem==4){
                //exit ...
                break;
            }else if(menuItem==3){
                //display Random ...
                System.out.println(Math.random());
            }else if(menuItem==2){
                //print Hello...
                System.out.println("Hello!!");
            }else if(menuItem==1){
                //get Name...
                String name=in.next();
            }
        }
    }
    public Main(){
        in=new Scanner(System.in);
        logic();
    }
    public static void main(String[] args) {
        new Main();
    }
}




در این مثال ساده متد logic هر بار متد displayMenu را فراخوانی می کند نتیجه را بررسی می کند و عمل مناسب را انجام می دهد.همانطور که دیده می شود بین منطق برنامه و نمایش منو ارتباط بسیار تنگاتنگی وجود دارد به طوری که اگر کمی متد logic را تغییر دهیم شاید دیگر

displayMenu معنا دار نباشد. در نرم افزار های امروزی که نمایش گرافیکی (GUI) دارند استفاده از Listener ها کار ها را ساده تر کرده است هنگامی که رویدادی اتفاق می افتد framework مورد نظر عمل مورد نیاز را انجام می دهد (در لیست Listener ها جست جو می کند تا Listener مورد نیاز را پیدا کند و متد مربوطه را اجرا کند) ، با استفاده از Listener ها دیگر لازم نیست برنامه نویس تمام رویداد ها را بررسی کند و سپس عمل مورد نیاز را انجام دهد ( busy waiting نداریم).

در کل می توان گفت که هدف از IoC این است که :

  • منطق چه چیزی انجام شود (what to do) از منطق چه زمانی انجام شود (when to do) جدا شود.
  • دو منطق ذکر شده حد الامکان اطلاعات کمی از یکدیگر داشته باشند.

نتیجه اسفاده از IoC کاهش وابستگی کد هاست. هر چه کد ها کمتر وابسته باشند بیشتر می توان آن ها را به اجزای جدا و قابل استفاده مجدد تبدیل کرد.

IoC در محیط های مختلف معنا های مختلفی دارد  و به شیوه های مختلفی می توان آن را پیاده سازی کرد که در اینجا به این موارد نمی پردازیم.

 

 

DI :

Dependency Injection یا DI همانطور که از نامش پیداست از دو بخش Dependency و Injection تشکیل شده است. Dependency هنگامی است که یک کلاس A و یک کلاس B داشته باشیم و کلاس B به کلاس A وابسته باشد این وابستگی در برنامه های معمولی جاوا با ساخت یک شی از کلاس A حل می شود :

 

class B {
    A a;
    void someMethod(){
        a=new A();
    }
}
 

هنگامی که A ها بیشتر و بیشتر می شوند رابطه B با A بیشتر و بیشتر می شود و جدا ساختن  A و B  از هم مشکل می شود. به علاوه بسیاری از وظایف بی دلیل بر گردن برنامه نویس می افتند.

به عنوان مثال در برنامه نویسی معمولی به این شیوه عمل می کنیم :

  • من پیچ شماره پنج دارم آچار شماره پنج را به من بده.
  • من پیچ شماره هفت را دارم آچار شماره هفت را به من بده.

به عنوان مثال :


class B {
    A a;
    void someMethod(){
        number=5;
        if(number==5){
            a=new A5();
        }if(number==7){
            a=new A7();
        }
        a.use();
    }
}

 

در محیطی که DI اعمال شود تشخیص وابستگی ها بر عهده Container خواهد بود. در چنین محیط هایی کافی است بگوییم :

  • هی این پیچ من است آچار را بده ...

container تشخیص دهنده است :هووم می بینم که پیچ شماره پنج داری ، بیا اینم آچار شماره پنج ;-)


class B {
    A a;
    void someMethod(){
        number=5;
        //use a
        a.use();
        
    }
}

تشخیص وابستگی و ایجاد شی مناسب و مدیریت lifecyle اشیا در محیطی که DI در آن وجود داشته باشد بر عهده Container است.

DI نوعی IoC محسوب می شود ولی الزاماً هر جایی که IoC وجود داشته باشد DI وجود ندارد و بدون DI نیز می توان IoC داشت.

 

 

در آموزش های مرتبط با اسپرینگ در قالب مثال های بیشتر با DI بیشتر آشنا می شویم.

 

AOP :

Aspect Oriented Programming یا همان AOP که در فارسی به آن برنامه نویسی جنبه گرا نیز می گویند ، مدل خاصی از برنامه نویسی است که در آن سعی می شود وظایف از هم مستقل گردند ، یعنی بر خلاف OOP که در آن استقلال Object  ها اهمیت دارد (و DI سعی در افزایش این نوع استقلال دارد) در AOP سعی داریم برنامه را از لحاظ cross-cutting-concern ها جدا کنیم. concern ها یا همان جنبه ها مفاهیمی هستند که قابل تجزیه نیستند مثلاً امنیت ، انتقال داده ،احراز هویت و ... ، AOP سبک خاصی از برنامه نویسی است و در اینجا قصد معرفی کامل آن را نداریم .اسپرینگ با ارائه ماژول AOP به ما این امکان را می دهد که مبتنی بر سبک AOP برنامه نویسی کنیم ، همچنین ماژول Aspect به ما اجازه می دهد تا اسپرینگ را با AspectJ ترکیب کنیم. AspectJ یکی از مشهور ترین و قوی ترین framework هایی است که به ما اجازه می دهد به سبک AOP برنامه بنویسیم.

ماژول ها :

همانطور که قبلاً گفتم اسپرینگ از هشت بخش تشکیل شده است که حدوداً بیست ماژول را شامل می شود در ادامه به صورت مختصر با بعضی از بخش ها آشنا می شویم :

Core Container :

این بخش از ماژول های Beans و Core و Context و Expression Language تشکیل شده است.

ماژول های Core و Beans هسته اصلی اسپرینگ را تشکیل می دهند و ویژگی های DI و IoC را در اختیار ما قرار می دهند. ماژول Beans نیز BeanFactory را در اختیار ما قرار می دهد که پیاده سازی پیچیده ای از الگوی factory pattern است.

Context به عنوان واسط عمل می کند و به اما اجازه دسترسی به آبجکت های ایجاد شده را می دهد.

Expression Language گسترشی از Expression Language معرفی شده در JSP 2.1 است و به ما اجازه اجرای کوئری های پیچیده و دسترسی به اشیا مختلف را می دهد.

 

Spring Web :

این بخش از ماژول های  Web و Portlet و Servlet و WebSocket تشکیل شده است.

همانطور که در ابتدای این آموزش نیز اشاره شد Spring Web برای طراحی web بر اساس مدل MVC به کار می رود و می تواند جایگزین بسیار خوبی برای framework هایی مثل struts باشد. اگر بگویم Spring Web پرکاربردترین و مشهور ترین بخش اسپرینگ است چندان بیراه نگفته ایم .(قبلاً هم اشاره کردم که خیلی ها Spring Web را با اسپرینگ اشتباه می گیرند).

Web : ماژول Web ویژگی ها پایه ای را در اختیار ما قرار می دهد.

Portelt  : اگر با پرتال ها (مانند Liferay) و مفهوم پرتلت آشنایی داشته باشید باید بگویم که ماژول Portlet امکان برنامه نویسی پرتلت بر اساس مدل MVC را به شما می دهد.

Web-Servlet : این ماژول پیاده سازی مدل MVC را در اختیار ما قرار می دهد.

 

Data Access/Integeration :

این بخش همانطور که از نام آن پیداست برای کار با داده ها در سطوح مختلف است.

ماژول JDBC کار با JDBC را آسان تر می کند و  ماژول ORM نیز کار با API هایی مانند JPA  و JDO و .. را ساده تر می کند.

Test :

یکی از مهم ترین مزایای اسپرینگ فرایند تست است ، به دلیل وابستگی کمی که بین کد ها وجود دارد به راحتی می توانیم هر بخش را به صورت جداگانه تست کنیم بدون اینکه نیاز باشد برنامه به صورت کامل توسعه یابد.ماژول test به ما اجازه می دهد از ابزار هایی مانند JUnit یا TestNG برای تست برنامه ها استفاده کنیم.

در این آموزش به صورت مختصر با اسپرینگ و امکانات آن آشنا شدیم ، برای اطلاعات کامل می توانید به مستندات اصلی مراجعه کنید.لینک زیر معرفی اسپرینگ توسط سایت اصلی آن است :

Introduction to Spring Framework.

 

 

منبع : safecomp.ir

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

منتشرشده در Other Languages
برچسب‌ها
  • بازدیدامروز 20
  • |
  • روزگذشته 88
  • |
  • هفته جاری 196
  • |
  • ماه جاری 914
  • |
  • بازدید کل 347371