springAan de slag met de lente


Opmerkingen

Het Spring Framework is een open source applicatie framework en inversie van besturingscontainer voor het Java-platform.

versies

Versie Publicatiedatum
4.3.x 2016/06/10
4.2.x 2015/07/31
4.1.x 2014/09/14
4.0.x 2013/12/12
3.2.x 2012/12/13
3.1.x 2011-12-13
3.0.x 2009-12-17
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

Setup (XML-configuratie)

Stappen om Hello Spring te maken:

  1. Onderzoek Spring Boot om te zien of dat beter bij u past.
  2. Laat een project opzetten met de juiste afhankelijkheden. Het wordt aanbevolen dat u Maven of Gradle gebruikt .
  3. maak een POJO-klasse, bijvoorbeeld Employee.java
  4. maak een XML-bestand waar u uw klasse en variabelen kunt definiëren. bijv. beans.xml
  5. maak uw hoofdklasse aan, bijv. Customer.java
  6. Inclusief de lente-bonen (en de transitieve afhankelijkheden!) Als een afhankelijkheid.

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

Voorbeeld van kernveerfuncties

Beschrijving

Dit is een op zichzelf staand uitvoeringsvoorbeeld inclusief / presentatie: minimaal benodigde afhankelijkheden , Java- configuratie , Bean-verklaring door annotatie en Java-configuratie, afhankelijkheidsinjectie per constructor en per eigenschap, en Pre / Post- hooks.

afhankelijkheden

Deze afhankelijkheden zijn nodig in het classpath:

  1. spring core
  2. spring-context
  3. lente-bonen
  4. spring-aop
  5. spring-expressie
  6. commons-logging

Hoofdklasse

Vanaf het einde is dit onze hoofdklasse die dient als een tijdelijke aanduiding voor de methode main() die de toepassingscontext initialiseert door te wijzen op de configuratieklasse en alle verschillende bonen laadt die nodig zijn om bepaalde functionaliteit te demonstreren.

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

Toepassing configuratiebestand

De configuratieklasse is geannoteerd door @Configuration en wordt gebruikt als parameter in de geïnitialiseerde toepassingscontext. De annotatie @ComponentScan op het @ComponentScan van de configuratieklasse @ComponentScan naar een pakket dat moet worden gescand op bonen en afhankelijkheden die zijn geregistreerd met annotaties. Ten slotte dient de annotatie @Bean als een @Bean in de configuratieklasse.

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

Bonenverklaring door annotatie

De annotatie @Component dient om de POJO af te bakenen als een Spring bean beschikbaar voor registratie tijdens het scannen van componenten.

@Component
public class BeanDeclaredByAnnotation {

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

Bonenverklaring per toepassingsconfiguratie

Merk op dat we onze POJO niet hoeven te annoteren of anderszins te markeren omdat de bonendeclaratie / definitie plaatsvindt in het klassebestand van de Application Configuration-klasse.

public class BeanDeclaredInAppConfig {

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

Constructor injectie

Merk op dat de annotatie @Autowired is ingesteld op constructorniveau. Merk ook op dat, tenzij expliciet gedefinieerd door de naam, de standaard automatische bekabeling gebeurt op basis van het type van de bean (in dit geval 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();
    }
}
 

Eigendom injectie

Merk op dat de annotatie @Autowired de setter-methode @Autowired waarvan de naam de JavaBeans-standaard volgt.

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

Haken na bouwen / vernietigen

We kunnen initialisatie en vernietiging van een Bean onderscheppen door de haken @PostConstruct en @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");
    }
}
 

Wat is Spring Framework, waarom zouden we ervoor gaan?

Spring is een raamwerk dat een groot aantal klassen biedt. Door dit te gebruiken, hoeven we geen ketelplaatlogica in onze code te schrijven, dus Spring biedt een abstracte laag op J2ee.


Bijvoorbeeld in Simple JDBC Application is programmeur verantwoordelijk voor

  1. De stuurprogrammaklasse laden
  2. Verbinding maken
  3. Statement-object maken
  4. Omgaan met de uitzonderingen
  5. Zoekopdracht maken
  6. Zoekopdracht uitvoeren
  7. Verbinding wordt verbroken

Die wordt behandeld als standaardplaatcode omdat elke programmeur dezelfde code schrijft. Dus voor de eenvoud zorgt het framework voor boilerplate-logica en hoeft de programmeur alleen bedrijfslogica te schrijven. Door het gebruik van Spring Framework kunnen we dus snel projecten ontwikkelen met minimale coderegels, zonder enige bug, waardoor de ontwikkelingskosten en -tijd ook worden verminderd.

Dus waarom kiezen voor de lente als stutten is er

Strut is een raamwerk dat alleen een oplossing biedt voor webaspecten en stutten zijn invasief van aard. De lente heeft veel functies ten opzichte van stutten, dus we moeten de lente kiezen.

  1. De lente is niet- invasief van aard: dat betekent dat u geen klassen hoeft uit te breiden of interfaces met uw klas hoeft te implementeren.
  2. Spring is veelzijdig : dat betekent dat het kan worden geïntegreerd met elke bestaande technologie in uw project.
  3. Spring biedt end-to-end projectontwikkeling: dat betekent dat we alle modules kunnen ontwikkelen, zoals bedrijfslaag, persistentielaag.
  4. De lente is licht van gewicht : dat betekent dat als u aan een bepaalde module wilt werken, u niet de volledige lente hoeft te leren, alleen die specifieke module moet leren (bijv. Spring Jdbc, Spring DAO)
  5. Spring ondersteunt afhankelijkheid injectie .
  6. Spring ondersteunt de ontwikkeling van meerdere projecten, bijvoorbeeld: Core Java-applicatie, Web-applicatie, Gedistribueerde applicatie, Enterprise-applicatie.
  7. Spring ondersteunt Aspect-georiënteerd programmeren voor horizontale problemen.

Dus eindelijk kunnen we zeggen dat Spring een alternatief is voor Struts. Maar Spring is geen vervanging van J2EE API, omdat door Spring geleverde klassen intern J2EE API-klassen gebruiken. De lente is een uitgebreid kader, dus het is verdeeld in verschillende modules. Geen enkele module is afhankelijk van een andere, behalve Spring Core. Sommige belangrijke modules zijn

  1. Spring Core
  2. Lente JDBC
  3. Lente AOP
  4. Voorjaarstransactie
  5. Lente ORM
  6. Lente MVC