बैकएंड के लिए कोड जनरेशन। क्या, कैसे और क्यों उत्पन्न करना है?

इस लेख में मैं यह बताना चाहता हूं कि हमारी कंपनी में एक बैकएंड (और फ्रंट-एंड का एक सा) कोड कैसे तैयार किया गया है, इसकी आवश्यकता क्यों है और इसे बेहतर कैसे करना है।

वास्तव में हम जो उत्पन्न करेंगे वह इतना महत्वपूर्ण नहीं है।
यह महत्वपूर्ण है कि हम 3 प्रकार की वस्तुओं का वर्णन करें, जिसके आधार पर हम बैकएंड के साथ फ्रंटेंड इंटरैक्शन उत्पन्न करेंगे, और कुछ स्थानों पर बैकएंड कार्यान्वयन पूरी तरह से होगा

इस प्रकार की वस्तुएँ:
1. संदेश - वस्तुएं, जो JSON में क्रमबद्ध की जा रही हैं, फ्रंटएंड और बैकएंड के बीच सूचनाओं के आदान-प्रदान में भाग लेती हैं
2. समापन बिंदु - URI जो HTTP विधि, अनुरोध पैरामीटर, अनुरोध बॉडी टाइप और रिस्पोंडर प्रकार के विवरण के साथ फ्रंट-एंड कॉल करता है
3. एंटिटीज - ये ऐसे मैसेज हैं जिनके लिए उनके पास Create / Update / List / Delete (शायद सभी के लिए नहीं) के मानक मानक हैं, वे डेटाबेस में स्टोर किए जाते हैं और उनके लिए डेटा एक्सेस ऑब्जेक्ट या स्प्रिंग JPA रिपॉजिटरी है - आम तौर पर निर्भर करता है प्रौद्योगिकी, लेकिन डेटाबेस तक किसी प्रकार की पहुंच

मैं आगे का अंत नहीं करता, लेकिन
1) मुझे पता है कि यह टाइपस्क्रिप्ट में लिखा है, इसलिए हम टाइपस्क्रिप्ट कक्षाएं भी बनाते हैं
2) बैकएंड डेवलपर्स में से अधिकांश बैकएंड की आवश्यकताएं हैं।

कोड आवश्यकताओं

तो, सामने के छोर से क्या आवश्यकताएं हैं?

1. REST- जैसे इंटरैक्शन इंटरफ़ेस
2. नीरस प्रतिक्रियाएं - json, 'डेटा' फ़ील्ड में पेलोड
3. नीरस त्रुटियां यदि बैकएंड पर कोई अपवाद हुआ, तो स्टैक ट्रेस भी जोड़ना उचित है
4. "सही" HTTP कोड - 404 यदि पुस्तक नहीं मिली है, तो 400 यदि अनुरोध खराब है (कहते हैं, वैध जंज़ नहीं), आदि।

मैं "अपने दम पर" बैकएंड कोड के लिए आवश्यकताओं को जोड़ूंगा:
1. एक जगह पर हैंडलिंग में त्रुटि
2. कोड में कहीं भी प्रवाह को रोकने और वांछित HTTP कोड वापस करने की क्षमता
3. मैं उपयोग किए गए पुस्तकालयों के आधार पर कुछ व्यावसायिक तर्क को अवरुद्ध करने के रूप में लिखना चाहता हूं, और कुछ को अतुल्यकालिक के रूप में। लेकिन यह सब एक अतुल्यकालिक ढांचे में काम करना चाहिए
4. यह सलाह दी जाती है कि बैकएंड डेवलपर्स HTTP अनुरोधों और प्रतिक्रियाओं के बारे में बिल्कुल नहीं सोचते हैं, वर्टेक्स मार्गों और इवेंट बेस के बारे में, लेकिन बस अपने व्यापार तर्क को लिखते हैं।

उपरोक्त सभी आवश्यकताओं को विरासत और संरचना के साथ लागू करना उचित है, और केवल जहां यह विफल रहता है, कोड पीढ़ी का उपयोग करें

टाइपस्क्रिप्ट और कोटलिन के लिए समानांतर में कक्षाएं उत्पन्न करने की भी सलाह दी जाती है ताकि सामने वाला हमेशा बैकएंड भेजता है कि क्या जरूरत है (और डेवलपर्स पर भरोसा न करें कि वे कक्षा में एक नया क्षेत्र जोड़ना नहीं भूलेंगे)

हम क्या पैदा करेंगे

उदाहरण के लिए, एक काल्पनिक वेब एप्लिकेशन लें जो पुस्तकों को सहेज और संपादित कर सकता है, उनकी सूची प्रदर्शित कर सकता है और नाम से खोज सकता है।

प्रौद्योगिकी के संदर्भ में, कोटलिन बैकएंड, वर्ट.एक्स, कोरटाइन। कुछ ऐसा जैसा मैंने लेख में दिखाया "वर्टेक्स में अतुल्यकालिक प्रोग्रामिंग के तीन प्रतिमान"

इसे और दिलचस्प बनाने के लिए, हम स्प्रिंग डेटा जेपीए के आधार पर डेटाबेस तक पहुंच बनाएंगे।
मैं यह नहीं कह रहा हूं कि आपको एक परियोजना में स्प्रिंग और वर्ट.एक्स को मिलाना होगा (हालांकि मैं इसे स्वयं करता हूं, मैं मानता हूं), लेकिन मैं बस वसंत लेता हूं क्योंकि एंटिटी के आधार पर पीढ़ी को दिखाना उसके लिए सबसे आसान है।

पीढ़ी के साथ परियोजना संरचना

अब आपको पीढ़ी के लिए एक परियोजना बनाने की आवश्यकता है।
हमारे पास कई ग्रेडल प्रोजेक्ट होंगे। अब मैं उन्हें एक गित भंडार में बनाऊंगा, लेकिन वास्तविक जीवन में सभी को अपने आप में बैठना चाहिए, क्योंकि वे अलग-अलग समय पर बदल जाएंगे, उनके अपने संस्करण होंगे।

तो, पहली परियोजना एनोटेशन वाली एक परियोजना है जो हमारे राउटर, HTTP तरीकों आदि को इंगित करेगी। इसे मेटेनफो कहें
दो अन्य परियोजनाएं इस पर निर्भर हैं:
कोडजेन और एपी

एपि में राउटर और मैसेज का वर्णन होता है - वे क्लासेस जो बैकएंड और फ्रंटेंड के बीच आगे और पीछे जाएंगे
कोडजेन एक कोड जेनरेशन प्रोजेक्ट है (लेकिन ऐसा प्रोजेक्ट नहीं जिसमें कोड जेनरेट हो!) - इसमें एपीआई क्लासेस और वास्तविक कोड जेनरेटर्स से मिली जानकारी का संग्रह होता है।
जनरेटर को तर्कों में पीढ़ी के सभी विवरण प्राप्त होंगे - किस पैकेज से राउटर का विवरण लेना है, किस निर्देशिका को उत्पन्न करना है, पीढ़ी के लिए वेग टेम्पलेट का क्या नाम है - अर्थात्। metainfo और कोडजेन आमतौर पर पूरी तरह से विभिन्न परियोजनाओं में इस्तेमाल किया जा सकता है

खैर, दो परियोजनाएँ जिनमें वास्तव में उत्पादन किया जाएगा:
फ्रंटएंड-जनरेट जिसमें हम टाइपस्क्रिप्ट क्लास को जेनरेट करेंगे जो हमारे कोटलिन संदेशों के अनुरूप है
और बैकएंड - वास्तविक वर्टेक्स एप्लिकेशन के साथ।

एक परियोजना के लिए दूसरे को संकलित करने के परिणाम को देखने के लिए, हम स्थानीय मावेन भंडार में कलाकृतियों को प्रकाशित करने के लिए प्लगइन का उपयोग करेंगे।

मेटाफ़िनो प्रोजेक्ट :

एनोटेशन जिसके साथ हम पीढ़ी के स्रोतों को चिह्नित करेंगे - एंडपेंस, संदेश, संस्थाओं का विवरण:

/* Contains a number of endpoints. We will generate Vert.x router or Spring MVC controller from it*/ annotation class EndpointController(val url:String) /* Endpoint inside a controller. Concrete URI and HTTP method. May be has query param */ annotation class Endpoint(val method: HttpMethodName, val param: String = "") /* For empty constructor generation */ annotation class EmptyConstructorMessage /* Make abstract implementation method for endpoint logic asynchronous */ annotation class AsyncHandler /* All the next annotations are for Entities only:*/ annotation class GenerateCreate annotation class GenerateUpdate annotation class GenerateGetById annotation class GenerateList annotation class GenerateDelete /* Make CRUD implementation abstract, so that we will override it*/ annotation class AbstractImplementation /* Generate search by this field in DAO layer */ annotation class FindBy /* This entity is child of another entity, so generate end point like /parent/$id/child to bring all children of concrete parent instead of /child - bring all entities of this type */ annotation class ChildOf(vararg val parents: KClass<*>) enum class HttpMethodName { POST,PUT,GET,DELETE } 

टाइपस्क्रिप्ट क्लासेस के लिए, हम उन एनोटेशन को परिभाषित करेंगे जो खेतों पर लटकाए जा सकते हैं और जो जेनरेट किए गए टाइपस्क्रिप्ट क्लास में आएंगे

 annotation class IsString annotation class IsEmail annotation class IsBoolean annotation class MaxLength(val len:Int) 

मेटेनॉफ परियोजना का स्रोत कोड

आपी परियोजना:

No.rg और jpa plugins को build.gradle में नोट करें, जिसमें कोई तर्क नहीं है

मेरे पास पर्याप्त फंतासी नहीं है, इसलिए हम अपने आवेदन के लिए नियंत्रकों और संस्थाओं के कुछ पागल विवरण तैयार करेंगे:

 @EndpointController("/util") interface SearchRouter { @Endpoint(HttpMethodName.GET, param = "id") fun search(id: String): String @Endpoint(method = HttpMethodName.POST) @AsyncHandler fun search(searchRequest: SearchRequest) // we have no check or response type } data class SearchRequest( @field:IsString val author: String?, @field:IsEmail val someEmail: String, @field:IsString val title: String? ) @GenerateList @GenerateGetById @GenerateUpdate @Entity @AbstractImplementation data class Book( @Id @GeneratedValue(strategy = GenerationType.IDENTITY) var id: Long?, @field:IsBoolean @Column(name = "is_deleted") var hardcover: Boolean, @field:IsString @field:MaxLength(128) @Column(nullable = false, length = 128) val title: String, @field:IsString @field:MaxLength(128) @Column(nullable = false, length = 255) val author: String ) @GenerateList @GenerateGetById @GenerateUpdate @GenerateDelete @GenerateCreate @Entity @ChildOf(Book::class) data class Chapter( @Id @GeneratedValue(strategy = GenerationType.IDENTITY) var id: Long?, @Column(nullable = false, name = "book_id") var bookId: Long?, @field:IsString @field:MaxLength(128) @Column(nullable = false, length = 128) @field:FindBy val name: String, @Column(nullable = false) val page:Int ) 

आपी परियोजना स्रोत कोड

कोडगन प्रोजेक्ट:

पहले हम "डिस्क्रिप्टर" को परिभाषित करते हैं - उन वर्गों को, जिन्हें हम अपने एपीआई प्रोजेक्ट पर प्रतिबिंब के माध्यम से भरेंगे:

 data class EndPoint( val url: String, val input: String?, val param: String?, val output: String, val method: String, val handler: String, val asyncHandler: Boolean ) data class Router(val name: String, val url: String, val endpoints: List<EndPoint>) class Entity( name: String, val parents: List<String>, val abstractVerticle: Boolean, val crudFeatures: CrudFeatures, fields: List<Field>, var children: List<Entity> ) : Message(name, fields) { fun shouldGenerateRouterAndVerticle(): Boolean { return crudFeatures.generateRouterAndVerticle() } override fun toString(): String { return "Entity(parents=$parents, abstractVerticle=$abstractVerticle, crudFeatures=$crudFeatures, children=$children)" } } data class CrudFeatures( val list: Boolean, val create: Boolean, val update: Boolean, val delete: Boolean, val get: Boolean ) { fun generateRouterAndVerticle(): Boolean { return list || create || update || delete || get } } open class Message(val name: String, val fields: List<Field>) data class Field(val name: String, val type: String, val validators: List<Annotation>, val findBy: Boolean) 

जानकारी एकत्रित करने वाला कोड इस तरह दिखता है:

 class EntitiesCreator(typeMapper: TypeMapper, frontendAnnoPackage:String) { private val messagesDescriptor = MessagesCreator(typeMapper, frontendAnnoPackage) fun createEntities(entitiesPackage: String): List<Entity> { val reflections = Reflections(entitiesPackage, SubTypesScanner(false)) val types = reflections.getSubTypesOf(Object::class.java) return types.map { createEntity(it) } } fun createEntityRestEndpoints(entity: Entity): List<EndPoint> { val name = entity.name val url = name.toLowerCase() val endpoints: MutableList<EndPoint> = mutableListOf() if (entity.crudFeatures.create) { endpoints.add( EndPoint(url, name, null, name, "post", "handleNew$name", false) ) } if (entity.crudFeatures.get) { endpoints.add( EndPoint( "$url/:id", null, "id", name, "get", "handleGet$name", false ) ) } if (entity.crudFeatures.update) { endpoints.add( EndPoint(url, name, null, name, "put", "handleUpdate$name", false) ) } if (entity.crudFeatures.delete) { endpoints.add( EndPoint( "$url/:id", null, "id", "", "delete", "handleDelete$name", false ) ) } if (entity.crudFeatures.list) { if (entity.parents.isEmpty()) { endpoints.add( EndPoint( url, null, null, "List<$name>", "get", "handleGetAllFor$name", false ) ) } } entity.children.forEach { endpoints.add( EndPoint( "$url/:id/${it.name.toLowerCase()}", null, "id", "List<$name>", "get", "handleGet${it.name}For$name", false ) ) } return endpoints } private fun createEntity(aClass: Class<*>): Entity { return Entity( aClass.simpleName, getParents(aClass), isVerticleAbstract(aClass), shouldGenerateCrud(aClass), messagesDescriptor.createFields(aClass), listOf() ) } private fun isVerticleAbstract(aClass: Class<*>): Boolean { return aClass.getDeclaredAnnotation(AbstractImplementation::class.java) != null } private fun getParents(aClass: Class<*>): List<String> { return aClass.getDeclaredAnnotation(ChildOf::class.java)?.parents?.map { it.simpleName }?.requireNoNulls() ?: listOf() } private fun shouldGenerateCrud(aClass: Class<*>): CrudFeatures { val listAnno = aClass.getDeclaredAnnotation(GenerateList::class.java) val createAnno = aClass.getDeclaredAnnotation(GenerateCreate::class.java) val getAnno = aClass.getDeclaredAnnotation(GenerateGetById::class.java) val updateAnno = aClass.getDeclaredAnnotation(GenerateUpdate::class.java) val deleteAnno = aClass.getDeclaredAnnotation(GenerateDelete::class.java) return CrudFeatures( list = listAnno != null, create = createAnno != null, update = updateAnno != null, delete = deleteAnno != null, get = getAnno != null ) } } class MessagesCreator(private val typeMapper: TypeMapper, private val frontendAnnotationsPackageName: String) { fun createMessages(packageName: String): List<Message> { val reflections = Reflections(packageName, SubTypesScanner(false)) return reflections.allTypes.map { Class.forName(it) }.map { createMessages(it) } } private fun createMessages(aClass: Class<*>): Message { return Message(aClass.simpleName, createFields(aClass)) } fun createFields(aClass: Class<*>): List<Field> { return ReflectionUtils.getAllFields(aClass).map { createField(it) } } private fun createField(field: java.lang.reflect.Field): Field { val annotations = field.declaredAnnotations return Field( field.name, typeMapper.map(field.type), createConstraints(annotations), annotations.map { anno -> anno::annotationClass.get() }.contains(FindBy::class) ) } private fun createConstraints(annotations: Array<out Annotation>): List<Annotation> { return annotations.filter { it.toString().startsWith("@$frontendAnnotationsPackageName") } } } class RoutersCreator(private val typeMapper: TypeMapper, private val endpointsPackage:String ) { fun createRouters(): List<Router> { val reflections = Reflections(endpointsPackage, SubTypesScanner(false)) return reflections.allTypes.map { createRouter( Class.forName( it ) ) } } private fun createRouter(aClass: Class<*>): Router { return Router(aClass.simpleName, getUrl(aClass), ReflectionUtils.getAllMethods(aClass).map { createEndpoint(it) }) } private fun getUrl(aClass: Class<*>): String { return aClass.getAnnotation(EndpointController::class.java).url } private fun getEndPointMethodName(declaredAnnotation: Endpoint?): String { val httpMethodName = declaredAnnotation?.method return (httpMethodName ?: HttpMethodName.GET).name.toLowerCase() } private fun getParamName(declaredAnnotation: Endpoint?): String { val paramName = declaredAnnotation?.param return (paramName ?: "id") } private fun createEndpoint(method: Method): EndPoint { val types = method.parameterTypes val declaredAnnotation: Endpoint? = method.getDeclaredAnnotation(Endpoint::class.java) val methodName = getEndPointMethodName(declaredAnnotation) var url = method.name var input: String? = null var param: String? = null val hasInput = types.isNotEmpty() val handlerName = "$methodName${StringUtils.capitalize(url)}" if (hasInput) { val inputType = types[0] val inputTypeName = typeMapper.map(inputType) val createUrlParameterName = inputType == java.lang.String::class.java if (createUrlParameterName) { param = getParamName(declaredAnnotation) url += "/:$param" } else { input = simpleName(inputTypeName) } } return EndPoint( url, input, param, method.returnType.toString(), methodName, handlerName, isHandlerAsync(method) ) } private fun isHandlerAsync(method: Method): Boolean { val declaredAnnotation: AsyncHandler? = method.getDeclaredAnnotation(AsyncHandler::class.java) return declaredAnnotation != null } private fun simpleName(name: String): String { val index = name.lastIndexOf(".") return if (index >= 0) name.substring(index + 1) else name } } 

खैर, "मुख्य" वर्ग भी हैं जो तर्क प्राप्त करते हैं - कौन से पैकेज पर प्रतिबिंबित किया जाना चाहिए, जो उपयोग करने के लिए वेग टेम्पलेट आदि।
वे इतनी रुचि नहीं हैं, आप भंडार में सब कुछ देख सकते हैं: स्रोत कोड

फ्रंटएंड-जनरेट और बैकएंड प्रोजेक्ट में, हम इसी तरह की चीजें करते हैं:
1. संकलन के समय एपी पर निर्भरता
2. बिल्ड स्टेज पर कोडजेन पर निर्भरता
3. जेनरेशन टेम्प्लेट बिल्डस्क आर्क डायरेक्टरी में स्थित होते हैं, जिसमें फाइल और कोड को ग्रेडल की जरूरत होती है, जिसकी जरूरत बिल्ड स्टेज पर होती है, लेकिन कंपटीशन या रनटाइम स्टेज पर नहीं। यानी हम कोडेन परियोजना को फिर से शुरू किए बिना पीढ़ी के पैटर्न को बदल सकते हैं
4. दृश्य -उत्पन्न जनरेट किए गए टाइपस्क्रिप्ट को संकलित करता है और इसे npm पैकेज रिपॉजिटरी में प्रकाशित करता है
5. बैकएंड में , राउटर उत्पन्न होते हैं जो एक गैर-जेनरेट किए गए सार राउटर से विरासत में मिलते हैं जो विभिन्न प्रकार के अनुरोधों को संभालना जानता है। सार वर्टिकल्स भी उत्पन्न होते हैं जो व्यापार तर्क के कार्यान्वयन के साथ विरासत में प्राप्त होने चाहिए। इसके अलावा, सभी प्रकार की छोटी चीजें उत्पन्न होती हैं जो मैं एक प्रोग्रामर के रूप में सोचना नहीं चाहता हूं - घटना के बास में कोडेक्स और एड्रेस कांस्टेंट को पंजीकृत करना।
स्रोत कोड दृश्य-उत्पन्न और बैकएंड

फ्रंटएंड-जनरेट में, आपको उस प्लगइन पर ध्यान देने की आवश्यकता है जो उत्पन्न हुए स्रोतों को npm रिपॉजिटरी में प्रकाशित करता है। इस काम के लिए, आपको अपनी रिपॉजिटरी का IP build.gradle में डालना होगा और अपना प्रमाणीकरण टोकन inpmpmrc पर रखना होगा।

उत्पन्न वर्ग इस तरह दिखते हैं:

 import { IsString, MaxLength, IsDate, IsArray, } from 'class-validator'; import { Type } from 'class-transformer'; // Entity(parents=[], abstractVerticle=false, crudFeatures=CrudFeatures(list=true, create=true, update=true, delete=true, get=true), children=[]) export class Chapter { // Field(name=bookId, type=number, validators=[], findBy=false) bookId!: number; @IsString() @MaxLength(128) // Field(name=name, type=string, validators=[@com.valapay.test.annotations.frontend.IsString(), @com.valapay.test.annotations.frontend.MaxLength(len=128)], findBy=false) name!: string; // Field(name=id, type=number, validators=[], findBy=false) id!: number; // Field(name=page, type=number, validators=[], findBy=false) page!: number; } 

वर्ग-सत्यापनकर्ता एनोटेशन tc पर ध्यान दें।

बैकएंड प्रोजेक्ट में, स्प्रिंग डेटा जेपीए के लिए रिपॉजिटरी भी उत्पन्न होती हैं, यह कहना संभव है कि वर्टिकल में संदेश प्रसंस्करण परियोजना अवरुद्ध है (और वर्टेक्सएक्सूट्यूटब्लॉकिंग के माध्यम से) या असिंक्रोनस (कोरआउट्स के साथ), यह कहना संभव है कि एंटिटी के लिए उत्पन्न वर्टिकल सार है और फिर एक संभावना है। ओवरराइड हुक जो उत्पन्न तरीकों को कॉल करने से पहले और बाद में कहा जाता है। वर्टिकल्स की तैनाती वसंत फलियों के इंटरफेस पर स्वचालित है - ठीक है, संक्षेप में, बहुत सारे उपहार।

और यह सब विस्तार करना आसान है - उदाहरण के लिए, एंडपॉइंट पर भूमिकाओं की एक सूची को लटका देना और एंडपॉइंट को कॉल करते समय लॉग-इन उपयोगकर्ता की भूमिका का एक चेक उत्पन्न करना और बहुत कुछ - इसके लिए पर्याप्त है।

यह भी आसान है कि वर्टैक्स उत्पन्न न करें, न कि स्प्रिंग, बल्कि कुछ और - यहां तक ​​कि अक्का-http भी, यह बैकएंड प्रोजेक्ट में केवल टेम्प्लेट बदलने के लिए पर्याप्त है।

एक और संभावित विकास दिशा अधिक फ्रंट-एंड उत्पन्न करना है।

सभी स्रोत कोड यहाँ है ।

हमारी परियोजना में पीढ़ी बनाने और लेख लिखने में मदद के लिए फ्रंट-एंड से इलदार का धन्यवाद