springPierwsze kroki ze wiosną


Uwagi

Spring Framework to platforma aplikacji typu open source i inwersja kontenera sterującego dla platformy Java.

Wersje

Wersja Data wydania
4.3.x 2016-06-10
4.2.x 2015-07-31
4.1.x 14.09.2014
4.0.x 12.12.2013
3.2.x 13.12.2012
3.1.x 13.12.2011
3.0.x 17.12.2009
2.5.x 2007-12-25
2.0.x 2006-10-04
1.2.x 2005-05-13
1.1.x 2004-09-05
1.0.x 2003-03-24

Konfiguracja (konfiguracja XML)

Kroki, aby utworzyć Hello Spring:

  1. Zbadaj Spring Boot, aby sprawdzić, czy lepiej spełni twoje potrzeby.
  2. Przygotuj projekt z poprawnymi zależnościami. Zalecane jest używanie Maven lub Gradle .
  3. utwórz klasę POJO, np. Employee.java
  4. utwórz plik XML, w którym możesz zdefiniować swoją klasę i zmienne. np. beans.xml
  5. utwórz swoją główną klasę, np. Customer.java
  6. Uwzględnij fasolkę szparagową (i jej zależności przechodnie!) Jako zależność.

Employee.java :

package com.test;

public class Employee {

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void displayName() {
        System.out.println(name);
    }
}
 

beans.xml :

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-4.3.xsd">
        
    <bean id="employee" class="com.test.Employee">
        <property name="name" value="test spring"></property>
    </bean>

</beans>
 

Customer.java :

package com.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Customer {
   public static void main(String[] args) {
      ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

      Employee obj = (Employee) context.getBean("employee");
      obj.displayName();
   }
}
 

Prezentacja podstawowych funkcji sprężyn poprzez przykład

Opis

Jest to samodzielny działający przykład obejmujący / showcasing: wymagane minimalne zależności , konfiguracja Java, deklaracja komponentu bean przez adnotację i konfigurację Java, wstrzykiwanie zależności przez konstruktor i właściwość oraz przechwytywanie przed / po .

Zależności

Te zależności są potrzebne w ścieżce klas:

  1. rdzeń sprężynowy
  2. kontekst wiosenny
  3. fasolka szparagowa
  4. wiosna
  5. wyraz wiosny
  6. wspólne logowanie

Główna klasa

Zaczynając od końca, jest to nasza klasa główna, która służy jako symbol zastępczy dla metody main() , która inicjuje kontekst aplikacji, wskazując klasę Configuration i ładując wszystkie różne komponenty niezbędne do zaprezentowania określonej funkcjonalności.

package com.stackoverflow.documentation;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;



public class Main {

    public static void main(String[] args) {

        //initializing the Application Context once per application.
        ApplicationContext applicationContext = 
                new AnnotationConfigApplicationContext(AppConfig.class);

        //bean registered by annotation
        BeanDeclaredByAnnotation beanDeclaredByAnnotation = 
                applicationContext.getBean(BeanDeclaredByAnnotation.class);
        beanDeclaredByAnnotation.sayHello();

        //bean registered by Java configuration file
        BeanDeclaredInAppConfig beanDeclaredInAppConfig = 
                applicationContext.getBean(BeanDeclaredInAppConfig.class);
        beanDeclaredInAppConfig.sayHello();

        //showcasing constructor injection
        BeanConstructorInjection beanConstructorInjection = 
                applicationContext.getBean(BeanConstructorInjection.class);
        beanConstructorInjection.sayHello();

        //showcasing property injection
        BeanPropertyInjection beanPropertyInjection = 
                applicationContext.getBean(BeanPropertyInjection.class);
        beanPropertyInjection.sayHello();

        //showcasing PreConstruct / PostDestroy hooks
        BeanPostConstructPreDestroy beanPostConstructPreDestroy = 
                applicationContext.getBean(BeanPostConstructPreDestroy.class);
        beanPostConstructPreDestroy.sayHello();
    }
}
 

Plik konfiguracji aplikacji

Klasa konfiguracji jest opatrzona adnotacjami @Configuration i jest używana jako parametr w zainicjowanym kontekście aplikacji. Adnotacja @ComponentScan na poziomie klasy klasy konfiguracji wskazuje na pakiet, który ma być skanowany w poszukiwaniu @ComponentScan i zależności zarejestrowanych za pomocą adnotacji. Wreszcie adnotacja @Bean służy jako definicja @Bean bean w klasie konfiguracji.

package com.stackoverflow.documentation;

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

@Configuration
@ComponentScan("com.stackoverflow.documentation")
public class AppConfig {

    @Bean
    public BeanDeclaredInAppConfig beanDeclaredInAppConfig() {
        return new BeanDeclaredInAppConfig();
    }
}
 

Deklaracja fasoli przez adnotację

Adnotacja @Component służy do wyznaczenia POJO jako fasoli wiosennej dostępnej do rejestracji podczas skanowania komponentów.

@Component
public class BeanDeclaredByAnnotation {

    public void sayHello() {
        System.out.println("Hello, World from BeanDeclaredByAnnotation !");
    }
}
 

Deklaracja komponentu Bean według konfiguracji aplikacji

Zauważ, że nie musimy adnotować ani w żaden inny sposób oznaczać naszego POJO, ponieważ deklaracja / definicja komponentu bean dzieje się w pliku klasy konfiguracji aplikacji.

public class BeanDeclaredInAppConfig {

    public void sayHello() {
        System.out.println("Hello, World from BeanDeclaredInAppConfig !");
    }
}
 

Wtrysk Konstruktora

Zauważ, że adnotacja @Autowired jest ustawiana na poziomie konstruktora. Zauważ też, że jeśli nie jest to wyraźnie zdefiniowane przez nazwę, domyślna automatyczna instalacja odbywa się na podstawie typu fasoli (w tym przypadku BeanToBeInjected ).

package com.stackoverflow.documentation;

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

@Component
public class BeanConstructorInjection {

    private BeanToBeInjected dependency;

    @Autowired
    public BeanConstructorInjection(BeanToBeInjected dependency) {
        this.dependency = dependency;
    }

    public void sayHello() {
        System.out.print("Hello, World from BeanConstructorInjection with dependency: ");
        dependency.sayHello();
    }
}
 

Zastrzyk nieruchomości

Zauważ, że adnotacja @Autowired wyznacza metodę ustawiającą, której nazwa jest zgodna ze standardem JavaBeans.

package com.stackoverflow.documentation;


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

@Component
public class BeanPropertyInjection {

    private BeanToBeInjected dependency;

    @Autowired
    public void setBeanToBeInjected(BeanToBeInjected beanToBeInjected) {
        this.dependency = beanToBeInjected;
    }

    public void sayHello() {
        System.out.println("Hello, World from BeanPropertyInjection !");
    }
}
 

Haki PostConstruct / PreDestroy

Możemy przechwycić inicjalizację i zniszczenie @PostConstruct @PreDestroy haków @PostConstruct i @PreDestroy .

package com.stackoverflow.documentation;

import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

@Component
public class BeanPostConstructPreDestroy {

    @PostConstruct
    public void pre() {
        System.out.println("BeanPostConstructPreDestroy - PostConstruct");
    }

    public void sayHello() {
        System.out.println(" Hello World, BeanPostConstructPreDestroy !");
    }

    @PreDestroy
    public void post() {
        System.out.println("BeanPostConstructPreDestroy - PreDestroy");
    }
}
 

Czym jest Spring Framework, dlaczego powinniśmy po niego sięgać?

Spring to framework, który zapewnia wiele klas, dzięki temu nie musimy pisać logiki płyty kotłowej w naszym kodzie, więc Spring zapewnia abstrakcyjną warstwę na J2ee.


Na przykład w Simple JDBC Application odpowiedzialny jest programista

  1. Ładowanie klasy sterownika
  2. Tworzenie połączenia
  3. Tworzenie obiektu instrukcji
  4. Obsługa wyjątków
  5. Tworzenie zapytania
  6. Wykonywanie zapytania
  7. Zamykanie połączenia

Który jest traktowany jako kod podstawowy, ponieważ każdy programista pisze ten sam kod. Tak więc dla uproszczenia struktura zajmuje się logiką podstawową, a programista musi pisać tylko logikę biznesową. Korzystając z frameworka Spring, możemy szybko opracowywać projekty przy minimalnej liczbie wierszy kodu, bez żadnych błędów, a także skrócić czas i koszty programowania.

Dlaczego więc wybrać Spring jako rozpórki?

Strut jest strukturą, która zapewnia rozwiązanie tylko aspektów sieciowych, a strut ma charakter inwazyjny. Wiosna ma wiele cech w stosunku do rozpór, więc musimy wybrać Wiosna.

  1. Wiosna ma charakter nieinwazyjny : oznacza to, że nie musisz rozszerzać żadnych klas ani implementować interfejsów do swojej klasy.
  2. Wiosna jest wszechstronna : oznacza to, że można ją zintegrować z dowolną istniejącą technologią w projekcie.
  3. Wiosna zapewnia kompleksowy rozwój projektu: oznacza to, że możemy opracować wszystkie moduły, takie jak warstwa biznesowa, warstwa trwałości.
  4. Wiosna jest lekka : oznacza to, że jeśli chcesz pracować nad danym modułem, nie musisz uczyć się pełnej sprężyny, tylko ucz się tego konkretnego modułu (np. Spring Jdbc, Spring DAO)
  5. Wiosna obsługuje wstrzykiwanie zależności .
  6. Spring wspiera rozwój wielu projektów, np .: Core Java, Web Application, Distributed Application, Enterprise Application.
  7. Sprężyna wspiera programowanie zorientowane na aspekty dla problemów przekrojowych.

Wreszcie możemy powiedzieć, że Wiosna jest alternatywą dla Struts. Ale Spring nie zastępuje J2EE API, ponieważ klasy dostarczone przez Spring wewnętrznie korzystają z klas J2EE API. Wiosna jest rozległą strukturą, dlatego podzieliła się na kilka modułów. Żaden moduł nie jest zależny od innego oprócz Spring Core. Niektóre ważne moduły to

  1. Spring Core
  2. Wiosna JDBC
  3. Wiosna AOP
  4. Transakcja wiosenna
  5. Wiosna ORM
  6. Wiosna MVC