spring Handledning
Komma igång med våren

Anmärkningar

versioner

Setup (XML-konfiguration)

Steg för att skapa Hello Spring:

0. Undersök Spring Boot för att se om det bäst passar dina behov.
1. Låt ett projekt inrättas med rätt beroenden. Det rekommenderas att du använder Maven eller Gradle .
2. skapa en POJO-klass, t.ex. Employee.java
3. skapa en XML-fil där du kan definiera din klass och variabler. t.ex. beans.xml
4. skapa din huvudklass t.ex. Customer.java
5. Inkludera vårbönor (och dess övergående beroende!) Som ett beroende.

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();
   }
}

Visa upp kärnfjäderfunktioner med exempel

Beskrivning

Detta är ett fristående körande exempel som inkluderar / visar upp: minsta beroende som behövs, Java- konfiguration , Bean-deklaration genom annotering och Java-konfiguration, beroende injektion av konstruktör och av egendom och Pre / Post- krokar.

beroenden

Dessa beroenden behövs i klassvägen:

1. fjäder-core
2. fjäder-kontext
3. våren-bönor
4. fjäder aop
5. fjäder-expression
6. commons-loggning

Huvudklass

Från slutet är detta vår huvudklass som fungerar som en platshållare för den main() metoden som initierar applikationskonteksten genom att peka på klassen Konfiguration och laddar alla olika bönor som behövs för att visa upp en viss funktionalitet.

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();
    }
}

Programkonfigurationsfil

Konfigurationsklassen kommenteras av @Configuration och används som en parameter i det initialiserade applikationskonteksten. @ComponentScan anteckningen på @ComponentScan i konfigurationsklassen pekar på ett paket som ska skannas efter Bönor och beroenden som registrerats med hjälp av kommentarer. Slutligen fungerar @Bean anteckningen som en bönedefinition i konfigurationsklassen.

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();
    }
}

Beandeklaration av kommentar

@Component anteckningen tjänar till att avgränsa POJO som en vårböna som är tillgänglig för registrering under komponentskanning.

@Component
public class BeanDeclaredByAnnotation {

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

Beandeklaration med applikationskonfiguration

Lägg märke till att vi inte behöver kommentera eller på annat sätt markera vår POJO eftersom bönedeklarationen / definitionen sker i klassen för applikationskonfiguration.

public class BeanDeclaredInAppConfig {

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

Constructor Injection

Lägg märke till att anteckningen @Autowired är inställd på konstruktornivå. Observera också att om inte exakt definierat med namnet sker automatisk autowiring baserat på typen av bönor (i detta fall 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();
    }
}

Fastighetsinsprutning

Observera att @Autowired anteckningen avgränsar setter-metoden vars namn följer JavaBeans-standarden.

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 !");
    }
}

PostConstruct / PreDestroy krokar

Vi kan fånga initieringen och förstörelsen av en @PostConstruct @PreDestroy @PostConstruct och @PreDestroy krokarna.

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");
    }
}

Vad är vårramen, varför ska vi gå efter det?

Våren är ett ramverk, som tillhandahåller massor av klasser, genom att använda detta behöver vi inte skriva pannplattlogik i vår kod, så våren ger ett abstrakt lager på J2ee.

Till exempel i Simple JDBC Application programmerare ansvarar för

1. Laddar förarklassen
2. Skapa anslutningen
3. Skapa uttalandeobjekt
4. Hantera undantagen
5. Skapar fråga
6. Utför frågan
7. Stänger anslutningen

Som behandlas som pannplåtkod eftersom varje programmerare skriver samma kod. Så för enkelhetens skötsel handlar det om pannplattlogik och programmeraren måste bara skriva affärslogik. Så genom att använda våren ramverk kan vi utveckla projekt snabbt med minimikoder, utan något fel, utvecklingskostnaden och tiden minskas också.

Så varför man väljer vår som stag är det

Strut är ett ramverk som endast tillhandahåller lösning på webbaspekter och struts är invasiva till sin natur. Våren har många funktioner över stag så vi måste välja vår.

1. Våren är icke-invasiv av natur: Det betyder att du inte behöver utöka klasser eller implementera gränssnitt till din klass.
2. Våren är mångsidig : Det betyder att den kan integreras med all befintlig teknik i ditt projekt.
3. Våren ger projektutveckling från slutet till slut : Det betyder att vi kan utveckla alla moduler som affärslager, uthållighetslager.
4. Våren är lätt : Det betyder att om du vill arbeta med en viss modul då, behöver du inte lära dig fullständig vår, bara lära dig den specifika modulen (t.ex. Spring Jdbc, Spring DAO)
5. Våren stöder beroendeinjektion .
6. Spring stöder flera projektutveckling, t.ex. Core Java-applikation, Web Application, Distribuerad Application, Enterprise Application.
7. Våren stöder aspektorienterad programmering för tvärgående problem.

Så äntligen kan vi säga att våren är ett alternativ till Struts. Men våren ersätter inte J2EE API, eftersom Spring levererade klasser internt använder J2EE API klasser. Våren är en enorm ram så den har delats upp i flera moduler. Ingen modul är beroende av en annan förutom Spring Core. Några viktiga moduler är

1. Spring Core
2. Spring JDBC
3. Spring AOP
4. Vårtransaktion
5. Spring ORM
6. Spring MVC