Node.js
익스프레스가 포함 된 웹 앱

소개

통사론

• app.get (경로 [, 미들웨어], 콜백 [, 콜백 ...])
• app.put (경로 [, 미들웨어], 콜백 [, 콜백 ...])
• app.post (경로 [, 미들웨어], 콜백 [, 콜백 ...])
• app [ 'delete'] (경로 [, 미들웨어], 콜백 [, 콜백 ...])
• app.use (경로 [, 미들웨어], 콜백 [, 콜백 ...])
• app.use (콜백)

매개 변수

시작하기

먼저 디렉토리를 만들고 쉘에 액세스하여 npm 을 사용하여 Express를 npm install express --save 합니다. npm install express --save

파일을 작성하고 app.js 이름을 app.js 하고 새로운 Express 서버를 작성하고 app.get 메소드를 사용하여 하나의 엔드 포인트 ( /ping )를 추가하는 다음 코드를 추가하십시오.

const express = require('express');

const app = express();

app.get('/ping', (request, response) => {
    response.send('pong');
});

app.listen(8080, 'localhost');

스크립트를 실행하려면 쉘에서 다음 명령을 사용하십시오.

> node app.js

응용 프로그램은 localhost 포트 8080에서 연결을 허용합니다. app.listen 대한 hostname 인수를 생략하면 서버는 localhost뿐만 아니라 시스템의 IP 주소에서도 연결을 허용합니다. 포트 값이 0이면 운영 체제에서 사용 가능한 포트를 할당합니다.

스크립트가 실행되면 셸에서 테스트하여 서버에서 예상되는 응답 "pong"을 얻었음을 확인할 수 있습니다.

> curl http://localhost:8080/ping
pong

웹 브라우저를 열고 url http : // localhost : 8080 / ping으로 이동하여 출력을 볼 수도 있습니다

기본 라우팅

먼저 특급 앱을 만듭니다.

const express = require('express');
const app = express();

그런 다음 아래와 같은 경로를 정의 할 수 있습니다.

app.get('/someUri', function (req, res, next) {})

이 구조는 모든 HTTP 메소드에 대해 작동하며 첫 번째 인수로 경로를, 요청 및 응답 객체를 수신하는 해당 경로에 대한 핸들러를 필요로합니다. 따라서 기본 HTTP 메소드의 경우 이는 경로입니다.

// GET www.domain.com/myPath
app.get('/myPath', function (req, res, next) {})

// POST www.domain.com/myPath
app.post('/myPath', function (req, res, next) {})

// PUT www.domain.com/myPath
app.put('/myPath', function (req, res, next) {})

// DELETE www.domain.com/myPath
app.delete('/myPath', function (req, res, next) {})

여기서 지원되는 동사의 전체 목록을 확인할 수 있습니다. 경로 및 모든 HTTP 메소드에 대해 동일한 동작을 정의하려면 다음을 사용할 수 있습니다.

app.all('/myPath', function (req, res, next) {}) 

또는

app.use('/myPath', function (req, res, next) {})

또는

app.use('*', function (req, res, next) {})

// * wildcard will route for all paths

단일 경로에 대해 경로 정의를 연결할 수 있습니다.

app.route('/myPath')
  .get(function (req, res, next) {})
  .post(function (req, res, next) {})
  .put(function (req, res, next) {})

HTTP 메소드에 함수를 추가 할 수도 있습니다. 그들은 최종 콜백 전에 실행될 것이고 매개 변수 (req, res, next)를 인수로 취할 것입니다.

// GET www.domain.com/myPath
app.get('/myPath', myFunction, function (req, res, next) {})

하나의 파일에 너무 많은 코드를 넣지 않으려면 최종 콜백을 외부 파일에 저장할 수 있습니다.

// other.js
exports.doSomething = function(req, res, next) {/* do some stuff */};

그런 다음 경로가 포함 된 파일에서 다음을 수행하십시오.

const other = require('./other.js');
app.get('/someUri', myFunction, other.doSomething);

이렇게하면 코드를 훨씬 깔끔하게 정리할 수 있습니다.

요청에서 정보 얻기

요청 URL에서 정보를 얻으려면 ( req 는 라우트의 핸들러 함수에서 요청 객체 임). 다음 경로 정의 /settings/:user_id 고려하십시오 /settings/:user_id 및이 특정 예제 /settings/32135?field=name

// get the full path
req.originalUrl // => /settings/32135?field=name

// get the user_id param
req.params.user_id // => 32135     

// get the query value of the field
req.query.field // => 'name'

요청의 헤더를 얻을 수도 있습니다.

req.get('Content-Type')
// "text/plain"

다른 정보를 얻는 것을 단순화하기 위해 미들웨어를 사용할 수 있습니다. 예를 들어, 요청의 본문 정보를 얻으려면 원시 요청 본문을 사용 가능한 형식으로 변환하는 body-parser 미들웨어를 사용할 수 있습니다.

var app = require('express')();
var bodyParser = require('body-parser');

app.use(bodyParser.json()); // for parsing application/json
app.use(bodyParser.urlencoded({ extended: true })); // for parsing application/x-www-form-urlencoded

이제 이와 같은 요청을 가정 해 봅시다.

PUT /settings/32135
{
  "name": "Peter"
}

다음과 같이 게시 된 이름에 액세스 할 수 있습니다.

req.body.name
// "Peter"

비슷한 방법으로 요청에서 쿠키에 액세스 할 수 있으며 쿠키 파서 와 같은 미들웨어도 필요합니다.

req.cookies.name

모듈 식 고속 애플리케이션

특급 웹 응용 프로그램을 모듈 식 라우터로 사용하려면 다음을 수행하십시오.

기준 치수:

// greet.js
const express = require('express');

module.exports = function(options = {}) { // Router factory
    const router = express.Router();

    router.get('/greet', (req, res, next) => {
        res.end(options.greeting);
    });

    return router;
};

신청:

// app.js
const express = require('express');
const greetMiddleware = require('./greet.js');

express()
    .use('/api/v1/', greetMiddleware({ greeting:'Hello world' }))
    .listen(8080);

이렇게하면 응용 프로그램을 모듈화하고 사용자 정의 할 수 있으며 코드를 재사용 할 수 있습니다.

http://<hostname>:8080/api/v1/greet 액세스 할 때 출력은 Hello world

보다 복잡한 예제

미들웨어 팩토리 장점을 보여주는 서비스 예제.

기준 치수:

// greet.js
const express = require('express');

module.exports = function(options = {}) { // Router factory
    const router = express.Router();
    // Get controller
    const {service} = options;

    router.get('/greet', (req, res, next) => {
        res.end(
            service.createGreeting(req.query.name || 'Stranger')
        );
    });

    return router;
};

신청:

// app.js
const express = require('express');
const greetMiddleware = require('./greet.js');

class GreetingService {
    constructor(greeting = 'Hello') {
        this.greeting = greeting;
    }

    createGreeting(name) {
        return `${this.greeting}, ${name}!`;
    }
}

express()
    .use('/api/v1/service1', greetMiddleware({
        service: new GreetingService('Hello'),
    }))
    .use('/api/v1/service2', greetMiddleware({
        service: new GreetingService('Hi'),
    }))
    .listen(8080);

http://<hostname>:8080/api/v1/service1/greet?name=World 액세스 할 때 출력은 Hello, World 되며 http://<hostname>:8080/api/v1/service2/greet?name=World 액세스합니다 http://<hostname>:8080/api/v1/service2/greet?name=World 출력은 Hi, World 가 될 것입니다.

템플릿 엔진 사용

템플릿 엔진 사용

다음 코드는 Jade를 템플릿 엔진으로 설정합니다. (참고 : Jade는 2015 년 12 월부터 pug 로 개명되었습니다.)

const express = require('express');  //Imports the express module
const app = express();  //Creates an instance of the express module

const PORT = 3000; //Randomly chosen port

app.set('view engine','jade'); //Sets jade as the View Engine / Template Engine
app.set('views','src/views'); //Sets the directory where all the views (.jade files) are stored.

//Creates a Root Route
app.get('/',function(req, res){
    res.render('index');  //renders the index.jade file into html and returns as a response. The render function optionally takes the data to pass to the view.
});

//Starts the Express server with a callback
app.listen(PORT, function(err) {
    if (!err) {
        console.log('Server is running at port', PORT);
    } else {
        console.log(JSON.stringify(err));
    }
});

비슷하게 Handlebars ( hbs ) 나 ejs 같은 다른 템플릿 엔진도 사용할 수 있습니다. 템플릿 엔진을 npm install 하는 것을 잊지 npm install . Handlebars는 hbs 패키지를 사용합니다. Jade에는 jade 패키지가 있고 EJS에는 ejs 패키지가 있습니다.

EJS 템플릿 예제

다른 Express 템플릿과 마찬가지로 EJS를 사용하면 서버 코드를 실행하고 HTML에서 서버 변수에 액세스 할 수 있습니다.
EJS에서는 " <% "를 시작 태그로 사용하고 " %> "를 종료 태그로 사용하여 렌더링 매개 변수로 전달 된 변수에 <%=var_name%>
예를 들어 서버 코드에 소모품 배열이있는 경우
당신은 그것을 통해 반복 할 수 있습니다.

<h1><%= title %></h1>
   <ul>
<% for(var i=0; i<supplies.length; i++) { %>
    <li>
        <a href='supplies/<%= supplies[i] %>'>
            <%= supplies[i] %>
        </a>
    </li>
<% } %>

이 예제에서 볼 수 있듯이 서버 측 코드와 HTML 사이를 전환 할 때마다 현재 EJS 태그를 닫고 나중에 새 EJS 태그를 열어야합니다. 여기에서 for 명령 내에 li 을 작성하여 EJS 태그를 닫아야했습니다 for 의 끝에서 중괄호를위한 새 태그를 만듭니다.
다른 예시
입력 기본 버전을 서버 측에서 변수로 사용하려면 <%=
예 :

 Message:<br>
<input type="text" value="<%= message %>" name="message" required>

여기에 서버 측에서 전달 된 메시지 변수가 입력 값의 기본값이 될 것입니다. 서버 측에서 메시지 변수를 전달하지 않으면 EJS가 예외를 throw합니다. res.render('index', {message: message}); 사용하여 매개 변수를 전달할 수 있습니다 res.render('index', {message: message}); (index.ejs라는 ejs 파일 용).

EJS 태그에서 if , while 또는 원하는 다른 javascript 명령을 사용할 수도 있습니다.

ExpressJS가있는 JSON API

var express = require('express');
var cors = require('cors'); // Use cors module for enable Cross-origin resource sharing

var app = express();
app.use(cors()); // for all routes

var port = process.env.PORT || 8080;

app.get('/', function(req, res) {
    var info = {
        'string_value': 'StackOverflow',
        'number_value': 8476
    }
    res.json(info);

    // or
    /* res.send(JSON.stringify({
        string_value: 'StackOverflow',
        number_value: 8476
    })) */

  //you can add a status code to the json response
   /* res.status(200).json(info) */
})

app.listen(port, function() {
    console.log('Node.js listening on port ' + port)
})

http://localhost:8080/ output 객체에서

{
    string_value: "StackOverflow",
    number_value: 8476
}

정적 파일 검색

Express가있는 웹 서버를 구축 할 때 종종 동적 컨텐츠와 정적 파일을 함께 제공해야합니다.

예를 들어 파일 시스템에 정적 파일 인 index.html과 script.js가있을 수 있습니다.

'public'이라는 폴더를 정적 파일로 사용하는 것이 일반적입니다. 이 경우 폴더 구조는 다음과 같습니다.

project root
├── server.js
├── package.json 
└── public
    ├── index.html
    └── script.js

다음은 정적 파일을 제공하도록 Express를 구성하는 방법입니다.

const express = require('express');
const app = express();

app.use(express.static('public'));

참고 : 폴더가 구성되면 index.html, script.js 및 "public"폴더의 모든 파일을 루트 경로에서 사용할 수 있습니다 (URL에 /public/ 을 지정하면 안됩니다). 이는 express가 구성된 고정 폴더를 기준으로 파일을 검색하기 때문입니다. 다음과 같이 가상 경로 접두어 를 지정할 수 있습니다.

app.use('/static', express.static('public'));

/static/ 접두사 아래에서 리소스를 사용할 수있게합니다.

여러 폴더

동시에 여러 폴더를 정의 할 수 있습니다.

app.use(express.static('public'));
app.use(express.static('images'));
app.use(express.static('files'));

자원을 제공 할 때 Express는 정의 순서대로 폴더를 검사합니다. 이름이 같은 파일의 경우 일치하는 첫 번째 폴더에있는 파일이 제공됩니다.

Django-style의 명명 된 경로

큰 문제 중 하나는 Express라는 독창적 인 기능으로 귀중한 이름의 라우트가 지원되지 않는다는 것입니다. 해결 방법은 지원되는 타사 패키지를 설치하는 것입니다 (예 : express-reverse) .

npm install express-reverse

프로젝트에 연결하십시오.

var app = require('express')();
require('express-reverse')(app);

다음과 같이 사용하십시오.

app.get('test', '/hello', function(req, res) {
  res.end('hello');
});

이 접근법의 단점은 고급 라우터 사용법 에서 볼 수 있듯이 route Express 모듈을 사용할 수 없다는 것입니다. 해결 방법은 app 을 라우터 팩터의 매개 변수로 전달하는 것입니다.

require('./middlewares/routing')(app);

그리고 그것을 다음과 같이 사용하십시오 :

module.exports = (app) => {
    app.get('test', '/hello', function(req, res) {
      res.end('hello');
    });
};

이제부터는 함수를 정의하여 지정된 사용자 정의 네임 스페이스와 병합하고 적절한 컨트롤러를 가리키는 방법을 알아낼 수 있습니다.

오류 처리

기본 오류 처리

기본적으로 Express는 /views 디렉토리에서 '오류'보기를 검색하여 렌더링합니다. '오류'보기를 작성하고 뷰 디렉토리에 놓으면 오류를 처리 할 수 ​​있습니다. 오류는 오류 메시지, 상태 및 스택 추적과 함께 기록됩니다 (예 :

views / error.pug

html
  body
      h1= message
      h2= error.status
      p= error.stack

고급 오류 처리

미들웨어 기능 스택 맨 끝에 오류 처리 미들웨어 기능을 정의하십시오. 이것들은 3 대신에 4 개의 인수 (err, req, res, next) 를 가지고 있습니다 :

app.js

// catch 404 and forward to error handler
app.use(function(req, res, next) {
    var err = new Error('Not Found');
    err.status = 404;

    //pass error to the next matching route.
    next(err);
});

// handle error, print stacktrace
app.use(function(err, req, res, next) {
    res.status(err.status || 500);

    res.render('error', {
        message: err.message,
        error: err
    });
});

일반적인 미들웨어 기능과 마찬가지로 몇 가지 오류 처리 미들웨어 기능을 정의 할 수 있습니다.

미들웨어와 다음 콜백 사용하기

Express는 여러 라우트 핸들러와 미들웨어 기능에 next 콜 i을 전달하여 여러 핸들러에서 단일 라우트에 대한 로직을 중단시키는 데 사용할 수 있습니다. 인수없이 next() 를 호출하면 다음 일치하는 미들웨어 또는 라우트 핸들러로 계속 진행됩니다. 오류가있는 next(err) 를 호출하면 오류 처리기 미들웨어가 트리거됩니다. next('route') 호출하면 현재 경로에서 이후 미들웨어를 무시하고 다음 일치 경로로 건너 뜁니다. 이를 통해 도메인 논리를 자체 포함되고 테스트가 간단하며 유지 보수 및 변경이 용이 한 재사용 가능한 구성 요소로 분리 할 수 ​​있습니다.

여러 개의 일치하는 경로

/api/foo 또는 /api/bar 대한 요청은 초기 처리기를 실행하여 구성원을 조회 한 다음 각 경로에 대한 실제 처리기로 제어를 전달합니다.

app.get('/api', function(req, res, next) {
  // Both /api/foo and /api/bar will run this
  lookupMember(function(err, member) {
    if (err) return next(err);
    req.member = member;
    next();
  });
});

app.get('/api/foo', function(req, res, next) {
  // Only /api/foo will run this
  doSomethingWithMember(req.member);
});

app.get('/api/bar', function(req, res, next) {
  // Only /api/bar will run this
  doSomethingDifferentWithMember(req.member);
});

오류 처리기

오류 처리기는 서명 function(err, req, res, next) 가있는 미들웨어입니다. 경로마다 설정할 수 있습니다 (예 : app.get('/foo', function(err, req, res, next) ). 일반적으로 오류 페이지를 렌더링하는 단일 오류 처리기로 충분합니다.

app.get('/foo', function(req, res, next) {
  doSomethingAsync(function(err, data) {
    if (err) return next(err);
    renderPage(data);
  });
});

// In the case that doSomethingAsync return an error, this special
// error handler middleware will be called with the error as the 
// first parameter.
app.use(function(err, req, res, next) {
  renderErrorPage(err);
});

미들웨어

위의 각 기능은 실제로 요청이 정의 된 라우트와 일치 할 때마다 실행되는 미들웨어 기능이지만 하나의 라우트에 여러 개의 미들웨어 기능을 정의 할 수 있습니다. 이를 통해 미들웨어를 별도의 파일로 정의하고 공통 논리를 여러 경로에 걸쳐 재사용 할 수 있습니다.

app.get('/bananas', function(req, res, next) {
  getMember(function(err, member) {
    if (err) return next(err);
    // If there's no member, don't try to look
    // up data. Just go render the page now.
    if (!member) return next('route');
    // Otherwise, call the next middleware and fetch
    // the member's data.
    req.member = member;
    next();
  });
}, function(req, res, next) {
  getMemberData(req.member, function(err, data) {
    if (err) return next(err);
    // If this member has no data, don't bother
    // parsing it. Just go render the page now.
    if (!data) return next('route');
    // Otherwise, call the next middleware and parse
    // the member's data. THEN render the page.
    req.member.data = data;
    next();
  });
}, function(req, res, next) {
  req.member.parsedData = parseMemberData(req.member.data);
  next();
});

app.get('/bananas', function(req, res, next) {
  renderBananas(req.member);
});

이 예에서 각 미들웨어 기능은 다른 경로에서 재사용 할 수 있도록 파일 자체 또는 파일의 다른 변수에 있습니다.

오류 처리

기본 문서는 여기 에서 찾을 수 있습니다 .

app.get('/path/:id(\\d+)', function (req, res, next) { // please note: "next" is passed
    if (req.params.id == 0) // validate param
        return next(new Error('Id is 0')); // go to first Error handler, see below

    // Catch error on sync operation
    var data;
    try {
        data = JSON.parse('/file.json');
    } catch (err) {
        return next(err);
    }

    // If some critical error then stop application
    if (!data)
        throw new Error('Smth wrong');

    // If you need send extra info to Error handler
    // then send custom error (see Appendix B)
    if (smth)
        next(new MyError('smth wrong', arg1, arg2))

    // Finish request by res.render or res.end
    res.status(200).end('OK');
});    

// Be sure: order of app.use have matter
// Error handler
app.use(function(err, req, res, next)) {
    if (smth-check, e.g. req.url != 'POST') 
        return next(err); // go-to Error handler 2.

    console.log(req.url, err.message);

    if (req.xhr) // if req via ajax then send json else render error-page
        res.json(err);
    else 
        res.render('error.html', {error: err.message});  
});

// Error handler 2
app.use(function(err, req, res, next)) {
    // do smth here e.g. check that error is MyError
    if (err instanceof MyError) {
        console.log(err.message, err.arg1, err.arg2);
    }     
    ...
    res.end();
});

부록

// "In Express, 404 responses are not the result of an error, 
// so the error-handler middleware will not capture them." 
// You can change it.
app.use(function(req, res, next) {
    next(new Error(404)); 
});

부록 B

// How to define custom error
var util = require('util');
...
function MyError(message, arg1, arg2) {
    this.message = message;
    this.arg1 = arg1;
    this.arg2 = arg2;
    Error.captureStackTrace(this, MyError);
}
util.inherits(MyError, Error);
MyError.prototype.name = 'MyError';

Hook : req 전과 res 후 코드를 실행하는 법

app.use() 및 미들웨어는 "before"에 사용할 수 있으며 close 및 finish 이벤트의 조합은 "after"에 사용할 수 있습니다.

app.use(function (req, res, next) {
    function afterResponse() {
        res.removeListener('finish', afterResponse);
        res.removeListener('close', afterResponse);

        // actions after response
    }
    res.on('finish', afterResponse);
    res.on('close', afterResponse);

    // action before request
    // eventually calling `next()`
    next();
});
...
app.use(app.router);

예를 들어, 로거 미들웨어가 있습니다.이 미들웨어는 기본적으로 응답 후에 로그에 추가됩니다.

이 "미들웨어"가 app.router 전에 순서대로 사용되는지 확인하십시오.

---

원래 게시물은 여기에 있습니다.

POST 요청 처리

app.get 메소드를 사용하여 Express에서 요청을 처리하는 것처럼 app.post 메소드를 사용하여 게시 요청을 처리 할 수 ​​있습니다.

그러나 POST 요청을 처리 할 수 ​​있으려면 먼저 body-parser 미들웨어를 사용해야합니다. 단순히 POST , PUT , DELETE 및 기타 요청의 본문을 구문 분석합니다.

Body-Parser 미들웨어는 요청의 본문을 파싱하여 req.body 에서 사용할 수있는 객체로 req.body

var bodyParser = require('body-parser');

const express = require('express');

const app = express();

// Parses the body for POST, PUT, DELETE, etc.
app.use(bodyParser.json());

app.use(bodyParser.urlencoded({ extended: true }));

app.post('/post-data-here', function(req, res, next){

    console.log(req.body); // req.body contains the parsed body of the request.

});

app.listen(8080, 'localhost');

쿠키 파서로 쿠키 설정하기

다음은 쿠키 파서 모듈을 사용하여 쿠키 를 설정하고 읽는 예제입니다.

var express = require('express');
var cookieParser = require('cookie-parser'); // module for parsing cookies
var app = express();
app.use(cookieParser());

app.get('/setcookie', function(req, res){
    // setting cookies
    res.cookie('username', 'john doe', { maxAge: 900000, httpOnly: true });
    return res.send('Cookie has been set');
});

app.get('/getcookie', function(req, res) {
    var username = req.cookies['username'];
    if (username) {
        return res.send(username);        
    }

    return res.send('No cookie found');
});

app.listen(3000);

Express의 사용자 정의 미들웨어

Express에서는 요청을 확인하거나 응답으로 일부 헤더를 설정하는 데 사용할 수있는 미들웨어를 정의 할 수 있습니다.

app.use(function(req, res, next){ });    // signature

예

다음 코드는 user 를 요청 개체에 추가하고 다음 일치하는 경로로 컨트롤을 전달합니다.

var express = require('express');
var app = express();

//each request will pass through it
app.use(function(req, res, next){
    req.user = 'testuser';
    next();    // it will pass the control to next matching route
});

app.get('/', function(req, res){
    var user = req.user;
    console.log(user); // testuser
    return res.send(user);
});

app.listen(3000);

Express에서 오류 처리

Express에서는 응용 프로그램에서 발생한 오류를 처리하기위한 통합 오류 처리기를 정의 할 수 있습니다. 모든 라우트와 로직 코드의 끝에서 핸들러를 정의하십시오.

예

var express = require('express');
var app = express();

//GET /names/john
app.get('/names/:name', function(req, res, next){
    if (req.params.name == 'john'){
        return res.send('Valid Name');
    } else{
        next(new Error('Not valid name'));    //pass to error handler
    }
});

//error handler
app.use(function(err, req, res, next){
    console.log(err.stack);    // e.g., Not valid name
    return res.status(500).send('Internal Server Occured');
});

app.listen(3000);

미들웨어 추가

미들웨어 기능은 요청 객체 (req), 응답 객체 (res) 및 응용 프로그램의 요청 - 응답주기에서 다음 미들웨어 기능에 액세스 할 수있는 기능입니다.

미들웨어 기능은 모든 코드를 실행하고 res 및 req 객체를 변경하고 응답주기를 종료하며 다음 미들웨어를 호출 할 수 있습니다.

미들웨어의 매우 일반적인 예는 cors 모듈입니다. CORS 지원을 추가하려면 간단히 설치하고 요구하고 다음 줄을 입력하십시오.

app.use(cors());

라우터 또는 라우팅 기능을 수행하기 전에

안녕하세요 세계

여기에서는 Express를 사용하여 기본 hello world 서버를 생성합니다. 경로 :

• '/'
• '/ 위키'

그리고 나머지는 "404", 즉 페이지를 찾을 수 없습니다.

'use strict';

const port = process.env.PORT || 3000;

var app = require('express')();
    app.listen(port);

app.get('/',(req,res)=>res.send('HelloWorld!'));
app.get('/wiki',(req,res)=>res.send('This is wiki page.'));
app.use((req,res)=>res.send('404-PageNotFound'));

참고 : Express는 경로를 순서대로 스택하고 각 요청에 대해 순차적으로 처리하므로 마지막 경로로 404 route를 입력했습니다.