పార్ట్ 8. స్ప్రింగ్ బూట్ ఉపయోగించి చిన్న అప్లికేషన్ వ్రాద్దాం

ఈ మెటీరియల్ "ఇంట్రడక్షన్ టు ఎంటర్‌ప్రైజ్ డెవలప్‌మెంట్" సిరీస్‌లో ముగింపు భాగం. మునుపటి కథనాలు:

• నెట్‌వర్కింగ్ గురించి
• సాఫ్ట్‌వేర్ ఆర్కిటెక్చర్ గురించి
• HTTP/HTTPS గురించి
• మావెన్ యొక్క ప్రాథమిక విషయాల గురించి
• సర్వ్లెట్ల గురించి (ఒక సాధారణ వెబ్ అప్లికేషన్ రాయడం)
• సర్వ్లెట్ కంటైనర్ల గురించి
• MVC యొక్క ప్రాథమిక అంశాల గురించి

స్ప్రింగ్ MVCని ఉదాహరణగా ఉపయోగించి MVC యొక్క సరళమైన అమలును చూద్దాం. దీన్ని చేయడానికి, మేము స్ప్రింగ్ బూట్ ఉపయోగించి చిన్న హలో వరల్డ్ అప్లికేషన్‌ను వ్రాస్తాము. నేను మీకు దశల వారీ సూచనలను ఇస్తాను, కాబట్టి మీరు ప్రతిదీ మీరే పునరావృతం చేయవచ్చు. మొదట, మేము ఒక చిన్న అప్లికేషన్ వ్రాస్తాము, ఆపై మేము దానిని విశ్లేషిస్తాము.

దశ 1. IntelliJ IDEAలో స్ప్రింగ్ బూట్ అప్లికేషన్‌ను సృష్టించడం.

కొత్త ప్రాజెక్ట్‌ను సృష్టించడానికి ఫైల్ -> కొత్తది -> ప్రాజెక్ట్...ని ఉపయోగించండి. తెరిచే విండోలో, ఎడమ వైపు మెనులో, స్ప్రింగ్ ఇనిషియలైజర్‌ని ఎంచుకుని, ప్రాజెక్ట్ SDKని ఎంచుకోండి. Initializr సర్వీస్ URL ఎంపిక కోసం డిఫాల్ట్‌ను వదిలివేయండి. "తదుపరి" బటన్ క్లిక్ చేయండి. తదుపరి విండోలో, మేము ప్రాజెక్ట్ సెట్టింగులను ఎంచుకోవాలి. మేము మావెన్ ప్రాజెక్ట్‌ను కలిగి ఉన్నాము. మావెన్ ప్రాజెక్ట్‌ను రకంగా ఎంచుకోండి. గ్రూప్ మరియు ఆర్టిఫాక్ట్ ఫీల్డ్‌లను పూరించండి తదుపరి క్లిక్ చేయండి. తదుపరి విండోలో, మనం ఉపయోగించే స్ప్రింగ్ ఫ్రేమ్‌వర్క్ భాగాలను ఎంచుకోవాలి. మాకు రెండు సరిపోతాయి:

• స్ప్రింగ్ వెబ్ అనేది వెబ్ అప్లికేషన్‌లను సృష్టించడానికి మమ్మల్ని అనుమతించే ఒక భాగం. ఈ భాగం స్ప్రింగ్ MVCని కలిగి ఉంటుంది.
• Thymeleaf మా టెంప్లేట్ ఇంజిన్. ఇది జావా నుండి HTML పేజీలకు డేటాను పంపడానికి మమ్మల్ని అనుమతించే విషయం

తదుపరి విండోలో, ఫైల్ సిస్టమ్‌లో ప్రాజెక్ట్ పేరు మరియు స్థానాన్ని ఎంచుకోండి: "ముగించు" బటన్‌ను క్లిక్ చేయండి. ప్రాజెక్ట్ రూపొందించబడింది. మేము ఈ క్రింది ప్రాజెక్ట్ నిర్మాణాన్ని ముగించాము: ఇక్కడ మేము 2 ఫైల్‌లపై ఆసక్తి కలిగి ఉన్నాము: pom.xml (డిప్లాయ్‌మెంట్ డిస్క్రిప్టర్). వివిధ ఫ్రేమ్‌వర్క్‌ల నుండి లైబ్రరీలను మా ప్రాజెక్ట్‌లోకి త్వరగా మరియు సులభంగా దిగుమతి చేసుకోవడానికి ఈ విషయం మిమ్మల్ని అనుమతిస్తుంది. మా అప్లికేషన్ ఎలా నిర్మించబడుతుందో కూడా ఇక్కడే మేము కాన్ఫిగర్ చేస్తాము. మా అప్లికేషన్ Maven ఉపయోగించి నిర్మించబడింది మరియు pom.xml అనేది ఈ బిల్డ్ సిస్టమ్ కోసం కాన్ఫిగరేషన్ ఫైల్. జావా క్లాస్ MvcDemoApplication. ఇది మా అప్లికేషన్ యొక్క ప్రధాన తరగతి. మేము దాని నుండి మా స్ప్రింగ్ బూట్ ప్రాజెక్ట్‌ను ప్రారంభిస్తాము. ప్రారంభించడానికి, ఈ తరగతి యొక్క ప్రధాన పద్ధతిని అమలు చేయండి. ఈ తరగతికి సంబంధించిన కోడ్, అలాగే pom.xml ఫైల్ ఇక్కడ ఉంది: MvcDemoApplication:

@SpringBootApplication
public class MvcDemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(MvcDemoApplication.class, args);
    }

}

pom.xml:

<?xml version="1.0" encoding="UTF-8"?>
<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>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.2.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.codegym/groupId>
    <artifactId>mvc_demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>mvc_demo</name>
    <description>Spring MVC Demo</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <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-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

దశ 2. వెబ్‌పేజీని సృష్టించడం

మా అప్లికేషన్ చాలా సులభం అవుతుంది. మాకు ప్రధాన పేజీ (index.html) ఉంటుంది, అందులో స్వాగత పేజీకి లింక్ ఉంటుంది (greeting.html). గ్రీటింగ్ పేజీలో, మేము గ్రీటింగ్‌ని ప్రదర్శిస్తాము. గ్రీటింగ్‌లో ఉపయోగించాల్సిన పేరును గ్రీటింగ్.html పేజీకి పాస్ చేయడానికి మేము URL పారామితులను ఉపయోగిస్తాము. మన అప్లికేషన్ యొక్క ప్రధాన పేజీని సృష్టిద్దాం — index.html:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Main page</title>
</head>
<body>
    <p>Get your greeting <a href="/greeting">here</a></p>
</body>
</html>

ఇప్పుడు మేము గ్రీటింగ్.html పేజీని సృష్టిస్తాము:

<!DOCTYPE HTML>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Getting Started: Serving Web Content</title>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
</head>
<body>
    <p th:text="'Hello, ' + ${name} + '!'" />
</body>
</html>

మా పేజీకి <p th:text="'Hello, ' + ${name} + '!'" />ట్యాగ్ ఉంది, ఇది HTMLకి సాధారణం కాదు. thట్యాగ్ యొక్క లక్షణం Thymeleaf pటెంప్లేట్ ఇంజిన్ ద్వారా ఉపయోగించే ఒక మెకానిజం. ట్యాగ్ pవిలువ "హలో," + వేరియబుల్ యొక్క విలువ name, దీనిని మనం జావా కోడ్‌లో సెట్ చేస్తాము.

దశ 3. నియంత్రికను సృష్టించడం

mvc_demo ప్యాకేజీ లోపల, మేము కంట్రోలర్ ప్యాకేజీని సృష్టిస్తాము, దీనిలో మేము మా కంట్రోలర్, HelloWorldControllerని సృష్టిస్తాము:

@Controller
public class HelloWorldController {

   @RequestMapping(value = "/greeting")
   public String helloWorldController(@RequestParam(name = "name", required = false, defaultValue = "World") String name, Model model) {
       model.addAttribute("name", name);
       return "greeting";
   }

}

ఒక వైపు చాలా తక్కువ కోడ్ ఉంది, కానీ మరోవైపు, చాలా జరుగుతోంది. మన విశ్లేషణను ప్రారంభిద్దాం. @Controller ఉల్లేఖన ఈ తరగతి నియంత్రిక అని సూచిస్తుంది. వసంతకాలంలో, కంట్రోలర్‌లు నిర్దిష్ట URLల వద్ద HTTP అభ్యర్థనలను ప్రాసెస్ చేస్తాయి. మా తరగతిలో @RequestMapping(value = "/greeting") ఉల్లేఖనతో గుర్తించబడిన helloWorldController పద్ధతి ఉంది. /గ్రీటింగ్ URL వద్ద సూచించబడిన HTTP GET అభ్యర్థనలను ఈ పద్ధతి ప్రాసెస్ చేస్తుందని ఈ ఉల్లేఖనం సూచిస్తుంది. మరో మాటలో చెప్పాలంటే, ఎవరైనా /గ్రీటింగ్‌కి నావిగేట్ చేస్తే ఈ పద్ధతి అమలు చేయబడుతుంది. ఈ పద్ధతి స్ట్రింగ్‌ను అందిస్తుంది. స్ప్రింగ్ MVC ప్రకారం, కంట్రోలర్ పద్ధతి వీక్షణ పేరును తిరిగి ఇవ్వాలి. తరువాత, స్ప్రింగ్ అదే పేరుతో HTML ఫైల్ కోసం చూస్తుంది, ఇది HTTP అభ్యర్థనకు ప్రతిస్పందనగా తిరిగి వస్తుంది. మీరు చూడగలరు గా, మా పద్ధతి 2 వాదనలను తీసుకుంటుంది. వాటిని చూద్దాం: పరామితి 1: @RequestParam(పేరు = "పేరు", అవసరం = తప్పు, డిఫాల్ట్ విలువ = "ప్రపంచం") స్ట్రింగ్ పేరు. @RequestParam ఉల్లేఖన స్ట్రింగ్ పేరు పరామితి URL పరామితి అని సూచిస్తుంది. ఉల్లేఖనం ఈ URL పరామితి ఐచ్ఛికం (అవసరం = తప్పు) అని సూచిస్తే, అది లేనట్లయితే, స్ట్రింగ్ పేరు పరామితి యొక్క విలువ "వరల్డ్" (డిఫాల్ట్ విలువ = "ప్రపంచం") అవుతుంది. అది ఉన్నట్లయితే, URL పరామితి "పేరు" (పేరు = "పేరు") అవుతుంది. ఇక్కడ మీకు అర్థం కానివి చాలా ఉండవచ్చు. కొన్ని ఉదాహరణలు అందజేద్దాం. దిగువ పట్టిక స్ట్రింగ్ పేరు పరామితి యొక్క విలువ ఎలా ఉంటుందో చూపుతుంది, యాక్సెస్ /గ్రీటింగ్ కోసం వివిధ ఎంపికలు (URL పారామీటర్‌లతో మరియు లేకుండా) పరామితి 2: రెండవ పరామితి మోడల్ మోడల్. ఈ పరామితి కొంత మోడల్. ఈ మోడల్ వివిధ అంతర్గత లక్షణాలను కలిగి ఉంటుంది. ప్రతి లక్షణానికి ఒక పేరు మరియు విలువ ఉంటుంది. కీ-విలువ జతల లాంటివి. జావా కోడ్ నుండి HTML పేజీలకు డేటాను పంపడానికి మేము ఈ పరామితిని ఉపయోగించవచ్చు. లేదా, MVC పరిభాషను ఉపయోగించి, మోడల్ నుండి వీక్షణకు డేటాను పంపండి. ఇది చివరి పంక్తిని పరిశీలించడానికి మాత్రమే మిగిలి ఉంది. మేము జావా నుండి HTMLకి లేదా మోడల్ నుండి వీక్షణకు డేటాను ఎలా పంపుతాము. పద్ధతి కింది పంక్తిని కలిగి ఉంటుంది: model.addAttribute("name", name); ఇక్కడ మేము పేరు అనే కొత్త లక్షణాన్ని సృష్టించి, పేరు పరామితి యొక్క విలువను కేటాయించాము. గుర్తుంచుకోండి, మేము ఇటీవల చర్చించాము <p th:text = "'Hello,' + ${name} + '!'" /> p ట్యాగ్ విలువ "హలో," + పేరు వేరియబుల్ విలువ, దీనిని మనం జావా కోడ్‌లో సెట్ చేస్తాము. మేము లైన్ ఉపయోగించి ఈ విలువను సెట్ చేస్తాము model.addAttribute("name", name);

దశ 5. రన్

ప్రారంభించడానికి, మేము MvcDemoApplication తరగతి యొక్క ప్రధాన పద్ధతిని అమలు చేయాలి: లాగ్‌లలో, మా వెబ్ అప్లికేషన్ పోర్ట్ 8080లో ప్రారంభమైందని మేము చూస్తాము: మరియు దీని అర్థం బ్రౌజర్‌లో, మేము http:// వద్ద ఉన్న పేజీకి వెళ్లవచ్చు. localhost:8080 : ఇక్కడ మనకు index.html పేజీ ఉంది. గ్రీటింగ్ పేజీకి లింక్‌ని అనుసరించండి: ఈ పరివర్తనలో మా కంట్రోలర్ ప్రారంభించబడింది. మేము URL ద్వారా ఏ పారామీటర్‌లను పాస్ చేయలేదు. ఫలితంగా, పేరు లక్షణం ఉల్లేఖనంలో సూచించబడిన డిఫాల్ట్ విలువ ("ప్రపంచం")ని తీసుకుంటుంది. URL ద్వారా పారామీటర్‌ను పాస్ చేయడానికి ప్రయత్నిద్దాం: అంతా అనుకున్నట్లుగానే పని చేస్తుంది. ఇప్పుడు పేరు వేరియబుల్ యొక్క మార్గాన్ని కనుగొనడానికి ప్రయత్నించండి:

1. వినియోగదారు URL ->లో "name=Amigo"ని ఆమోదించారు
2. కంట్రోలర్ మా చర్యను ప్రాసెస్ చేసింది, పేరు వేరియబుల్‌ను పొందింది మరియు అందుకున్న విలువకు సమానమైన పేరు అనే మోడల్ లక్షణాన్ని సెట్ చేసింది ->
3. ఈ డేటా మోడల్ నుండి వీక్షించడానికి వచ్చింది, గ్రీటింగ్.html పేజీలో ముగుస్తుంది మరియు వినియోగదారుకు ప్రదర్శించబడుతుంది

ప్రస్తుతానికి అంతే!