Applicazioni Web in React, Bootstrap, MongoDB, Express/Creare un web server Node Express per MySql

Wikibooks, manuali e libri di testo liberi.
Jump to navigation Jump to search
Indice del libro

Nel caso in cui si volesse realizzare un web server Node Express, che si connetta ad un database Mysql invece che ad un database MongoDB bisogna procedere in questo modo:

Installare Node.Js ed Express Generator[modifica]

  • 1) Node.Js è un framework Javascript che consente anche di scrivere codice lato server e quindi in particolare consente di realizzare un web server Express . npm (abbreviazione di Node Package Manager[2]) è il gestore di pacchetti predefinito per l'ambiente di runtime JavaScript Node.js. Consiste in un client da linea di comando, chiamato anch'esso npm, e un database online di pacchetti pubblici e privati, chiamato npm registry.
  • 2) Installare Node.js sul proprio PC da qui: https://nodejs.org/
  • 3) Nel terminale digitare:
node -v
npm -v

per verificare che sia node che npm siano installati correttamente nel proprio sistema.

  • 4) Installare il package express-generator tramite npm digitando nel terminale:
npm install express-generator -g
  • 5) Aprire il terminale nei Documenti e digitare:
express Items-Server
  • 6) Nelle dipendenze del file package.json appena creato inserire la dipendenza:
"mysql2": "^2.3.3"
  • 7) Nella cartella Items-Server, digitare nel terminale:
npm install

in questo modo verranno installati tutti i moduli necessari per realizzare il web server, incluso il modulo relativo a Mysql

  • 8) Nella dir Items-Server digitare nel terminale per avviare il server:
npm start
  • 9) Nel browser al link http://localhost:3000/ apparirà il messaggio "Welcome to Express" . Un web server Node Express è stato creato !

API REST e creazione del web server[modifica]

Le richieste che il client fa al server si realizzano tramite le API REST . Ad esempio, se si esegue una richiesta GET, si sta chiedendo al server di restituire la risorsa. Se si esegue una richiesta POST, si sta chiedendo al server di creare una nuova risorsa. Se si esegue una richiesta PUT, si sta chiedendo al server di aggiornare una risorsa esistente. E se si emette una richiesta DELETE, si sta chiedendo al server di eliminare la risorsa identificata dal particolare URL. Lo scambio dei dati tra client e server avviene in formato JSON che rappresenta lo standard con cui si costruiscono gli oggetti Javascript. Ad esempio l'URL http://localhost:3000/items/234 significa che il client chiede al server di agire sull'item 234, su cui è possibile svolgere operazioni di GET, PUT o DELETE.


  • 1) Creare in Items-Server il file config.js
// config.js
const config = {
  db: {
    /* esporre la password o altre info sensibili solo nella demo! */
    host: "localhost",
    user: "root",
    password: "password",
    database: "items_db",
  }
};

module.exports = config;
  • 2) Creare una sotto cartella services di Items-Server e dentro il file db.js
// db.js
const mysql = require("mysql2/promise");
const config = require("../config");

async function query(sql, params) {
  const connection = await mysql.createConnection(config.db);
  const [results] = await connection.execute(sql, params);

  return results;
}

module.exports = {
  query,
};


  • 3) Nella sotto cartella services di Items-Server, creare il file items.js, contenente le query SQL che verranno richiamate dal router :
// items.js
const db = require("./db");
const config = require("../config");

async function getMultiple() {
  const rows = await db.query(
    `SELECT id, name, quantity, measure  FROM items`
  );
  
  if (!rows) rows=[];
  
  return rows;
}


async function getItem(id) {
  const row = await db.query(
    `SELECT id, name, quantity, measure  FROM items WHERE id=${id}`
  );
  
  if (!row) row=[];
  
  return row;
}


async function create(item) {
  const result = await db.query(
    `INSERT INTO items 
    (name, quantity, measure) 
    VALUES 
    ("${item.name}", ${item.quantity}, "${item.measure}")`
  );

  let message = "Error in creating item";

  if (result.affectedRows) {
    message = "Item created successfully";
  }

  return { message };
}

async function update(id, item) {
  const result = await db.query(
    `UPDATE items 
    SET name="${item.name}", quantity=${item.quantity}, measure="${item.measure}"  
    WHERE id=${id}`
  );

  let message = "Error in updating item";

  if (result.affectedRows) {
    message = "Item updated successfully";
  }

  return { message };
}

async function remove(id) {
  const result = await db.query(
    `DELETE FROM items WHERE id=${id}`
  );

  let message = "Error in deleting item";

  if (result.affectedRows) {
    message = "Item deleted successfully";
  }

  return { message };
}

module.exports = {
  getMultiple,
  getItem,
  create,
  update,
  remove,
};
  • 4) Nella cartella routes inserire il file itemRouter.js che richiama in modo asincrono le query SQL che si trovano in items.js
//itemRouter.js
const express = require('express');
const Items = require("../services/items");
const itemRouter = express.Router();

/* GET items. */
itemRouter.get("/", async function (req, res, next) {
  try {
    res.json(await Items.getMultiple(req.query.page));
  } catch (err) {
    console.error(`Error while getting items `, err.message);
    next(err);
  }
});

/* GET item */
itemRouter.get("/:id", async function (req, res, next) {
  try {
    res.json(await Items.getItem(req.params.id));
  } catch (err) {
    console.error(`Error while getting item`, err.message);
    next(err);
  }
});


/* POST item */
itemRouter.post("/", async function (req, res, next) {
  try {
    res.json(await Items.create(req.body));
  } catch (err) {
    console.error(`Error while creating item`, err.message);
    next(err);
  }
});

/* PUT item */
itemRouter.put("/:id", async function (req, res, next) {
  try {
    res.json(await Items.update(req.params.id, req.body));
  } catch (err) {
    console.error(`Error while updating item`, err.message);
    next(err);
  }
});

/* DELETE item */
itemRouter.delete("/:id", async function (req, res, next) {
  try {
    res.json(await Items.remove(req.params.id));
  } catch (err) {
    console.error(`Error while deleting item`, err.message);
    next(err);
  }
});


module.exports = itemRouter;


  • 4) modificare il file app.js nella dir Items-Server  :
// app.js
var createError = require('http-errors');
var express = require('express');
var path = require('path');
var cookieParser = require('cookie-parser');
var logger = require('morgan');

var indexRouter = require('./routes/index');
var usersRouter = require('./routes/users');
var itemsRouter = require('./routes/itemRouter');


var app = express();

// view engine setup
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'jade');

app.use(logger('dev'));
app.use(express.json());
app.use(express.urlencoded({ extended: false }));
app.use(cookieParser());
app.use(express.static(path.join(__dirname, 'public')));

app.use(function(req, res, next) {
  res.header("Access-Control-Allow-Origin", "*");
  res.header("Access-Control-Allow-Methods", "GET,POST,PUT,DELETE");
  res.header("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept, Authorization");
  next();
  });


app.use('/', indexRouter);
app.use('/users', usersRouter);
app.use('/items', itemsRouter);


// catch 404 and forward to error handler
app.use(function(req, res, next) {
  next(createError(404));
});

// error handler
app.use(function(err, req, res, next) {
  // set locals, only providing error in development
  res.locals.message = err.message;
  res.locals.error = req.app.get('env') === 'development' ? err : {};

  // render the error page
  res.status(err.status || 500);
  res.render('error');
});

module.exports = app;
  • 5) Abbiamo creato un web server Node Express che si connette con un database MySql. Per avviarlo digitare in un terminale nella cartella Items-Server: npm start