ts装饰器实现controller

在 TypeScript 中，你可以使用装饰器来实现控制器。装饰器是一种特殊的函数，它可以用于修改类、方法、属性或参数的行为。下面是一个简单的示例，展示如何使用装饰器来实现一个控制器：

// 定义一个装饰器函数
function Controller(target: any) {
  // 在装饰器中修改目标类的行为
  // 这里可以添加一些逻辑，比如添加路由信息等
}

@Controller
class MyController {
  // 添加控制器的方法和逻辑
}

上面的例子中，我们定义了一个名为 `Controller` 的装饰器函数，并将其应用到 `MyController` 类上。在装饰器函数中，你可以执行一些自定义的逻辑，比如添加路由信息、验证等。你可以根据实际需求，在装饰器中做任何你需要的操作。

请注意，这只是一个简单的示例，实际的控制器实现可能需要更多的代码和逻辑。你可以根据自己的需求扩展和修改这个示例来实现更复杂的控制器功能。

相关问题

nestjs 实现用户注册、登录和验证功能 要求控制器的登录接口使用@body() 装饰器 使用jwt和passport

好的，针对你的要求，我来介绍一下nestjs如何实现用户注册、登录和验证功能，并使用@body()装饰器、jwt和passport来实现登录接口。

首先，我们需要安装nestjs的依赖包：

npm i @nestjs/common @nestjs/core @nestjs/platform-express @nestjs/typeorm typeorm mysql passport passport-local @nestjs/passport passport-jwt @nestjs/jwt

然后，我们需要创建一个User实体类，在这个实体类中定义用户的属性和方法。示例代码如下：

import { Entity, Column, PrimaryGeneratedColumn } from 'typeorm';

@Entity()
export class User {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  username: string;

  @Column()
  password: string;
}

接着，我们需要创建一个UserService服务，用于实现用户注册、登录和验证功能。示例代码如下：

import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { User } from './user.entity';
import * as bcrypt from 'bcrypt';

@Injectable()
export class UserService {
  constructor(
    @InjectRepository(User)
    private readonly userRepository: Repository<User>,
  ) {}

  async register(username: string, password: string): Promise<User> {
    const saltOrRounds = 10;
    const hash = await bcrypt.hash(password, saltOrRounds);
    const user = new User();
    user.username = username;
    user.password = hash;
    return await this.userRepository.save(user);
  }

  async login(username: string, password: string): Promise<User> {
    const user = await this.userRepository.findOne({ username });
    if (user && await bcrypt.compare(password, user.password)) {
      return user;
    }
    return null;
  }

  async validateUser(username: string, password: string): Promise<User> {
    const user = await this.userRepository.findOne({ username });
    if (user && await bcrypt.compare(password, user.password)) {
      return user;
    }
    return null;
  }
}

在上面的代码中，我们使用了Injectable装饰器来定义UserService服务，使用InjectRepository装饰器来注入User实体类的Repository对象，然后在register、login和validateUser方法中实现用户注册、登录和验证功能。在register和login方法中，我们使用bcrypt加密库对密码进行加密和校验，保证密码的安全性。

接下来，我们需要创建一个AuthController控制器，用于定义用户注册、登录和验证接口。示例代码如下：

import { Controller, Post, Body, Req, UseGuards } from '@nestjs/common';
import { AuthGuard } from '@nestjs/passport';
import { AuthService } from './auth.service';
import { UserService } from '../user/user.service';

@Controller()
export class AuthController {
  constructor(
    private readonly authService: AuthService,
    private readonly userService: UserService,
  ) {}

  @Post('/register')
  async register(@Body('username') username: string, @Body('password') password: string): Promise<any> {
    const user = await this.userService.register(username, password);
    return { code: 200, message: '注册成功', data: user };
  }

  @Post('/login')
  @UseGuards(AuthGuard('local'))
  async login(@Req() req): Promise<any> {
    const token = await this.authService.generateToken(req.user);
    return { code: 200, message: '登录成功', data: { user: req.user, token } };
  }

  @Post('/profile')
  @UseGuards(AuthGuard('jwt'))
  async profile(@Req() req): Promise<any> {
    return { code: 200, message: '获取用户信息成功', data: req.user };
  }
}

在上面的代码中，我们使用了Controller装饰器来定义AuthController控制器，使用Post装饰器来定义register、login和profile接口，并使用@Body()装饰器来获取请求体中的username和password参数，在register方法中调用UserService服务中的register方法来实现用户注册功能。在login方法中，我们使用@UseGuards(AuthGuard('local'))装饰器来使用passport-local策略实现用户登录，并使用AuthService服务中的generateToken方法生成jwt token。在profile方法中，我们使用@UseGuards(AuthGuard('jwt'))装饰器来使用passport-jwt策略验证jwt token，并返回用户信息。

接着，我们需要创建一个AuthService服务，用于实现jwt token的生成和验证功能。示例代码如下：

import { Injectable } from '@nestjs/common';
import { JwtService } from '@nestjs/jwt';
import { User } from '../user/user.entity';

@Injectable()
export class AuthService {
  constructor(private readonly jwtService: JwtService) {}

  async generateToken(user: User): Promise<string> {
    const payload = { username: user.username, sub: user.id };
    return this.jwtService.sign(payload);
  }

  async validateToken(token: string): Promise<any> {
    try {
      const payload = this.jwtService.verify(token);
      return payload;
    } catch (error) {
      return null;
    }
  }
}

在上面的代码中，我们使用了Injectable装饰器来定义AuthService服务，使用JwtService来生成和验证jwt token，其中generateToken方法将用户信息添加到payload中，然后使用this.jwtService.sign方法生成jwt token，并返回生成的jwt token。validateToken方法使用this.jwtService.verify方法验证jwt token的有效性，并返回payload中的信息。

最后，我们需要在app.module.ts中配置PassportModule和JwtModule。示例代码如下：

import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { User } from './user/user.entity';
import { UserService } from './user/user.service';
import { UserController } from './user/user.controller';
import { AuthController } from './auth/auth.controller';
import { AuthService } from './auth/auth.service';
import { PassportModule } from '@nestjs/passport';
import { JwtModule } from '@nestjs/jwt';

@Module({
  imports: [
    TypeOrmModule.forRoot({
      type: 'mysql',
      host: 'localhost',
      port: 3306,
      username: 'root',
      password: 'root',
      database: 'nestjs',
      entities: [User],
      synchronize: true,
    }),
    TypeOrmModule.forFeature([User]),
    PassportModule.register({ defaultStrategy: 'jwt' }),
    JwtModule.register({
      secret: 'nestjs',
      signOptions: { expiresIn: '60s' },
    }),
  ],
  controllers: [UserController, AuthController],
  providers: [UserService, AuthService],
})
export class AppModule {}

在上面的代码中，我们使用了PassportModule和JwtModule来配置passport和jwt的相关信息，其中PassportModule.register方法中的{ defaultStrategy: 'jwt' }表示默认使用jwt策略，JwtModule.register方法中的secret表示生成jwt token的密钥，signOptions中的expiresIn表示jwt token的过期时间。

至此，我们就完成了nestjs实现用户注册、登录和验证功能，并使用@body()装饰器、jwt和passport来实现登录接口的教程。

nestjs代码实现对接微信小程序授权登录获取用户信息

1. 安装微信开发者工具和nestjs

首先，需要安装微信开发者工具和nestjs。微信开发者工具用于调试和运行小程序代码，nestjs用于编写后端接口。

2. 创建小程序

在微信开发者工具中，创建一个新的小程序，并获取小程序的AppID和AppSecret。

3. 创建nestjs项目

使用nestjs cli工具创建一个新的nestjs项目。在终端中运行以下命令：

npm install -g @nestjs/cli
nest new my-project

4. 安装依赖

在nestjs项目根目录下运行以下命令安装依赖：

npm install @nestjs/common @nestjs/core @nestjs/platform-express @nestjs/swagger @nestjs/passport passport passport-wechat express-session

5. 配置nestjs

在nestjs项目中，需要配置passport和wechat strategy。

在app.module.ts文件中，添加passport和session模块：

import { Module } from '@nestjs/common';
import { PassportModule } from '@nestjs/passport';
import { WechatStrategy } from './wechat.strategy';
import * as session from 'express-session';

@Module({
  imports: [
    PassportModule,
    session({
      secret: 'my-secret',
      resave: false,
      saveUninitialized: false,
    }),
  ],
  providers: [WechatStrategy],
})
export class AppModule {}

在wechat.strategy.ts文件中，添加wechat strategy：

import { Injectable } from '@nestjs/common';
import { PassportStrategy } from '@nestjs/passport';
import { Strategy } from 'passport-wechat';

@Injectable()
export class WechatStrategy extends PassportStrategy(Strategy, 'wechat') {
  constructor() {
    super({
      appID: 'YOUR_APP_ID',
      appSecret: 'YOUR_APP_SECRET',
      scope: 'snsapi_userinfo',
      state: 'STATE',
    });
  }

  async validate(accessToken: string, refreshToken: string, profile: any) {
    const { openid, nickname, headimgurl } = profile;
    return { openid, nickname, headimgurl };
  }
}

在validate方法中，可以获取用户的openid，昵称和头像等信息。这些信息可以保存到数据库中，用于后续的用户验证和业务逻辑。

6. 编写接口

在nestjs中，可以使用@Controller和@Get等装饰器编写接口。

在app.controller.ts文件中，添加/login接口：

import { Controller, Get, Req, Res, UseGuards } from '@nestjs/common';
import { AuthGuard } from '@nestjs/passport';

@Controller()
export class AppController {
  @Get('/login')
  @UseGuards(AuthGuard('wechat'))
  async login(@Req() req, @Res() res) {
    res.redirect('/');
  }
}

在/login接口中，使用wechat strategy进行授权登录，并重定向到首页。

7. 运行nestjs项目

在nestjs项目根目录下运行以下命令启动nestjs项目：

npm run start

8. 配置小程序

在微信开发者工具中，配置小程序的请求域名和授权域名。

在小程序的app.js文件中，添加以下代码：

const app = getApp()

App({
  onLaunch: function () {
    // 登录
    wx.login({
      success: res => {
        // 发送 res.code 到后台换取 openId, sessionKey, unionId
        wx.request({
          url: 'http://localhost:3000/login',
          method: 'GET',
          data: {
            code: res.code
          },
          success: res => {
            console.log(res.data)
          }
        })
      }
    })
  }
})

在onLaunch方法中，调用wx.login方法获取用户的code，并发送请求到nestjs的/login接口进行授权登录。

9. 测试

在微信开发者工具中，启动小程序并查看控制台输出。

如果输出了用户的openid，昵称和头像等信息，则说明授权登录已经成功，可以保存这些信息到数据库中，用于后续的用户验证和业务逻辑。