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

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

技术杂谈小彩虹2021-07-12 14:34:3280A+A-

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

我们在这里先把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~~~

屏幕快照 2018-07-28 下午10.21.08.png-634.7kB

走到这里,我们要停下来对后端的路由做一个提取个封装。首先,我这项目页面量不大,如果单纯的用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,数据库如何建表研究的还很肤浅,小弟在这里班门弄斧啦~真心希望和我一样喜欢倒腾的小伙伴可以自己也上手玩玩~真的能学到不少知识~

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

Unknown.png-27.5kB


2018/07/31

源码地址

点击这里复制本文地址 以上内容由权冠洲的博客整理呈现,请务必在转载分享时注明本文地址!如对内容有疑问,请联系我们,谢谢!

支持Ctrl+Enter提交

联系我们| 本站介绍| 留言建议 | 交换友链 | 域名展示
本站资源来自互联网收集,仅供用于学习和交流,请遵循相关法律法规,本站一切资源不代表本站立场,如有侵权、后门、不妥请联系本站删除

权冠洲的博客 © All Rights Reserved.  Copyright quanguanzhou.top All Rights Reserved
苏公网安备 32030302000848号   苏ICP备20033101号-1

联系我们