Czym na świecie są fasolki szparagowe?

Mam jeszcze znaleźć definicję wysokiego poziomu fasoli jarej, którą mogę zrozumieć. Widzę je często przywoływane w dokumentacji i książkach Grailsa, ale myślę, że zrozumienie, czym są, byłoby korzystne. Czym są fasolki szparagowe? Jak można ich używać? Czy mają coś wspólnego z Dependency Injection?

Obiekty tworzące szkielet aplikacji i zarządzane przez kontener Spring IoC * nazywane są komponentami bean. Fasola to obiekt, który jest tworzony w instancji, składany i w inny sposób zarządzany przez kontener Spring IoC. Te komponenty bean są tworzone przy użyciu metadanych konfiguracji dostarczanych do kontenera, na przykład w postaci <bean/>definicji XML .

Więcej informacji o fasoli i zakresie z SpringSource :

Kiedy tworzysz definicję komponentu bean, tak naprawdę tworzysz przepis na tworzenie rzeczywistych instancji klasy zdefiniowanej przez tę definicję komponentu bean. Idea, że ​​definicja komponentu bean jest przepisem, jest ważna, ponieważ oznacza, że ​​podobnie jak klasa, możesz potencjalnie mieć wiele instancji obiektów utworzonych z jednego przepisu.

Możesz kontrolować nie tylko różne zależności i wartości konfiguracyjne, które mają być podłączone do obiektu utworzonego na podstawie określonej definicji komponentu bean, ale także zakres obiektów utworzonych na podstawie określonej definicji komponentu bean. To podejście jest bardzo wydajne i daje elastyczność wyboru zakresu obiektów tworzonych przez konfigurację zamiast konieczności „bażowania” zakresu obiektu na poziomie klasy Java. Fasole można zdefiniować do wdrożenia w jednym z wielu zakresów

* IoC: Odwrócenie kontroli

Fasolka szparagowa to tylko obiekty instancji, którymi zarządza kontener Spring, a mianowicie są one tworzone i łączone przez szkielet i umieszczane w „torbie obiektów” (kontenerze), skąd można je później pobrać.

Część „okablowanie” polega na tym, na czym polega wstrzykiwanie zależności, co oznacza, że ​​możesz po prostu powiedzieć „Będę potrzebować tego”, a struktura będzie przestrzegać pewnych reguł, aby uzyskać odpowiednią instancję.

Dla kogoś, kto nie jest przyzwyczajony do wiosny, myślę, że artykuł Wikipedii Spring ma ładny opis :

Centralnym elementem Spring Framework jest jego odwrócenie kontenera sterującego, który zapewnia spójny sposób konfigurowania i zarządzania obiektami Java za pomocą odbicia. Kontener jest odpowiedzialny za zarządzanie cyklem życia obiektu dla określonych obiektów: tworzenie tych obiektów, wywoływanie ich metod inicjowania i konfigurowanie tych obiektów przez ich połączenie.

Obiekty utworzone przez kontener są również nazywane obiektami zarządzanymi lub komponentami bean . Kontener można skonfigurować, ładując pliki XML lub wykrywając określone adnotacje Java w klasach konfiguracji. Te źródła danych zawierają definicje ziaren, które dostarczają informacji wymaganych do utworzenia ziaren.

Obiekty można uzyskać za pomocą wyszukiwania zależności lub wstrzykiwania zależności . Wyszukiwanie zależności jest wzorcem, w którym program wywołujący pyta obiekt kontenera o obiekt o określonej nazwie lub określonym typie. Wstrzykiwanie zależności to wzorzec, w którym kontener przekazuje obiekty według nazwy innym obiektom za pomocą konstruktorów, właściwości lub metod fabrycznych.

Najpierw pozwól nam zrozumieć wiosnę:

Wiosna to lekka i elastyczna konstrukcja.

Analogia:

Fasola: to obiekt tworzony, zarządzany i niszczony w Spring Container. Możemy wstrzyknąć obiekt do kontenera sprężynowego za pomocą metadanych (xml lub adnotacji), co nazywa się odwróceniem kontroli.

Analogia: Załóżmy, że rolnik uprawia ziemię uprawną za pomocą nasion (lub fasoli). Tutaj Farmer to Spring Framework, Farmland to Spring Container, Beans to Spring Beans, Hodowanie to Spring Processors.

Podobnie jak cykl życia fasoli, fasola szparagowa również ma swój cykl życia.

źródło img

Oto sekwencja cyklu życia fasoli na wiosnę:

• Instancja: Najpierw kontener sprężynowy odnajduje definicję komponentu bean z pliku XML i tworzy instancję komponentu bean.

• Wypełnij właściwości: przy użyciu wstrzykiwania zależności sprężyna zapełnia wszystkie właściwości określone w definicji komponentu bean.

• Ustaw nazwę fasoli: jeśli fasola implementuje BeanNameAwareinterfejs, wiosna przekazuje identyfikator fasoli do setBeanName()metody.

• Ustaw fabrykę fasoli: jeśli Bean implementuje BeanFactoryAwareinterfejs, sprężyna przekazuje fabrykę fasoli do setBeanFactory()metody.

• Przedinicjalizacja: nazywana także post procesami fasoli. Jeśli z komponentem bean są powiązane komponenty BeanPostProcessors, postProcesserBeforeInitialization()metoda wywołań Spring .

• Zainicjuj fasole: jeśli implementuje fasolę IntializingBean, afterPropertySet()wywoływana jest jej metoda. Jeśli komponent bean ma deklarację metody inicjowania, wywoływana jest określona metoda inicjalizacji.

• Po inicjalizacji: - Jeśli są jakieś BeanPostProcessorspowiązane z fasolą, postProcessAfterInitialization()zostaną wywołane ich metody.

• Gotowy do użycia: Teraz fasola jest gotowa do użycia przez aplikację

• Zniszcz: Jeśli fasola się zaimplementuje DisposableBean, wywoła destroy()metodę

Dobrze to częściowo zrozumiałeś. Musisz dostosować fasolę do swoich potrzeb i poinformować kontener Spring, aby zarządzał nim, gdy zajdzie taka potrzeba, za pomocą popularnej metodologii znanej jako IoC ( Inversion of Control ) opracowanej przez Martina Fowlera , znanej również jako Dependency Injection (DI).

Drut fasoli łączy się w taki sposób, aby nie trzeba było zajmować się tworzeniem instancji ani oceniać zależności od fasoli. Jest to powszechnie znane jako Zasada Hollywood .

Google jest najlepszym narzędziem do odkrywania tego więcej, oprócz linków, które zostałyby zalane tutaj w tym pytaniu. :)

Wiosna ma pojemnik IoC, który zawiera worek fasoli; utrzymanie i usuwanie kreacji jest obowiązkiem Spring Container. Możemy wprowadzić fasolę do wiosny za pomocą okablowania i automatycznego okablowania. Okablowanie oznacza, że ​​ręcznie konfigurujemy go w pliku XML, a „Automatyczne okablowanie” oznacza, że ​​umieszczamy adnotacje w pliku Java, a następnie Spring automatycznie skanuje kontekst główny, w którym znajduje się plik konfiguracyjny Java, tworzy go i umieszcza w torbie Spring.

Oto szczegółowy identyfikator URI, w którym masz więcej informacji na temat fasoli

Fasolka szparagowa to klasy. Zamiast tworzenia instancji klasy (za pomocą new) otrzymujesz instancję jako beanrzut na typ swojej klasy z kontekstu aplikacji, gdzie komponent bean jest tym, co skonfigurowałeś w konfiguracji kontekstu aplikacji. W ten sposób cała aplikacja zachowuje instancję singleton-scope w całej aplikacji. Wszystkie komponenty bean są inicjowane zgodnie z kolejnością konfiguracji zaraz po utworzeniu instancji kontekstu aplikacji. Nawet jeśli w aplikacji nie ma żadnych komponentów bean, wszystkie instancje typu bean są już tworzone zaraz po utworzeniu kontekstu aplikacji.

• Fasolka szparagowa to tylko instancja obiektu zarządzana przez kontener Spring IOC.

• W wiosennym kontenerze MKOl znajduje się Bag of Bean. Tworzenie, konserwacja i usuwanie zawartości leżą w gestii Spring Container.

• Możemy wprowadzić fasolę do wiosny za pomocą okablowania i automatycznego okablowania.

• Okablowanie oznacza, że ​​ręcznie konfigurujemy go w pliku XML.

• Automatyczne okablowanie oznacza, że ​​umieszczamy adnotacje w pliku Java, a następnie Spring automatycznie skanuje kontekst główny, w którym plik konfiguracyjny Java, tworzy go i umieszcza w torbie Spring.

Fasola to POJO (Plain Old Java Object), który jest zarządzany przez kontener wiosenny.

Kontenery sprężynowe domyślnie tworzą tylko jedno wystąpienie fasoli. Ta fasola jest buforowana w pamięci, więc wszystkie żądania fasoli zwrócą wspólne odwołanie do tej samej fasoli.

Adnotacja @Bean zwraca obiekt, który sprężyna rejestruje jako komponent bean w kontekście aplikacji. Logika wewnątrz metody odpowiada za utworzenie instancji.

Kiedy używamy adnotacji @Bean?

Gdy automatyczna konfiguracja nie jest opcją. Na przykład, gdy chcemy połączyć komponenty z biblioteki innej firmy, ponieważ kod źródłowy jest niedostępny, więc nie możemy adnotować klas za pomocą @Component.

Scenariusz w czasie rzeczywistym może polegać na tym, że ktoś chce połączyć się z segmentem Amazon S3. Ponieważ źródło nie jest dostępne, musiałby utworzyć @bean.

@Bean
public AmazonS3 awsS3Client() {
    BasicAWSCredentials awsCreds = new BasicAWSCredentials(awsKeyId, accessKey);
    return AmazonS3ClientBuilder.standard().withRegion(Regions.fromName(region))
            .withCredentials(new AWSStaticCredentialsProvider(awsCreds)).build();
}

Źródło powyższego kodu -> https://www.devglan.com/spring-mvc/aws-s3-java

Ponieważ wspomniałem o adnotacji @Component powyżej.

@Component Wskazuje, że klasa z adnotacjami jest „komponentem”. Takie klasy są uważane za kandydatów do automatycznego wykrywania w przypadku korzystania z konfiguracji opartej na adnotacjach i skanowania ścieżki klasy.

Adnotacja komponentu rejestruje klasę jako pojedynczą fasolę.

Wiosną te obiekty, które tworzą szkielet aplikacji i którymi zarządza kontener Spring IoC, są nazywane fasolami. Fasola jest po prostu obiektem, który jest tworzony w instancji, składany i zarządzany w inny sposób przez kontener Spring IoC;

Na wiosnę wszystkie obiekty to fasola! Podstawowym krokiem w Spring Framework jest zdefiniowanie obiektów jako fasoli. Fasole są niczym innym jak instancjami obiektowymi, które zostałyby stworzone przez strukturę wiosny, patrząc na ich definicje klas. Te definicje zasadniczo tworzą metadane konfiguracji. Struktura tworzy następnie plan, dla którego należy utworzyć instancję obiektów, które zależności należy ustawić i wprowadzić, zakres nowo utworzonej instancji itp., W oparciu o te metadane konfiguracji.

Metadane mogą być dostarczane w prostym pliku XML, podobnie jak w pierwszym rozdziale. Alternatywnie można podać metadane jako adnotację lub konfigurację Java.

Książka: Just Spring

Konfiguracja XML Springa składa się z Fasoli, a Fasola to w zasadzie klasy. To tylko POJO, których używamy wewnątrz naszego ApplicationContext. Zdefiniowanie fasoli można traktować jako zastąpienie słowa kluczowego new. Więc gdziekolwiek używasz słowa kluczowego new w swojej aplikacji, coś takiego:

MyRepository myRepository =new MyRepository ();

Tam, gdzie używasz tego słowa kluczowego new , gdzieś możesz spojrzeć na usunięcie tej konfiguracji i umieszczenie jej w pliku XML. Więc zakodujemy w ten sposób:

<bean name="myRepository " 
      class="com.demo.repository.MyRepository " />

Teraz możemy po prostu użyć Setter Injection / Constructor Injection. Używam Setter Injection.

public class MyServiceImpl implements MyService {
    private MyRepository myRepository;
    public void setMyRepository(MyRepository myRepository)
        {
    this.myRepository = myRepository ;
        }
public List<Customer> findAll() {
        return myRepository.findAll();
    }
}