Creating a Maven Project and Understanding Standard Directory Layout | Maven & Java Build Management – शुरुआत से Professional Build Automation तक | हिंदी

1. Learning Outcomes#

इस chapter को पूरा करने के बाद आप:

Maven project की basic anatomy समझ पाएँगे।
समझ पाएँगे कि project root directory क्या होती है।
pom.xml को सही location पर create और identify कर पाएँगे।
पहले सीखे गए Maven coordinates को minimal POM में apply कर पाएँगे।
src/main/java और src/main/resources का purpose समझ पाएँगे।
src/test/java और src/test/resources का role समझ पाएँगे।
target directory क्यों बनती है और उसमें क्या रहता है, यह समझ पाएँगे।
Java package और folder structure के बीच का संबंध समझ पाएँगे।
Maven के Convention over Configuration approach का practical मतलब समझ पाएँगे।
common Maven project-structure mistakes पहचान और avoid कर पाएँगे।

2. Maven Project केवल Files का Collection नहीं है#

मान लीजिए आप एक Java application बना रहे हैं।

उस project में अलग-अलग प्रकार की चीजें होंगी:

Java source code
configuration files
test code
test resources
project configuration
build के बाद generate होने वाली files

अगर हर developer इन files को अपनी पसंद की जगह रखे, तो project जल्दी confusing हो जाएगा।

एक developer Java code code folder में रख सकता है।

दूसरा developer उसे source folder में रख सकता है।

तीसरा developer tests को production code के साथ ही रख सकता है।

ऐसी स्थिति में build tool को भी बार-बार बताना पड़ेगा कि कौन-सी file कहाँ है।

Maven इस problem को एक standard structure देकर solve करता है।

Key Idea

Maven कहता है: अगर project को standard directory layout के अनुसार organize किया जाए, तो बहुत-सी सामान्य build settings अलग से configure करने की जरूरत नहीं पड़ती।

यही Maven project structure को समझने का सबसे important mental model है।

3. Maven Project की Basic Anatomy#

एक सामान्य Maven Java project को high level पर इस तरह समझ सकते हैं:

Visual Diagram80%

Rendering diagram…

इस diagram में तीन बड़े हिस्से दिखाई देते हैं:

pom.xml
src
target

लेकिन इन तीनों का nature समान नहीं है।

pom.xml project की Maven configuration है।

src में वह content रहता है जिसे developer लिखता या maintain करता है।

target आमतौर पर Maven build के दौरान generate करता है।

इसे धीरे-धीरे समझते हैं।

4. Project Root Directory क्या होती है?#

हर Maven project की एक top-level directory होती है।

इसे हम project root directory कह सकते हैं।

उदाहरण के लिए यदि project का नाम employee-service है, तो directory हो सकती है:

employee-service

इस directory के अंदर project की बाकी important files और folders रहते हैं।

उदाहरण:

Location	Purpose
`employee-service/pom.xml`	Maven project configuration
`employee-service/src`	Source और resource files
`employee-service/target`	Build-generated files

यहाँ employee-service project root है।

Remember

Maven project root को केवल project का नाम समझना पर्याप्त नहीं है। Practical रूप से यह वह directory है जहाँ project का main pom.xml रखा होता है और जहाँ से project की standard structure शुरू होती है।

5. Project Root कैसे Create करें?#

Project root create करने के लिए किसी special Maven file format की जरूरत नहीं होती।

यह शुरुआत में एक normal directory ही होती है।

आप इसे:

IDE से create कर सकते हैं,
File Explorer से create कर सकते हैं,
terminal से create कर सकते हैं,
या Maven tooling से generated project के रूप में प्राप्त कर सकते हैं।

इस chapter में important बात यह नहीं है कि directory किस button या command से बनी।

Important बात है कि उसके अंदर Maven की expected structure सही हो।

उदाहरण के लिए हम project का root मानते हैं:

hello-maven

अब इस root के अंदर सबसे important Maven file बनाएँगे।

6. `pom.xml` कहाँ होती है?#

एक basic single-module Maven project में main pom.xml project root में रखी जाती है।

सही location:

hello-maven/pom.xml

गलत mental model यह होगा कि pom.xml को src/main/java के अंदर रखा जाए।

pom.xml Java source file नहीं है।

यह पूरे Maven project का build descriptor है।

Maven इसी file से project के बारे में important information पढ़ता है।

Common Mistake

pom.xml को source-code directory के अंदर रखने से बचें। Basic Maven project में main POM project root पर होती है।

7. POM का छोटा Recap#

आप Maven coordinates पहले सीख चुके हैं।

यहाँ हमें केवल उन्हें actual project structure से connect करना है।

मान लेते हैं हमारे project के coordinates हैं:

groupId → com.codelangsai
artifactId → hello-maven
version → 1.0-SNAPSHOT

अब project root में minimal pom.xml बनाई जा सकती है:

XML

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <groupId>com.codelangsai</groupId>
    <artifactId>hello-maven</artifactId>
    <version>1.0-SNAPSHOT</version>

</project>

ध्यान दीजिए कि हमने यहाँ Maven coordinates को दोबारा deeply नहीं पढ़ाया।

हमने उन्हें actual Maven project की pom.xml में place किया है।

अब Maven को कम से कम यह पहचान मिल गई कि project कौन-सा है।

8. अभी तक Project कैसा दिखता है?#

अभी conceptual structure बहुत छोटी है:

project root: hello-maven
root के अंदर: pom.xml

लेकिन Java application बनाने के लिए source code रखने की standard location भी चाहिए।

यहीं src/main/java काम आता है।

9. `src/main/java` क्या है?#

Maven में application का मुख्य Java source code सामान्यतः यहाँ रखा जाता है:

src/main/java

Path को parts में समझिए:

src → source-related content
main → main application content
java → Java source files

इसका मतलब यह नहीं है कि हर .java file सीधे java directory के अंदर रखनी चाहिए।

Java source files आमतौर पर packages के अनुसार आगे organize होती हैं।

उस पर हम थोड़ी देर में आएँगे।

पहले directory का role clear कर लेते हैं।

मान लीजिए application में एक production class है:

App.java

वह class application का actual source code है।

इसलिए उसका logical home src/main/java के नीचे होगा।

Key Idea

src/main/java Maven project का standard production Java source location है।

10. `src/main/resources` क्या है?#

Application को केवल Java files की जरूरत नहीं होती।

कभी application को ऐसी files भी चाहिए होती हैं जो Java source code नहीं हैं।

उदाहरण:

.properties files
text templates
application-specific configuration data
static data files
other runtime resources

इनके लिए Maven का standard location है:

src/main/resources

उदाहरण:

src/main/resources/config.properties

यहाँ एक simple resource file हो सकती है:

PROPERTIES

application.name=Hello Maven
application.mode=development

यह Java code नहीं है।

इसलिए इसे src/main/java में रखने के बजाय src/main/resources में रखना structure को साफ रखता है।

`java` और `resources` में Difference#

Directory	मुख्य Purpose
`src/main/java`	Main Java source code
`src/main/resources`	Main application की non-Java resource files

यह separation बहुत useful है।

Developer directory देखते ही समझ सकता है कि कहाँ source code मिलेगा और कहाँ supporting resource files।

11. `main` का मतलब क्या है?#

यहाँ एक common confusion हो सकती है।

src/main/java में मौजूद main directory का मतलब Java का main() method नहीं है।

यह Maven directory structure का हिस्सा है।

main यहाँ broadly application के primary content को represent करता है।

इसके अंदर Java source और resources अलग-अलग रखे जाते हैं।

Common Mistake

src/main/java के main को Java के public static void main(...) method के साथ confuse न करें। दोनों में शब्द समान है, लेकिन context अलग है।

12. Tests कहाँ रखेंगे?#

अब मान लीजिए application code के लिए tests लिखने हैं।

अगर test classes को production classes के साथ ही src/main/java में रख दिया जाए, तो दोनों responsibilities mix हो जाएँगी।

Maven इसके लिए separate standard structure देता है:

src/test/java

और test-specific resources के लिए:

src/test/resources

इसलिए high-level separation है:

main application content → src/main/...
test-related content → src/test/...

13. `src/test/java`#

Test Java source files की standard Maven location है:

src/test/java

उदाहरण के लिए अगर future में Calculator class के लिए test लिखा जाए, तो test source इस tree के अंदर रहेगा।

यह separation Maven और developers दोनों को यह समझने में मदद करती है कि कौन-सा code application का हिस्सा है और कौन-सा testing के लिए है।

Remember

Production Java code और test Java code के लिए Maven अलग source directories use करता है।

14. `src/test/resources`#

Tests को कभी-कभी supporting data की जरूरत होती है।

उदाहरण:

sample input files
test configuration
expected-data files
test-only properties

ऐसी files के लिए standard location है:

src/test/resources

इससे test-only data production resources के साथ unnecessarily mix नहीं होता।

Main और Test Structure को साथ में देखें#

Content	Standard Location
Production Java code	`src/main/java`
Production resources	`src/main/resources`
Test Java code	`src/test/java`
Test resources	`src/test/resources`

इस table को memorize करने के बजाय pattern समझिए।

पहला decision:

main या test?

दूसरा decision:

java या resources?

यही pattern directory structure को याद रखना आसान बनाता है।

15. अब Standard Structure को एक साथ देखें#

एक basic Maven Java project conceptually इस तरह organize होगा:

Path	क्या रखा जाता है?
`pom.xml`	Maven project configuration
`src/main/java`	Main Java source code
`src/main/resources`	Main non-Java resources
`src/test/java`	Test Java source code
`src/test/resources`	Test-specific resources
`target`	Maven-generated build output

अब इसमें Java packages जोड़ते हैं।

16. Java Packages Maven Structure में कहाँ आते हैं?#

मान लीजिए Java class का package है:

com.codelangsai.app

और class का नाम है:

App

Java source file का logical path होगा:

src/main/java/com/codelangsai/app/App.java

इसे दो layers में समझिए।

Maven source root:

src/main/java

उस source root के बाद Java package hierarchy:

com/codelangsai/app

इसलिए पूरा path बनता है:

src/main/java/com/codelangsai/app/App.java

Java file:

JAVA

package com.codelangsai.app;

public class App {

    public static void main(String[] args) {
        System.out.println("Hello from Maven project!");
    }
}

यहाँ:

JAVA

package com.codelangsai.app;

और directory path:

com/codelangsai/app

एक-दूसरे के साथ logically correspond करते हैं।

Source Root को Package का हिस्सा मत समझिए#

यह बहुत important distinction है।

Full file path:

src/main/java/com/codelangsai/app/App.java

लेकिन Java package यह नहीं है:

src.main.java.com.codelangsai.app

सही package है:

com.codelangsai.app

क्यों?

क्योंकि src/main/java Maven का source root है।

Package hierarchy उसके बाद शुरू होती है।

Common Mistake

src/main/java को Java package name का हिस्सा न बनाएँ।

17. Package Structure क्यों Useful है?#

मान लीजिए project में कई areas हैं:

application startup
customer-related classes
order-related classes
utilities

Packages classes को logical groups में organize करने में मदद करते हैं।

Maven standard source root देता है।

Java packages उस source root के अंदर code को organize करते हैं।

इसलिए दोनों responsibilities अलग हैं:

Maven structure तय करता है कि source code का root कहाँ है।

Java package structure तय करता है कि उस source root के अंदर classes कैसे organize होंगी।

18. पूरा Example Project#

मान लेते हैं project का नाम hello-maven है।

उसमें:

root POM है,
एक Java class है,
एक resource file है,
test directories ready हैं।

Conceptually structure ऐसी होगी:

Visual Diagram80%

Rendering diagram…

इस diagram में एक चीज खास ध्यान दें:

target को हमने src के अंदर नहीं रखा।

वह project root के नीचे अलग generated directory है।

19. `target` Directory क्या है?#

अब तक जिन directories की बात हुई, उनमें developer अपने source या resources रखता है।

target अलग प्रकार की directory है।

Maven build process के दौरान generated output सामान्यतः target के अंदर रखा जाता है।

उदाहरण के तौर पर इसमें build के आधार पर ऐसी चीजें दिखाई दे सकती हैं:

compiled classes
copied resources
test-related build output
packaged artifact जैसे JAR
temporary build metadata

Exact content इस बात पर depend कर सकती है कि आपने कौन-सा build operation किया है और project कैसे configured है।

लेकिन basic mental model बहुत simple है:

src → developer-maintained input

target → build-generated output

Key Idea

target को source directory की तरह treat नहीं करना चाहिए। यह सामान्यतः Maven build का generated workspace/output area है।

20. क्या `target` Manually Create करना चाहिए?#

सामान्य Maven workflow में इसकी जरूरत नहीं होती।

जब Maven को build output generate करने की जरूरत होती है, वह target directory create कर सकता है।

इसलिए शुरुआत में आपका नया project target के बिना भी बिल्कुल normal हो सकता है।

उदाहरण के लिए initial structure में केवल यह हो सकता है:

pom.xml
src/main/java
src/main/resources
src/test/java
src/test/resources

Build होने के बाद target दिखाई दे सकता है।

21. क्या `target` के अंदर Files Manually Edit करनी चाहिए?#

आमतौर पर नहीं।

मान लीजिए आपने generated .class file या copied resource को target के अंदर manually modify किया।

अगले build में Maven उस generated content को replace कर सकता है।

इसलिए permanent changes source side पर करने चाहिए।

Java source बदलना है?

src/main/java में बदलें।

Main resource बदलना है?

src/main/resources में बदलें।

Test source बदलना है?

src/test/java में बदलें।

Generated build output को source-of-truth मत बनाइए।

Warning

target के अंदर manual changes पर भरोसा न करें। Build-generated content दोबारा create या replace हो सकता है।

22. Maven को Standard Directory Names कैसे पता हैं?#

अब एक important question आता है।

हमने Maven को explicitly नहीं बताया:

Java source src/main/java में है,
resources src/main/resources में हैं,
tests src/test/java में हैं।

फिर Maven इन locations को कैसे समझता है?

क्योंकि Maven conventions use करता है।

Standard project layout Maven के established conventions का हिस्सा है।

यदि हम conventions follow करते हैं, तो common configuration की जरूरत कम हो जाती है।

इसी idea को Convention over Configuration कहा जाता है।

23. Convention over Configuration को Simple Example से समझें#

मान लीजिए एक office में rule है:

incoming documents tray A में जाएँगे,
approved documents tray B में जाएँगे।

अगर हर employee यही convention follow करता है, तो हर document के लिए अलग instruction देने की जरूरत नहीं है।

Maven project में भी similar idea है।

अगर Java source standard location:

src/main/java

में है, तो build system को हर basic project में बार-बार custom source location बताने की जरूरत कम हो जाती है।

Technical Meaning#

Convention over Configuration का मतलब है कि framework या tool sensible standard defaults और established structure provide करता है।

आप convention follow करते हैं तो कम configuration लिखनी पड़ती है।

यह configuration को पूरी तरह समाप्त नहीं करता।

जरूरत पड़ने पर customization संभव हो सकती है।

लेकिन normal case में standard convention सबसे simple path देता है।

Interview Point

Maven follows convention over configuration. Its standard directory layout allows common project behavior to work with less explicit configuration.

24. Convention क्यों Valuable है?#

इसका benefit केवल Maven को नहीं होता।

Developers को भी होता है।

जब आप किसी unfamiliar Maven project में जाएँ और src/main/java देखें, तो तुरंत अंदाजा हो जाता है कि application Java code कहाँ होगा।

src/test/java देखकर testing code की expected location समझ आती है।

pom.xml देखकर Maven configuration मिल जाती है।

target देखकर generated build output का area पहचान में आता है।

इससे projects के बीच consistency बढ़ती है।

25. Standard Layout का मतलब यह नहीं कि हर Folder हमेशा मौजूद होगा#

यह एक subtle point है।

हर Maven project में हर standard directory physically मौजूद होना जरूरी नहीं है।

उदाहरण के लिए किसी छोटे project में अभी कोई resource file नहीं है।

तो src/main/resources खाली हो सकती है या अभी create भी न की गई हो।

इसी तरह tests अभी नहीं लिखे गए हों तो test directories खाली हो सकती हैं।

Standard layout आपको expected location बताता है।

यह नहीं कहता कि हर possible directory हर समय populated होनी ही चाहिए।

26. एक Minimal Project Step by Step बनाते हैं#

अब पूरे concept को practically connect करते हैं।

मान लेते हैं project root है:

hello-maven

Step 1: Project Root बनाएँ#

एक directory बनाएँ:

hello-maven

यही हमारे project की top-level directory है।

Step 2: Root में `pom.xml` रखें#

Path:

hello-maven/pom.xml

Content:

XML

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <groupId>com.codelangsai</groupId>
    <artifactId>hello-maven</artifactId>
    <version>1.0-SNAPSHOT</version>

</project>

अब project के पास Maven identity और main project descriptor दोनों हैं।

Step 3: Main Java Source Directory बनाएँ#

Standard source root:

src/main/java

अब package:

com.codelangsai.app

के लिए उसके अंदर folders होंगे:

com/codelangsai/app

इसलिए final Java source location:

src/main/java/com/codelangsai/app/App.java

Step 4: Java Class रखें#

JAVA

package com.codelangsai.app;

public class App {

    public static void main(String[] args) {
        System.out.println("Hello from Maven project!");
    }
}

अब class सही Maven source root और matching Java package hierarchy के अंदर है।

Step 5: Main Resources Directory बनाएँ#

Create:

src/main/resources

Example resource:

src/main/resources/config.properties

PROPERTIES

application.name=Hello Maven
application.environment=local

Step 6: Test Locations समझें#

Test source के लिए:

src/test/java

Test resources के लिए:

src/test/resources

अभी tests न हों तो भी आपको उनकी सही standard location पता है।

Step 7: `target` को Source Folder की तरह मत बनाएँ#

जब build process generated output create करेगा, target project root के नीचे दिखाई दे सकती है।

Permanent application source उसमें न रखें।

27. एक File कहाँ रखनी है? Decision Method#

जब नई file project में add करनी हो, तो खुद से दो simple questions पूछें।

यह Source है या Resource?Show Answer

अगर Java source code है:

java

अगर non-Java supporting resource है:

resources

यह Main Application के लिए है या Test के लिए?Show Answer

अगर production/application content है:

main

अगर testing content है:

test

फिर दोनों answers combine करें।

File Type	Purpose	Location
Java class	Main application	`src/main/java`
Properties/data file	Main application	`src/main/resources`
Java test class	Testing	`src/test/java`
Test data/config	Testing	`src/test/resources`

यह decision pattern याद रखने से structure रटने की जरूरत बहुत कम हो जाती है।

28. Common Maven Project Structure Mistakes#

Mistake 1: `pom.xml` को `src` के अंदर रखना#

गलत idea:

src/pom.xml

Basic Maven project में main POM root पर रखें:

pom.xml

Mistake 2: Java Files को `src` में सीधे रखना#

उदाहरण:

src/App.java

Maven standard Java source root है:

src/main/java

इसके बाद package structure आता है।

Mistake 3: Package और Directory Structure को Mismatch करना#

अगर file में है:

JAVA

package com.codelangsai.app;

तो source root के बाद expected hierarchy logically होनी चाहिए:

com/codelangsai/app

Package declaration और source organization को consistent रखें।

Mistake 4: Test Classes को Main Source के साथ रखना#

Production और test responsibilities mix न करें।

Main code:

src/main/java

Test code:

src/test/java

Mistake 5: Resources को Java Source समझना#

Properties या दूसरी resource files को बिना कारण Java package folders में न डालें।

Main resources के लिए:

src/main/resources

Test resources के लिए:

src/test/resources

Mistake 6: `target` में Permanent Code रखना#

target generated build output के लिए है।

Permanent source code वहाँ रखने पर build के बाद content overwrite या remove हो सकता है।

Mistake 7: हर चीज को Custom Directory में रखना#

Maven custom configuration support कर सकता है, लेकिन केवल personal preference के कारण standard layout छोड़ना unnecessary complexity पैदा कर सकता है।

जब standard structure आपकी requirement पूरी करती है, convention follow करना simpler होता है।

29. Self-Check#

pom.xml और src/main/java में fundamental difference क्या है?Show Answer

pom.xml Maven project की configuration और identity describe करती है, जबकि src/main/java application के main Java source code की standard location है।

src/main/java/com/codelangsai/app/App.java में Java package कौन-सा होगा?Show Answer

Source root src/main/java के बाद package hierarchy शुरू होती है, इसलिए package com.codelangsai.app होगा।

क्या target directory को application source code रखने के लिए use करना चाहिए?Show Answer

नहीं। target सामान्यतः Maven-generated build output के लिए होती है। Permanent source code src की appropriate standard directory में रहना चाहिए।

Convention over Configuration का Maven project layout में practical benefit क्या है?Show Answer

Standard locations follow करने पर Maven और developers दोनों common project structure को बिना unnecessary custom configuration के समझ सकते हैं।

30. Practical Mental Model#

Maven project को चार responsibilities में बाँटकर याद रखें:

Project description

→ pom.xml

Application content

→ src/main/java
→ src/main/resources

Testing content

→ src/test/java
→ src/test/resources

Generated build content

→ target

अगर यह mental model clear है, तो Maven directory structure याद रखना काफी आसान हो जाता है।

31. Recap#

इस chapter से ये बातें याद रखें:

Maven project की top-level directory project root होती है।
Basic Maven project की main pom.xml project root में रहती है।
src/main/java main Java source code की standard location है।
src/main/resources main non-Java resources की standard location है।
src/test/java test Java source code के लिए है।
src/test/resources test-specific resources के लिए है।
Java packages src/main/java source root के बाद directory hierarchy के रूप में organize होती हैं।
target Maven-generated build output के लिए होती है।
target को permanent source location की तरह use नहीं करना चाहिए।
Maven का standard directory layout Convention over Configuration का practical example है।
Standard conventions project को predictable, maintainable और team-friendly बनाती हैं।

Printing is unavailable

1. Learning Outcomes#

2. Maven Project केवल Files का Collection नहीं है#

3. Maven Project की Basic Anatomy#

4. Project Root Directory क्या होती है?#

5. Project Root कैसे Create करें?#

6. pom.xml कहाँ होती है?#

7. POM का छोटा Recap#

8. अभी तक Project कैसा दिखता है?#

9. src/main/java क्या है?#

10. src/main/resources क्या है?#

java और resources में Difference#

11. main का मतलब क्या है?#

12. Tests कहाँ रखेंगे?#

13. src/test/java#

14. src/test/resources#

Main और Test Structure को साथ में देखें#

15. अब Standard Structure को एक साथ देखें#

16. Java Packages Maven Structure में कहाँ आते हैं?#

Source Root को Package का हिस्सा मत समझिए#

17. Package Structure क्यों Useful है?#

18. पूरा Example Project#

19. target Directory क्या है?#

20. क्या target Manually Create करना चाहिए?#

21. क्या target के अंदर Files Manually Edit करनी चाहिए?#

22. Maven को Standard Directory Names कैसे पता हैं?#

23. Convention over Configuration को Simple Example से समझें#

Technical Meaning#

24. Convention क्यों Valuable है?#

25. Standard Layout का मतलब यह नहीं कि हर Folder हमेशा मौजूद होगा#

26. एक Minimal Project Step by Step बनाते हैं#

Step 1: Project Root बनाएँ#

Step 2: Root में pom.xml रखें#

Step 3: Main Java Source Directory बनाएँ#

Step 4: Java Class रखें#

Step 5: Main Resources Directory बनाएँ#

Step 6: Test Locations समझें#

Step 7: target को Source Folder की तरह मत बनाएँ#

27. एक File कहाँ रखनी है? Decision Method#

28. Common Maven Project Structure Mistakes#

Mistake 1: pom.xml को src के अंदर रखना#

Mistake 2: Java Files को src में सीधे रखना#

Mistake 3: Package और Directory Structure को Mismatch करना#

Mistake 4: Test Classes को Main Source के साथ रखना#

Mistake 5: Resources को Java Source समझना#

Mistake 6: target में Permanent Code रखना#

Mistake 7: हर चीज को Custom Directory में रखना#

29. Self-Check#

30. Practical Mental Model#

31. Recap#

6. `pom.xml` कहाँ होती है?#

9. `src/main/java` क्या है?#

10. `src/main/resources` क्या है?#

`java` और `resources` में Difference#

11. `main` का मतलब क्या है?#

13. `src/test/java`#

14. `src/test/resources`#

19. `target` Directory क्या है?#

20. क्या `target` Manually Create करना चाहिए?#

21. क्या `target` के अंदर Files Manually Edit करनी चाहिए?#

Step 2: Root में `pom.xml` रखें#

Step 7: `target` को Source Folder की तरह मत बनाएँ#

Mistake 1: `pom.xml` को `src` के अंदर रखना#

Mistake 2: Java Files को `src` में सीधे रखना#

Mistake 6: `target` में Permanent Code रखना#