Cet article expliquera brièvement ce qu'est le mappage relationnel d'objet (ORM), ce qu'est ORM Library , et pourquoi vous devriez envisager de l'utiliser dans votre prochain projet JavaScript. Nous vous aiderons également à évaluer les meilleures bibliothèques ORM JavaScript et TypeScript en fonction de vos besoins en tant que développeur de projet et travailleur de maintenance.
Nous examinerons chacun des outils suivants:
La cartographie relationnelle des objets peut sembler compliquée, mais son objectif est de vous faciliter la vie en tant que programmeur. Pour obtenir des données de la base de données, vous devez rédiger une requête. Mais cela signifie-t-il que vous devez apprendre SQL? Non, le mappage relationnel d'objet vous permet d'écrire des requêtes dans la langue de votre choix.
Le mappage relationnel des objets est une technique qui convertit les résultats de la requête de la base de données en instances de classe d'entité. Les entités ne sont que des emballages d'objets pour les tables de base de données. Il contient des propriétés mappées à la colonne de table de base de données. Les instances d'entité ont des méthodes pour effectuer des opérations CRUD et prendre en charge d'autres fonctionnalités qui incluent une logique personnalisée telle que la vérification et le chiffrement des données.
Si vous construisez un petit projet, vous n'avez pas besoin d'installer la bibliothèque ORM. Il suffit d'utiliser des instructions SQL pour piloter votre application. ORM est très bénéfique pour les projets moyens et grands qui obtiennent des données de centaines de tables de base de données. Dans ce cas, vous avez besoin d'un cadre qui vous permet de fonctionner et de maintenir la couche de données de votre application de manière cohérente et prévisible.
Les cours d'entités sont des éléments constitutifs des applications commerciales, car ils sont conçus pour encapsuler la logique utilisée pour implémenter les règles métier. Les règles commerciales sont définies pour garantir que les processus automatisés ne sont exécutés que dans le cadre des politiques commerciales. Des exemples de règles commerciales comprennent:
Le cartographie relationnelle des objets se fait généralement à l'aide des bibliothèques. Le terme ORM fait le plus souvent référence à la bibliothèque ORM réelle - Relation de l'objectif mappeur - il fait le travail de la cartographie des relations d'objet pour vous.
Les règles métier nécessitent généralement l'exécution par lots de plusieurs instructions SQL. Si une seule instruction SQL échoue, elle peut laisser la base de données dans un état incohérent. La plupart des bibliothèques ORM prennent en charge une fonctionnalité appelée Transactions, ce qui empêche de tels événements de se produire. Si l'instruction SQL ne parvient pas à s'exécuter dans ce contexte de transaction, toutes les autres instructions SQL qui ont été exécutées avec succès dans ce lot sont non dotées par une opération appelée Rollback.
Par conséquent, l'utilisation de la bibliothèque ORM pour créer votre couche de données permet de garantir que la base de données est toujours cohérente. La bibliothèque ORM contient généralement des fonctions plus basiques, telles que:
Dans cet article, je fournirai un extrait de code sur la façon dont chaque bibliothèque ORM fait ce qui suit:
J'inclut également des informations importantes telles que la date de lancement, le nombre d'utilisateurs et les liens de documents, ainsi que les canaux de support disponibles. Je discuterai également des questions les plus importantes liées aux performances de la requête, à la maintenance de la bibliothèque et à la philosophie de l'architecture que vous devez peser soigneusement lors de vos décisions.
J'ai trié la liste à la date de début du plus ancien au dernier. J'ai divisé la liste en deux parties selon les principaux langages pris en charge: JavaScript et TypeScript.
Avant de commencer l'évaluation, regardons d'abord Knex.js, un constructeur de requête SQL populaire qui a été intégré à de nombreuses bibliothèques ORM répertoriées ici. Knex.js est très flexible et fonctionne généralement mieux que certaines bibliothèques ORM qui ont leur propre implémentation intégrée de constructeurs de requêtes. Considérez cela comme un avantage lors du choix d'une bibliothèque ORM pour utiliser Knex.js comme base.
knex.js est actuellement le constructeur de requête SQL JavaScript le plus mature qui peut fonctionner dans Node.js et dans les navigateurs (via WebPack ou Browserify). Il est capable de générer les mêmes requêtes SQL haute performance que les instructions SQL écrites manuellement.
Alors, qu'est-ce qu'un constructeur de requêtes?
C'est juste une API qui fournit un ensemble de fonctions qui peuvent être liées entre elles pour former des requêtes. Voici un exemple:
<code>knex({ a: 'table', b: 'table' })
.select({
aTitle: 'a.title',
bTitle: 'b.title'
})
.whereRaw('?? = ??', ['a.column_1', 'b.column_2'])
SQL 输出：
select `a`.`title` as `aTitle`, `b`.`title` as `bTitle` from `table`
as `a`, `table` as `b` where `a`.`column_1` = `b`.`column_2`
</code>Cela pose la question, pourquoi devriez-vous utiliser un constructeur de requête au lieu d'écrire des instructions SQL originales? Je vais vous donner quatre raisons:
Ces fonctions incluent:
L'installation de l'installation dans votre application vous oblige à installer le package knex.js et le pilote de la base de données que vous utilisez:
<code>$ npm install knex --save # 然后添加以下一个（添加 --save）标志： $ npm install pg $ npm install sqlite3 $ npm install mysql $ npm install mysql2 $ npm install oracledb $ npm install mssql </code>
Il s'agit d'un exemple de code de configuration:
<code>const knex = require('knex')({
client: 'mysql',
connection: {
host : '127.0.0.1',
user : 'your_database_user',
password : 'your_database_password',
database : 'myapp_test'
}
});
knex.schema.createTable('users', function (table) {
table.increments();
table.string('name');
table.timestamps();
})
输出：
create table `users` (`id` int unsigned not null auto_increment primary key, `name` varchar(255),
`created_at` datetime, `updated_at` datetime)
</code>Il s'agit d'un exemple de requête de base:
<code>knex('users').where({
first_name: 'Test',
last_name: 'User'
}).select('id')
输出：
select `id` from `users` where `first_name` = 'Test' and `last_name` = 'User'
</code>prend également en charge les instructions SQL brutes. Voici un exemple de requête complexe:
<code>const subcolumn = knex.raw('select avg(salary) from employee where dept_no = e.dept_no')
.wrap('(', ') avg_sal_dept');
knex.select('e.lastname', 'e.salary', subcolumn)
.from('employee as e')
.whereRaw('dept_no = e.dept_no')
输出：
select `e`.`lastname`, `e`.`salary`, (select avg(salary) from employee where dept_no = e.dept_no)
avg_sal_dept from `employee` as `e` where dept_no = e.dept_no
</code>knex.js prend également en charge TypeScript, ce qui est génial car il vous permet d'écrire du code comme celui-ci:
<code>knex({ a: 'table', b: 'table' })
.select({
aTitle: 'a.title',
bTitle: 'b.title'
})
.whereRaw('?? = ??', ['a.column_1', 'b.column_2'])
SQL 输出：
select `a`.`title` as `aTitle`, `b`.`title` as `bTitle` from `table`
as `a`, `table` as `b` where `a`.`column_1` = `b`.`column_2`
</code>Dans l'exemple de type ci-dessus, knex.js agit presque comme un orm. Cependant, aucune instance d'objet entité n'est créée. Au lieu de cela, utilisez des définitions d'interface pour créer des objets JavaScript avec des propriétés de type type.
Notez que de nombreuses bibliothèques ORM répertoriées dans cet article utilisent Knex.js en arrière-plan. Ceux-ci incluent:
Les bibliothèques ORM fournissent généralement des fonctionnalités supplémentaires au-dessus de Knex.js. Jetons un œil à-les dans la section suivante.
Dans cette catégorie, toutes les bibliothèques répertoriées ici sont écrites en javascript et peuvent être exécutées directement dans Node.js. La prise en charge de TypeScript est fournie via des types de types intégrés ou des packages de définition de types / nœuds. Si vous souhaitez une prise en charge de premier ordre pour votre projet TypeScript, vous devez passer à la section TypeScript Orm Library.
Dans la couche d'accès aux données, deux modèles architecturaux populaires sont utilisés:
En utilisant le motif de mappeur de données, la classe d'entité est pure et ne contient que des propriétés. Les opérations CRUD et les règles commerciales sont mises en œuvre dans des conteneurs appelés référentiels. Voici un exemple:
<code>$ npm install knex --save # 然后添加以下一个（添加 --save）标志： $ npm install pg $ npm install sqlite3 $ npm install mysql $ npm install mysql2 $ npm install oracledb $ npm install mssql </code>
La logique des opérations CRUD et des règles métier est implémentée dans la classe d'entité en utilisant le mode d'enregistrement actif. Voici un exemple similaire qui illustre ce qui précède:
<code>const knex = require('knex')({
client: 'mysql',
connection: {
host : '127.0.0.1',
user : 'your_database_user',
password : 'your_database_password',
database : 'myapp_test'
}
});
knex.schema.createTable('users', function (table) {
table.increments();
table.string('name');
table.timestamps();
})
输出：
create table `users` (`id` int unsigned not null auto_increment primary key, `name` varchar(255),
`created_at` datetime, `updated_at` datetime)
</code>L'utilisation de l'un ou l'autre mode a ses avantages et ses inconvénients. Ces modèles ont été nommés par Martin Fowler dans son livre de 2003 Book Enterprise Architecture Patterns. Si vous voulez en savoir plus sur ce sujet, vous devriez consulter ce livre. La plupart des bibliothèques ORM répertoriées dans cet article prennent en charge un ou les deux modes.
Commençons par les prêter attention maintenant.
Sequelize est une bibliothèque Node.js ORM très mature et populaire avec une excellente documentation avec des exemples de code bien expliqués. Il prend en charge de nombreuses fonctionnalités de couche de données que nous avons mentionnées dans les bibliothèques précédentes. Contrairement à la bibliothèque, il a son propre constructeur de requêtes qui se produit ainsi que Knex.js.
L'installation de la bibliothèque est très simple, et le pilote de base de données est également très direct:
<code>knex('users').where({
first_name: 'Test',
last_name: 'User'
}).select('id')
输出：
select `id` from `users` where `first_name` = 'Test' and `last_name` = 'User'
</code>Ce qui suit est un code de configuration et des exemples de CRUD et des instructions de requête de base:
<code>const subcolumn = knex.raw('select avg(salary) from employee where dept_no = e.dept_no')
.wrap('(', ') avg_sal_dept');
knex.select('e.lastname', 'e.salary', subcolumn)
.from('employee as e')
.whereRaw('dept_no = e.dept_no')
输出：
select `e`.`lastname`, `e`.`salary`, (select avg(salary) from employee where dept_no = e.dept_no)
avg_sal_dept from `employee` as `e` where dept_no = e.dept_no
</code>Ce qui suit est un exemple de la façon d'écrire une requête complexe:
<code>import { Knex, knex } from 'knex'
interface User {
id: number;
age: number;
name: string;
active: boolean;
departmentId: number;
}
const config: Knex.Config = {
client: 'sqlite3',
connection: {
filename: './data.db',
},
};
const knexInstance = knex(config);
try {
const users = await knex<user>('users').select('id', 'age');
} catch (err) {
// 错误处理
}
</user></code>Dans le dernier exemple de requête complexe, la sortie SQL est:
<code>const repository = connection.getRepository(User);. const user = new User(); user.firstName = "Timber"; await repository.save(user); const allUsers = await repository.find(); </code>
Sequelize prend en charge les instructions SQL brutes, qui donne aux développeurs la flexibilité d'écrire des instructions SQL complexes et haute performance. Les résultats peuvent également être mappés à l'instance de l'entité de l'objet. Voici un exemple:
<code>const user = new User(); user.firstName = "Timber"; await user.save(); const allUsers = await User.find(); </code>
Le principal inconvénient du séquelle est qu'il ralentit en développement et que les problèmes s'accumulent et ne sont pas résolus. Heureusement, un responsable a annoncé que la bibliothèque attirerait l'attention qu'elle mérite à partir de 2021. Notez que tous les projets de bibliothèque ORM dans cet article sont open source et qu'ils nécessitent l'aide des développeurs pour l'améliorer.
La partie restante est similaire au texte d'entrée. En raison des limites de l'espace, cet endroit ne sera pas élargi. Veuillez noter que le format d'image reste le même.
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
