java nodejs框架 nodejs的框架有哪些

转载

mob6454cc680fc0 2023-12-25 10:55:57

文章标签 java nodejs框架前端 node.js javascript 应用程序 文章分类 Java 后端开发

Node.js是一个底层平台。为了方便开发者的工作变得简单高效，社区诞生了超过上千个库。

随着时间的推移，有很多优秀的库可以供大家选择，下面是不完全选择列表：

Express: 提供非常简单的方式来创建Web服务器，且功能足够强大并且足够的轻量，专注于服务器的核心功能。

// server.js
const express = require('express')
const app = express()
const port = 3000

app.get('/', (req, res) => {
  res.send('Hello World!')
})

app.listen(port, () => {
  console.log(`Example app listening on port ${port}`)
})

koa: 它是由Express背后的同一团队打造，提供更加简单、更小巧的库，并且支持ES NEXT的async await语法。

// server.js
const Koa = require('koa');
const app = new Koa();

app.use(async ctx => {
  ctx.body = 'Hello World';
});

app.listen(3000);

NestJS: 一个基于TypeScript的渐进式Node.js框架，用于构建高效、可靠、可扩展的企业级服务端应用程序。

// app.controller.ts
import { Get, Controller, Render } from '@nestjs/common';
import { AppService } from './app.service';

@Controller()
export class AppController {
    constructor(private readonly appService: AppService) {}

    @Get()
    @Render('index')
    render() {
        const message = this.appService.getHello();
        return { message };
    }
}

Egg.js: 使用Node.js和Koa构建更好的企业级服务端框架。

// app/controller/home.js
const Controller = require('egg').Controller;

class HomeController extends Controller {
  async index() {
    this.ctx.body = 'Hello world';
  }
}

module.exports = HomeController;

Next.js: React 框架提供了良好的开发体验，提供生产环境的所有功能：服务端渲染、支持TypeScript、路由预获取等等。

// first-post.js
export default function FirstPost() {
  return <h1>First Post</h1>
}

Remix: Remix 是一个全栈Web框架，它开箱即用，包含构建现代Web应用程序前端和后端。

// index.tsx
export async function loader({ request }) {
  return getProjects();
}

export async function action({ request }) {
  const form = await request.formData();
  return createProject({ title: form.get("title") });
}

export default function Projects() {
  const projects = useLoaderData();
  const { state } = useTransition();
  const busy = state === "submitting";

  return (
    <div>
      {projects.map((project) => (
        <Link to={project.slug}>{project.title}</Link>
      ))}

      <Form method="post">
        <input name="title" />
        <button type="submit" disabled={busy}>
          {busy ? "Creating..." : "Create New Project"}
        </button>
      </Form>
    </div>
  );
}

Gatsby: 一个基于React、GraphQL的静态站点生成器，具有非常丰富的插件和生态。

// src/pages/index.js
import * as React from 'react'

const IndexPage = () => {
  return (
    <main>
      <title>Home Page</title>
      <h1>Welcome to my Gatsby site!</h1>
      <p>I'm making this by following the Gatsby Tutorial.</p>
    </main>
  )
}

export default IndexPage

hapi: 用于构建Web应用服务的框架，使开发人员能够专注于编写可重用的应用程序逻辑，而不是花费时间构建基础设施。

// index.js

'use strict';

const Hapi = require('@hapi/hapi');

const init = async () => {

    const server = Hapi.server({
        port: 3000,
        host: 'localhost'
    });

    server.route({
        method: 'GET',
        path: '/',
        handler: (request, h) => {
            return 'Hello World!';
        }
    });

    await server.start();
    console.log('Server running on %s', server.info.uri);
};

process.on('unhandledRejection', (err) => {
    console.log(err);
    process.exit(1);
});

init();

Fastify: 一个高度专注于以最少的开销和强大的插件架构，提供最佳的开发体验的Web框架。Fastify是最快的Node.js Web框架之一。

// server.js
const fastify = require('fastify')({ logger: true })

// Declare a route
fastify.get('/', async (request, reply) => {
  return { hello: 'world' }
})

// Run the server!
const start = async () => {
  try {
    await fastify.listen(3000)
  } catch (err) {
    fastify.log.error(err)
    process.exit(1)
  }
}
start()

AdonisJS: 一个基于TypeScript的全功能框架，高度关注开发人员的体验和稳定性。Adonis是最快的Node.js Web框架之一。

// PostsController.js
import Post from 'App/Models/Post'

export default class PostsController {

  public async index () {
    return Post.all()
  }

  public async store ({ request }) {
    return request.body()
  }

}

FeatherJS: Feathers是一个轻量级的Web框架，用于使用JavaScript或者TypeScript创建实时应用程序和REST API。在几分钟内构建原型程序，在几天内构建企业级应用程序。

// app.ts
import feathers from '@feathersjs/feathers';

interface Message {
  id?: number;
  text: string;
}


class MessageService {
  messages: Message[] = [];

  async find () {
    return this.messages;
  }

  async create (data: Pick<Message, 'text'>) {
    const message: Message = {
      id: this.messages.length,
      text: data.text
    }

    this.messages.push(message);

    return message;
  }
}

const app = feathers();

app.use('messages', new MessageService());

app.service('messages').on('created', (message: Message) => {
  console.log('A new message has been created', message);
});

const main = async () => {
  await app.service('messages').create({
    text: 'Hello Feathers'
  });

  await app.service('messages').create({
    text: 'Hello again'
  });

  const messages = await app.service('messages').find();

  console.log('All messages', messages);
};

main();

Loopback.io: 使构建复杂集成的现代应用程序变得更加容易。

// hello.controller.ts
import {get} from '@loopback/rest';
export class HelloController {
  @get('/hello')
  hello(): string {
    return 'Hello world!';
  }
}

Meteor: 一个非常强大的全栈框架，提供同构的方法来使用JavaScript构建应用程序，在客户端和服务端共享代码。以前提供全套的现成工具，现在与前端库React、Vue和Angular集成。也可用于创建移动应用程序。
Micro: 它提供非常轻量级的服务器来创建异步HTTP微服务。

// index.js
const https = require('https');
const {run, send} = require('micro');

const {key, cert, passphrase} = require('openssl-self-signed-certificate');

const PORT = process.env.PORT || 3443;

const options = {key, cert, passphrase};

const microHttps = fn => https.createServer(options, (req, res) => run(req, res, fn));

const server = microHttps(async (req, res) => {
    send(res, 200, {encrypted: req.client.encrypted});
});

server.listen(PORT);
console.log(`Listening on https://localhost:${PORT}`);

Nx: 使用NestJS、Express、React、Angular等进行全栈monorepo开发的工具包，Nx有助于将您的开发从一个团队构建一个应用程序扩展到多个团队协作开发多个应用程序！
Sapper: Sapper是一个用于构建各种规模的Web应用程序框架，具有出色的开发体验和灵活的基于文件系统的路由，提供SSR等等。
Socket.io: 用于构建实时网络应用程序的WebSocket框架。

// index.js
const express = require('express');
const app = express();
const http = require('http');
const server = http.createServer(app);
const { Server } = require("socket.io");
const io = new Server(server);

app.get('/', (req, res) => {
  res.sendFile(__dirname + '/index.html');
});

io.on('connection', (socket) => {
  console.log('a user connected');
});

server.listen(3000, () => {
  console.log('listening on *:3000');
});