Giới thiệu về LoopBack
LoopBack là một framework mạnh mẽ cho Node.js giúp lập trình viên dễ dàng xây dựng các ứng dụng API cùng với cơ sở dữ liệu mạnh mẽ, linh hoạt và có thể mở rộng. LoopBack cung cấp các công cụ và tính năng giúp bạn dễ dàng thiết kế, kết nối và khai thác dữ liệu trong ứng dụng của mình.
Những lý do nên sử dụng LoopBack bao gồm: hỗ trợ TypeScript, khả năng mở rộng mạnh mẽ, tích hợp dễ dàng với nhiều cơ sở dữ liệu khác nhau, và khả năng tạo ra các API mạnh mẽ với ít nỗ lực.
Trong bài viết này, chúng ta sẽ cùng tìm hiểu cách cài đặt và sử dụng thư viện LoopBack trong JavaScript.
Yêu cầu hệ thống
Để cài đặt LoopBack, bạn cần có các yêu cầu hệ thống sau:
- Node.js: phiên bản 10 hoặc mới hơn.
- NPM: đi kèm với Node.js.
- Git: để tải về các mẫu mã nguồn nếu cần.
Lưu ý: Nếu chưa cài đặt Node.js và NPM, bạn có thể tải chúng từ trang web chính thức Node.js.
Cài đặt LoopBack CLI
Bước 1: Cài đặt LoopBack CLI
Trước tiên, chúng ta cần cài đặt LoopBack Command Line Interface (CLI) để giúp tạo dự án LoopBack mới và tạo các model, datasource, và nhiều hơn nữa.
Chúng ta có thể cài đặt LoopBack CLI toàn cục trên hệ thống bằng cách sử dụng NPM:
npm install -g @loopback/cli
Kiểm tra xem LoopBack CLI đã được cài đặt thành công chưa bằng cách kiểm tra phiên bản của nó:
lb4 --version
Nếu CLI trả về phiên bản, điều đó có nghĩa là LoopBack CLI đã được cài đặt thành công.
Bước 2: Tạo dự án LoopBack
Sau khi đã cài đặt LoopBack CLI, tiếp theo chúng ta sẽ tạo một dự án mới với LoopBack. Chúng ta có thể sử dụng lệnh sau để bắt đầu:
lb4 app
CLI sẽ hỏi bạn một số câu hỏi để thiết lập dự án, bao gồm tên ứng dụng và loại ứng dụng (như API server). Trả lời các câu hỏi này để hoàn tất việc tạo dự án.
Sau khi dự án đã được tạo, đi vào thư mục project:
cd [project-name]
Tiếp theo, cài đặt các gói cần thiết:
npm install
Bạn đã có một ứng dụng LoopBack cơ bản. Bắt đầu ứng dụng bằng lệnh sau:
npm start
Mở trình duyệt và truy cập vào http://localhost:3000 để xem ứng dụng chạy.
Thiết lập Datasource
Datasources trong LoopBack dùng để kết nối ứng dụng với cơ sở dữ liệu. LoopBack hỗ trợ nhiều loại cơ sở dữ liệu khác nhau như MySQL, PostgreSQL, MongoDB, và SQLite.
Tạo Datasource
Để tạo một datasource mới, sử dụng lệnh CLI sau:
lb4 datasource
CLI sẽ hỏi bạn tên của datasource, loại cơ sở dữ liệu và chi tiết kết nối. Cung cấp thông tin cần thiết để thiết lập datasource.
Ví dụ, để thiết lập datasource với MySQL, bạn cần cung cấp tên datasource, chọn connector MySQL, và cung cấp các chi tiết kết nối như host, port, user, password, và database name.
Cấu hình Datasource
Sau khi tạo datasource, bạn có thể cấu hình nó trong tập tin src/datasources/[datasource-name].datasource.ts. Tập tin này chứa các thông tin kết nối tới cơ sở dữ liệu mà bạn đã cung cấp.
{
"name": "mysql",
"connector": "mysql",
"url": "",
"host": "localhost",
"port": 3306,
"user": "root",
"password": "password",
"database": "testdb"
}
Kiểm tra Datasource
Để kiểm tra xem datasource đã được thiết lập đúng cách chưa, bạn có thể sử dụng các công cụ quản lý cơ sở dữ liệu hoặc lệnh SQL trực tiếp để chắc chắn kết nối thành công.
Tạo Model và Repository
Một model trong LoopBack biểu thị một đối tượng dữ liệu. Repository là nơi xử lý các logic thao tác với dữ liệu của model.
Tạo Model
Để tạo model mới, sử dụng lệnh sau:
lb4 model
CLI sẽ hỏi bạn tên của model và các thuộc tính của nó. Ví dụ, chúng ta tạo một model Product với các thuộc tính như name (string) và price (number).
Product
- name (string)
- price (number)
CLI sẽ tạo ra tập tin model product.model.ts trong thư mục src/models chứa định nghĩa của model như sau:
import {Entity, model, property} from '@loopback/repository';
@model({settings: {}})
export class Product extends Entity {
@property({
type: 'string',
required: true,
})
name: string;
@property({
type: 'number',
required: true,
})
price: number;
constructor(data?: Partial<Product>) {
super(data);
}
}
Tạo Repository
Tiếp theo, để tương tác với model Product, chúng ta cần tạo một repository mới:
lb4 repository
CLI sẽ hỏi bạn tên của repository và model mà repository này sẽ làm việc cùng (ở đây là Product).
Tập tin product.repository.ts sẽ được tạo trong thư mục src/repositories.
import {DefaultCrudRepository} from '@loopback/repository';
import {Product, ProductRelations} from '../models';
import {MysqlDataSource} from '../datasources';
import {inject} from '@loopback/core';
export class ProductRepository extends DefaultCrudRepository<
Product,
typeof Product.prototype.id,
ProductRelations
> {
constructor(
@inject('datasources.mysql') dataSource: MysqlDataSource,
) {
super(Product, dataSource);
}
}
Tạo REST API cho Model
Cuối cùng, để tạo REST API cho model Product, chúng ta sẽ sử dụng trình điều khiển (controller):
lb4 controller
Chọn REST Controller with CRUD functions và chọn model Product.
Tập tin product.controller.ts sẽ được tạo trong thư mục src/controllers, bao gồm các phương thức CRUD cho model Product.
import {
Count,
CountSchema,
Filter,
FilterExcludingWhere,
repository,
Where,
} from '@loopback/repository';
import {post, param, get, getModelSchemaRef, patch, put, del, requestBody} from '@loopback/rest';
import {Product} from '../models';
import {ProductRepository} from '../repositories';
export class ProductController {
constructor(
@repository(ProductRepository)
public productRepository : ProductRepository,
) {}
@post('/products', {
responses: {
'200': {
description: 'Product model instance',
content: {'application/json': {schema: getModelSchemaRef(Product)}},
},
},
})
async create(
@requestBody({
content: {
'application/json': {
schema: getModelSchemaRef(Product, {
title: 'NewProduct',
exclude: ['id'],
}),
},
},
})
product: Omit<Product, 'id'>,
): Promise<Product> {
return this.productRepository.create(product);
}
@get('/products/count', {
responses: {
'200': {
description: 'Product model count',
content: {'application/json': {schema: CountSchema}},
},
},
})
async count(
@param.where(Product) where?: Where<Product>,
): Promise<Count> {
return this.productRepository.count(where);
}
@get('/products', {
responses: {
'200': {
description: 'Array of Product model instances',
content: {
'application/json': {
schema: {
type: 'array',
items: getModelSchemaRef(Product, {includeRelations: true}),
},
},
},
},
},
})
async find(
@param.filter(Product) filter?: Filter<Product>,
): Promise<Product[]> {
return this.productRepository.find(filter);
}
@patch('/products', {
responses: {
'200': {
description: 'Product PATCH success count',
content: {'application/json': {schema: CountSchema}},
},
},
})
async updateAll(
@requestBody({
content: {
'application/json': {
schema: getModelSchemaRef(Product, {partial: true}),
},
},
})
product: Product,
@param.where(Product) where?: Where<Product>,
): Promise<Count> {
return this.productRepository.updateAll(product, where);
}
@get('/products/{id}', {
responses: {
'200': {
description: 'Product model instance',
content: {
'application/json': {
schema: getModelSchemaRef(Product, {includeRelations: true}),
},
},
},
},
})
async findById(
@param.path.number('id') id: number,
@param.filter(Product, {exclude: 'where'}) filter?: FilterExcludingWhere<Product>
): Promise<Product> {
return this.productRepository.findById(id, filter);
}
@patch('/products/{id}', {
responses: {
'204': {
description: 'Product PATCH success',
},
},
})
async updateById(
@param.path.number('id') id: number,
@requestBody({
content: {
'application/json': {
schema: getModelSchemaRef(Product, {partial: true}),
},
},
})
product: Product,
): Promise<void> {
await this.productRepository.updateById(id, product);
}
@put('/products/{id}', {
responses: {
'204': {
description: 'Product PUT success',
},
},
})
async replaceById(
@param.path.number('id') id: number,
@requestBody() product: Product,
): Promise<void> {
await this.productRepository.replaceById(id, product);
}
@del('/products/{id}', {
responses: {
'204': {
description: 'Product DELETE success',
},
},
})
async deleteById(@param.path.number('id') id: number): Promise<void> {
await this.productRepository.deleteById(id);
}
}
Bây giờ bạn đã có các endpoint CRUD cho model Product. Khởi động lại ứng dụng:
npm start
Truy cập http://localhost:3000/explorer để xem và thử nghiệm các API này.
Kết luận
Trong bài viết này, chúng ta đã tìm hiểu cách cài đặt và sử dụng LoopBack để tạo một ứng dụng API RESTful. Chúng ta đã đi qua các bước từ cài đặt LoopBack CLI, tạo dự án mới, thiết lập datasource, tạo model và repository, và cuối cùng là tạo REST API cho model.
LoopBack là một công cụ mạnh mẽ giúp lập trình viên dễ dàng xây dựng các ứng dụng API hiệu quả. Với các thư viện và công cụ mà LoopBack cung cấp, bạn có thể nhanh chóng thiết kế, xây dựng và mở rộng ứng dụng của mình.
Comments