Az Önhöz hasonló olvasók támogatják a MUO-t. Amikor a webhelyünkön található linkek használatával vásárol, társult jutalékot kaphatunk.
A termelésre kész webalkalmazás elkészítéséhez biztosítania kell, hogy az biztonságos és méretezhető.
Az egyik legfontosabb tudnivaló az adatbázisokról az ACID elv, amely az atomitást, a konzisztenciát, az elszigeteltséget és a tartósságot jelenti. A relációs adatbázisok, mint például a MySQL, natív módon támogatják az ACID-tranzakciókat. De a MongoDB egy NoSQL-adatbázis, és alapértelmezés szerint nem támogatja az ACID-tranzakciókat.
Programozóként tudnia kell, hogyan viheti be az ACID tulajdonságokat a MongoDB adatbázisokba.
Mik azok az adatbázis-tranzakciók?
Az adatbázis-tranzakció olyan adatbázis-lekérdezések vagy műveletek sorozata, amelyek mindegyike egy egységként fut egy feladat végrehajtása érdekében.
Az adatbázis-tranzakciók megfelelnek az ACID-jellemzők fogalmának. Ez segít abban, hogy ne történjen változás, hacsak nem minden művelet sikeres. Azt is biztosítja, hogy az adatbázis konzisztens legyen.
Az ACID tulajdonságok magyarázata
Az ACID elveket alkotó négy tulajdonság a következő:
- Atomos állapot az a tulajdonság, amely a tranzakciókat egy program kis egységeiként értelmezi. Ez azt jelenti, hogy az összes lekérdezés vagy sikeresen fut, vagy együtt sikertelen.
- Következetesség kimondja, hogy az adatbázis rekordoknak konzisztensnek kell maradniuk minden tranzakció előtt és után.
- Elkülönítés biztosítja, hogy amikor több tranzakció fut egyidejűleg, az egyik ne legyen hatással a másikra.
- Tartósság rendszerhibákra vagy hibákra összpontosít. Biztosítja, hogy a véglegesített tranzakció ne vesszen el rendszerhiba esetén. Ez magában foglalhat olyan technikákat, amelyek szükségesek az adatok automatikus visszaállításához a biztonsági másolatból, amint a rendszer újra megjelenik.
MongoDB-adatbázis-tranzakciók megvalósítása a Node.js-ben a Mongoose használatával
A MongoDB az évek során széles körben használt adatbázis-technológiává vált NoSQL-jellegét és rugalmas dokumentum alapú modell. Lehetővé teszi az adatok jobb és rugalmasabb rendszerezését is, mint az SQL vagy relációs adatbázisokban.
Az adatbázis-tranzakciók MongoDB-ben való megvalósításához fontolóra vehet egy mintaforgatókönyvet egy munkalista-alkalmazáson, ahol a felhasználó közzétehet, frissíthet vagy törölhet egy feladatot. Íme egy egyszerű adatbázisséma kialakítás ehhez az alkalmazáshoz:
A folytatáshoz ebben a szakaszban a Node.js programozás és a MongoDB alapismeretei szükségesek.
A tranzakciók nem támogatottak az önálló MongoDB-telepítéseken. Használnia kell a MongoDB replikakészlet vagy MongoDB szilánkos fürt hogy a tranzakciók működjenek. Ezért a tranzakciók használatának legegyszerűbb módja az hozzon létre egy felhőalapú MongoDB-példányt (MongoDB Atlas). Alapértelmezés szerint minden Atlas adatbázis-példány replikakészlet vagy szilánkos fürt.
Egy működő Node.js és MongoDB projekt beállítása után beállíthat egy kapcsolatot egy Mongo adatbázishoz a Node.js-ben. Ha még nem tette meg, futással telepítse a mongoose-t npm install mongoose a termináljában.
import indiai menyét tól től 'indiai menyét'legyen MONGO_URL = process.env. MONGO_URL || 'your-mongo-adatbázis-url';
hagyja kapcsolat;
const connectDb = async () => {
próbáld ki {
várja mongoose.connect (MONGO_URL, {
useNewUrlParser: igaz,
UseUnifiedTopology: igaz,
});
console.log("ADATBÁZISHOZ CSATLAKOZTATVA");
kapcsolat = mongoose.connection;
} fogás (hiba) {
console.error("AZ ADATBÁZIS KAPCSOLAT SIKERTELEN!");
konzol.hiba(téved.üzenet);
folyamat.kijárat(1); // zárja be az alkalmazást, ha az adatbázis-kapcsolat meghiúsul
}
};
A kapcsolatot egy változóban kell tárolnia, hogy később a programban tranzakciót kezdeményezhessen vele.
Így implementálhatja a felhasználókat és a feladatgyűjteményeket:
const userSchema = új indiai menyét. Séma({
név: Húr,
email: Húr,
munkahelyek: [indiai menyét. Séma. Típusok. ObjectId]
});const jobSchema = új indiai menyét. Séma({
cím: Húr,
elhelyezkedés: Húr,
fizetés: Húr,
poszter: indiai menyét.Séma.Típusok.ObjectId
});
const userCollection = mongoose.model('felhasználó', userSchema);
const jobCollection = mongoose.model('munka', jobSchema);
A következőképpen írhat függvényt egy felhasználó hozzáadásához az adatbázishoz:
const createUser = async (felhasználó) => {
const newUser = várja userCollection.create (felhasználó);
konzol.log("Felhasználó hozzáadva az adatbázishoz");
konzol.log (newUser);
}
Az alábbi kód bemutatja azt a funkciót, amellyel létrehozhat egy feladatot, és adatbázis-tranzakció segítségével hozzáadhatja azt a poszter munkalistájához.
const createJob = async (munka) => {
const { userEmail, title, location, paying } = munkakör;// lekérni a felhasználót a DB-ből
const felhasználó = várja userCollection.findOne({ email: userEmail });// tranzakciós munkamenet indítása
const munkamenet = várja connect.startSession();// az összes adatbázis-lekérdezést egy try-catch blokkban futtatja
próbáld ki {
várja session.startTransaction();// munkahely létrehozása
const új Munka = várja jobCollection.create(
[
{
cím,
elhelyezkedés,
fizetés,
poszter: user._id,
},
],
{ munkamenet }
);
konzol.log("Létrehozva új sikeres munkát!");
konzol.log (newJob[0]);// munka hozzáadása a közzétett munkák felhasználói listájához
const newJobId = newJob[0]._id;
const AddToUser = várja userCollection.findByIdAndUpdate(
Felhasználói azonosító,
{ $addToSet: { munkahelyek: newJobId } },
{ munkamenet }
);konzol.log("A munka sikeresen hozzáadva a felhasználó feladatlistájához");
konzol.log (addedToUser);várja session.commitTransaction();
konzol.log("DB tranzakció sikeresen végrehajtva");
} fogás (e) {
konzol.error (e);
konzol.log("Nem sikerült befejezni az adatbázis-műveleteket");
várja session.abortTransaction();
} végül {
várja session.endSession();
konzol.log("Tranzakciós munkamenet befejeződött");
}
};
A teremt A tranzakcióban futó lekérdezés általában bevesz és visszaad egy tömböt. Ezt a fenti kódban láthatja, ahol létrehozza új Munka és tárolja _id ingatlan anewJobId változó.
Az alábbiakban bemutatjuk a fenti funkciók működését:
const mockUser = {
név: "Timmy Omolana",
e-mail: "[email protected]",
};const mockJob = {
cím: "Értékesítési vezető",
Helyszín: "Lagos, Nigéria",
fizetés: "$40,000",
userEmail: "[email protected]", // a létrehozott felhasználó e-mailje
};const startServer = async () => {
várja connectDb();
várja createUser (mockUser);
várja createJob (mockJob);
};
startServer()
.akkor()
.catch((err) => konzol.log (hiba));
Ha elmenti ezt a kódot és futtatja a használatával npm start vagy a csomópont parancsot, a következő kimenetet kell produkálnia:
Az ACID-tranzakciók megvalósításának másik módja a MongoDB-ben a Mongoose használatával a with Transaction() funkció. Ez a megközelítés kevés rugalmasságot biztosít, mivel minden lekérdezést futtat egy visszahívási függvényen belül, amelyet argumentumként ad át a függvénynek.
A fenti adatbázis-tranzakciót újraaktiválhatja a használathoz with Transaction() mint ez:
const createJob = async (munka) => {
const { userEmail, title, location, paying } = munkakör;// lekérni a felhasználót a DB-ből
const felhasználó = várja userCollection.findOne({ email: userEmail });// tranzakciós munkamenet indítása
const munkamenet = várja connect.startSession();// az összes adatbázis-lekérdezést egy try-catch blokkban futtatja
próbáld ki {
const tranzakcióSiker = várja session.withTransaction(async () => {
const új Munka = várja jobCollection.create(
[
{
cím,
elhelyezkedés,
fizetés,
poszter: user._id,
},
],
{ munkamenet }
);konzol.log("Létrehozva új sikeres munkát!");
konzol.log (newJob[0]);// munka hozzáadása a közzétett munkák felhasználói listájához
const newJobId = newJob[0]._id;
const AddToUser = várja userCollection.findByIdAndUpdate(
Felhasználói azonosító,
{ $addToSet: { munkahelyek: newJobId } },
{ munkamenet }
);konzol.log("A munka sikeresen hozzáadva a felhasználó feladatlistájához");
konzol.log (addedToUser);
});
ha (tranzakciósiker) {
konzol.log("DB tranzakció sikeresen végrehajtva");
} más {
konzol.log("A tranzakció sikertelen");
}
} fogás (e) {
konzol.error (e);
konzol.log("Nem sikerült befejezni az adatbázis-műveleteket");
} végül {
várja session.endSession();
konzol.log("Tranzakciós munkamenet befejeződött");
}
};
Ez ugyanazt a kimenetet eredményezi, mint az előző megvalósítás. Szabadon választhatja meg, hogy melyik stílust használja adatbázis-tranzakciók megvalósítása során a MongoDB-ben.
Ez a megvalósítás nem használja a commitTransaction() és megszakítás() funkciókat. Ez azért van, mert a with Transaction() A funkció automatikusan végrehajtja a sikeres tranzakciókat, és megszakítja a sikerteleneket. Az egyetlen függvény, amelyet minden esetben meg kell hívnia, az a session.endSession() funkció.
ACID adatbázis-tranzakciók megvalósítása a MongoDB-ben
Az adatbázis-tranzakciók könnyen használhatók, ha helyesen hajtják végre. Most már meg kell értenie, hogyan működnek az adatbázis-tranzakciók a MongoDB-ben, és hogyan valósíthatja meg őket a Node.js alkalmazásokban.
Az ACID-tranzakciók ötletének és a MongoDB-ben való működésének további felfedezéséhez fontolja meg egy fintech pénztárca vagy blogoló alkalmazás létrehozását.
