Study nodejs「3」 - Zsm's blog

MVC#

这真的很java吧（）

安装依赖#

npm install inversify reflect-metadata express inversify-express-util prisma class-validator class-transformer

(数据库的东西用的还是上次的，懒得搞了，然后有个版本问题，npm install inversify-express-utils要求inversify@6.0.3express@4.21.1 )

封装方法#

main.tx

1
import { InversifyExpressServer } from 'inversify-express-utils'
2
import { Container } from 'inversify'
3

4
const container = new Container()
5

6
const server = new InversifyExpressServer(container)
7
const app = server.build()
8

9
app.listen(3000, () => {
10
    console.log('server started')
11
})

这是最简单的封装，把express封装成一个server

src 下面创建亮个文件夹，一个user,一个db

1
db
2
     --index.ts
3
user
4
     --server.ts
5
     --user.dto.ts
6
     --controller.ts

正式写入#

main.ts

1
import 'reflect-metadata'
2
import { InversifyExpressServer } from 'inversify-express-utils'
3
import { Container } from 'inversify'
4
import { UserController } from './src/user/controller'
5
import { UserService } from './src/user/service'
6
import express from 'express'
7
import { PrismaClient } from '@prisma/client'
8
import { PrismaDB } from './src/db'
9
const container = new Container() //Ioc搞个容器
10
/**
11
 * prisma依赖注入
12
 */
13
 //注入工厂封装db
14
container.bind<PrismaClient>('PrismaClient').toFactory(()=>{
15
    return () => {
16
        return new PrismaClient()
17
    }
18
})
19
container.bind(PrismaDB).toSelf()
20
/**
21
 * user模块
22
 */
23
container.bind(UserService).to(UserService) //添加到容器
24
container.bind(UserController).to(UserController) //添加到容器
25
/**
26
 * post模块
27
 */
28
const server = new InversifyExpressServer(container) //返回server
29
//中间件编写在这儿
30
server.setConfig(app => {
31
    app.use(express.json()) //接受json
32
})
33
const app = server.build() //app就是express
34

35
app.listen(3000, () => {
36
    console.log('http://localhost:3000')
37
})

user/controller.ts

1
import { controller, httpGet as GetMapping, httpPost as PostMapping } from 'inversify-express-utils'
2
import { inject } from 'inversify'
3
import { UserService } from './service'
4
import type { Request, Response } from 'express'
5
@controller('/user') //路由
6
export class UserController {
7

8
    constructor(
9
        @inject(UserService) private readonly userService: UserService, //依赖注入
10
    ) { }
11

12
    @GetMapping('/index') //get请求
13
    public async getIndex(req: Request, res: Response) {
14
        console.log(req?.user.id)
15
        const info = await this.userService.getUserInfo()
16
        res.send(info)
17
    }
18

19
    @PostMapping('/create') //post请求
20
    public async createUser(req: Request, res: Response) {
21
        const user = await this.userService.createUser(req.body)
22
        res.send(user)
23
    }
24
}

user/service.ts

1
import { injectable, inject } from 'inversify'
2
import { UserDto } from './user.dto'
3
import { plainToClass } from 'class-transformer' //dto验证
4
import { validate } from 'class-validator' //dto验证
5
import { PrismaDB } from '../db'
6
@injectable()
7
export class UserService {
8

9
    constructor(
10
        @inject(PrismaDB) private readonly PrismaDB: PrismaDB //依赖注入
11
    ) {
12

13
    }
14

15
    public async getUserInfo() {
16
        return await this.PrismaDB.prisma.user.findMany()
17
    }
18

19
    public async createUser(data: UserDto) {
20
        const user = plainToClass(UserDto, data)
21
        const errors = await validate(user)
22
        const dto = []
23
        if (errors.length) {
24
            errors.forEach(error => {
25
                Object.keys(error.constraints).forEach(key => {
26
                    dto.push({
27
                        [error.property]: error.constraints[key]
28
                    })
29
                })
30
            })
31
            return dto
32
        } else {
33
            const userInfo =  await this.PrismaDB.prisma.user.create({ data: user })
34
            return userInfo
35
        }
36
    }
37
}

user/user.dto.ts

1
import { IsNotEmpty, IsEmail } from 'class-validator'
2
import { Transform } from 'class-transformer'
3
export class UserDto {
4
    @IsNotEmpty({ message: '用户名必填' })
5
    @Transform(user => user.value.trim())
6
    name: string
7

8
    @IsNotEmpty({ message: '邮箱必填' })
9
    @IsEmail({},{message: '邮箱格式不正确'})
10
    @Transform(user => user.value.trim())
11
    email: string
12
}

db/index.ts

1
import { injectable, inject } from 'inversify'
2
import { PrismaClient } from '@prisma/client'
3

4
@injectable()
5
export class PrismaDB {
6
    prisma: PrismaClient
7
    constructor(@inject('PrismaClient') PrismaClient: () => PrismaClient) {
8
       this.prisma = PrismaClient()
9
    }
10
}

总体思想是去把不同的部分去分别封装，然后通过inversify去注入，这样子就实现了一个简单的MVC框架，有点类似java了，但是更加手动，dto验证可以去限制文件内容，类似python的re。

JWT#

安装依赖#

npm install jsonwebtoken passport passport-jwt

实现#

我们在src中新建一个文件夹jwt，新建一个index.ts

jwt/index.ts

1
import { injectable} from 'inversify'
2
import passport from 'passport'
3
import jsonwebtoken from 'jsonwebtoken'
4
import {Strategy,ExtractJwt} from 'passport-jwt'
5

6
@injectable()
7
export class JWT {
8
    private secret:string='awfbkuahfbakjhfbafuwhjbeawhjfn'
9
    private jwtOptions={
10
        jwtFromRequest:ExtractJwt.fromAuthHeaderAsBearerToken(),
11
        secretOrKey:this.secret
12
    }
13
    constructor(){
14
        this.strategy()
15
    }
16
    public strategy(){
17
        let str=new Strategy(this.jwtOptions,(payload,done)=>{
18
            done(null,payload)
19
        })
20
        passport.use(str)//激活插件
21
    }
22

23
    static middleware(){
24
        return passport.authenticate('jwt',{session:false})
25
    }//经过jwt认证后才能进入到下一个
26
    //生成token
27
    public createToken(data:Object) {
28
          jsonwebtoken.sign(data,this.secret,{expiresIN:'1h'})
29
    }
30
    //关联express
31
    public init(){
32
        return passport.initialize()
33
    }
34
}

需要注意的是我们要去激活插件，并且要关联express

main.ts

1
import 'reflect-metadata'
2
import { InversifyExpressServer } from 'inversify-express-utils'
3
import { Container } from 'inversify'
4
import { User } from './src/user/controller'
5
import { UserService } from './src/user/services'
6
import express from 'express'
7
import { PrismaClient } from '@prisma/client'
8
import { PrismaDB } from './src/db'
9
import { JWT } from './src/jwt'
10
const container = new Container()
11
/**
12
 * user模块
13
 */
14
container.bind(User).to(User)
15
container.bind(UserService).to(UserService)
16
/**
17
 *  封装PrismaClient
18
 */
19
container.bind<PrismaClient>('PrismaClient').toFactory(() => {
20
    return () => {
21
        return new PrismaClient()
22
    }
23
})
24
container.bind(PrismaDB).to(PrismaDB)
25
/**
26
 * jwt模块
27
 */
28
container.bind(JWT).to(JWT) //主要代码
29

30

31
const server = new InversifyExpressServer(container)
32
server.setConfig((app) => {
33
    app.use(express.json())
34
    app.use(container.get(JWT).init()) //主要代码
35
})
36
const app = server.build()
37

38
app.listen(3000, () => {
39
    console.log('Listening on port 3000')
40
})

user/controller.ts

1
import { controller, httpGet as GetMapping, httpPost as PostMapping } from 'inversify-express-utils'
2
import { UserService } from './services'
3
import { inject } from 'inversify'
4
import type { Request, Response } from 'express'
5
import { JWT } from '../jwt'
6
const {middleware}  = new JWT()
7
@controller('/user')
8
export class User {
9
    constructor(@inject(UserService) private readonly UserService: UserService) {
10

11
    }
12
    @GetMapping('/index',middleware()) //主要代码
13
    public async getIndex(req: Request, res: Response) {
14
        let result = await this.UserService.getList()
15
        res.send(result)
16
    }
17

18
    @PostMapping('/create')
19
    public async createUser(req: Request, res: Response) {
20
        let result = await this.UserService.createUser(req.body)
21
        res.send(result)
22
    }
23
}

user/services.ts

1
import { injectable, inject } from 'inversify'
2
import { PrismaDB } from '../db'
3
import { UserDto } from './user.dto'
4
import { plainToClass } from 'class-transformer'
5
import { validate } from 'class-validator'
6
import { JWT } from '../jwt'
7
@injectable()
8
export class UserService {
9
    constructor(
10
        @inject(PrismaDB) private readonly PrismaDB: PrismaDB,
11
        @inject(JWT) private readonly jwt: JWT //依赖注入
12
    ) {
13

14
    }
15
    public async getList() {
16
        return await this.PrismaDB.prisma.user.findMany()
17
    }
18

19
    public async createUser(user: UserDto) {
20
        let userDto = plainToClass(UserDto, user)
21
        const errors = await validate(userDto)
22
        if (errors.length) {
23
            return errors
24
        } else {
25
            const result = await this.PrismaDB.prisma.user.create({
26
                data: user
27
            })
28
            return {
29
                ...result,
30
                token: this.jwt.createToken(result) //生成token
31
            }
32
        }
33

34
    }
35
}

然后会发现接收信息存在类型问题，我们在main.ts加入

1
declare global {
2
    namespace Express {
3
        interface Request {
4
            id: number
5
            name: string
6
            email: string
7
        }
8
    }
9
}

最后结构#

1
├── main.ts                 # 应用入口文件
2
├── src/
3
    ├── db/                 # 数据库相关
4
    │   └── index.ts
5
    ├── jwt/               # JWT认证相关
6
    │   └── index.ts
7
    └── user/              # 用户模块
8
        ├── controller.ts  # 控制器
9
        ├── service.ts     # 服务层
10
        └── user.dto.ts    # 数据传输对象

a ctfer on the load

MVC#

安装依赖#

封装方法#

正式写入#

JWT#

安装依赖#

实现#

最后结构#