5 چارچوب قدرتمند جاوا برای توسعه بدون سرور: برنامه های Cloud-Native خود را تقویت کنید

به عنوان یک نویسنده پرفروش، از شما دعوت می کنم کتاب های من را در آمازون جستجو کنید. فراموش نکنید که من را در Medium دنبال کنید و حمایت خود را نشان دهید. متشکرم حمایت شما یعنی دنیا!

توسعه بدون سرور جاوا روش ساخت و استقرار برنامه های کاربردی را متحول کرده است. به‌عنوان یک توسعه‌دهنده، من از نزدیک دیدم که چگونه این چارچوب‌ها می‌توانند کار ما را ساده‌سازی کنند و عملکرد برنامه را افزایش دهند. بیایید پنج چارچوب کلیدی جاوا را برای ایجاد برنامه‌های بدون سرور بومی ابری بررسی کنیم.

AWS Lambda با جاوا یک ترکیب قدرتمند برای توسعه بدون سرور است. من متوجه شده ام که استفاده از AWS SDK برای جاوا فرآیند ایجاد توابع Lambda را ساده می کند. مدل کاربردی بدون سرور AWS (SAM) به ویژه برای کارهای استقرار و مدیریت مفید است.

در اینجا یک مثال اساسی از یک تابع Lambda با استفاده از جاوا آورده شده است:

public class LambdaHandler implements RequestHandler<APIGatewayProxyRequestEvent, APIGatewayProxyResponseEvent> {
    public APIGatewayProxyResponseEvent handleRequest(APIGatewayProxyRequestEvent input, Context context) {
        String name = input.getQueryStringParameters().get("name");
        String message = String.format("Hello, %s!", name);
        return new APIGatewayProxyResponseEvent()
            .withStatusCode(200)
            .withBody(message);
    }
}

این تابع به رویدادهای API Gateway پاسخ می دهد، یک پارامتر نام را از رشته query استخراج می کند و یک تبریک شخصی را برمی گرداند. این یک راه ساده و در عین حال موثر برای ایجاد API های بدون سرور است.

هنگام کار با AWS Lambda، من اغلب از AWS SAM CLI برای آزمایش و استقرار محلی استفاده می کنم. در اینجا یک نمونه الگوی SAM برای تابع Lambda ما آمده است:

AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Resources:
  HelloFunction:
    Type: AWS::Serverless::Function
    Properties:
      Handler: com.example.LambdaHandler::handleRequest
      Runtime: java11
      Events:
        HelloApi:
          Type: Api
          Properties:
            Path: /hello
            Method: get

این الگو تابع Lambda ما را تعریف می کند و یک نقطه پایانی API Gateway برای راه اندازی آن ایجاد می کند.

با حرکت به Quarkus، متوجه شدم که آن را یک انتخاب عالی برای برنامه‌های جاوا بومی ابری می‌دانم. زمان راه اندازی سریع و حافظه کم آن، آن را برای محیط های بدون سرور ایده آل می کند. Quarkus از کامپایل تصویر مادری GraalVM پشتیبانی می کند که می تواند عملکرد را به طور قابل توجهی بهبود بخشد.

در اینجا یک برنامه ساده Quarkus آمده است:

@Path("/hello")
public class GreetingResource {
    @GET
    @Produces(MediaType.TEXT_PLAIN)
    public String hello() {
        return "Hello from Quarkus";
    }
}

برای ساختن یک تصویر بومی با Quarkus، می توانیم از دستور Maven زیر استفاده کنیم:

./mvnw package -Pnative

این یک فایل اجرایی بومی ایجاد می کند که بسیار سریعتر از برنامه های کاربردی جاوا سنتی راه اندازی می شود.

Spring Cloud Function فریمورک دیگری است که من به طور گسترده از آن استفاده کرده ام. این یک مدل برنامه نویسی یکنواخت را در بین ارائه دهندگان مختلف بدون سرور ارائه می دهد و به ما امکان می دهد منطق تجاری را به عنوان توابع ساده جاوا بنویسیم. در اینجا یک مثال است:

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

    @Bean
    public Function<String, String> uppercase() {
        return String::toUpperCase;
    }
}

این تابع ساده رشته های ورودی را به حروف بزرگ تبدیل می کند. ما می‌توانیم این را در پلتفرم‌های ابری مختلف، از جمله AWS Lambda، Azure Functions و Google Cloud Functions اجرا کنیم.

Micronaut به طور خاص برای ساخت میکروسرویس ها و برنامه های کاربردی بدون سرور طراحی شده است. جمع‌آوری زودهنگام و کاهش بازتاب آن منجر به زمان راه‌اندازی سریع‌تر و مصرف کمتر حافظه می‌شود. در اینجا یک عملکرد اصلی Micronaut آمده است:

@FunctionBean("hello")
public class HelloFunction implements Function<String, String> {
    @Override
    public String apply(String name) {
        return "Hello, " + name + "!";
    }
}

تزریق وابستگی زمان کامپایل Micronaut و AOP نیاز به بازتاب را از بین می برد و آن را به یک انتخاب عالی برای محیط های بدون سرور تبدیل می کند.

در نهایت، پروژه Fn یک پلت فرم منبع باز و بدون سرور بومی کانتینر است که به نظر من انعطاف پذیر است. از چندین زبان از جمله جاوا پشتیبانی می کند و به ما امکان می دهد برنامه های بدون سرور را روی هر زیرساخت ابری یا داخلی اجرا کنیم. در اینجا یک تابع ساده Fn در جاوا آمده است:

public class HelloFunction {
    public String handleRequest(String input) {
        String name = (input == null || input.isEmpty()) ? "world"  : input;
        return "Hello, " + name + "!";
    }
}

برای استقرار این تابع با استفاده از Fn، از دستوراتی مانند:

fn create app myapp
fn deploy --app myapp --local

این فریم ورک ها ویژگی های منحصر به فردی را ارائه می دهند که متناسب با محیط های مختلف بدون سرور و نیازهای توسعه است. در تجربه من، انتخاب چارچوب اغلب به الزامات خاص پروژه و تخصص تیم بستگی دارد.

هنگام توسعه برنامه های بدون سرور، توجه به عواملی مانند زمان شروع سرد، استفاده از حافظه و ادغام با سرویس های ابری بسیار مهم است. به عنوان مثال، AWS Lambda با جاوا، به طور یکپارچه با سایر خدمات AWS ادغام می شود و آن را به یک انتخاب عالی برای معماری های AWS محور تبدیل می کند.

کوارکوس در سناریوهایی که زمان راه‌اندازی سریع و حافظه کم اهمیت دارد، می‌درخشد. من از آن با موفقیت در پروژه هایی استفاده کرده ام که در آن نیاز به بهینه سازی استفاده از منابع و کاهش هزینه ها در محیط های بدون سرور داشتیم.

قدرت Spring Cloud Function در قابل حمل بودن آن نهفته است. اگر روی پروژه‌ای کار می‌کنید که ممکن است نیاز به جابجایی بین ارائه‌دهندگان ابری داشته باشد یا در محیط‌های ترکیبی اجرا شود، Spring Cloud Function یک مدل برنامه‌نویسی سازگار ارائه می‌کند که می‌تواند این انتقال‌ها را ساده کند.

پردازش زمان کامپایل و حداقل بازتاب زمان اجرا Micronaut آن را به گزینه ای عالی برای برنامه های بدون سرور تبدیل می کند که نیاز به شروع سریع و استفاده از حداقل منابع دارند. من آن را به ویژه در پروژه هایی که نیاز به استقرار تعداد زیادی از عملکردهای کوچک و متمرکز داریم مفید یافته ام.

پروژه Fn به دلیل انعطاف پذیری و قابلیت حمل آن متمایز است. اگر در یک محیط چند ابری کار می کنید یا نیاز به اجرای عملکردهای بدون سرور در محل دارید، Fn Project یک پلتفرم ثابت در زیرساخت های مختلف ارائه می دهد.

هنگام توسعه برنامه های بدون سرور، طراحی با مقیاس پذیری در ذهن بسیار مهم است. همه این چارچوب‌ها از مقیاس‌بندی خودکار پشتیبانی می‌کنند، اما نحوه ساختار کدتان می‌تواند بر میزان مقیاس برنامه شما تأثیر بگذارد. به عنوان مثال، این تابع AWS Lambda را در نظر بگیرید که از DynamoDB استفاده می کند:

public class OrderProcessor implements RequestHandler<APIGatewayProxyRequestEvent, APIGatewayProxyResponseEvent> {
    private final AmazonDynamoDB dynamoDB;

    public OrderProcessor() {
        this.dynamoDB = AmazonDynamoDBClientBuilder.standard().build();
    }

    @Override
    public APIGatewayProxyResponseEvent handleRequest(APIGatewayProxyRequestEvent input, Context context) {
        // Process order logic here
        return new APIGatewayProxyResponseEvent().withStatusCode(200).withBody("Order processed");
    }
}

در این مثال، ما یک مشتری DynamoDB جدید برای هر فراخوانی ایجاد می کنیم. یک رویکرد کارآمدتر ایجاد یک مشتری و استفاده مجدد از آن در فراخوان‌ها خواهد بود:

public class OrderProcessor implements RequestHandler<APIGatewayProxyRequestEvent, APIGatewayProxyResponseEvent> {
    private static final AmazonDynamoDB dynamoDB = AmazonDynamoDBClientBuilder.standard().build();

    @Override
    public APIGatewayProxyResponseEvent handleRequest(APIGatewayProxyRequestEvent input, Context context) {
        // Process order logic here
        return new APIGatewayProxyResponseEvent().withStatusCode(200).withBody("Order processed");
    }
}

این رویکرد از استفاده مجدد از زمینه اجرای لامبدا بهره می‌برد و به طور بالقوه عملکرد را بهبود می‌بخشد و هزینه‌ها را کاهش می‌دهد.

هنگام کار با معماری های بدون سرور، در نظر گرفتن نحوه مدیریت وضعیت نیز مهم است. توابع بدون سرور معمولاً بدون حالت هستند، بنابراین هر حالتی باید خارجی شود. این اغلب شامل استفاده از سرویس هایی مانند DynamoDB، Redis یا سایر سرویس های پایگاه داده مدیریت شده است.

به عنوان مثال، در اینجا نحوه استفاده از DynamoDB برای ذخیره و بازیابی حالت در یک برنامه Quarkus آورده شده است:

@ApplicationScoped
public class OrderService {
    @Inject
    DynamoDbClient dynamoDB;

    public void saveOrder(Order order) {
        PutItemRequest putItemRequest = PutItemRequest.builder()
            .tableName("Orders")
            .item(Map.of(
                "orderId", AttributeValue.builder().s(order.getId()).build(),
                "customerName", AttributeValue.builder().s(order.getCustomerName()).build(),
                "orderDate", AttributeValue.builder().s(order.getOrderDate().toString()).build()
            ))
            .build();
        dynamoDB.putItem(putItemRequest);
    }

    public Order getOrder(String orderId) {
        GetItemRequest getItemRequest = GetItemRequest.builder()
            .tableName("Orders")
            .key(Map.of("orderId", AttributeValue.builder().s(orderId).build()))
            .build();
        Map<String, AttributeValue> item = dynamoDB.getItem(getItemRequest).item();
        return new Order(
            item.get("orderId").s(),
            item.get("customerName").s(),
            LocalDate.parse(item.get("orderDate").s())
        );
    }
}

این سرویس را می توان به توابع بدون سرور ما تزریق کرد تا عملیات حالت دار را در یک محیط بدون حالت ارائه دهد.

یکی دیگر از جنبه های مهم توسعه بدون سرور، مدیریت خطا و ثبت نام است. از آنجایی که توابع بدون سرور در یک محیط مدیریت شده اجرا می شوند، باید اطمینان حاصل کنیم که خطاها به درستی شناسایی و ثبت می شوند. در اینجا یک مثال با استفاده از عملکرد ابری Spring آورده شده است:

@Component
public class ErrorHandler implements Function<Tuple2<APIGatewayProxyRequestEvent, Context>, APIGatewayProxyResponseEvent> {

    private static final Logger logger = LoggerFactory.getLogger(ErrorHandler.class);

    @Override
    public APIGatewayProxyResponseEvent apply(Tuple2<APIGatewayProxyRequestEvent, Context> input) {
        try {
            // Process the request
            return processRequest(input.getT1(), input.getT2());
        } catch (Exception e) {
            logger.error("Error processing request", e);
            return new APIGatewayProxyResponseEvent()
                .withStatusCode(500)
                .withBody("An error occurred processing your request");
        }
    }

    private APIGatewayProxyResponseEvent processRequest(APIGatewayProxyRequestEvent request, Context context) {
        // Actual request processing logic here
        return new APIGatewayProxyResponseEvent()
            .withStatusCode(200)
            .withBody("Request processed successfully");
    }
}

این رویکرد تضمین می‌کند که همه استثناها شناسایی و ثبت می‌شوند، و از خطاهای کنترل‌نشده جلوگیری می‌کند که عملکرد ما را بی‌صدا از کار بیاندازند.

همانطور که ما برنامه‌های پیچیده‌تر بدون سرور را توسعه می‌دهیم، اغلب نیاز داریم که چندین عملکرد را هماهنگ کنیم. AWS Step Functions یک ابزار عالی برای این کار هنگام کار با AWS Lambda است. در اینجا نمونه‌ای از تعریف ماشین حالت توابع مرحله است که دو تابع لامبدا را هماهنگ می‌کند:

{
  "Comment": "A simple order processing workflow",
  "StartAt": "ProcessOrder",
  "States": {
    "ProcessOrder": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:us-west-2:123456789012:function:ProcessOrder",
      "Next": "SendConfirmation"
    },
    "SendConfirmation": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:us-west-2:123456789012:function:SendConfirmation",
      "End": true
    }
  }
}

این ماشین حالت ابتدا یک تابع ProcessOrder و سپس یک تابع SendConfirmation را فراخوانی می کند. توابع مرحله‌ای، هماهنگ‌سازی را انجام می‌دهد و به ما امکان می‌دهد تا از توابع ساده و متمرکز Lambda، گردش‌های کاری پیچیده بسازیم.

وقتی نوبت به آزمایش برنامه‌های بدون سرور می‌رسد، هر فریم‌ورک مجموعه‌ای از ابزارها و بهترین روش‌ها را ارائه می‌کند. به عنوان مثال، با Quarkus، می‌توانیم از حاشیه‌نویسی @QuarkusTest برای اجرای آزمایش‌ها در یک محیط آزمایشی خاص Quarkus استفاده کنیم:

@QuarkusTest
public class GreetingResourceTest {

    @Test
    public void testHelloEndpoint() {
        given()
          .when().get("/hello")
          .then()
             .statusCode(200)
             .body(is("Hello from Quarkus"));
    }

}

این تست یک نسخه آزمایشی از برنامه Quarkus ما را راه اندازی می کند و درخواستی را به نقطه پایانی /hello ارسال می کند و پاسخ را تأیید می کند.

برای توابع AWS Lambda، می‌توانیم از کتابخانه aws-lambda-java-tests برای شبیه‌سازی فراخوان‌های Lambda استفاده کنیم:

public class LambdaHandlerTest {

    @Test
    public void testHandleRequest() {
        LambdaHandler handler = new LambdaHandler();
        APIGatewayProxyRequestEvent input = new APIGatewayProxyRequestEvent();
        input.setQueryStringParameters(Map.of("name", "John"));
        Context context = new TestContext();
        APIGatewayProxyResponseEvent response = handler.handleRequest(input, context);
        assertEquals(200, response.getStatusCode());
        assertEquals("Hello, John!", response.getBody());
    }
}

این تست یک رویداد و زمینه دروازه API ساختگی ایجاد می کند، تابع Lambda ما را فراخوانی می کند و پاسخ را تأیید می کند.

همانطور که می بینیم، توسعه بدون سرور جاوا یک اکوسیستم غنی از چارچوب ها و ابزارها را ارائه می دهد. هر چارچوبی نقاط قوت خود را دارد و انتخاب اغلب به نیازهای پروژه خاص، تخصص تیم و محیط استقرار هدف بستگی دارد. با استفاده از این چارچوب‌ها و پیروی از بهترین روش‌ها برای توسعه بدون سرور، می‌توانیم اپلیکیشن‌های بومی ابری کارآمد، مقیاس‌پذیر و مقرون‌به‌صرفه ایجاد کنیم.

101 کتاب

101 کتاب یک شرکت انتشاراتی مبتنی بر هوش مصنوعی است که با همکاری نویسنده تأسیس شده است آراو جوشی. با استفاده از فناوری پیشرفته هوش مصنوعی، هزینه‌های انتشارات خود را بسیار پایین نگه می‌داریم—بعضی کتاب‌ها قیمت پایینی دارند. 4 دلار– در دسترس قرار دادن دانش با کیفیت برای همه.

کتاب ما را بررسی کنید کد پاک گلانگ در آمازون موجود است.

منتظر به روز رسانی ها و اخبار هیجان انگیز باشید. هنگام خرید کتاب، جستجو کنید آراو جوشی برای یافتن عناوین بیشتر ما برای لذت بردن از لینک ارائه شده استفاده کنید تخفیف های ویژه!

مخلوقات ما

حتماً خلاقیت های ما را بررسی کنید:

مرکز سرمایه گذار | سرمایه گذار اسپانیایی مرکزی | سرمایه گذار آلمان مرکزی | زندگی هوشمند | دوره ها و پژواک ها | اسرار گیج کننده | هندوتوا | Elite Dev | مدارس JS

ما در حالت متوسط ​​هستیم

بینش کوآلای فنی | دوران و پژواک جهان | سرمایه گذار مرکزی متوسط | رازهای گیج کننده رسانه | رسانه علم و عصر | هندوتوای مدرن