npx create-nuxt-app <项目名>

mkdir egg-example && cd egg-example
npm init egg --type=simple
npm i

egg-project
├── package.json
├── app.js (可选)
├── agent.js (可选)
├── app  接口等编写的主要文件夹
|   ├── router.js   路由（接口定义位置，与控制器组合为一个完整接口）
│   ├── controller  控制器（接口位置）
│   |   └── home.js
│   ├── service (可选)
│   |   └── user.js
│   ├── middleware (可选)
│   |   └── response_time.js
│   ├── schedule (可选)
│   |   └── my_task.js
│   ├── public (可选)
│   |   └── reset.css
│   ├── view (可选)
│   |   └── home.tpl
│   └── extend (可选)
│       ├── helper.js (可选)
│       ├── request.js (可选)
│       ├── response.js (可选)
│       ├── context.js (可选)
│       ├── application.js (可选)
│       └── agent.js (可选)
├── config  配置文件
|   ├── plugin.js  插件配置文件
|   ├── config.default.js 默认配置文件,返回的对象可以使用`this.app.config`获取
│   ├── config.prod.js
|   ├── config.test.js (可选)
|   ├── config.local.js (可选)
|   └── config.unittest.js (可选)
└── test  测试文件
    ├── middleware
    |   └── response_time.test.js
    └── controller
        └── home.test.js

export default {
      modules: ["@nuxtjs/proxy"],
      proxy: {
            "/api/": {
                  target: "http://localhost:7001",
                  screen: false,
                  pathRewrite: {
                        "^/api": "",
                  },
            },
      },
};

 npm install @nuxtjs/proxy

import Vue from "vue";
import axios from "axios";

const $http = axios.create({
      baseURL: "/api",
});

// 请求拦截,所有请求前会通过这里，这里可以为请求添加参数
$http.interceptors.request.use((config) => {
      const token = localStorage.getItem("token");
      if (token) {
            config.headers.common["Authorization"] = "Bearer " + token;
      }

      return config;
});

// 响应拦截，所以请求响应都会走这里，这里可以处理返回的参数
$http.interceptors.response.use((response) => {
      const { data } = response;

      return data;
});

Vue.prototype.$http = $http;

// 拓展Vue原型方法
import { AxiosInstance } from "axios";
declare module "vue/types/vue" {
      interface Vue {
            $http: AxiosInstance;
      }
}

{
      "compilerOptions": {
            "paths": {
                  "@type/*": ["./type/*"],
                  "@comp/*": ["./components/*"]
            }
      }
}

export default {
      alias: {
            // ts type
            "@type": "./type/*",
      },
};

this.$http.post("/uploadfile", form, {
      onUploadProgress: (progress: any) => {
            this.uploadProgress = Number(
                  ((progress.loaded / progress.total) * 100).toFixed(2)
            );
      },
});

return {
      security: {
            csrf: {
                  enable: false,
            },
      },
};

return {
      mongoose: {
            client: {
                  url: "mongodb://127.0.0.1:<端口号：默认端口号为27017>/<databaseName>",
                  options: {},
            },
      },
};

config.multipart = {
      mode: "file",
      whitelist: () => true,
};

module.exports = ({ app }) => {
      return async function verify(ctx, next) {
            // 搞事情
            await next();
      };
};

module.exports = (app) => {
      const { router, controller } = app;
      const jwt = app.middleware.jwt({ app });
      router.post("/uploadfile", jwt, controller.util.uploadFile);
};

function blobToString(blob: Blob) {
      return new Promise(resolve => {
          	// 创建读取文件的对象
            const reader = new FileReader();
			// 二进制文件加载完成后
            reader.onload = function () {
                  const result = reader.result as string;
                  // 对读取到的内容进行处理
                  const res = result.split("")
                        .map(v => v.charCodeAt(0))
                        .map(v => v.toString(16).toUpperCase())
                        .join(" ");
                  resolve(res);
            }

			// 读取二进制文件
            reader.readAsBinaryString(blob);
      })
}

async function isGif(blob: Blob) {
      const res = await blobToString(blob.slice(0, 6))
      return (res === "47 49 46 38 39 61") || (res === "47 49 46 38 37 61");
}

async function isPng(blob: Blob) {
      const res = await blobToString(blob.slice(0, 8))
      console.log(res)
      return (res == "89 50 4E 47 0D 0A 1A 0A")  || (res === "89 50 4E 47 D A 1A A");
}

async function isJpg(blob: Blob) {
      let len = blob.size;
      const start = await blobToString(blob.slice(0, 2))
      const tail = await blobToString(blob.slice(-2, len))
      return (start === "FF D8") && (tail === "FF D9");
}

"use strict";

const Controller = require("egg").Controller;

class BasicController extends Controller {
      success(data) {
            const { ctx } = this;
            ctx.body = {
                  code: 0,
                  data,
            };
      }

      error(code = -1, message, errors) {
            const { ctx } = this;
            ctx.body = {
                  code,
                  message,
                  errors,
            };
      }

      message(message) {
            const { ctx } = this;
            ctx.body = {
                  code: 0,
                  message,
            };
      }
}
module.exports = BasicController;

"use strict";

const BasicController = require("./basic");

const registerRule = {
      password: { type: "string" },
      username: { type: "string" },
      email: { type: "email" },
      captcha: { type: "string" },
};

class UserController extends BasicController {
      async register() {
            const num = parseInt(Math.random() * 10, 10);

            if (num % 2 === 0) {
                  return this.error("参数校验失败", -1, "其他消息");
            }
            this.success("注册成功");
      }
}

module.exports = UserController;