nodejs深入学（12）产品化

前言

尽早接触node有很多好处，首先，由于node相对于很多web技术还比较年轻，这可以让开发者接触到较多的底层细节，例如http协议、进程模型、服务模型等，这些底层原理与其他现有技术并无实质性的差别。由于，node的生态尚不成熟，因此，在开发实际的产品中，还是需要很多非编码相关的工作以保证项目的进展和产品的正常运行等，这些工作包括工程化、架构、容灾备份、部署、运维等。

项目工程化

所谓项目工程化，就是项目的组织能力，具体包括目录结构、构建工具、编码规范和代码审查等。

目录结构

node下主要存在两类项目，web应用和模块应用，我们来看下边的一个例子:

web应用项目结构

构建工具

项目写完代码，并测试完毕后还需要进行合并静态文件、压缩文件大小、打包应用、编译模块等工作。如果每次都手工完成这些重复的操作，那样的效率就比较低下了，为了节约资源，此类工作交给工具来完成比较合适，这样的工具就是构建工具。

Makefile

$ ./configure
$ make
$ make install

以静态文件合并编译、应用打包、运行测试、清理目录、扫描代码的Makefile文件为例：

TESTS = $(shell ls -S `find test -type f -name "*.js" -print`)
TESTTIMEOUT = 5000
MOCHA_OPTS =
REPORTER = spec
install:
@$PYTHON=`which python2.6` NODE_ENV=test npm install
test:
@NODE_ENV=test ./node_modules/mocha/bin/mocha \
--reporter $(REPORTER) \
--timeout $(TIMEOUT) \
$(MOCHA_OPTS) \
$(TESTS)
test-cov:
@$(MAKE) test REPORTER=dot
@$(MAKE) test MOCHA_OPTS='--require blanket' REPORTER=html-cov > coverage.html
@$(MAKE) test MOCHA_OPTS='--require blanket' REPORTER=travis-cov
reinstall: clean
@$(MAKE) install
clean:
@rm -rf ./node_modules
build:
@./bin/combo views .
.PHONY: test test-cov clean install reinstall

上边这个makefile将测试、测试覆盖率、项目清理、依赖安装等整合进了make命令

Grunt

Grunt的核心是基于插件式的项目构建管理，核心插件是以grunt-contrib-开头的，我们可以通过安装，grunt、 grunt-init、 grunt-cli，来使用grunt。我们看一下gruntfile.js的样子：

module.exports = function (grunt) {
    grunt.loadNpmTasks('grunt-contrib-clean');
    grunt.loadNpmTasks('grunt-contrib-concat');
    grunt.loadNpmTasks("grunt-contrib-jshint");
    grunt.loadNpmTasks('grunt-contrib-uglify');
    grunt.loadNpmTasks('grunt-replace');
    // Project configuration
    grunt.initConfig({
        pkg: grunt.file.readJSON('package.json'),
        jshint: {
            all: {
                src: ['Gruntfile.js', 'src/**/*.js', 'test/**/*.js'],
                options: {
                    jshintrc: "jshint.json"
                }
            }
        },
        clean: ["lib"],
        concat: {
            htmlhint: {
                src: ['src/core.js', 'src/reporter.js', 'src/htmlparser.js', 'src/rules/*.js'],
                dest: 'lib/htmlhint.js'
            }
        },
        uglify: {
            htmlhint: {
                options: {
                    banner: "/*!\r\n * HTMLHint v< = pkg.version > % % \r\n *
    https://github.com/yaniswang/HTMLHint\r\n *\r\n * (c) 2013 Yanis Wang
                        <yanis.wang@gmail.com>.\r\n * MIT Licensed\r\n * /\n",
    beautify: {
        ascii_only: true
    }
},
    files: {
    'lib/< = pkg.name >.js': ['< = concat.htmlhint.dest % % % %>']
}
    }
    },
replace: {
    htmlhint: {
        files: { 'lib/htmlhint.js': 'lib/htmlhint.js' },
        options: {
            prefix: '@',
                variables: {
                'VERSION': '< = pkg.version >' % %
    }
        }
    }
}
    });
grunt.registerTask('dev', ['jshint', 'concat']);
grunt.registerTask('default', ['jshint', 'clean', 'concat', 'uglify', 'replace']);
    };

Gulp

原书中并没有Gulp的介绍，我在此处进行补充，首先也是需要用npm安装gulp，然后，写gulpfile.js文件，文件样子如下:

var gulp = require('gulp'),
    compass = require('gulp-compass'),
    mincss=require('gulp-minify-css');

gulp.task('css', function() {
    // 编译css
    console.log("hello gulp-css");
    //压缩css
    gulp.src('./sass/*.scss')
        .pipe(compass({
            config_file: './config.rb',
            css: './public/css2',
            sass: 'sass'
        }))
        //css压缩
        .pipe(mincss())
        .pipe(gulp.dest('./public/css2'));
});

gulp.task('watch',function(){
    gulp.watch('./sass/*.scss',['css'])
});

gulp.task('default', ['watch'],function() {
    // 将你的默认的任务代码放在这
    console.log("hello gulp");

    gulp.src('./sass/*.scss')
        .pipe(compass({
            config_file: './config.rb',
            css: './public/css2',
            sass: 'sass'
        }))
        //css压缩
        .pipe(mincss())
        .pipe(gulp.dest('./public/css2'));

    gulp.src('./sass/billmanager/*.scss')
        .pipe(compass({
            config_file: './config_billmanager.rb',
            css: './public/css2',
            sass: 'sass'
        }))
        //css压缩
        .pipe(mincss())
        .pipe(gulp.dest('./public/css2/billmanager'));

    gulp.src('./sass/common/*.scss')
        .pipe(compass({
            config_file: './config_common.rb',
            css: './public/css2',
            sass: 'sass'
        }))
        //css压缩
        .pipe(mincss())
        .pipe(gulp.dest('./public/css2/common'));

    gulp.src('./sass/trading/*.scss')
        .pipe(compass({
            config_file: './config_trading.rb',
            css: './public/css2',
            sass: 'sass'
        }))
        //css压缩
        .pipe(mincss())
        .pipe(gulp.dest('./public/css2/trading'));

    gulp.src('./sass/wx/*.scss')
        .pipe(compass({
            config_file: './config_wx.rb',
            css: './public/css2',
            sass: 'sass'
        }))
        //css压缩
        .pipe(mincss())
        .pipe(gulp.dest('./public/css2/wx'));


});

//gulp.src(); 该方法用于返回我们匹配的文件

通过构建一个个的task实现css的压缩、图片压缩、静态文件合并等工作。

编码规范

一般情况下，编码规范既需要文档式的约定，也需要在提交代码时通过代码强制检查工具进行检测。这个工具可以是JSLint或者JSHint。团队可以约定编码规范的详细规则，生成一份规范文件，并写入.jshintrc文件帮助检测编码规范。

代码审查

可以使用gitlab在企业内部搭建代码托管平台，这类平台可以实现代码托管、bug跟踪、代码审查等功能。（类似于github）


发起合并请求和代码审查的流程示意图

那么代码审查需要审查的点有:功能是否正确完成、编码风格是否符合规范、单元测试是否有同步添加等。流程如下：

代码审查的流程示意图

部署流程

代码完成开发、审查、合并之后，才会进入部署流程。

部署环境

一个项目的开发到正式发布会存在几种环境，首先是开发环境，然后是测试环境，也叫stage环境。接着是预发布环境，也称为pre-release环境，最后是生产环境，也叫product环境。部署流程如下：

部署流程图

部署操作

部署，其实就是要启动一个长时间执行的服务进程，因此，需要使用nohup和&命令，以不挂断进程的方式执行：nohup node app.js &。同时还要考虑项目停止和项目重启。因此需要写一个bash脚本来简化操作。bash脚本的内容通过与web应用约定好的方式来实现，这里所说的约定，其实就是要解决进程ID不容易查找的问题。如果没有约定，我们只能手工的ps查找了

$ ps aux | grep node
jacksontian 3618 0.0 0.0 2432768 592 s002 R+ 3:00PM 0:00.00 grep node
jacksontian 3614 0.0 0.4 3054400 32612 s000 S+ 2:59PM 0:00.69 /usr/local/bin/node/Users/jacksontian/git/h5/app.js

然后，还是手工的kill掉进程。

这里的约定就是主进程启动时将进程ID写入一个pid文件中，这个文件可以存放在一个约定的路径下，可以在node的进程文件，如app.js中添加个小功能来写pid。

var fs = require('fs');
var path = require('path');
var pidfile = path.join(__dirname, 'run/app.pid');
fs.writeFileSync(pidfile, process.pid);

脚本停止或者重启时，可以kill掉进程，然后发送SIGTERM信号给node，那么进程在收到信号后，将会删除app.pid文件，同时退出进程：

process.on('SIGTERM', function () {
if (fs.existsSync(pidfile)) {
fs.unlinkSync(pidfile);
}
process.exit(0);
});

我们来看一下这个bash怎么写：

#!/bin/sh
DIR = `pwd`
NODE = `which node`
# get action
ACTION = $1
# help
usage() {
    echo "Usage: ./appctl.sh {start|stop|restart}"
    exit 1;
}
get_pid() {
    if [-f./ run / app.pid]; then
    echo`cat ./run/app.pid`
    fi
}
# start app
start() {
    pid = `get_pid`
    if [! -z $pid]; then
    echo 'server is already running'
else
    $NODE $DIR / app.js 2 >& 1 &
        echo 'server is running'
    fi
}
# stop app
stop() {
    pid = `get_pid`
    if [-z $pid]; then
    echo 'server not running'
else
    echo "server is stopping ..."
    kill - 15 $pid
    echo "server stopped !"
    fi
}
restart() {
    stop
    sleep 0.5
    echo =====
        start
}
case "$ACTION" in
    start)
start
    ;;
stop)
stop
    ;;
restart)
restart
    ;;
*)
usage
    ;;
esac

然后执行这些命令即可：

./appctl.sh start
./appctl.sh stop
./appctl.sh restart

另外，我还提供了一种比较轻量的机制，为那些没有在node中实现pid写入的程序使用，这样就可以在不修改代码的基础上，完成启动、停止、重启服务的bash脚本了。

结构如下：


结构

bash代码如下：

//env.sh
export NODE_HOME=/home/userp/luluda
export NODE_PATH=$NODE_HOME/node_modules
export NODE_PID=$NODE_HOME/bin/node.pid
export MAIN_JS="./bin/www"

//start
#!/bin/sh
cd /home/userp/luluda/bin
. ./env.sh

#run
cd $NODE_HOME/bin

echo $NODE_PID

if [ -e $NODE_PID ]
then
    echo "服务已启动，线程,请先执行 shutdown_node.sh 结束服务后,再启动!"
    exit -1
fi

#run
cd $NODE_HOME
echo "Start Node.js ... ...."
nohup node $MAIN_JS \
    1>>$NODE_HOME/log/node.log 2>&1 &
if [ ! -z "$NODE_PID" ]
then
    echo $! > $NODE_PID
fi

echo "Node PID: "`cat $NODE_PID`

//stop
#!/bin/sh
cd /home/userp/luluda/bin
. ./env.sh

if [ -e $NODE_PID ]
then
    echo "Stop Node ... ..."
    echo "Killing: `cat $NODE_PID`"
    kill -9 `cat $NODE_PID`
    rm -r $NODE_PID
else
      echo "服务尚未启动!"
fi

//restart
#!/bin/sh
#根据实际路径进行修改
/home/userp/meet_server/bin/shutdown_node.sh
sleep 10
#根据实际路径进行修改
/home/userp/meet_server/bin/start_node.sh

性能

提升web应用性能的方法有好多，例如动静分离、多进程架构、分布式，但是这些都是需要进行拆分的，因此，先说一下拆分原则：
1.做专一的事
2.让擅长的工具做擅长的事情
3.将模型简化
4.将风险分离

动静分离

node可以通过中间件的方式实现动静分离，但是，还是那个原则，让擅长的工具做擅长的事情。因此，将图片、脚本、样式表和多媒体等静态文件都引导到专业的静态文件服务器上，让node只处理动态请求即可。这个过程可以使用nginx或者利用CDN来处理。

动静分离示意图

CDN会让静态文件与用户尽可能靠近，同时CDN自己也有更加精确和高效的缓存机制。静态文件请求分离后，对静态请求使用不同的域名或多个域名还能消除掉不必要的cookie传输和浏览器对下载线程数的限制。另外，有些网页中，动态内容内还存在静态内容，因此，将此部分的静态内容再次分离还可以提高效率。（这里就要使用buffer了，因此，静态内容无需进行字符串转化，直接使用buffer二进制就可以显示，也就是说，直接保留buffer原始内容即可。因此，效率又可以进一步提升。）

启用缓存

提升性能差不多只有两个途径，一是提升服务的速度，二是避免不必要的计算。避免不必要的计算使用最多的场景就是缓存的使用。现在的通常做法是使用redis作为缓存。将从数据库中查询出来的静态内容或者不变的内容，通过redis进行存储，等到下一次同样的请求到来时，就会优先检查缓存是否存在数据，如果存在就命中缓存中的数据，如果没有就去db中再次请求，然后返回并同步缓存。

接下来的内容是朴灵在书中，没有写的，我在这里简单的补充一下：

redis+node的缓存小代码

例如，我们请求一个api

const express = require('express')
const superagent = require('superagent')
const PORT = 3000
 
const app = express()
 
function getNumberOfRepos(req, res, next) {
    const org = req.query.org
    superagent.get(`https://api.github.com/orgs/${org}/repos`, (err, response) => {
        if (err) throw err
 
        var num = response.body.length
        res.send(`Organization "${org}" has ${num} public repositories.`)
    })
}
 
app.get('/repos', getNumberOfRepos)
 
app.listen(PORT, () => console.log(`app listen on port ${PORT}`))

因为要到外网访问，因此，速度没有保障，同时这个api获取的是一个静态的结果，因此，可以使用缓存。

另外，值得注意的是，redis的流行，也是因为redis的简单，使用redis就像使用一般编程语言中的hash map一样简单。

添加数据只需要：

client.set(‘some key’, ‘some value’);

然后再设置个过期时间，防止内存过满，另外设置lru也是非常必要的。

client.setex(‘some key’, 3600, ‘some value’);

const express = require('express')
const superagent = require('superagent')
const redis_client = require('redis').createClient(6379)
const PORT = 3000
 
const app = express()
 
function getNumberOfRepos(req, res) {
    const org = req.query.org
    superagent.get(`https://api.github.com/orgs/${org}/repos`, (err, response) => {
        if (err) throw err
 
        var num = response.body.length
        redis_client.setex(org, 10, num)
        res.send(`Organization "${org}" has ${num} public repositories.`)
    })
}
 
function cache(req, res, next) {
    const org = req.query.org
    redis_client.get(org, (err, data) => {
        if (err) throw err
 
        if (data != null) {
            res.send(`Organization "${org}" has ${data} public repositories.`)
        } else {
            next()
        }
    })
}
 
app.get('/repos', cache, getNumberOfRepos)
 
app.listen(PORT, () => console.log(`app listen on port ${PORT}`))

redis的lru置换策略

置换缓存时，记得设置置换策略。

noeviction: 不进行置换，表示即使内存达到上限也不进行置换，所有能引起内存增加的命令都会返回error
allkeys-lru: 优先删除掉最近最不经常使用的key，用以保存新数据
volatile-lru: 只从设置失效（expire set）的key中选择最近最不经常使用的key进行删除，用以保存新数据
allkeys-random: 随机从all-keys中选择一些key进行删除，用以保存新数据
volatile-random: 只从设置失效（expire set）的key中，选择一些key进行删除，用以保存新数据
volatile-ttl: 只从设置失效（expire set）的key中，选出存活时间（TTL）最短的key进行删除，用以保存新数据

redis的数据类型

此处只说Redis的五种数据类型：string（字符串），hash（哈希），list（列表），set（集合）及zset(sorted set：有序集合)。

我们做的行情tick就是使用了list这个结构。

多进程架构

首先，第九章中就已经明白了，使用多进程架构可以充分利用cpu，同时，因为node不需要额外的容器就可以使用http服务（基于http模块），因此，需要开发者自己处理多进程的管理，另外，也可以使用官方提供的cluster模块，或者pm、forever、pm2这样的模块来进行进程的管理。详细内容见第九章。

读写分离

读写分离主要是对于数据库的操作时读写分离的，读的速度要远远快于写的速度。（因为写需要锁表，来保护数据一致性），读写分离需要将数据库进行主从设计，但是，因为我公司没有专门的运维人员，因此，我们当时使用的阿里的rds进行读写分离的实现的。

日志

为了建立健全的排查和跟踪机制，需要为系统增加日志，完善的日志最能还原问题现场，好似侦探断案的第一手线索。

一般情况下，如果使用nginx作为反向代理，可以通过nginx来启用日志。

我的项目是使用node来自己记录日志的。

另外，对于用户的来访，还可以记录remote-addr和response-time，来定位用户分布情况、服务器响应时间、响应状态和客户端类型。

日志的等级

console.log：输出给process.stdout
console.info：输出给process.stdout
console.warn：输出给process.stderr
console.error：输出给process.stderr

捕获抓不到的异常

有些异常很是诡异，抓不到，因此，给全局设置一个uncaughtException，来抓取全局异常。

日志内容格式化

var format = function (msg) {
var ret = '';
if (!msg) {
return ret;
}
var date = moment();
var time = date.format('YYYY-MM-DD HH:mm:ss.SSS');
if (msg instanceof Error) {
var err = {
name: msg.name,
data: msg.data
};
err.stack = msg.stack;
ret = util.format(' s s: s % % % \nHost: s % \nData: j % \n s % \n\n',
time,
err.name,
err.stack,
os.hostname(),
err.data,
time
);
console.log(ret);
} else {
ret = time + ' ' + util.format.apply(util, arguments) + '\n';
}
return ret;
}

上边的代码展示了如何格式化日志，以此精确定位错误的发生。

日志与数据库

日志在线写，日志分析通过一些文件同步到数据库中。

分割日志

可以按照日期分割，也可以按照日志类型分割（_stdout和_stderr）。

监控报警

对于新上线的应用，需要两个方面的监控，业务逻辑的监控和硬件型的监控。我们来看看具体怎么做。

监控

1.日志监控

例如查看具体的业务实现，通过日志时间分析，来反映某项业务的qps，同时，在日志上也可以查询到pv（每日ip访问或者刷新次数）和uv（每日某个客户端访问的次数，不重复计算），可以通过pv和uv很好地知道使用者的习惯、预知访问高峰等。

2.响应时间

健康的系统响应时间波动较小，持续均衡。

3.进程监控

检查操作系统中运行的应用（工作）进程数，如果低于某个预估值，就应当发出报警。

4.磁盘监控

监控磁盘用量，防止因为磁盘空间不足造成的系统问题，一旦磁盘用量超过警戒值，服务器的管理者就应该清理日志或者清理磁盘了。

5.内存监控

检查是否有内存泄漏的情况。如果内存只升不降，那么铁定就是内存泄漏了。健康的内存应该是有升有降的。

如果进程中存在内存泄漏，又一时没有排查解决，有一种方案可以解决这种情况，这种方案应用于多进程架构的服务集群，让每个工作进程指定服务多少次请求，达到请求数之后进程就不再服务新的链家，主进程启动新的工作进程来服务客户，旧的进程等所有连接断开后就退出。

6.cpu占用监控

cpu使用分为用户态、内核态、IOWait等，如果用户态cpu使用率较高，说明服务器上的应用需要大量的cpu开销，如果内核态cpu使用率较高，说明服务器花费大量时间进行进程调度或者系统调用，IOWait使用率则反应的是cpu等待磁盘IO操作。

用户态小于70%、内核态小于35%且整体小于70%，cpu处于健康状态。

7.cpu load监控

cpu load又称为cpu平均负载，描述操作系统当前的繁忙程度，可以简单的理解为cpu在单位时间内正在使用和等待使用cpu的平均任务数。它有三个指标，即1分钟的平均负载、5分钟的平均负载、15分钟的平均负载。cpu load 高说明进程数量过多，这在node中可能体现在用子进程模块反复启动新的进程。

8.IO负载

IO负载，主要讲的是磁盘IO，对于node来说，此类IO压力多半来源于数据库IO。

9.网络监控

主要监控网络流量，这个值可以查看公司的相关宣传是否有效，广告是否有效，是否增加了访问流量。（监控流入流量和流出流量）

10.应用状态监控

这个监控可以通过增加时间戳来实现：

app.use('/status', function (req, res) {
res.writeHead(200);
res.end(new Date());
})

同时，对于业务相关的内容也需要尽可能的打印出来。

11.DNS监控

可以基于第三方的软件进行检测，如DNSPod等，我们用的阿里云的DNS。

报警的实现

有了监控，那么就一定应该提供报警系统。一般情况下，报警系统有：邮件报警、IM报警、短信报警、电话报警

邮件报警

基于node编写邮件报警系统，可以通过nodemailer模块来实现，看个例子:

var nodemailer = require("nodemailer");
// 建建立一个SMTP传输连接
var smtpTransport = nodemailer.createTransport("SMTP", {
    service: "Gmail",
    auth: {
        user: "gmail.user@gmail.com",
        pass: "userpass"
    }
});
// 邮件选项
var mailOptions = {
    from: "Fred Foo ✔ <foo@bar.com>", // 发件人地址
    to: "bar@bar.com, baz@bar.com", // 收件人地址
    subject: "Hello ✔ ", // 标题
    text: "Hello world ✔ ", // 纯文本内容
    html: "<b>Hello world ✔ </b>" // HTML内容
}
// 发送邮件
smtpTransport.sendMail(mailOptions, function (err, response) {
    if (err) {
        console.log(err);
    } else {
        console.log("Message sent: " + response.message);
    }
})

短信或电话报警

对接短信或者电话平台即可。

监控系统的稳定性

对，需要确保监控系统的稳定性，否则，监控系统频繁出错，反而得不偿失了。我们公司使用了阿里云提供的检测系统，还不错，基本满足需求。

node服务稳定性

这本书，经常在阐述应用的稳定性问题，其中第四章从单进程角度描述了应用的稳定性，第九章从多进程角度阐述了应用的稳定性。单独一台服务器满足不了业务无限增长的需求，这就需要将node按多进程的方式部署到多台机器中，这样如果某台机器出现问题，其余机器为用户继续提供服务。另外，大企业也会进行异地机房灾备和搭建就近的服务器。这就抵消了一部分因为地理位置带来的网络延迟的问题。为了更好的稳定性，典型的水平扩展方式就是多进程、多机器、多机房，这样的分布式设计在现在的互联网公司并不少见。

多机器

多机器负载均衡

看到上边的示意图，可以发现，在多机器的情况下，需要考虑负载均衡、状态共享和数据一致性等问题。

多机房

这个作者在书中秋风扫落叶的一笔带过。我也没有机会玩这样的部署，因此，不懂。

容灾备份

容灾备份

异构共存

node虽然神奇，但是，任何神奇的node功能，都是由操作系统的底层功能进行支持的。因此，node的异构共存，也是很简单和普遍的一件事。

编程语言与服务通过网络协议进行调用的示意图

如果不是标准协议，而是一个RESTful服务接口的话，也完全不存在问题，这样做其实就是现在比较流行的微服务架构的一个基础设计了。

总之，使用node不存在推翻已有设计的情况，node可以通过标准协议（tcp之类）和各种系统、语言和平相处。

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 156,757评论 4赞 359
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 66,478评论 1赞 289
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 106,540评论 0赞 237
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 43,593评论 0赞 203
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 51,903评论 3赞 285
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 40,329评论 1赞 210
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 31,659评论 2赞 309
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 30,383评论 0赞 195
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 34,055评论 1赞 238
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 30,337评论 2赞 241
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 31,864评论 1赞 256
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 28,227评论 2赞 251
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 32,820评论 3赞 231
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 25,999评论 0赞 8
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 26,750评论 0赞 192
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 35,365评论 2赞 269
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 35,260评论 2赞 258

推荐阅读更多精彩内容

  • Spring Cloud
    Spring Cloud为开发人员提供了快速构建分布式系统中一些常见模式的工具（例如配置管理，服务发现，断路器，智...
    卡卡罗2017阅读 134,087评论 18赞 139
  • nodejs深入学（3）模块机制
    前言 js是从网页小脚本演变过来的，至今，前端的js库，也不像一个真正的模块。前端js经历了工具类库、组件库、前端...
    白昔月阅读 3,210评论 2赞 11
  • Android - 收藏集
    Android 自定义View的各种姿势1 Activity的显示之ViewRootImpl详解 Activity...
    passiontim阅读 170,543评论 25赞 707
  • 你拥有的才是最好的
    在我们还小的时候，总有个邻居家的孩子如影随形。在我们长大后，总会有个别人家的某某相伴左右。总是别人的好，似...
    如雾如电阅读 285评论 0赞 2
  • php 设计模式- 委托模式
    委托模式 通过分配或委托其他对象，委托设计模式能够去除核心对象中的判决和复杂的功能性。应用场景设计了一个cd类，类...
    不器1843阅读 355评论 0赞 1