ஜாவா வகுப்புகளைத் தொகுத்து சோதிக்க மேவன் வார்ப்புரு இயந்திரத்தை எவ்வாறு பயன்படுத்துவது

மேவன் வார்ப்புரு இயந்திரத்தால் உருவாக்கப்பட்ட ஜாவா குறியீட்டின் துல்லியத்தை உறுதி செய்கிறது

குறியீடு தலைமுறையை தானியக்கமாக்குவது உற்பத்தித்திறனை கணிசமாக மேம்படுத்தலாம், குறிப்பாக மீண்டும் மீண்டும் கட்டமைப்புகளைக் கையாளும் போது. ஒரு மேவன் திட்டத்தில், போன்ற ஒரு வார்ப்புரு இயந்திரத்தைப் பயன்படுத்துதல் அப்பாச்சி ஃப்ரீமார்க்கர் JSON கோப்புகள் போன்ற பயனர் உள்ளீட்டு தரவின் அடிப்படையில் ஜாவா வகுப்புகளை மாறும் வகையில் உருவாக்க டெவலப்பர்கள் அனுமதிக்கிறது. இருப்பினும், இந்த உருவாக்கப்பட்ட வகுப்புகளின் துல்லியம் மற்றும் நம்பகத்தன்மையை உறுதி செய்வது வளர்ச்சி சுழற்சியில் ஒரு முக்கியமான படியாகும். .

இந்த சூழலில், உங்கள் திட்டம் a ஐக் கொண்டுள்ளது பெற்றோர் தொகுதி மற்றும் ஒரு கோர் தொகுதி வகுப்புகளை உருவாக்குவதற்கு பொறுப்பு. யூனிட் சோதனைகள் இயந்திரத்தின் செயல்பாட்டை சரிபார்க்கும்போது, ​​உண்மையான சவால் இந்த உருவாக்கப்பட்ட வகுப்புகளை மேலும் சோதனைக்கு தொகுத்து ஒருங்கிணைப்பதில் உள்ளது. இது கேள்வியை எழுப்புகிறது: இது நேரடியாக மைய தொகுதிக்குள் செய்யப்பட வேண்டுமா, அல்லது ஒரு தனி சோதனை தொகுதி ஒரு சிறந்த அணுகுமுறையா?

இதேபோன்ற திட்டங்களில் பணிபுரியும் பல டெவலப்பர்கள் அதே சங்கடத்தை எதிர்கொள்கின்றனர். நன்கு கட்டமைக்கப்பட்ட தீர்வு உருவாக்கப்பட்ட குறியீடு செயல்படுவதை உறுதி செய்வதோடு மட்டுமல்லாமல், இந்த வகுப்புகளை பயனர்களுக்கான குறிப்பு எடுத்துக்காட்டுகளாக பேக்கேஜிங் செய்ய உதவுகிறது. திட்ட கட்டமைப்பை சுத்தமாக வைத்திருக்கும்போது இந்த படியை தானியக்கமாக்குவதற்கான சரியான வழியைக் கண்டுபிடிப்பது பராமரிக்கக்கூடிய பணிப்பாய்வுகளுக்கு முக்கியமானது.

இந்த கட்டுரையில், சிறந்த உத்திகளை ஆராய்வோம் தொகுத்தல், சோதனை மற்றும் தொகுப்பு உருவாக்கப்பட்ட ஜாவா வகுப்புகள். இந்த கோப்புகளை இறுதி கட்டமைப்பில் ஒருங்கிணைப்பதற்கான அர்ப்பணிப்பு மேவன் கட்டங்கள், சோதனை தொகுதிகள் மற்றும் சிறந்த நடைமுறைகள் உள்ளிட்ட வெவ்வேறு அணுகுமுறைகளை நாங்கள் கருத்தில் கொள்வோம். முடிவில், உங்கள் சொந்த திட்டங்களில் இந்த செயல்முறையை நெறிப்படுத்த ஒரு தெளிவான வரைபடம் உங்களிடம் இருக்கும். .

மேவனில் உருவாக்கப்பட்ட ஜாவா வகுப்புகளின் தொகுப்பு மற்றும் சோதனையை தானியங்குபடுத்துதல்

ஒரு உடன் பணிபுரியும் போது மேவன் வார்ப்புரு இயந்திரம் அப்பாச்சி ஃப்ரீமார்க்கரைப் போலவே, உருவாக்கப்பட்ட ஜாவா வகுப்புகள் சரியாக செயல்படுவதை உறுதிசெய்ய தொகுக்கப்பட்டு சரிபார்க்கப்பட வேண்டும். முதல் ஸ்கிரிப்ட் தனிப்பயன் மேவன் சொருகி உருவாக்குகிறது, இது இந்த உருவாக்கப்பட்ட வகுப்புகளை தானாக தொகுக்கும். மேவன் வாழ்க்கைச் சுழற்சியில் ஒரு இலக்கை வரையறுப்பதன் மூலம் இது அடையப்படுகிறது @மோஜோ, இது தொகுப்பு கட்டத்தில் இயங்குகிறது. ஜாவா கம்பைலரை நிரல் ரீதியாக செயல்படுத்துவதற்கு முன் இலக்கு அடைவு இருக்கிறதா என்று ஸ்கிரிப்ட் சரிபார்க்கிறது Courtprovider.getSystemjavacompiler (). உருவாக்கப்பட்ட ஆதாரங்கள் காணவில்லை என்றால், அது ஒரு பிழையை வீசுகிறது, தேவையற்ற கட்டமைப்பைத் தடுக்கிறது. .

ஜாவா வகுப்புகள் தொகுக்கப்பட்டவுடன், அவற்றின் கட்டமைப்பு மற்றும் நடத்தை சரிபார்க்க அவை சோதிக்கப்பட வேண்டும். இரண்டாவது ஸ்கிரிப்ட் ஜூனிட் 5 ஐ மாறும் வகையில் ஏற்றவும், உருவாக்கப்பட்ட வகுப்பை ஆய்வு செய்யவும் பயன்படுத்துகிறது Class.forname (). இது டெவலப்பர்கள் குறிப்பிட்ட முறைகள் உள்ளதா என்பதை சரிபார்க்கவும், எதிர்பார்த்தபடி செயல்படவும் அனுமதிக்கிறது. எடுத்துக்காட்டாக, "getData ()" என்ற பெயரில் ஒரு முறை தேவைப்பட்டால், சோதனை என்பது தொகுக்கப்பட்ட வகுப்பில் அதைப் பயன்படுத்தி இருப்பதை உறுதி செய்கிறது getDeclaredMethod (). பாரம்பரிய நிலையான பகுப்பாய்வு கருவிகள் அனைத்து விளிம்பு நிகழ்வுகளையும் மறைக்காது என்பதால் மாறும் வகையில் உருவாக்கப்பட்ட குறியீட்டைக் கையாளும் போது இந்த வகை சோதனை முக்கியமானது.

தொகுப்பு மற்றும் சோதனைக்குப் பிறகு, அடுத்த கட்டமாக உருவாக்கப்பட்ட வகுப்புகளை இறுதி கட்டமைப்பில் சேர்க்க வேண்டும். மூன்றாவது ஸ்கிரிப்ட் மேவன் ஜாடி சொருகி ஒன்றை குறிப்பிடுவதன் மூலம் இந்த வகுப்புகளை தொகுக்க உள்ளது <இதழ்கள்> /உருவாக்கப்பட்ட கிளாஸ். கிளாஸ் உத்தரவு. பயனர்கள் திட்டத்தைப் பதிவிறக்கும்போது, ​​அவர்கள் பிரதான மூலக் குறியீட்டோடு முன் தொகுக்கப்பட்ட எடுத்துக்காட்டுகளைப் பெறுகிறார்கள் என்பதை இது உறுதி செய்கிறது. இந்த அணுகுமுறை முன்பே கட்டப்பட்ட வார்ப்புருக்கள் அல்லது கட்டமைப்பை வழங்கும் திட்டங்களுக்கு குறிப்பாக நன்மை பயக்கும், ஏனெனில் இது பயனர்களுக்கு பயன்படுத்தத் தயாராக உள்ள குறிப்பு செயலாக்கங்களை வழங்குகிறது. .

இந்த பணிகளை தானியக்கமாக்குவதன் மூலம், டெவலப்பர்கள் தங்கள் பணிப்பாய்வுகளை நெறிப்படுத்துகிறார்கள், கையேடு தலையீடு மற்றும் சாத்தியமான பிழைகள் ஆகியவற்றைக் குறைக்கிறார்கள். சேர்க்கை மேவன் செருகுநிரல்கள், ஜூனிட் சோதனை மற்றும் பேக்கேஜிங் உள்ளமைவுகள் உருவாக்கப்பட்ட வகுப்புகள் எப்போதும் தொகுக்கப்பட்டு, சரிபார்க்கப்பட்டு சரியாக விநியோகிக்கப்படுவதை உறுதி செய்கிறது. இந்த முறையை ஏபிஐ கிளையன்ட் குறியீடு உருவாக்கம் அல்லது உள்ளமைவு அடிப்படையிலான ஜாவா வகுப்பு உருவாக்கம் போன்ற பிற பயன்பாட்டு நிகழ்வுகளுக்கு நீட்டிக்க முடியும். இறுதியில், இந்த செயல்முறைகளை உருவாக்க வாழ்க்கை சுழற்சியில் ஒருங்கிணைப்பது குறியீடு பராமரித்தல் மற்றும் டெவலப்பர் செயல்திறனை மேம்படுத்துகிறது. .

// Step 1: Define a Maven Plugin to Compile Generated Classes
package com.example.mavenplugin;
import org.apache.maven.plugin.AbstractMojo;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.MojoFailureException;
import org.apache.maven.plugins.annotations.LifecyclePhase;
import org.apache.maven.plugins.annotations.Mojo;
import org.apache.maven.project.MavenProject;
import javax.tools.JavaCompiler;
import javax.tools.ToolProvider;
import java.io.File;
@Mojo(name = "compile-generated", defaultPhase = LifecyclePhase.COMPILE)
public class CompileGeneratedClassesMojo extends AbstractMojo {
    public void execute() throws MojoExecutionException, MojoFailureException {
        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
        if (compiler == null) {
            throw new MojoExecutionException("No Java compiler found!");
        }
        File generatedDir = new File("target/generated-sources");
        if (!generatedDir.exists()) {
            throw new MojoExecutionException("Generated sources not found!");
        }
        int result = compiler.run(null, null, null, generatedDir.getAbsolutePath());
        if (result != 0) {
            throw new MojoExecutionException("Compilation failed!");
        }
    }
}

package com.example.tests;
import org.junit.jupiter.api.Test;
import java.lang.reflect.Method;
import static org.junit.jupiter.api.Assertions.*;
class GeneratedCodeTest {
    @Test
    void testGeneratedClassMethods() throws Exception {
        Class<?> generatedClass = Class.forName("com.example.GeneratedClass");
        Method method = generatedClass.getDeclaredMethod("getData");
        assertNotNull(method, "Method getData() should exist");
    }
}

<build>
  <plugins>
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-jar-plugin</artifactId>
      <version>3.2.0</version>
      <configuration>
        <includes>
          <include>/GeneratedClass.class</include>
        </includes>
      </configuration>
    </plugin>
  </plugins>
</build>

உருவாக்கப்பட்ட ஜாவா வகுப்புகளுக்கான உருவாக்க செயல்முறையை மேம்படுத்துதல்

ஒரு ஒருங்கிணைக்கும்போது a வார்ப்புரு இயந்திரம் ஒரு மேவன் திட்டத்தில் அப்பாச்சி ஃப்ரீமார்க்கரைப் போலவே, அடிக்கடி கவனிக்கப்படாத ஒரு அம்சம் உருவாக்க உகப்பாக்கம் ஆகும். ஜாவா வகுப்புகளை மாறும் வகையில் உருவாக்குவது திறமையானது, ஆனால் சரியான உருவாக்க உள்ளமைவுகள் இல்லாமல், செயல்முறை மெதுவாகவும் பிழையாகவும் மாறும். நன்கு கட்டமைக்கப்பட்ட வாழ்க்கை சுழற்சியை உருவாக்குங்கள் உருவாக்கப்பட்ட கோப்புகள் தேவைப்படும்போது மட்டுமே தொகுக்கப்படுவதை உறுதிசெய்கிறது, வளர்ச்சியைக் குறைக்கும் தேவையற்ற செயல்பாடுகளைத் தவிர்க்கிறது. ஒரு பயனுள்ள நுட்பம் மேவனின் அதிகரிக்கும் உருவாக்க முறையைப் பயன்படுத்துகிறது, இது மூல கோப்புகளில் ஏற்படும் மாற்றங்களைக் கண்டறிந்து மாற்றியமைக்கப்பட்டவற்றை மட்டுமே மீண்டும் தொகுக்கிறது.

மற்றொரு முக்கியமான அம்சம் சார்பு மேலாண்மை. உருவாக்கப்பட்ட வகுப்புகள் முன் வரையறுக்கப்பட்ட வார்ப்புருக்கள் மற்றும் உள்ளீட்டுத் தரவை நம்பியிருப்பதால், ஃப்ரீமார்க்கர் மற்றும் JSON பாகுபடுத்திகள் போன்ற சார்புகள் சரியாக கையாளப்படுவதை உறுதிசெய்கிறது. மேவன் சுயவிவரங்களைப் பயன்படுத்தி, டெவலப்பர்கள் வளர்ச்சி, சோதனை மற்றும் உற்பத்தி சூழல்களுக்கு வெவ்வேறு உள்ளமைவுகளை உருவாக்க முடியும். உதாரணமாக, ஒரு "சோதனை" சுயவிவரத்தில் கூடுதல் சரிபார்ப்பு படிகள் இருக்கலாம், அதே நேரத்தில் "வெளியீடு" சுயவிவரம் விநியோகத்திற்கான நிலையான பதிப்புகளை பேக்கேஜிங் செய்வதில் கவனம் செலுத்துகிறது. இந்த மட்டு அணுகுமுறை தேவையற்ற செயலாக்கத்தைத் தடுக்கிறது மற்றும் பராமரிப்பை மேம்படுத்துகிறது. .

கூடுதலாக, பதிவுசெய்தல் மற்றும் பிழைத்திருத்தம் ஆகியவை எதிர்பார்த்தபடி குறியீடு செயல்பாடுகளை உருவாக்குவதை உறுதி செய்வதில் முக்கிய பங்கு வகிக்கின்றன. SLF4J அல்லது LOGBACK போன்ற பதிவு கட்டமைப்பை ஒருங்கிணைப்பதன் மூலம், டெவலப்பர்கள் வார்ப்புருக்கள் எவ்வாறு செயலாக்கப்படுகின்றன என்பதைக் கண்காணிக்க முடியும் மற்றும் நிகழ்நேரத்தில் சாத்தியமான பிழைகளை அடையாளம் காணலாம். உருவாக்கப்பட்ட கோப்புகளை கைமுறையாக ஆய்வு செய்வதற்குப் பதிலாக, கட்டமைக்கப்பட்ட பதிவுகள் உருமாற்ற செயல்முறை பற்றிய நுண்ணறிவுகளை வழங்குகின்றன, நேரத்தையும் முயற்சியையும் மிச்சப்படுத்துகின்றன. இறுதியில், உருவாக்க செயல்முறையை சுத்திகரிப்பது விரைவான வளர்ச்சி சுழற்சிகள் மற்றும் உயர் தரமான உருவாக்கப்பட்ட குறியீட்டிற்கு வழிவகுக்கிறது. .

தானியங்கி ஜாவா குறியீடு உருவாக்கம் ஒரு மேவன் திட்டத்திற்குள் சரியானது மற்றும் பராமரிப்பை உறுதிப்படுத்த ஒரு கட்டமைக்கப்பட்ட அணுகுமுறை தேவைப்படுகிறது. A வார்ப்புரு இயந்திரம் அப்பாச்சி ஃப்ரீமார்க்கரைப் போலவே டைனமிக் வர்க்க உருவாக்கத்தையும் அனுமதிக்கிறது, ஆனால் இந்த வகுப்புகளை திறம்பட தொகுத்து சோதிப்பது முக்கியம். அர்ப்பணிப்பு தொகுப்பு படிகளை ஒருங்கிணைப்பதன் மூலம் மற்றும் அலகு சோதனை ஜூனிட் மூலம், டெவலப்பர்கள் இறுதி திட்டத்தில் பேக்கேஜிங் செய்வதற்கு முன்பு உருவாக்கப்பட்ட குறியீட்டை சரிபார்க்க முடியும். மேவன் செருகுநிரல்களைப் பயன்படுத்தி, இந்த செயல்முறைகள் தானியங்கி செய்யப்படலாம், கையேடு முயற்சியைக் குறைக்கும் மற்றும் திட்ட நம்பகத்தன்மையை மேம்படுத்துகின்றன. கட்டமைக்கப்பட்ட பதிவு மற்றும் அதிகரிக்கும் கட்டமைப்பை செயல்படுத்துவது செயல்திறன் மற்றும் பிழைத்திருத்த திறன்களை மேலும் மேம்படுத்துகிறது. .