欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

房价在手,天下我有 --反手就撸一个爬虫(终)

程序员文章站 2022-04-26 08:06:41
...

接上篇,科科,好,我们继续

我们在这里先把json数据入库吧~

首先,database/scheme里定义好数据类型。

const mongoose = require('mongoose')

const detailHouseSchema = new mongoose.Schema({ //定义数据模式
  link:String,
  text:String,
  _id:String,
  areaDetail:[
    {
      link: String,
      text: String,
      _id: String,
      house:[
        {
          name: String,
          huxing: String,
          favorPos: String,
          aroundPrice: Number,
          adress: String,
          area: String 
        }
      ]
    }
  ]
})

mongoose.model('detailHouse',detailHouseSchema)

然后我们需要到中间件里去建立连接数据库和执行插入的动作。

middleWares/database.js

import mongoose from 'mongoose'
import config from '../config'
import fs from 'fs'
import { resolve } from 'path'

const r = path => resolve(__dirname,path) //将路径片段转成一个绝对路径
const models = r('../database/schema')
/**
 * 依次引入本地爬去好的json文件,插入数据库
 */
var areaJson = require('database/json/AreaDetail.json')
var areaHouseJson = require('database/json/AreaHouse.json')
var detailHouseJson = require('database/json/detailHouse.json')

/**
 * 依次引入schema
 */
fs.readdirSync(models) //读取文件
    .filter(file => ~file.search(/^[^\.].*js$/)) //筛选出后缀是js的文件
    .forEach(file => require(resolve(models,file))) 

export const database = app =>{
    mongoose.set('debug',true)
    mongoose.connect(config.db)
    mongoose.connection.on('disconnected', ()=>{
        mongoose.connect(config.db)
    })
    mongoose.connection.on('error', err =>{
        console.log(err)
    })
    mongoose.connection.on('open', async () =>{
        console.log('connected to MongoDb',config.db)
        /**
         * 杭州主城区数据入库
         */
        let area = mongoose.model('area')
        let areaDataBase = await area.find({}).exec()
        if (!areaDataBase.length) area.insertMany(areaJson)
        /**
         * 杭州主城区的房价数据入库
         */
        let areaHouse = mongoose.model('areaHouse')
        let areaHouseDataBase = await areaHouse.find({}).exec()
        if(!areaHouseDataBase.length) areaHouse.insertMany(areaHouseJson)

        /**
         * 杭州主城区里包括了分区的房价数据入库
         */
        let detailHouse = mongoose.model('detailHouse')
        let detailHouseDataBase = await detailHouse.find({}).exec()
        if(!detailHouseDataBase.length) detailHouse.insertMany(detailHouseJson)

    })
}

成功的话,如下图~ bling~~~

房价在手,天下我有 --反手就撸一个爬虫(终)

走到这里,我们要停下来对后端的路由做一个提取个封装。首先,我这项目页面量不大,如果单纯的用koa-router去原生去写是没有问题的,但是如果你是实际的项目,路由很多,这个时候再去那么写,代码的可读性就很差了。

Decorator可以动态地给一个对象添加额外的职责。虽然,利用子类继承也可以实现这样的功能,但是Decorator提供了一个更灵活的方式。因为继承会为类型引入的静态特质,使得这种扩展方式缺乏灵活性;并且随着子类的增多(扩展功能的增多),各种子类的组合(扩展功能的组合)会导致更多子类的膨胀。

那么我们要在decorator/router.js里要定义一些公用的方法,其中还添加了打印日志功能,在调试的时候也是美滋滋的一匹。

先去middlewares/routers/router.js里去调用我们用修饰起封装好的方法和Route。

import  Route  from '../decorator/router'
import { resolve } from 'path'

const r = path => resolve(__dirname, path)

export const router = app => {
  const apiPath = r('../routes')
  /**
   * 路由分离
   */
  const router = new Route(app, apiPath)

  router.init()
}

现在去封装Route

decorator/router.js

import Router from 'koa-router'
import { resolve } from 'path'
import _ from 'lodash'
import { glob } from 'glob' //用正则去匹配文件

export let routesMap = new Map()
export const symbolPrefix = Symbol('prefix')
export const normalizePath = path => path.startsWith('/') ? path : `/${path}`
export const isArray = c => _.isArray(c) ? c : [c]

export default class Route{
    constructor(app,apipath){
        this.app = app
        this.router = new Router()
        this.apipath = apipath
    }
    init(){
        /**
         * 这里利用传进来的apipath去引入后缀为js的文件
         */
        glob
          .sync(resolve(this.apipath,'./*.js'))
          .forEach(require);
        
        for(let [ conf , controller ] of routesMap){
            /*
            *思路就是把每一个路由文件的controller拎出来
            * 然后跟它的路由做一个一一匹配
            * */
            const controllers = isArray(controller) 
            let prefixPath = conf.target[symbolPrefix]
            if(prefixPath) prefixPath = normalizePath(prefixPath)

            const routerPath = prefixPath   conf.path
            this.router[conf.method](routerPath,...controllers) //function (name, path, middlewares)
        }
        this.app.use(this.router.routes()) // 添加路由中间件
        this.app.use(this.router.allowedMethods()) // 对请求进行一些限制处理
    }
}

/**
 * 
 * @param {path,target} 
 * 保证每一个controller都是独一无二的 
 */
export const controller = path => target => target.prototype[symbolPrefix] = path

/**
 * 
 * @param {conf} 
 * 定义简单的route 
 */
export const route = conf => (target, key, desc) =>{
    conf.path = normalizePath(conf.path)
    routesMap.set({
        target:target,
        ...conf,
    },target[key])
}

/**
 * 
 * @param {path} 
 * 定义get方法
 */
export const get = path => route({
    method:'get',
    path:path
})

/**
 * 
 * @param {path} 
 * 定义post方法 
 */
export const post = path => route({
    method:'post',
    path:path
})

/**
 * 
 *  打印日志
 */
let reqID = 0

const decorate = (args, middleware) => {
  let [ target, key, descriptor ] = args
  target[key] = isArray(target[key])
  target[key].unshift(middleware)
  return descriptor
}

export const convert = middleware => (...args) => decorate(args, middleware)

export const log = convert(async (ctx, next) => {
    let currentReqID = reqID  
    console.time(`${currentReqID} ${ctx.method} ${ctx.url}`)
    await next()
    console.timeEnd(`${currentReqID} ${ctx.method} ${ctx.url}`)
  })
  

然后再来看看我们接口定义的文件,代码赶紧简洁的一匹.

routes/crawler.js

import { controller, get , log} from '../decorator/router'
import mongoose from 'mongoose'

const areaDataBase = mongoose.model('area')
const areaHouseDataBase = mongoose.model('areaHouse')
const detailHouse = mongoose.model('detailHouse')

@controller('')
export class Crawler{
    /**
     * 获取杭州城区下的房子信息
     */
    @get('/getDetail')
    @log
    async detailHouse (ctx,next){
        let query = ctx.query
        let { _id } = query;
        if (!_id) return (ctx.body = '_id is required')

        let area = await detailHouse
        .findById(_id)
        .exec()
        ctx.body = {
            code:0,
            area
        }
    }
/**
 * 获取杭州城区下的房子信息
 */
    @get('/getAreaHouse')
    @log
    async areaHouse (ctx,next){
        let areaHouse = await areaHouseDataBase
        .find({})
        .exec()
        ctx.body = {
            code:0,
            areaHouse
        }
    }
/**
 * 获取杭州城区单条的名称
 */
    @get('/getArea/:_id')
    @log
    async getArea (ctx,next){
        const { params } = ctx
        const { _id } = params

        if (!_id) return (ctx.body = '_id is required')

        let area = await areaDataBase
        .findById(_id)
        .exec()
        ctx.body = area
    }
/**
 * 获取杭州城区的名称
 */
    @get('/getArea')
    @log
    async Area (ctx,next){
        let area = await areaDataBase
        .find({})
        .exec()
        ctx.body = {
            code:0,
            area
        }
    }

}

走到这里,后端的代码基本上全部完成了,我们从数据的爬取-->入数据库-->-->接口的定义。

剩下的就是简单的前端的接口调用啦~ 我这里就不具体展示出代码啦~接口调用完成,基本上就能完成我们的目标样子啦~

真心的话要放在最后,这是小弟第一次从后到前撸的项目,对于node,mongo,数据库如何建表研究的还很肤浅,小弟在这里班门弄斧啦~真心希望和我一样喜欢倒腾的小伙伴可以自己也上手玩玩~真的能学到不少知识~

本来还想放上源码的,碍于注释都没有添加的很全,容老夫慢慢把注释不全了在贴出来~

房价在手,天下我有 --反手就撸一个爬虫(终)


2018/07/31

源码地址