Spring Cloud-függvény az Azure-ban

Ez a cikk bemutatja, hogyan hozhat létre, tesztelhet, hibakereshet és helyezhet üzembe egy Java Spring Cloud Function függvényt az Azure Functionsben. Ha elkészült, a függvény a használati terven fut, és a HTTP-kérelmekre válaszol.

Előfeltételek

Azure-előfizetés. Ha nem rendelkezik Azure-előfizetéssel, első lépésként mindössze néhány perc alatt létrehozhat egy ingyenes fiókot.

A függvények Java használatával történő fejlesztéséhez telepítse a következő eszközöket:

Java Developer Kit, 11-es verzió
Apache Maven, 3.0-s vagy újabb verzió
Azure parancssori felület
Az Azure Functions Core Tools 4-es verziója

Fontos

A gyorsútmutató befejezéséhez állítsa be a JAVA_HOME környezeti változó értékét a JDK telepítési helyére.

Győződjön meg arról, hogy az alapvető eszközök verziója legalább 4.0.5455.

Amit létre fog hozni

Egy klasszikus "Hello, World" függvényt fog létrehozni, amely Azure Functions fut, és a Spring Cloud-függvénnyel van konfigurálva.

A függvény kap egy User JSON-objektumot, amely egy felhasználónevet tartalmaz, és visszaküld egy Greeting objektumot, amely az adott felhasználó üdvözlő üzenetét tartalmazza.

A projekt elérhető a GitHub -ján, a azure-function-java-worker mintában. Ezt a mintát közvetlenül is használhatja, ha meg szeretné tekinteni az ebben a rövid útmutatóban leírt végső munkát.

Új Maven-projekt létrehozása

Hozzon létre egy üres Maven-projektet, és konfigurálja azt a Spring Cloud Function és az Azure Functions használatára.

Egy üres mappában hozzon létre egy új pom.xml fájlt. Ezután másolja ki a tartalmat a mintaprojekt pom.xml fájljából.

Megjegyzés

Ez a fájl a Spring Boot és a Spring Cloud függvény Maven-függőségeit használja. Emellett konfigurálja a Spring Boot és Azure Functions Maven beépülő modulokat.

Szabjon testre néhány tulajdonságot az alkalmazáshoz:

<functionAppName>a Azure függvény neve.
<functionAppRegion>annak a Azure régiónak a neve, amelyben üzembe helyezi a függvényt.
<functionResourceGroup>a használt Azure erőforráscsoport neve.

Módosítsa ezeket a tulajdonságokat közvetlenül a pom.xml fájl tetején, az alábbi példában látható módon:

    <properties>
        <java.version>11</java.version>

        <!-- Spring Boot start class. WARNING: correct class must be set -->
        <start-class>com.example.DemoApplication</start-class>

        <!-- customize those properties. WARNING: the functionAppName should be unique across Azure -->
        <azure.functions.maven.plugin.version>1.36.0</azure.functions.maven.plugin.version>
        <functionResourceGroup>my-spring-function-resource-group</functionResourceGroup>
        <functionAppServicePlanName>my-spring-function-service-plan</functionAppServicePlanName>
        <functionAppName>my-spring-function</functionAppName>
        <functionPricingTier>Y1</functionPricingTier>
        <functionAppRegion>eastus</functionAppRegion>
    </properties>

Azure-beli konfigurációs fájlok létrehozása

Hozzon létre egy src/main/resources mappát, és adja hozzá az alábbi Azure Functions-konfigurációs fájlokat.

host.json:

{
  "version": "2.0",
  "extensionBundle": {
    "id": "Microsoft.Azure.Functions.ExtensionBundle",
    "version": "[4.*, 5.2.0)"
  },
  "functionTimeout": "00:10:00"
}

local.settings.json:

{
  "IsEncrypted": false,
  "Values": {
    "AzureWebJobsStorage": "",
    "FUNCTIONS_WORKER_RUNTIME": "java",
    "FUNCTIONS_EXTENSION_VERSION": "~4",
    "AzureWebJobsDashboard": ""
  }
}

Tartományi objektumok létrehozása

Az Azure Functions JSON formátumban fogadhat és küldhet objektumokat. Hozzon létre Greeting és User objektumokat, amelyek az Ön tartománymodelljét reprezentálják. Ha testre szeretné szabni ezt a rövid útmutatót, összetettebb objektumokat hozhat létre több tulajdonságokkal.

Hozzon létre egy src/main/java/com/example/model mappát, majd adja hozzá a következő két fájlt:

User.java:

package com.example.model;

public class User {

    private String name;

    public User() {
    }

    public User(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

Greeting.java:

package com.example.model;

public class Greeting {

    private String message;

    public Greeting() {
    }

    public Greeting(String message) {
        this.message = message;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }
}

A Spring Boot-alkalmazás létrehozása

Ez az alkalmazás minden üzleti logikát kezel, és hozzáféréssel rendelkezik a teljes Spring Boot-ökoszisztémához. Ez a képesség két fő előnyt biztosít egy standard Azure-függvénnyel szemben:

Nem támaszkodik az Azure Functions API-kra, így könnyen átkötheti más rendszerekbe. Használhatja például egy normál Spring Boot-alkalmazásban.
A Spring Boot összes @Enable megjegyzésével új funkciókat vehet fel.

Az src/main/java/com/example mappában hozza létre a következő fájlt, amely egy normál Spring Boot-alkalmazás:

DemoApplication.java:

package com.example;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {
    public static void main(String[] args) throws Exception {
        SpringApplication.run(DemoApplication.class, args);
    }
}

Most hozza létre a következő fájlt az src/main/java/com/example/hello mappában. Ez a kód egy Spring Boot-összetevőt tartalmaz, amely a futtatni kívánt függvényt jelöli:

Hello.java:

package com.example.hello;

import com.example.model.*;
import org.springframework.stereotype.Component;
import java.util.function.Function;

@Component
public class Hello implements Function<User, Greeting> {

    @Override
    public Greeting apply(User user) {
        return new Greeting("Hello, " + user.getName() + "!\n");
    }
}

Megjegyzés

A Hello függvény igen konkrét:

Ez egy java.util.function.Function. Tartalmazza az üzleti logikát, és egy szabványos Java API-t használ az egyik objektum egy másikká alakításához.
Mivel a @Component széljegyzete van, ez egy Spring Bean. Alapértelmezés szerint a neve megegyezik az osztály nevével, de kisbetűvel kezdődik: hello. Az elnevezési konvenció követése akkor fontos, ha más függvényeket szeretne létrehozni az alkalmazásban. A névnek meg kell egyeznie a következő szakaszban létrehozott Azure Functions nevével.

Hozza létre az Azure-függvényt

A teljes Azure Functions API használatához hozzon létre egy Azure függvényt, amely delegálja annak végrehajtását az előző lépésben létrehozott Spring Cloud-függvényhez.

Az src/main/java/com/example/hello mappában hozza létre a következő Azure-függvényosztályfájlt:

HelloHandler.java:

package com.example.hello;

import com.microsoft.azure.functions.*;
import com.microsoft.azure.functions.annotation.AuthorizationLevel;
import com.microsoft.azure.functions.annotation.FunctionName;
import com.microsoft.azure.functions.annotation.HttpTrigger;
import com.example.model.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.Optional;

@Component
public class HelloHandler {

    @Autowired
    private Hello hello;

    @FunctionName("hello")
    public HttpResponseMessage execute(
        @HttpTrigger(name = "request", methods = {HttpMethod.GET, HttpMethod.POST}, authLevel = AuthorizationLevel.ANONYMOUS) HttpRequestMessage<Optional<User>> request, ExecutionContext context) {
        User user = request.getBody()
                           .filter(u -> u.getName() != null)
                           .orElseGet(() -> new User(request.getQueryParameters().getOrDefault("name", "world")));
        context.getLogger().info("Greeting user name: " + user.getName());
        return request.createResponseBuilder(HttpStatus.OK)
                      .body(hello.apply(user))
                      .header("Content-Type", "application/json")
                      .build();
    }
}

Ez a Java osztály egy Azure függvény, amely a következő funkciókkal rendelkezik:

Az osztály rendelkezik a @Component széljegyzetekkel, szóval ez egy Spring Bean.
A függvény neve, ahogy a @FunctionName("hello") széljegyzet definiálja, hello.
Az osztály valós Azure-függvényt implementál, így itt használhatja a teljes Azure Functions API-t.

Egységtesztek hozzáadása

Ez a lépés nem kötelező, de ajánlott ellenőrizni, hogy az alkalmazás megfelelően működik-e.

Hozzon létre egy src/test/java/com/example mappát, és adja hozzá a következő JUnit-teszteket:

HelloTest.java:

package com.example;

import com.example.hello.Hello;
import com.example.model.Greeting;
import com.example.model.User;
import org.junit.jupiter.api.Test;

import static org.assertj.core.api.Assertions.assertThat;

public class HelloTest {

    @Test
    public void test() {
        Greeting result = new Hello().apply(new User("foo"));
        assertThat(result.getMessage()).isEqualTo("Hello, foo!\n");
    }
}

Most már tesztelheti a Azure függvényt a Maven használatával:

mvn clean test

A függvény helyi futtatása

Mielőtt telepíti az alkalmazását az Azure Functionsbe, tesztelje helyben.

Először csomagolja be az alkalmazást egy JAR-fájlba:

mvn package

Most, hogy az alkalmazás becsomagolt, futtassa a azure-functions Maven beépülő modullal:

mvn azure-functions:run

A Azure függvény már elérhető a localhoston a 7071-ös port használatával. Tesztelje a függvényt egy POST-kérés elküldésével, egy User JSON formátumú objektummal. Használja például a cURL-t:

curl -X POST http://localhost:7071/api/hello -d "{\"name\":\"Azure\"}"

A függvény egy Greeting JSON formátumú objektummal válaszol:

{
  "message": "Hello, Azure!\n"
}

Íme egy képernyőkép a cURL-kérésről a képernyő tetején, alul pedig a helyi Azure-függvényről:

Helyileg futó Azure-függvény

A függvény helyi hibakeresése

A következő szakaszok a függvény hibakeresését ismertetik.

Hibakeresés az Intellij IDEA használatával

Nyissa meg a projektet az IntelliJ IDEA-ban, majd hozzon létre egy távoli JVM hibakeresési futtatási konfigurációt a csatoláshoz. További információ: Oktatóanyag: Távoli hibakeresés.

Távoli JVM-hibakeresési futtatási konfiguráció létrehozása

Futtassa az alkalmazást a következő paranccsal:

mvn azure-functions:run -DenableDebug

Az alkalmazás indításakor a következő kimenet jelenik meg:

Worker process started and initialized.
Listening for transport dt_socket at address: 5005

Indítsa el a projekt hibakeresését az IntelliJ IDEA-ban. A következő kimenet jelenik meg:

Connected to the target VM, address: 'localhost:5005', transport: 'socket'

Jelölje meg a hibakereséshez használni kívánt töréspontokat. Az IntelliJ IDEA hibakeresési módot ad meg a kérés elküldése után.

Hibakeresés a Visual Studio Code használatával

Nyissa meg a projektet Visual Studio Code, majd konfigurálja a következő launch.json fájltartalmat:

{
    "version": "0.2.0",
    "configurations": [
        {
            "type": "java",
            "name": "Attach to Remote Program",
            "request": "attach",
            "hostName": "127.0.0.1",
            "port": 5005
        }
    ]
}

Futtassa az alkalmazást a következő paranccsal:

mvn azure-functions:run -DenableDebug

Az alkalmazás indításakor a következő kimenet jelenik meg:

Worker process started and initialized.
Listening for transport dt_socket at address: 5005

Indítsa el a projekt hibakeresését Visual Studio Code, majd jelölje meg a hibakereséshez használni kívánt töréspontokat. Visual Studio Code a kérés elküldése után hibakeresési módot ad meg. További információ: Java futtatása és hibakeresése.

A függvény üzembe helyezése az Azure Functions szolgáltatásban

Az Azure-függvényt most fogja éles környezetben közzétenni. Ne feledje, hogy a <functionAppName> fájlban definiált <functionAppRegion>, <functionResourceGroup> és tulajdonságokat a függvény konfigurálására használják.

Megjegyzés

A Maven beépülő modulnak hitelesítenie kell magát az Azure-ral. Ha telepítve van az Azure CLI, a folytatás előtt használja az login .

További hitelesítési lehetőségekért lásd: Hitelesítés az azure-maven-plugins adattárban.

A függvény automatikus üzembe helyezéséhez futtassa a Mavent:

mvn azure-functions:deploy

Most nyissa meg az Azure Portal, és keresse meg a létrehozott Function App elemet.

Válassza ki a függvényt:

A függvény áttekintésében jegyezze fel a függvény URL-címét.
A futó függvény ellenőrzéséhez válassza a napló streaming lehetőséget a navigációs menüben.

Most, ahogy az előző szakaszban is tette, a cURL használatával érheti el a futó függvényt az alábbi példában látható módon. Mindenképpen cserélje le a your-function-name-t a valódi függvény nevére.

curl https://your-function-name.azurewebsites.net/api/hello -d "{\"name\":\"Azure\"}"

Az előző szakaszhoz hasonlóan a függvénynek egy Greeting objektummal kell válaszolnia, szintén JSON formátumban:

{
  "message": "Hello, Azure!\n"
}

Gratulálunk, egy Spring Cloud-függvény fut az Azure Functions szolgáltatásban! A Spring Cloud-függvényekkel kapcsolatos további információkért és mintákért tekintse meg a következő erőforrásokat:

Következő lépések

Ha szeretne többet megtudni a Spring és az Azure szolgáltatásról, lépjen tovább a Spring on Azure dokumentációs központra.

A Spring használata az Azure-ban

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2026-09-11

Spring Cloud-függvény az Azure-ban

Előfeltételek

Amit létre fog hozni

Új Maven-projekt létrehozása

Azure-beli konfigurációs fájlok létrehozása

Tartományi objektumok létrehozása

A Spring Boot-alkalmazás létrehozása

Hozza létre az Azure-függvényt

Egységtesztek hozzáadása

A függvény helyi futtatása

A függvény helyi hibakeresése

Hibakeresés az Intellij IDEA használatával

Hibakeresés a Visual Studio Code használatával

A függvény üzembe helyezése az Azure Functions szolgáltatásban

Következő lépések

Visszajelzés

További források