typescript-koa-postgresql 实现一个简单的rest风格服务器 —— 连接 postgresql 数据库

接上一篇，这里使用 sequelize 来连接 postgresql 数据库

1、安装 sequelize，数据库驱动 pg

yarn add sequelize sequelize-typescript pg reflect-metadata

2、新建配置文件夹 conf 及 配置文件 db.conf.ts

/**
 * @name: 数据库配置
 * @param : undefined
 * @return : undefined
 */
export const dbConfig = {
  host: 'localhost',
  database: 'demo',
  dialect: 'postgres',
  username: 'postgres',
  password: '123456'
}

3、连接数据库，新建文件夹 db 及 配置文件 db.ts

 /*
  * @Description: 数据库连接类
  */

 import * as path from 'path'
 import { Sequelize } from 'sequelize-typescript'
 import { dbConfig } from '../conf/db.conf'

 class DbContext {
   private sequelize: Sequelize
   constructor() {
     const { host, database, dialect, username, password } = dbConfig
     this.sequelize = new Sequelize({
       host: host,
       database: database,
       dialect: dialect,
       username: username,
       password: password,
       define: {
         timestamps: true,  //开启时间戳 create_at delete_at update_at
         paranoid: true,    //开启假删除
         underscored: true, //下划线
         charset: 'utf8',
         freezeTableName: true //固定表名为单数  默认表名是xxxs
       },
       pool: {
         max: 10,
         min: 0,
         acquire: 30000,
         idle: 10000
       },
       timezone: '+08:00',
       modelPaths: [path.resolve(__dirname, `./models`)]
     })
     this.sequelize.sync()
   }
   init(): Boolean {
     return !!this.sequelize
   }
   getInstance(): Sequelize {
     return this.sequelize
   }
   isInit(): Boolean {
     return !!this.sequelize
   }
 }
 export const dbContext = new DbContext()

4、数据库实体类，新建文件夹 models 及文件 user.ts

 /*
  * @Description: 数据库实体类
  */

 import { Table, Column, Model } from 'sequelize-typescript'

 @Table({
   tableName: 'user'
 })
 export default class User extends Model<User> {
   @Column({
     comment: '自增ID',
     primaryKey: true,
     autoIncrement: true,
   })
   id: number

   @Column
   username: string

   @Column
   password: string
 }

5、编写业务逻辑接口，在 src 目录下新建文件夹 dao、service，在 dao 目录下新建 UserDao.ts 及子目录  impl，在 service  目录下新建 UserService.ts 及子目录  impl

 /*
  * @Description: 数据库表操作基础接口 UserDao.ts
  */
 export interface UserDao {
   /**
    * @name: 查询
    * @param :
    * @return : Array<User>
    */
   findAll();
   /**
    * @name: 查询
    * @param :
    * @return : Array<User>
    */
   findByName(username:string);
   /**
    * @name: 新增
    * @param : undefined
    * @return : undefined
    */
   create(entity:UserInfo);

   /**
    * @name: 删除
    * @param : undefined
    * @return : undefined
    */
   delete(id:number);
 }
 export interface UserInfo {
   username:string;
   password:string;
 }

 /*
  * @Description: service接口  UserService.ts
  * @version:
  */

 export interface UserService{
   /**
    * @name: 查询
    * @param : undefined
    * @return : undefined
    */
   findAll();

   /**
    * @name: 查询
    * @param : undefined
    * @return : undefined
    */
   findByName(username:string);

   /**
    * @name: 新增
    * @param : undefined
    * @return : undefined
    */
   create(username:string,password:string);

   /**
    * @name: 删除
    * @param : undefined
    * @return : undefined
    */
   delete(id:String);
 }

6、编写业务逻辑实现类 UserDaoImpl.ts、UserServiceImpl.ts

 /*
  * @Description: 数据库表操作基础实现类 UserDaoImpl.ts
  */

 import { dbContext } from '../../db/db'
 import { UserDao, UserInfo } from '../UserDao';
 import User from '../../db/models/user';

 export class UserDaoImpl implements UserDao{
   constructor(){
     dbContext.init();
   }
   /**
    * @name: 查询
    * @param : undefined
    * @return : undefined
    */
   public async findAll(){
     const results = await User.findAll({
       raw: true
     })
     return results;
   } 

    /**
    * @name: 查询
    * @param : undefined
    * @return : undefined
    */
   public async findByName(username:string){
     const results = await User.findOne({
       where:{
         username:username
       }
     })
     return results;
   } 

   /**
    * @name: 新增
    * @param : entity
    * @return : undefined
    */
   public async create(entity:UserInfo) {
     const results = await User.create(entity)
     return results;
   }

    /**
    * @name: 删除
    * @param : undefined
    * @return : undefined
    */
   public async delete(id: number) {
     const results = await User.destroy({
       where:{
           id:{
             $eq:id
           }
       }
     });
     return results;
   }
 } 

 import { UserService } from "../UserService";
 import { UserDao } from "../../dao/UserDao";
 import { UserDaoImpl } from "../../dao/impl/UserDaoImpl";

 /*
  * @Description: service实现类 UserServiceImpl.ts
  */

 export class UserServiceImpl implements UserService{
   private userDao:UserDao;

   constructor(){
     this.userDao = new UserDaoImpl();
   }

   /**
    * @name: 查询
    * @param : undefined
    * @return : undefined
    */
   public findAll() {
     return this.userDao.findAll();
   }
   /**
    * @name: 查询
    * @param : undefined
    * @return : undefined
    */
   public findByName(username:string) {
     return this.userDao.findByName(username);
   }
   /**
    * @name: 新增
    * @param : entity
    * @return : undefined
    */
   public create(username: string, password: string) {
     return this.userDao.create({username,password});
   }

   /**
    * @name: 删除
    * @param : undefined
    * @return : undefined
    */
   public delete(id: String) {
     return this.userDao.delete(~~id);
   }

 } 

7、查看成果，修改 router/index.ts

 /*
  * @Description: 后台路由组件
  * @version: 0.1.0
  */
 import * as Router from 'koa-router';
 import { UserInfo } from '../dao/UserDao';
 import { UserService } from '../service/UserService';
 import { UserServiceImpl } from '../service/impl/UserServiceImpl';

 const router = new Router();
 const userService:UserService =new UserServiceImpl();

 router.get('/*', async (ctx) => {
   ctx.body = await userService.findAll();
 })

 export { router }

8、浏览器输入 http://localhost:8080

至此连接数据库完成

目录结构：