యుద్ధం మరియు జార్ ఫైళ్ల మధ్య తేడాలు

నిజానికి , జార్ లైబ్రరీ అనేది కేవలం జిప్ ఆర్కైవ్, ఇది నేరుగా దాని పేరు నుండి అనుసరిస్తుంది: జావా ఆర్కైవ్ . చాలా తరచుగా ఇది కేవలం నాలుగు విషయాలను కలిగి ఉంటుంది:

  • సంకలనం చేసిన తరగతులు;
  • వనరులు: ప్రాపర్టీస్ ఫైల్స్ మరియు ఇలాంటివి;
  • మానిఫెస్ట్ MANIFEST.MF;
  • ఇతర జార్ లైబ్రరీలు (అరుదైన).

అటువంటి ఆర్కైవ్ యొక్క సాధారణ నిర్మాణం ఇలా కనిపిస్తుంది:

  META-INF/
  	MANIFEST.MF
  com/
  	codegym/
	      MyApplication.class
  application.properties

ఇప్పుడు ఒక సాధారణ యుద్ధ ఫైల్‌ని చూద్దాం. మార్గం ద్వారా, యుద్ధం అనేది యుద్ధం అనే పదం నుండి కాదు, W eb Ar chive . యుద్ధ ఫైల్ యొక్క నిర్మాణం సాధారణంగా మరింత క్లిష్టంగా ఉంటుంది. చాలా తరచుగా ఇది రెండు భాగాలను కలిగి ఉంటుంది:

  • జావా భాగం
    • సంకలనం చేసిన తరగతులు
    • జావా తరగతులకు వనరులు: ప్రాపర్టీస్ ఫైల్స్ మరియు ఇలాంటివి
    • ఇతర జార్ లైబ్రరీలు (తరచూ)
    • మానిఫెస్ట్ MANIFEST.MF
  • వెబ్ భాగం
    • web-xml - వెబ్ సర్వీస్ డిప్లాయ్‌మెంట్ డిస్క్రిప్టర్
    • jsp సర్వ్లెట్స్
    • స్టాటిక్ వెబ్ వనరులు: HTML, CSS, JS ఫైల్‌లు

సాధారణ యుద్ధ ఫైల్ యొక్క ఉదాహరణ:

META-INF/
    MANIFEST.MF
WEB-INF/
    web.xml
    jsp/
    	helloWorld.jsp
    classes/
    	static/
    	templates/
    	application.properties
    lib/
    	// *.jar files as libs

ముఖ్యమైనది! jar ఫైల్‌ను కేవలం జావా మెషీన్ ద్వారా అమలు చేయవచ్చు, కానీ వార్ ఫైల్‌ను అమలు చేయడానికి, అది తప్పనిసరిగా వెబ్ సర్వర్‌కు అప్‌లోడ్ చేయబడాలి. ఇది దానంతట అదే ప్రారంభం కాదు.

Java webinar

మావెన్-వార్-ప్లగ్ఇన్‌తో యుద్ధ ఫైల్ ప్లగిన్

మనకు ఒక సాధారణ వెబ్ ప్రాజెక్ట్ ఉందని ఊహించుకుందాం. ప్రాజెక్ట్‌కు అటువంటి ఫైల్ నిర్మాణాన్ని ఇవ్వనివ్వండి, మేము దానిని ఎలా సమీకరించాలి?

|-- pom.xml
 `-- src
 	`-- main
     	|-- java
     	|   `-- com
     	|   	`-- example
     	|       	`-- projects
     	|           	`-- SampleAction.java
     	|-- resources
     	|   `-- images
     	|   	`-- sampleimage.jpg
     	`-- webapp
         	|-- WEB-INF
         	|   `-- web.xml
         	|-- index.jsp
         	`-- jsp
             	`-- websource.jsp

ముందుగా, వీటన్నిటినీ వార్ ఫైల్‌గా నిర్మించమని మేము మావెన్‌కి చెప్పాలి , దీని కోసం <package> ట్యాగ్ ఉంది , ఉదాహరణకు:

	<project>
  	...
      <groupId>com.example.projects</groupId>
      <artifactId>simple-war</artifactId>
  	<packaging>war</packaging>
      <version>1.0-SNAPSHOT</version>
  	<name>Simple War Project</name>
      <url>http://codegym.cc</url>
  	...
    </project>

రెండవది, మేము maven-war-plugin pluginని చేర్చాలి . ఉదాహరణ:

  <build>
	<plugins>
  	<plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-war-plugin</artifactId>
    	<version>3.3.2</version>
    	<configuration>
          <webappDirectory>/sample/servlet/container/deploy/directory</webappDirectory>
    	</configuration>
      </plugin>
    </plugins>
  </build>

ఇక్కడ మేము భవిష్యత్తులో కాన్ఫిగర్ చేయగల ప్లగిన్‌ను నిర్వచించాము. అలాగే, webappDirectory ట్యాగ్‌ని ఉపయోగించి , ప్రాజెక్ట్ అమలు చేయబడే డైరెక్టరీని మేము పునర్నిర్వచించాము. ఇప్పుడు నేను మాట్లాడుతున్న దాని గురించి మరింత మీకు చెప్తాను.

ప్లగ్ఇన్‌ను రెండు బిల్డ్ మోడ్‌లకు సెట్ చేయవచ్చు (రెండు రకాల గోల్):

  • యుద్ధం: యుద్ధం
  • యుద్ధం: పేలింది

మొదటి సందర్భంలో, ఫలిత వార్ ఫైల్ లక్ష్య ఫోల్డర్‌లో ఉంచబడుతుంది మరియు <artifactId>-<version>.war .

కానీ మీరు ప్లగ్ఇన్‌ను "అడగవచ్చు" తద్వారా వార్ ఫైల్ యొక్క కంటెంట్‌లు చివరి ఫోల్డర్‌లో ఉంచబడతాయి, దీనిలో లోపల ఉన్న వెబ్ సర్వర్ ద్వారా అన్‌ప్యాక్ చేయబడుతుంది. దీని కోసం, గోల్ వార్: ఎక్స్‌ప్లోడెడ్ ఉపయోగించబడుతుంది .

మీరు Intellij IDEA నుండి నేరుగా ప్రాజెక్ట్‌ను అమలు చేస్తున్నట్లయితే లేదా డీబగ్ చేస్తున్నట్లయితే రెండవ విధానం తరచుగా ఉపయోగించబడుతుంది.

మార్గం ద్వారా, పైన ఉన్న ఉదాహరణలోని webappDirectory ట్యాగ్ , war:exploded మోడ్‌లో నిర్మించేటప్పుడు మీ వార్ ఫైల్ అన్‌ప్యాక్ చేయబడే డైరెక్టరీని పునర్నిర్వచించటానికి మిమ్మల్ని అనుమతిస్తుంది.

మీరు దాని అధికారిక పేజీ నుండి ఇతర ప్లగ్ఇన్ సెట్టింగ్‌ల గురించి తెలుసుకోవచ్చు .

SpringBoot ఆధారంగా వెబ్ అప్లికేషన్‌ను రూపొందించడం

సరే, నేను కొన్ని నిజమైన అసెంబ్లీ ఉదాహరణను విడదీయాలనుకుంటున్నాను. మనం ట్రిఫ్లెస్‌గా ఉండకూడదు మరియు స్ప్రింగ్‌బూట్ ఆధారంగా ఒక ఉదాహరణ అప్లికేషన్‌ని ఉపయోగించి దీనిని పరిగణించండి.

మొదటి అడుగు. IDEAతో ఖాళీ మావెన్ వెబ్ ప్రాజెక్ట్‌ను సృష్టించండి.

దశ రెండు. దాని pom.xmlకి స్ప్రింగ్ డిపెండెన్సీలను జోడించండి.

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-tomcat</artifactId>
    <scope>provided</scope>
</dependency>

దశ మూడు. com.codegym.spring.MainController తరగతిని సృష్టించండి . ఇది src/main/java ఫోల్డర్‌లో ఉంచాలి :

@Controller
public class MainController {

	@GetMapping("/")
    public String viewIndexPage(Model model) {
        model.addAttribute("header", "Maven Generate War");
    	return "index";
	}
}

ఇక్కడ 3 విషయాలు వివరించబడ్డాయి. ముందుగా, ఇన్‌కమింగ్ వెబ్ అభ్యర్థనలను అందించడానికి ఈ తరగతి ఉపయోగించబడుతుంది అని @Controller ఉల్లేఖన SpringBoot ఫ్రేమ్‌వర్క్‌కి చెబుతుంది.

రెండవది, @GetMapping ఉల్లేఖనం , URI - / రూట్‌లో GET అభ్యర్థనను అందించడానికి మా పద్ధతిని పిలవబడుతుందని సూచిస్తుంది

మూడవది, పద్ధతి స్ట్రింగ్ "ఇండెక్స్"ని అందిస్తుంది . ఇది స్ప్రింగ్‌బూట్ ఫ్రేమ్‌వర్క్‌కు index.html ఫైల్ యొక్క కంటెంట్‌లను ప్రతిస్పందనగా తిరిగి ఇవ్వమని చెబుతుంది .

దశ నాలుగు. మీరు ఈ క్రింది కంటెంట్‌తో ప్రాజెక్ట్‌కి index.html ఫైల్‌ను జోడించాలి:

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Index</title>
    <!-- Bootstrap core CSS -->
    <link th:href="@{/css/bootstrap.min.css}" rel="stylesheet">
</head>
<body>
    <nav class="navbar navbar-light bg-light">
    	<div class="container-fluid">
        	<a class="navbar-brand" href="#">
            	CodeGym Tutorial
        	</a>
    	</div>
    </nav>
    <div class="container">
    	<h1>[[${header}]]</h1>
    </div>
</body>
</html>

ఇది html మాత్రమే కాదు. దాని కంటెంట్ క్లయింట్‌కు ఇవ్వడానికి ముందు, ఇది థైమ్‌లీఫ్ ఫ్రేమ్‌వర్క్ ద్వారా సర్వర్‌లో సవరించబడుతుంది . ఈ ఫైల్‌లో ప్రత్యేక ట్యాగ్‌లు పొందుపరచబడ్డాయి, ఇవి థైమ్‌లీఫ్ లైబ్రరీని పేజీలోని కంటెంట్‌ను ప్రాసెస్ చేయడానికి మరియు సవరించడానికి అనుమతిస్తాయి.

ఎరుపు రంగులో ఉన్న ట్యాగ్‌లు థైమ్‌లీఫ్ లైబ్రరీ ద్వారా ప్రాసెస్ చేయబడే ట్యాగ్‌లు, ఆకుపచ్చ రంగులు బూట్‌స్ట్రాప్ CSS లైబ్రరీ యొక్క శైలులు.

దశ ఐదు. pom.xmlలో ప్లగిన్‌ని సెట్ చేయండి:

<plugin>
    <artifactId>maven-war-plugin</artifactId>
    <version>3.3.1</version>
</plugin>

నేను నా బలాన్ని కొంచెం ఎక్కువగా అంచనా వేసాను. ఒక సాధారణ ఉదాహరణను పూర్తిగా అన్వయించడానికి చాలా సమయం పడుతుంది. కానీ మీరు GitHub నుండి ప్రాజెక్ట్ యొక్క పూర్తి కోడ్‌ను డౌన్‌లోడ్ చేసుకోవచ్చు మరియు దానిని మీరే అర్థం చేసుకోవడానికి ప్రయత్నించవచ్చు. మార్గం ద్వారా, మీ పని సమయంలో 80% మీరు అలా చేస్తారు :)

మీరు GitHubలోని లింక్ నుండి పూర్తి కోడ్‌ని డౌన్‌లోడ్ చేసుకోవచ్చు .