Java

თუ @KafkaListener-ის ნაცვლად გამჭვირვალე polling-ს გამოიყენებთ, რა დაკარგავთ და რა მოგეთხოვებათ?

შერჩეული გადაწყვეტილების სტრუქტურის ძირითადი პრობლემა რა არის? - ტიპის მკაცრი დაკავშირება, დაბალი მოქნილობა - ელემენტების დამუშავების დროს პოლიმორფიზმის დარღვევა - WardrobeItem-ისთვის ფაბრიკის მეთოდი არ არსებობს - ახალი ოპტიმიზატორებისთვის ადაპტერის ნიმუში არ არსებობს - ოპტიმიზაციის პროცესში მაღალი ხარჯის ოპერაციები

ეს Dockerfile-ის მაგალითის ძირითადი პრობლემა არის FROM golang:1.16 WORKDIR /app COPY go.mod . COPY go.sum . RUN go mod download COPY . . RUN go build -o crashAnalysis . CMD ["./crashAnalysis"] EXPOSE 9090 - კონფიგურაციისთვის ENV არ არის - მრავალსაფეხურიანი ბილდები არ არის - დროებითი ფაილები არასდროს იწმინდება - RUN-ის ოპტიმალური გამოყენება არ არის - პორტი 8081 არ არის მითითებული EXPOSE ბრძანებაში

კოდის ძირითადი არასათანადო ქცევის მიზეზი რა არის? ობჯექტების უცვლელობა დარღვეულია შეწყვეტის მდგომარეობა არ არის მართვადი შეკავების ობიექტების კონფლიქტი იწვევს deadlock-ს რესურსების ზედმეტად სინქრონიზაცია ობჯექტების საწყისი მდგომარეობები არ არის ინიციალიზებულიimport java.util.concurrent.*; class Competition { private final Object lock = new Object(); public void syncMethodA(Competition competitor) { synchronized (lock) { try { Thread.sleep(100); } catch (InterruptedException e) {} competitor.syncMethodB(this); } } public void syncMethodB(Competition competitor) { synchronized (lock) { try { Thread.sleep(100); } catch (InterruptedException e) {} competitor.syncMethodA(this); } } } public class FitnessApp { public static void main(String[] args) { Competition comp1 = new Competition(); Competition comp2 = new Competition(); Thread t1 = new Thread(() -> comp1.syncMethodA(comp2)); Thread t2 = new Thread(() -> comp2.syncMethodB(comp1)); t1.start(); t2.start(); } }

რა დაბრუნდება მწარმოებელზე, თუ ის უკვე რამდენიმე ხნის წინ გაგზავნილი ID-ს აგზავნის (6 საათიანი იდემპოტენციის პერიოდი)?

რა არის ძირითადი მიზეზი კოდის არასწორი ქცევის უცვლელი რუკის გამოყენებისას? მინდვრები, რომლებიც არ არის "მხოლოდ წაკითხვა", შეიძლება შეიცვალოს HashMap არ ინახავს ელემენტების წესს მეტი შრიფტების გამოყენება იწვევს დაბნეულობას "უცვლელი" რუკა ასახავს თავდაპირველი რუკის ცვლილებებს ობიექტის არასწორი გამოყენება იწვევს შეცდომას

საერთო ჯამში როგორ გექნებათ DevOps ტექნოლოგიებთან — Kubernetes, CI/CD და სხვა?

როგორ უნდა განსაზღვროს აპლიკაციამ, რომელ გამოცდაზე არსებობს Kafka კავშირები და თემები? როგორ განახორციელოთ Kafka-ის ჯანმრთელობის შემოწმება?

რატომ არ არის იქ განცხადებები? რატომ არ ახორციელებს განცხადების კომპილაციას ბაზაზე?

იდემპოტენტური გაგზავნის დროს Kafka-ზე რა დამატებითი დატვირთვაა? ამ შემთხვევაში Kafka რა გამოიწვევს?

ამ განხორციელების ძირითადი პრობლემა რა არის? - ოპტიმიზაციისთვის მეხსიერების კეში არ გამოიყენება. - ერთ ჰეშში სხვადასხვა ტიპის მონაცემთა შენახვა - მონაცემების წაკითხვის წინ გამორთვის შემოწმება შედეგს არ იძლევა - `RedisTemplate`-ში სტანდარტული სერილიზატორების არარსებობა - ნაწილობრივი ოპერაციებისათვის პაიპლაინი არ გამოიყენება

თქვით კაფკაში იდემპოტენტური გაგზავნა ან Exactly-Once. რომელს იყენებდი?

თუ ჩვენ იგივე გავაკეთოთ DataSource-თან, რა უნდა გავაკეთოთ?

DLT მომხმარებელი იმავე სერვისში იყო, რაც ძირითადი? რატომ უნდა გავუსმინოთ მას ისევ და დავრეგისტრიროთ?

როგორ შევამოწმოთ, რომ თემა ცოცხალია და მას აქვს საჭირო რაოდენობის პარტიციები, და რომ მინიმუმ ერთი ლიდერი აქვს პარტიციაში?

როდესაც აკეთებ ჩვეულებრივ SELECT-ს, რამდენი შეკითხვა აგზავნის დრაივერი Postgres-კი? რა შეკითხვები და რა იქნება იქ?

ჩვენ უნდა დავიჭიროთ ყველა მოთხოვნა Kafka-ში და გადავცეთ აუდიტის ან ტელემეტრიის სისტემას. როგორ გააკეთებდი ამას?

თუ გვაქვს გარე API, რომელიც მაქსიმუმ 10 ერთდროულ კავშირს იძლევა, რომელ კლასს გამოიყენებდით java.util.concurrent პაკეტიდან პარალელური ზარების რაოდენობის შეზღუდვისთვის?

HTTP რა ტრანსპორტის ფენაზე მუშაობს?

გააზიარე შენი ბოლო სამუშაო ადგილის შესაბამისი გამოცდილება — რა მოგეწონა, რა არა?