Untuk apa sebenarnya Spring Framework? [Tutup]

Saya mendengar banyak tentang Spring , orang mengatakan di seluruh web bahwa Spring adalah kerangka kerja yang baik untuk pengembangan web. Untuk apa sebenarnya Spring Framework?

Pada dasarnya Spring adalah kerangka kerja untuk injeksi ketergantungan yang merupakan pola yang memungkinkan membangun sistem yang sangat terpisah.

Masalah

Misalnya, Anda perlu membuat daftar pengguna sistem dan dengan demikian mendeklarasikan antarmuka yang disebut UserLister:

public interface UserLister {
    List<User> getUsers();
}

Dan mungkin implementasi mengakses database untuk mendapatkan semua pengguna:

public class UserListerDB implements UserLister {
    public List<User> getUsers() {
        // DB access code here
    }
}

Dalam pandangan Anda, Anda harus mengakses sebuah instance (hanya sebuah contoh, ingat):

public class SomeView {
    private UserLister userLister;

    public void render() {
        List<User> users = userLister.getUsers();
        view.render(users);
    }
}

Perhatikan bahwa kode di atas tidak menginisialisasi variabel userLister. Apa yang harus kita lakukan? Jika saya secara eksplisit instantiate objek seperti ini:

UserLister userLister = new UserListerDB();

... Saya akan memasangkan pandangan dengan implementasi saya dari kelas yang mengakses DB. Bagaimana jika saya ingin beralih dari implementasi DB ke yang lain yang mendapatkan daftar pengguna dari file yang dipisahkan koma (ingat, ini contohnya)? Dalam hal ini, saya akan pergi ke kode saya lagi dan mengubah baris di atas menjadi:

UserLister userLister = new UserListerCommaSeparatedFile();

Ini tidak ada masalah dengan program kecil seperti ini tetapi ... Apa yang terjadi dalam program yang memiliki ratusan pandangan dan jumlah kelas bisnis yang serupa? Perawatan menjadi mimpi buruk!

Pendekatan Spring (Dependency Injection)

Apa Musim Semi dilakukan adalah untuk kawat kelas atas dengan menggunakan file XML atau penjelasan, cara ini semua benda yang dipakai dan diawali dengan musim semi dan disuntikkan di tempat yang tepat (Servlets, Web Frameworks, kelas Bisnis, DAOs, dll, dll, dll ...).

Kembali ke contoh di Musim Semi kita hanya perlu memiliki setter untuk userListerbidang tersebut dan memiliki file XML seperti ini:

<bean id="userLister" class="UserListerDB" />

<bean class="SomeView">
    <property name="userLister" ref="userLister" />
</bean>

atau lebih sederhana membubuhi keterangan yang diajukan di kelas tampilan kami dengan @Inject:

@Inject
private UserLister userLister;

Dengan cara ini ketika tampilan dibuat secara ajaib akan memiliki UserListersiap untuk bekerja.

List<User> users = userLister.getUsers();  // This will actually work
                                           // without adding any line of code

Sangat bagus! Bukan?

• Bagaimana jika Anda ingin menggunakan implementasi lain dari UserListerantarmuka Anda ? Cukup ganti XML.
• Bagaimana jika tidak memiliki UserListerimplementasi yang siap? Memprogram implementasi tiruan temporal UserListerdan memudahkan pengembangan pandangan.
• Bagaimana jika saya tidak ingin menggunakan Spring lagi? Hanya saja, jangan menggunakannya! Aplikasi Anda tidak digabungkan dengannya. Pembalikan status Kontrol : "Aplikasi mengontrol kerangka kerja, bukan kerangka kerja mengontrol aplikasi".

Ada beberapa pilihan lain untuk Dependency Injection di sekitar sana, apa yang menurut saya telah membuat Spring begitu terkenal selain kesederhanaan, keanggunan dan stabilitasnya adalah bahwa orang-orang SpringSource telah memprogram banyak POJO yang membantu mengintegrasikan Spring dengan banyak kerangka kerja umum lainnya tanpa menjadi mengganggu dalam aplikasi Anda. Selain itu, Spring memiliki beberapa sub proyek yang bagus seperti Spring MVC, Spring WebFlow, Spring Security dan lagi daftar panjang dlleteras.

Semoga ini membantu. Bagaimanapun, saya mendorong Anda untuk membaca artikel Martin Fowler tentang Dependency Injection dan Inversion of Control karena dia melakukannya lebih baik daripada saya. Setelah memahami dasar-dasarnya, lihat di Spring Documentation , menurut saya, ini digunakan untuk menjadi buku Spring terbaik yang pernah ada.

Spring berisi ( seperti yang ditunjukkan oleh Skaffman ) kerangka kerja MVC. Untuk menjelaskan secara singkat di sini adalah masukan saya. Spring mendukung pemisahan lapisan layanan, lapisan web, dan lapisan bisnis, tetapi yang terbaik adalah "injeksi" objek. Jadi untuk menjelaskannya dengan contoh perhatikan contoh di bawah ini:

public interface FourWheel
{
   public void drive();
}

public class Sedan implements FourWheel
{
   public void drive()
   {
      //drive gracefully
   }
}

public class SUV implements FourWheel
{
   public void drive()
   {
      //Rule the rough terrain
   }
}

Sekarang dalam kode Anda, Anda memiliki kelas yang disebut RoadTrip sebagai berikut

public class RoadTrip
{
    private FourWheel myCarForTrip;
}

Sekarang kapan pun Anda ingin tur Trip; kadang-kadang Anda mungkin ingin SUV menginisialisasi FourWheel atau kadang-kadang Anda ingin Sedan. Itu benar-benar tergantung apa yang Anda inginkan berdasarkan situasi tertentu.

Untuk mengatasi masalah ini, Anda ingin memiliki Pola Pabrik sebagai pola kreasi. Di mana pabrik mengembalikan contoh yang tepat. Jadi pada akhirnya Anda akan berakhir dengan banyak kode lem hanya untuk membuat instance objek dengan benar. Spring melakukan pekerjaan kode lem terbaik tanpa kode lem itu. Anda mendeklarasikan pemetaan dalam XML dan menginisialisasi objek secara otomatis. Itu juga tidak banyak menggunakan arsitektur tunggal untuk instance dan yang membantu dalam penggunaan memori yang dioptimalkan.

Ini juga disebut Pembalikan Kontrol. Kerangka kerja lain untuk melakukan ini adalah Google guice, wadah Pico dll.

Terlepas dari ini, Spring memiliki kerangka validasi, dukungan luas untuk lapisan DAO bekerja sama dengan JDBC, iBatis dan Hibernate (dan banyak lagi lainnya). Memberikan kontrol Transaksional yang sangat baik atas transaksi basis data.

Ada banyak lagi ke Spring yang dapat dibaca di buku-buku bagus seperti "Pro Spring".

URL berikut juga dapat membantu.
http://static.springframework.org/docs/Spring-MVC-step-by-step/
http://en.wikipedia.org/wiki/Spring_Framework
http://www.theserverside.com/tt/articles/article .tss? l = SpringFramework

Dulu, Spring hanya berfungsi sebagai kerangka injeksi ketergantungan ( Guice , PicoContainer , ...), tetapi sekarang ini adalah solusi total untuk membangun Aplikasi Perusahaan Anda .

Injeksi ketergantungan pegas, yang, tentu saja, jantung pegas masih ada (dan Anda dapat meninjau jawaban bagus lainnya di sini), tetapi ada lebih banyak dari pegas ...

Spring sekarang memiliki banyak proyek, masing-masing dengan beberapa sub-proyek ( http://spring.io/projects ). Ketika seseorang berbicara tentang pegas, Anda harus mencari tahu apa proyek pegas yang ia bicarakan, apakah hanya pegas inti, yang dikenal sebagai kerangka pegas , atau itu adalah pegas proyek lain.

Beberapa proyek musim semi yang layak disebutkan adalah:

• Spring Security - http://projects.spring.io/spring-security/
• Layanan Web Spring - http://projects.spring.io/spring-ws/
• Spring Integration - http://projects.spring.io/spring-integration/

Jika Anda memerlukan beberapa fitur yang lebih spesifik untuk aplikasi Anda, Anda mungkin menemukannya di sana juga:

• Kerangka kerja pegas batch yang dirancang untuk memungkinkan pengembangan
  aplikasi batch
• Spring HATEOAS pembuatan mudah REST API berdasarkan prinsip HATEOAS
• Spring Mobile dan Spring Andriod untuk pengembangan aplikasi mobile
• Spring Shell membuat aplikasi shell dengan fitur lengkap (alias command line)
• Spring Cloud dan Spring Cloud Data Flow untuk aplikasi cloud

Ada juga beberapa proyek kecil di sana misalnya spring-social-facebook ( http://projects.spring.io/spring-social-facebook/ )

Anda dapat menggunakan pegas untuk pengembangan web karena memiliki Spring MVCmodul yang merupakan bagian dari proyek Kerangka Kerja Spring . Atau Anda bisa menggunakan pegas dengan kerangka web lain, seperti struts2 .

Untuk apa Spring? Saya akan menjawab pertanyaan itu segera, tetapi pertama-tama, mari kita lihat kembali contoh dari victor hugo. Ini bukan contoh yang bagus karena tidak membenarkan perlunya kerangka kerja baru.

public class BaseView {
  protected UserLister userLister;

  public BaseView() {
    userLister = new UserListerDB(); // only line of code that needs changing
  }
}

public class SomeView extends BaseView {
  public SomeView() {
    super();
  }

  public void render() {
    List<User> users = userLister.getUsers();
    view.render(users);
  }
}

Selesai! Jadi sekarang bahkan jika Anda memiliki ratusan atau ribuan tampilan, Anda masih perlu mengubah satu baris kode, seperti pada pendekatan Spring XML. Tetapi mengubah sebaris kode masih membutuhkan kompilasi ulang daripada mengedit XML yang Anda katakan? Nah temanku yang cerewet, gunakan semut dan naskah!

Jadi untuk apa Spring? Ini untuk:

1. Pengembang buta yang mengikuti kawanan
2. Pengusaha yang tidak pernah ingin merekrut lulusan programer karena mereka tidak mengajarkan kerangka kerja seperti itu di Uni
3. Proyek yang dimulai dengan desain yang buruk dan perlu tambal sulam (seperti yang ditunjukkan oleh contoh victor hugo)

Bacaan lebih lanjut: http://discuss.joelonsoftware.com/?joel.3.219431.12

Sangat singkat, saya akan mengatakan bahwa Spring adalah "lem" dalam aplikasi Anda. Ini digunakan untuk mengintegrasikan kerangka kerja yang berbeda dan kode Anda sendiri.

Musim semi adalah tiga hal.

1. Spring menangani Dependency Injection dan saya sarankan Anda membaca pengantar bagus Martin Fowler tentang injeksi ketergantungan.
2. Hal kedua yang dilakukan Spring adalah membungkus pustaka Java yang sangat baik dengan cara yang sangat elegan untuk digunakan dalam aplikasi Anda. Untuk contoh yang baik, lihat bagaimana Pegas membungkus Pelaksana Tugas dan Penjadwal Kuarsa.
3. Thirdly Spring menyediakan banyak implementasi hal-hal web seperti REST, kerangka kerja MVC, dan banyak lagi. Mereka tahu karena Anda menggunakan Spring untuk dua yang pertama, mungkin Anda bisa menggunakannya untuk semua kebutuhan aplikasi web Anda.

Masalahnya adalah bahwa Spring DI dipikirkan dengan sangat baik, pembungkus di sekitar hal-hal lain dipikirkan dengan sangat baik dalam hal-hal lain memikirkan semuanya dan Spring dengan baik membungkusnya. Implementasi Spring dari MVC dan REST dan semua hal lainnya tidak dilakukan dengan baik (YMMV, IMHO) tetapi ada pengecualian (Spring Security adalah da bomb). Jadi saya cenderung menggunakan Spring untuk DI, dan pembungkusnya yang keren tetapi lebih suka barang-barang lain untuk Web (saya sangat menyukai Tapestry), REST (Jersey sangat kuat), dll.

Apa yang mungkin Anda inginkan dalam aplikasi web dengan Spring -

• Spring MVC, yang dengan 2,5+ memungkinkan Anda untuk menggunakan POJO sebagai kelas Controller, artinya Anda tidak perlu memperluas dari kerangka kerja tertentu (seperti dalam Struts atau Spring pre-2.5). Kelas-kelas pengendali juga sederhana untuk diuji, sebagian berkat injeksi ketergantungan
• Integrasi pegas dengan Hibernate, yang melakukan pekerjaan menyederhanakan pekerjaan dengan solusi ORM dengan baik (untuk sebagian besar kasus)
• Menggunakan Spring untuk aplikasi web memungkinkan Anda untuk menggunakan Objek Domain Anda di semua tingkatan aplikasi - kelas yang sama yang dipetakan menggunakan Hibernate adalah kelas yang Anda gunakan sebagai "kacang bentuk." Secara alami, ini akan mengarah pada model domain yang lebih kuat, sebagian karena itu akan mengurangi jumlah kelas.
• Tag pegas formulir memudahkan Anda membuat formulir tanpa repot.

Selain itu, Spring adalah BESAR - jadi ada banyak hal lain yang mungkin Anda tertarik gunakan di aplikasi web seperti Spring AOP atau Spring Security. Tetapi empat hal yang tercantum di atas menggambarkan komponen umum Spring yang digunakan dalam aplikasi web.

Saya melihat dua bagian dari ini:

1. "Apa sebenarnya Spring untuk" -> lihat jawaban yang diterima oleh victor hugo.
2. "[...] Spring adalah kerangka kerja yang baik untuk pengembangan web" -> orang mengatakan ini berbicara tentang Spring MVC. Spring MVC adalah salah satu dari banyak bagian Spring, dan merupakan kerangka kerja web yang menggunakan fitur-fitur umum Spring, seperti injeksi ketergantungan. Ini adalah kerangka kerja yang sangat umum karena sangat dapat dikonfigurasi: Anda dapat menggunakan lapisan db yang berbeda (Hibernate, iBatis, JDBC biasa), lapisan tampilan yang berbeda (JSP, Velocity, Freemarker ...)

Perhatikan bahwa Anda dapat menggunakan Spring dengan baik di aplikasi web tanpa menggunakan Spring MVC. Saya akan mengatakan sebagian besar aplikasi web Java melakukan ini, sambil menggunakan kerangka kerja web lain seperti Wicket, Struts, Seam, ...

Musim semi sangat bagus untuk menempelkan instance kelas bersama-sama. Anda tahu bahwa kelas Hibernate Anda akan selalu membutuhkan sumber data, Spring kabel mereka bersama-sama (dan juga memiliki implementasi sumber data).

Objek akses data Anda akan selalu membutuhkan akses Hibernate, Spring menyambungkan kelas Hibernate ke dalam DAO Anda untuk Anda.

Selain itu, Spring pada dasarnya memberi Anda konfigurasi yang solid dari banyak perpustakaan, dan di dalamnya, memberi Anda panduan tentang lib apa yang harus Anda gunakan.

Musim semi adalah alat yang hebat. (Saya tidak berbicara tentang Spring MVC, hanya kerangka dasar).

Jawaban yang diterima tidak melibatkan penggunaan penjelasan karena Spring memperkenalkan dukungan untuk berbagai penjelasan untuk konfigurasi.

Pendekatan Spring (Dependency Injection)

Ada cara lain untuk mentransfer kelas bersama dengan menggunakan file XML: penjelasan. Mari kita gunakan contoh dari jawaban yang diterima dan mendaftar kacang langsung pada kelas menggunakan salah satu penjelasan @Component, @Service, @Repositoryatau @Configuration:

@Component
public class UserListerDB implements UserLister {
    public List<User> getUsers() {
        // DB access code here
    }
}

Dengan cara ini ketika tampilan dibuat secara ajaib akan memiliki UserLister siap bekerja.

Pernyataan di atas valid dengan sedikit bonus tanpa memerlukan penggunaan file XML dan kabel dengan anotasi lain @Autowiredyang menemukan implementasi yang relevan dan menyuntikkannya.

@Autowired
private UserLister userLister;

Gunakan @Beananotasi pada metode yang digunakan untuk mendapatkan implementasi kacang untuk menyuntikkan.

Keuntungannya adalah Dependency Injection (DI) . Itu berarti outsourcing tugas pembuatan objek. Mari saya jelaskan dengan sebuah contoh.

public interface Lunch
{
   public void eat();
}

public class Buffet implements Lunch
{
   public void eat()
   {
      // Eat as much as you can 
   }
}

public class Plated implements Lunch
{
   public void eat()
   {
      // Eat a limited portion
   }
}

Sekarang dalam kode saya, saya memiliki kelas LunchDecide sebagai berikut:

public class LunchDecide {
    private Lunch todaysLunch;
    public LunchDecide(){
        this.todaysLunch = new Buffet(); // choose Buffet -> eat as much as you want
        //this.todaysLunch = new Plated(); // choose Plated -> eat a limited portion 
    }
}

Di kelas di atas, tergantung pada suasana hati kita, kita memilih Prasmanan () atau Berlapis (). Namun sistem ini sangat erat. Setiap kali kita membutuhkan jenis Objek yang berbeda, kita perlu mengubah kodenya. Dalam hal ini, mengomentari garis! Bayangkan ada 50 kelas berbeda yang digunakan oleh 50 orang berbeda. Itu akan sangat berantakan. Dalam hal ini, kita perlu Decouple sistem. Mari kita menulis ulang kelas LunchDecide.

public class LunchDecide {
    private Lunch todaysLunch;
    public LunchDecide(Lunch todaysLunch){
        this.todaysLunch = todaysLunch
        }
    }

Perhatikan bahwa alih-alih membuat objek menggunakan kata kunci baru, kami meneruskan referensi ke objek Tipe Makan Siang sebagai parameter untuk konstruktor kami. Di sini, pembuatan objek dilakukan oleh pihak luar. Kode ini dapat ditransfer dengan menggunakan file konfigurasi Xml (legacy) atau Java Annotations (modern). Either way, keputusan yang Jenis objek akan dibuat akan dilakukan di sana selama runtime. Objek akan disuntikkan oleh Xml ke dalam kode kami - Kode kami bergantung pada Xml untuk pekerjaan itu. Makanya, Dependency Injection (DI). DI tidak hanya membantu dalam membuat sistem kami digabungkan secara longgar, ini menyederhanakan penulisan tes Unit karena memungkinkan dependensi untuk dipermainkan. Last but not least, DI merampingkan Aspect Oriented Programming (AOP) yang mengarah pada decoupling lebih lanjut dan peningkatan modularitas. Perhatikan juga bahwa DI di atas adalah Injeksi Konstruktor.

• Spring adalah kerangka kerja yang ringan dan fleksibel dibandingkan dengan J2EE.
• Kontainer pegas bertindak sebagai inversi kontrol.
• Spring menggunakan AOP yaitu proksi dan pola desain Metode Singleton, Factory and Template Method.
• Arsitektur berjenjang: Pemisahan masalah dan lapisan yang dapat digunakan kembali dan perawatan yang mudah.

Spring adalah alternatif yang baik untuk teknologi Enterprise JavaBeans (EJB) . Ini juga memiliki kerangka kerja web dan komponen kerangka kerja layanan web.

Musim semi dimulai sebagai sistem injeksi ketergantungan yang cukup sederhana. Sekarang sangat besar dan memiliki semua yang ada di dalamnya (kecuali untuk wastafel dapur pepatah).

Tapi jangan takut, ini cukup modular sehingga Anda bisa menggunakan hanya potongan yang Anda inginkan.

Untuk melihat dari mana semuanya dimulai, cobalah:

http://www.amazon.com/Expert-One-Design-Development-Programmer/dp/0764543857/ref=sr_1_1?ie=UTF8&s=books&qid=1246374863&sr=1-1

Mungkin sudah tua tapi ini buku yang bagus.

Untuk buku bagus lain kali ini khusus dikhususkan untuk Spring lihat:

http://www.amazon.com/Professional-Java-Development-Spring-Framework/dp/0764574833/ref=sr_1_2?ie=UTF8&s=books&qid=1246374863&sr=1-2

Ini juga mereferensikan versi Spring yang lebih lama tetapi jelas layak untuk dilihat.

Musim semi adalah injeksi ketergantungan pada awalnya, lalu tambahkan king of wrappers untuk hampir semua (bungkus implementasi JPA dll).

Ceritanya panjang ... sebagian besar solusi Spring Preffer XML (mesin skrip XML ... brrrr), jadi untuk DI saya menggunakan Guice

Pustaka yang bagus, tetapi dengan bertambahnya depnedenciec, misalnya Spring JDBC (mungkin satu solusi jdbc Java dengan parameter nama asli) ambil dari maven 4-5 berikutnya.

Menggunakan Spring MVC (bagian dari "big spring") untuk pengembangan web ... ini adalah kerangka kerja "berdasarkan permintaan", ada perang suci "request vs komponen" ... terserah Anda

Di masa lalu saya berpikir tentang kerangka kerja Spring dari sudut pandang teknis murni.

Diberikan beberapa pengalaman kerja tim dan mengembangkan Webapps perusahaan - Saya akan mengatakan bahwa Spring adalah untuk pengembangan aplikasi yang lebih cepat (aplikasi web) dengan memisahkan elemen-elemen individualnya (kacang-kacangan). Pengembangan lebih cepat membuatnya sangat populer. Pegas memungkinkan pengalihan tanggung jawab untuk membangun (memasang kabel) aplikasi ke kerangka Pegas. Injeksi ketergantungan Spring framework bertanggung jawab untuk menghubungkan / menghubungkan setiap biji ke dalam aplikasi yang berfungsi.

Dengan cara ini pengembang dapat lebih fokus pada pengembangan komponen individu (biji) segera setelah antarmuka antara biji didefinisikan.

Menguji aplikasi seperti itu mudah - fokus utama diberikan pada kacang secara individu. Mereka dapat dengan mudah dipisahkan dan diejek, sehingga pengujian unit cepat dan efisien.

Kerangka pegas mendefinisikan beberapa kacang khusus seperti @Controller ( @Restcontroller ), @Repository , @Component untuk melayani tujuan web. Pegas bersama Maven menyediakan struktur yang intuitif bagi pengembang. Kerja tim itu mudah dan cepat karena ada elemen individual yang dipisahkan dan dapat digunakan kembali.

Kerangka kerja pegas jelas baik untuk pengembangan web dan lebih spesifik untuk layanan api yang tenang.

Ini bagus untuk yang di atas karena ketergantungan injeksi dan integrasi dengan modul lain seperti keamanan pegas , pegas aop , kerangka mvc , layanan microser

Dengan aplikasi apa pun, keamanan kemungkinan besar merupakan persyaratan.
Jika Anda bertujuan untuk membangun produk yang membutuhkan perawatan lama, maka Anda perlu menggunakan konsep Aop.

Jika aplikasi Anda memiliki banyak lalu lintas sehingga menambah beban, Anda perlu menggunakan konsep layanan-mikro.

Spring memberikan semua fitur ini dalam satu platform. Dukungan dengan banyak modul .
Yang paling penting, pegas adalah sumber terbuka dan kerangka kerja yang dapat diperluas, memiliki kait di mana-mana untuk mengintegrasikan kode kustom dalam siklus hidup.

Spring Data adalah salah satu proyek yang menyediakan integrasi dengan proyek Anda.

Sehingga pegas dapat masuk ke hampir setiap kebutuhan.