ग्राफकॉइल माइक्रोसर्विस का भविष्य है?

ग्राफकॉल को अक्सर REST की तुलना में वेब APIs को डिजाइन करने के लिए एक क्रांतिकारी तरीके के रूप में प्रस्तुत किया जाता है। हालांकि, अगर आप इन तकनीकों पर करीब से नज़र डालें, तो आप देखेंगे कि उनके बीच बहुत अंतर हैं। ग्राफकॉल एक अपेक्षाकृत नया समाधान है, जिसके स्रोत 2015 में फेसबुक समुदाय के लिए खोले गए थे। आज, REST अभी भी सबसे लोकप्रिय प्रतिमान है जिसका उपयोग माइक्रोसिस्टर्स के बीच एपीआई और इंटरऑपरेबिलिटी प्रदान करने के लिए किया जाता है। क्या ग्राफकाइल्ड भविष्य में REST से आगे निकल पाएगी? आइए देखें कि स्प्रिंग बूट और जीक्यूएल लाइब्रेरी का उपयोग करते हुए ग्राफकॉइन एपीआई के माध्यम से माइक्रोसर्विस इंटरैक्शन कैसे होता है।

आइए अपने सिस्टम के आर्किटेक्चर उदाहरण से शुरू करें। मान लीजिए कि हमारे पास तीन माइक्रोसेरेस हैं जो स्प्रिंग क्लाउड यूरेका अनुप्रयोगों से प्राप्त यूआरएल के माध्यम से एक-दूसरे के साथ संवाद करते हैं।

स्प्रिंग बूट में ग्राफकॉल सपोर्ट को सक्षम करना

हम आसानी से शुरुआत का उपयोग करके स्प्रिंग बूट एप्लिकेशन के सर्वर साइड पर ग्राफकॉल के लिए समर्थन सक्षम कर सकते हैं। ग्राफकल-स्प्रिंग-बूट-स्टार्टर को जोड़ने के बाद, ग्राफक्यूएल सर्वलेट स्वचालित रूप से / ग्राफकल पर उपलब्ध होगा। हम application.yml फ़ाइल में graphql.servlet.mapping संपत्ति निर्दिष्ट करके इस डिफ़ॉल्ट पथ को ओवरराइड कर सकते हैं। हम ग्राफ़िक्विक, लिखने के लिए एक ब्राउज़र-आधारित आईडीई भी शामिल करते हैं, ग्राफकाइक प्रश्नों और ग्राफक्लाइन जावा टूल्स लाइब्रेरी का परीक्षण करते हैं, जिसमें क्वेरीज़ और म्यूटेशन बनाने के लिए उपयोगी घटक होते हैं। इस पुस्तकालय के लिए धन्यवाद, विस्तार के साथ वर्गपथ की सभी फाइलें .graphqls का उपयोग स्कीमा परिभाषा बनाने के लिए किया जाएगा।

compile('com.graphql-java:graphql-spring-boot-starter:5.0.2') compile('com.graphql-java:graphiql-spring-boot-starter:5.0.2') compile('com.graphql-java:graphql-java-tools:5.2.3') 

ग्रापाहिल्का स्कीमा का विवरण

योजना के प्रत्येक विवरण में प्रकारों की घोषणा, उनके बीच संबंध, और कई ऑपरेशन शामिल हैं जो डेटा बनाने, अपडेट करने या हटाने के लिए ऑब्जेक्ट और म्यूटेशन की खोज करने के लिए क्वेरी शामिल करते हैं। हम आमतौर पर उस प्रकार को परिभाषित करके शुरू करते हैं जो वर्णित ऑब्जेक्ट के डोमेन के लिए जिम्मेदार है। आप इंगित कर सकते हैं कि क्या क्षेत्र की आवश्यकता है ! चरित्र या अगर यह एक सरणी है - […] । विवरण में निर्दिष्ट प्रकार या विनिर्देश में उपलब्ध अन्य प्रकारों का संदर्भ होना चाहिए।

 type Employee { id: ID! organizationId: Int! departmentId: Int! name: String! age: Int! position: String! salary: Int! } 

स्कीमा परिभाषा के अगले भाग में प्रश्नों और उत्परिवर्तन की घोषणाएँ हैं। अधिकांश प्रश्न स्कीमा में [कर्मचारी] के रूप में चिह्नित वस्तुओं की सूची लौटाते हैं। EmployeeQueries प्रकार के अंदर, हम सभी खोज विधियों की घोषणा करते हैं, जबकि EmployeeMutations प्रकार में, कर्मचारियों को जोड़ने, अद्यतन करने और हटाने के तरीके। यदि आप किसी विधि के लिए संपूर्ण ऑब्जेक्ट पास करते हैं, तो आपको इसे इनपुट प्रकार के रूप में घोषित करना होगा।

 schema { query: EmployeeQueries mutation: EmployeeMutations } type EmployeeQueries { employees: [Employee] employee(id: ID!): Employee! employeesByOrganization(organizationId: Int!): [Employee] employeesByDepartment(departmentId: Int!): [Employee] } type EmployeeMutations { newEmployee(employee: EmployeeInput!): Employee deleteEmployee(id: ID!) : Boolean updateEmployee(id: ID!, employee: EmployeeInput!): Employee } input EmployeeInput { organizationId: Int departmentId: Int name: String age: Int position: String salary: Int } 

क्वेरी और म्यूटेशन को लागू करना

ग्राफक्लाइन जावा टूल्स और स्प्रिंग बूट ग्राफकॉइन के ऑटो-कॉन्फ़िगरेशन के लिए धन्यवाद, हमें अपने आवेदन में प्रश्नों और उत्परिवर्तन को लागू करने के लिए बहुत प्रयास करने की आवश्यकता नहीं है। EmployeesQuery बीन को ग्राफकाइक्यूलाइजेशन इंसॉलवर इंटरफ़ेस लागू करना चाहिए। इसके आधार पर, स्प्रिंग स्कीमा के अंदर घोषित किए गए ग्राफ़कॉल प्रश्नों में से एक के जवाब के रूप में स्वचालित रूप से सही विधि को खोजने और कॉल करने में सक्षम होगा। यहां प्रश्नों से संबंधित प्रतिक्रियाओं को लागू करने वाला वर्ग है:

 @Component public class EmployeeQueries implements GraphQLQueryResolver { private static final Logger LOGGER = LoggerFactory.getLogger(EmployeeQueries.class); @Autowired EmployeeRepository repository; public List employees() { LOGGER.info("Employees find"); return repository.findAll(); } public List employeesByOrganization(Long organizationId) { LOGGER.info("Employees find: organizationId={}", organizationId); return repository.findByOrganization(organizationId); } public List employeesByDepartment(Long departmentId) { LOGGER.info("Employees find: departmentId={}", departmentId); return repository.findByDepartment(departmentId); } public Employee employee(Long id) { LOGGER.info("Employee find: id={}", id); return repository.findById(id); } } 

यदि आप कॉल करना चाहते हैं, उदाहरण के लिए, कर्मचारी (लंबी आईडी) विधि, तो निम्नलिखित प्रश्न लिखें। अपने एप्लिकेशन में इसका परीक्षण करने के लिए, ग्राफिक्वेल का उपयोग करें, जो कि / ग्रेफिक पर उपलब्ध है।



म्यूटेशन विधियों को लागू करने के लिए ज़िम्मेदार बीन को ग्राफ़क्यूलमुटेशनResolver इंटरफ़ेस को लागू करने की आवश्यकता होती है। EmployeeInput नाम के बावजूद, हम उसी कर्मचारी डोमेन ऑब्जेक्ट का उपयोग करना जारी रखते हैं जो अनुरोध द्वारा वापस किया जाता है।

 @Component public class EmployeeMutations implements GraphQLMutationResolver { private static final Logger LOGGER = LoggerFactory.getLogger(EmployeeQueries.class); @Autowired EmployeeRepository repository; public Employee newEmployee(Employee employee) { LOGGER.info("Employee add: employee={}", employee); return repository.add(employee); } public boolean deleteEmployee(Long id) { LOGGER.info("Employee delete: id={}", id); return repository.delete(id); } public Employee updateEmployee(Long id, Employee employee) { LOGGER.info("Employee update: id={}, employee={}", id, employee); return repository.update(id, employee); } } 

और यहाँ हम म्यूटेशन का परीक्षण करने के लिए ग्राफिंक का उपयोग करते हैं। यहां एक कमांड है जो एक नया कर्मचारी जोड़ता है और कर्मचारी की आईडी और नाम के साथ प्रतिक्रिया को स्वीकार करता है।



इस पर, मैं इस लेख के अनुवाद को रोक देता हूं और अपना "गीतात्मक विषयांतर" लिखता हूं, लेकिन वास्तव में अपोलो क्लाइंट के माध्यम से माइक्रोसर्विस भाग के वर्णन को प्रतिस्थापित करता है, ताकि जीएसएल और यूनीस्ट लाइब्रेरी के माध्यम से बातचीत करने के लिए - HTTP अनुरोधों को निष्पादित करने के लिए पुस्तकालय।

Groovy पर GraphQL ग्राहक।

विभाग-सेवारत माइक्रोसिस्ट सेवा में ग्राफकॉल क्वेश्चन बनाने के लिए, मैं क्वेरी बिल्डरों का उपयोग करूंगा:

 String queryString = DSL.buildQuery { query('employeesByDepartment', [departmentId: departmentId]) { returns { id name position salary } } } 

DSL GQL पर यह निर्माण प्रपत्र की एक क्वेरी बनाता है:

 { employeesByDepartment (departmentId: 1) { id name position salary } } 

और, आगे, मैं विधि से पारित पते पर एक HTTP अनुरोध करूंगा।
हम यह पता लगाएंगे कि अनुरोध का पता आगे कैसे बनता है।

 (Unirest.post(serverUrl) .body(JsonOutput.toJson([query: queryString])) .asJson() .body.jsonObject['data']['employeesByDepartment'] as List) .collect { JsonUtils.jsonToData(it.toString(), Employee.class) } 

प्रतिक्रिया प्राप्त करने के बाद, हम इसे JSONObject से कर्मचारी सूची दृश्य में बदल देते हैं।

कर्मचारी microservice के लिए GrpahQL ग्राहक

Microservice कर्मचारियों के कार्यान्वयन पर विचार करें। इस उदाहरण में, मैंने सीधे यूरेका क्लाइंट का उपयोग किया। eurekaClient को कर्मचारी-सेवा के रूप में पंजीकृत सभी रनिंग सर्विस इंस्टेंसेस मिलते हैं। फिर वह बेतरतीब ढंग से पंजीकृत लोगों (2) से कुछ उदाहरण का चयन करता है। इसके बाद, यह अपना पोर्ट नंबर लेता है और अनुरोध पता (3) बनाता है और इसे EmployeeGQL ऑब्जेक्ट के पास देता है जो ग्रूवी पर ग्राफक्यूएल क्लाइंट है और जिसे पिछले पैराग्राफ में वर्णित किया गया है।

 @Component public class EmployeeClient { private static final Logger LOGGER = LoggerFactory.getLogger(EmployeeClient.class); private static final String SERVICE_NAME = "EMPLOYEE-SERVICE"; private static final String SERVER_URL = "http://localhost:%d/graphql"; Random r = new Random(); @Autowired private EurekaClient discoveryClient; // (1) public List<Employee> findByDepartment(Long departmentId) { Application app = discoveryClient.getApplication(SERVICE_NAME); InstanceInfo ii = app.getInstances().get(r.nextInt(app.size())); // (2) String serverUrl = String.format(SERVER_URL, ii.getPort()); // (3) EmployeeGQL clientGQL = new EmployeeGQL(); return clientGQL.getEmployeesByDepartmentQuery(serverUrl, departmentId.intValue()); // (4) } } 

इसके अलावा, मैं लेखक को फिर से "पास" करता हूं, या फिर मैं उसके लेख का अनुवाद जारी रखता हूं।

अंत में, EmployeeClient को एक वर्ग में इंजेक्ट किया जाता है जो विभाग के अनुरोधों का जवाब देता है और इसका उपयोग विभागों के अंदर किया जाता है।

 public List<Department> departmentsByOrganizationWithEmployees(Long organizationId) { LOGGER.info("Departments find: organizationId={}", organizationId); List<Department> departments = repository.findByOrganization(organizationId); for (int i = 0; i < departments.size(); i++) { departments.get(i).setEmployees(employeeClient.findByDepartment(departments.get(i).getId())); } return departments; } 

आवश्यक अनुरोध करने से पहले, हमें विभाग-सेवा के लिए बनाए गए आरेख पर एक नज़र डालनी चाहिए। प्रत्येक विभाग ऑब्जेक्ट में असाइन किए गए कर्मचारियों की एक सूची हो सकती है, और हमने विभाग प्रकार द्वारा संदर्भित कर्मचारी प्रकार को भी परिभाषित किया है।

 schema { query: DepartmentQueries mutation: DepartmentMutations } type DepartmentQueries { departments: [Department] department(id: ID!): Department! departmentsByOrganization(organizationId: Int!): [Department] departmentsByOrganizationWithEmployees(organizationId: Int!): [Department] } type DepartmentMutations { newDepartment(department: DepartmentInput!): Department deleteDepartment(id: ID!) : Boolean updateDepartment(id: ID!, department: DepartmentInput!): Department } input DepartmentInput { organizationId: Int! name: String! } type Department { id: ID! organizationId: Int! name: String! employees: [Employee] } type Employee { id: ID! name: String! position: String! salary: Int! } 

अब हम अपनी परीक्षा की क्वेरी को ग्राफीक्यूएल का उपयोग करके आवश्यक फ़ील्ड की सूची के साथ कह सकते हैं। विभाग-सेवा आवेदन डिफ़ॉल्ट रूप से पोर्ट 8091 पर उपलब्ध है, अर्थात् , हम इसे http: // localhost: 8091 / graphiql पर देख सकते हैं

निष्कर्ष

शायद रेखाकन मानक REST API का एक दिलचस्प विकल्प हो सकता है। हालाँकि, हमें इसे REST के प्रतिस्थापन के रूप में नहीं समझना चाहिए। ऐसे कई मामले हैं जहां ग्राफकॉल सबसे अच्छा विकल्प हो सकता है, लेकिन वे जहां REST सबसे अच्छा विकल्प है। यदि आपके क्लाइंट को सर्वर साइड से सभी फ़ील्ड्स वापस करने की आवश्यकता नहीं है, और इसके अलावा आपके पास एक प्रविष्टि बिंदु के लिए विभिन्न आवश्यकताओं वाले कई क्लाइंट हैं, तो ग्राफकॉल एक अच्छा विकल्प है। यदि आप देखते हैं कि माइक्रोसर्विस समुदाय में क्या है, तो आप देख सकते हैं कि अब कोई जावा-आधारित समाधान नहीं है जो आपको सर्विस डिस्कवरी, बैलेंसर या बॉक्स के बाहर गेटवे एपीआई के साथ मिलकर ग्राफकॉल का उपयोग करने की अनुमति देता है। इस लेख में, मैंने माइक्रोक्रेगर संचार के लिए स्प्रिंग क्लाउड यूरेका के साथ एक ग्राफक्यूएल क्लाइंट बनाने के लिए जीक्यूएल और यूनेस्ट का उपयोग करने का एक उदाहरण दिखाया। GitHub github.com/piomin/sample-graphql-microservices.git पर अंग्रेजी में एक लेख के लेखक के लिए नमूना कोड।

GQL लाइब्रेरी के साथ मेरा एक उदाहरण : github.com/lynx-r/sample-graphql-microservices