在controller文件夹中新建一个index.ts文件
====

```ts
import { Controller, Blueprint } from 'burnjs';

@Blueprint.restfulClass('/article')
export default class Index extends Controller {
    @Blueprint.get('/article/:id')
    async getArticle() {
    }

    @Blueprint.get('/articles/:start')
    async getArticleList() {
    }

    async Post() {
       
    }

    async Del() {

    }

    async Put() {
    }
}

```

在这里，我为大家提供了一个api, Blueprint.restfulClass()。当使用这个以后，框架会自动注册类中的：

Get(),Post(),Del(),Put()方法，非常方便。

我们只要实现这几个方法，就可以了。


我们还可以和普通的方法混搭使用。


完成文章获取的逻辑
======
```ts
@Blueprint.restfulClass('/article')
export default class Index extends Controller {
    //获取文章的接口
    @Blueprint.get('/article/:id')
    async getArticle() {
        const articleEntity = await this.ctx.service.article.get();
        if (articleEntity) {
            this.ctx.body = JSON.stringify(articleEntity);
        } else {
            this.ctx.body = '没有文章';
        }
    }

    //获取列表的接口
    @Blueprint.get('/articles/:start')
    async getArticleList() {
        const list = await this.ctx.service.article.list(5);
        this.ctx.body = JSON.stringify(list);
        this.ctx.set('Content-Type', 'application/json');
    }

    //发布文章的接口
    async Post() {
        await this.ctx.service.article.create();
    }

    //删除文章的接口
    async Del() {
        await this.ctx.service.article.delete();
    }

    //跟新文章的接口
    async Put() {
        await this.ctx.service.article.update();
    }
}


```
在这里，可以看到我们保持了控制器的干净程度，控制只做，流程控制即：

请求到来->调用业务逻辑->返回数据.

我们将业务逻辑，封装到了service里。


编写service
====
在service文件夹中创建service.ts

```ts
import { Service } from "burnjs";
import { ArticleModel } from "../model/article";

export default class Article extends Service {
    async get(): Promise<ArticleModel | null> {
        const d: any | null = await this.ctx.model.article.findOne({
            where: {
                articleID: this.ctx.params.id
            }
        })
        if (d) {
            return <ArticleModel>d
        }
        return null
    }

    async create() {
        this.ctx.model.article.create(this.ctx.request.body);
    }

    async update() {
        this.ctx.model.article.update({
            content: this.ctx.request.body.content,
            title: this.ctx.request.body.title
        }, {
                where: {
                    articleId: this.ctx.request.body.articleId
                }
            })
    }

    async delete() {
        const id = this.ctx.params.id;
        this.ctx.model.article.destroy({
            where: {
                id: id
            }
        })
    }

    async list(limits: number): Promise<ArticleModel[] | null> {
        const list = await this.ctx.model.article.findAll({
            limit: limits,
            offset: parseInt(this.ctx.params.start) * limits
        })
        if (list) {
            return <ArticleModel[]>list
        }
        return null
    }

}

declare module 'burnjs' {
    export interface FService {
        article: Article
    }
}
```
简单的几个crud封装。

值得注意的是最后的
```ts
declare module 'burnjs' {
    export interface FService {
        article: Article
    }
}
```
这一行是typescript中的拓展接口。
- 拓展 burnjs包
- 拓展FService接口
- 拓展一个article属性

然后我们就可以在controller中的service里，获得只能提示和调用:

```ts
await this.ctx.service.article.create();
```

妈妈再也不担心这些古怪的api哪里来的了。