进光猫后

找到的密码是星号隐藏的，

需要在浏览器按 F12 进入开发者调试器，对着“密码”框右键选择检查，进行选择 HTML 元素，在开发者调试器内的 HTML 元素内，找到 type=password 代码，双击删除掉 password，或者选择删除 type=password 代码，操作完成就可以看到自己电信光猫的宽带密码了，然后把宽带密码保存下来，电信猫的宽带密码很多都是 32位 小写 MD5 加密的，可以通过MD5解密https://www.cmd5.com获得真正的密码

如今大多数电脑、笔记本、NAS、甚至是打印机等设备都支持「网络唤醒」(WOL / Wake On Lan) 功能，直接通过发送网络命令，即可实现远程开机操作，平时自己的电脑做的很隐蔽，每次开机不方便，就利用 OpenWRT 提供的网络唤醒实现手机语音远程开机。

首先把你的电脑在BIOS上设置好网络唤醒（设置时记住mac地址，一般还会有唤醒使用的命令）

使用 SSH 登录到OpenWRT终端，执行以下命令进行安装网络唤醒所需的程序依赖和 luci 界面，提供的 WOL 和 Etherwake 是实现网络唤醒的主要依赖，luci-app-wol 与 luci-i18n-wol-zh-cn 分别为主程序和汉化包

opkg update
opkg install wol etherwake
opkg install luci-app-wol luci-i18n-wol-zh-cn

进入LUCI管理界面找到网络唤醒，在网络唤醒插件处选择网络接口是指设备连接路由的 LAN 口，接着根据 MAC 地址选择要唤醒的设备，选择完成点击“唤醒主机”，成功提示 Sendto worked ! 116

设置好后尝试唤醒没有问题后，再设置手机上语音唤醒

在 苹果手机 上设置 Siri 语音唤醒，打开快捷指令，新建通过 SSH 运行脚本（SSH连接openwrt），设置快捷指令名称，比如：打开电脑，并将 /usr/bin/etherwake 整句命令复制粘贴到第一行，主机地址设置路由地址，端口默认，填写用户和密码，然后点击右下角的三角形运行测试，正常也会提示：Sendto worked ! 116

唤醒命令：/usr/bin/etherwake -D -i "br-lan" "你设备的MAC地址"
主机地址：路由器地址
端口默认：22
用户默认：root
密码：你路由器的密码，没有设置，去设置一个

现在你可以在手机上语音说上面设置的指令名称“打开电脑”来开机了。

论坛https://bbs.histb.com/官网https://www.ecoo.top/

支持的机顶盒列表https://www.ecoo.top/histb.html

装socket5： 需要自行准备节点！没有正确的节点配置文件是无法联通的。
安装下面的脚本后盒子打开了 Socks5 的代理服务功能, 端口号10808
你在浏览器或者系统自行设置通过盒子的IP192.168.12.106代理 Socks5 上网即可

装好系统后里面有alist等

装docker部署OpenWRT-(装上后旁路由实测无法科学上网)

hi3798mv100型号，其它型号自行测试。

• 设置网络
  把网卡混杂模式打开
• sudo ip link set 你自己的网卡名称 promisc on
  ifconfig
  ##以下是我的网卡名称，每台设备可能不一样，要注意！！！！
  sudo ip link set eth0 promisc on
  打开后为eth0: flags=4419<UP,BROADCAST,RUNNING,PROMISC,MULTICAST> mtu 1500
• 创建 docker 网卡
  IP地址和网关根据自己的情况设置
  docker network create -d macvlan --subnet=192.168.1.67/24 --gateway=192.168.1.1 -o parent=eth0 macnet

-OpenWrt 标准镜像
原项目地址：https://github.com/SuLingGG/OpenWrt-Docker
一般情况下阿里云镜像仓库比较快
armv7
DockerHub———sulinggg/openwrt:rpi1
阿里云镜像仓库—–registry.cn-shanghai.aliyuncs.com/suling/openwrt:rpi1

arm8/aarch64
DockerHub———sulinggg/openwrt:armv8
阿里云镜像仓库—–registry.cn-shanghai.aliyuncs.com/suling/openwrt:armv8

x86_64/amd64
DockerHub———sulinggg/openwrt:x86_64
阿里云镜像仓库—–registry.cn-shanghai.aliyuncs.com/suling/openwrt:x86_64

查看系统架构 uname -a

##以下是hi3798mv100系统架构是armv7

创建并启动docker 镜像
docker run --restart always --name openwrt -d --network macnet --privileged registry.cn-shanghai.aliyuncs.com/suling/openwrt:armv7 /sbin/init
其它系统架构只需更改registry.cn-shanghai.aliyuncs.com/suling/openwrt:rpi1

• 设置Openwrt容器 ip

点击进入bash命令控制台
输入 vim /etc/config/network
其它设置不用改，自行设置config interface ‘lan’下边 option ipaddr为OpenWRT的IP，geteway是主路由IP（网关）
如果报错重启容器再试。

• 重启网络
  /etc/init.d/network restart

重启网络, 重启完成后便可以通过浏览器访问了

网心云
docker run -d \
–name=wxedge \
–restart=always \
–privileged \
–net=host \
–tmpfs /run \
–tmpfs /tmp \
-v /mnt/sda1:/storage:rw \
onething1/wxedge
1.-v 冒号前半部分改成自己本地路径，该路径重装时保持不变，则节点不变
2.安装完成后，使用IP：18888，登录后管界面，使用网心云APP扫描页面下方的二维码绑定

下面是在海纳斯上面装上tailscale

#停止固件自带的tailscale
systemctl stop tailscaled
#关闭固件自带的tailscale的开机自启
systemctl disable tailscaled
#删除执行文件和服务文件
rm -rf /usr/bin/tailscaled
rm -rf /etc/systemd/system/tailscaled.service
#执行官方的安装脚本
curl -fsSL https://tailscale.com/install.sh | sh
#启动软件并设为自启
systemctl start tailscaled
systemctl enable tailscaled
#启动软件，并在链接中登录账号
tailscale up

另外说下服务器做流量出口节点设置

在服务器上打开forword

 echo 'net.ipv4.ip_forward = 1' | sudo tee -a /etc/sysctl.d/99-tailscale.conf
echo 'net.ipv6.conf.all.forwarding = 1' | sudo tee -a /etc/sysctl.d/99-tailscale.conf
sudo sysctl -p /etc/sysctl.d/99-tailscale.conf

再设置可以做出口节点sudo tailscale up -advertise-exit-node

最后在https://login.tailscale.com/admin/machines的节点最右边编辑路由设置里打开Use as exit node，

其它的节点设置exit node为这个服务器，就可以这个服务器为出口代理来上网了。

首先，安装you-get $ pip3 install you-get

Youtube-dl

再部署python代码，一般如果you-get下载不来的再用Youtube-dl来下，

最后如果离线下载要用就用clouddrive加个云盘到系统。

参考文章

https://github.com/soimort/you-get

视频专业下载工具，Youtube-dl 详细使用教程与初学上手示例

https://blog.csdn.net/Kim_Linshuo/article/details/109630654

https://zhuanlan.zhihu.com/p/344090839

https://blog.csdn.net/weixin_44578029/article/details/120676879

另外考虑加入下面这个，但是用go写的

https://github.com/iawia002/lux

还考虑加入代理池

https://github.com/ydf0509/proxypool_framework/tree/master

网上的在线宽带测试常因为网络环境的变动不太准确。

介绍
Iperf3 是一个网络性能测试工具。Iperf可以测试最大TCP和UDP带宽性能，具有多种参数和UDP特性，可以根据需要调整，可以报告带宽、延迟抖动和数据包丢失.对于每个测试，它都会报告带宽，丢包和其他参数，可在Windows、Mac OS X、Linux、FreeBSD等各种平台使用，是一个简单又实用的小工具。

    Iperf3也是C/S(客户端/服务器端)架构模式，在使用iperf3测试时，要同时在server端与client端都各执行一个程序，让它们互相传送报文进行测试。

    iperf3.0之前的版本只能用来测试千兆速率，但是万兆网络强烈建议使用iperf3测试。

下载
iperf下载链接

安装
在CentOS 7上使用下列命令即可安装：

yum install iperf3

在ubuntu 上使用下列命令安装:

apt-get install iperf3

测试：

用iperf3 -h来查看中文帮助

服务器端直接运行

iperf3 -s

然后客户端按不同参数来测试，如设置多个并行数据流-P

iperf3 -c serverIP -P streams

例：iperf3 -c 192.168.1.1 -P 3

运行iperf3在客户端，反向测试（服务器端发送数据到客户端）iperf3 -c serverIP -R

例：iperf3 -c 192.168.1.1 -R

运行iperf3在客户端，使用UDP协议，并设置使用的测试带宽

iperf3 -c serverIP -b 1000M -t 60 -d

-c 为客户端运行并要指定服务端的IP地址

-b 表示使用的测试带宽

-t 表示以时间为测试结束条件进行测试，默认为 10 秒;

-d 打印出更详细的debug调试信息

例：iperf3 -c 192.168.1.1 -b 1000M -t 60 -d

参考https://blog.csdn.net/hhd1988/article/details/123918481

一、安装Redis

官网下载地址：https://redis.io/download

Redis  centos安装过程：

yum -y install gcc gcc-c++
wget http://download.redis.io/releases/redis-4.0.10.tar.gz
tar -zxvf redis-4.0.10.tar.gz
cd redis-4.0.10
make && make install
./utils/install_server.sh
#测试redis是否运行
redis-cli
> ping #返回pong表示成功

安装flask-redis

#清华源
pip3 install -i https://pypi.tuna.tsinghua.edu.cn/simple flask-redis

二、安装开源插件Dplayer

Dplayer官网地址：http://dplayer.js.org/#/    (有时候会打不开哦)

Dplayer github地址:https://github.com/MoePlayer/DPlayer

#html引入css/js
<link rel="stylesheet" href="{{ url_for('static',filename='dplayer/dist/Dplayer.min.css') }}" >
<script src="{{ url_for('static',filename='dplayer/dist/DPlayer.min.js') }}"></script>
#引用到页面
<div id="dplayer" style="height: 500px;width: 774px"></div>
#弹幕和视频接口
 <script>
        var dp1 = new DPlayer({
            container: document.getElementById('dplayer'),
            video: {
                url: "{{ url_for('static',filename='uploads/'+movie.url) }}"
            },
            danmaku: {
                id: '{{ movie.id }}',
                api: "/tm/"
            }
        });
 </script>
 
#Python返回弹幕的处理方法
@home.route("/tm/v3/",methods=["GET","POST"])
def tm():
    import json
    if request.method=="GET":
        #获取弹幕消息队列
        mid = request.args.get("id")
        key="movie"+str(mid)
        if rd.llen(key):
            msgs=rd.lrange(key,0,2999)
            res={
                "code":0,
                "data":[json.loads(v) for v in msgs]
            }
        else:
            res={
                "code":1,
                "danmaku":[]
            }
        resp=json.dumps(res)
    if request.method=="POST":
        #添加弹幕
        data=json.loads(request.get_data())
        msg= {
        "__v": 0,
        "_id": datetime.datetime.now().strftime("%Y%m%d%H%M%S") + uuid.uuid4().hex,
        "author": data["author"],
        "time": data["time"],
        "text": data["text"],
        "color": data["color"],
        "type": data["type"],
        "ip": request.remote_addr,
        "player": data["id"]
        }
        res = {
            "code": 0,
            "danmaku":msg
        }
        resp=json.dumps(res)
        msg=[data["time"],data["type"],data["color"],data["author"],data["text"]]
        rd.lpush("movie"+str(data["id"]),json.dumps(msg))
    return Response(resp,mimetype="application/json")

何时使用logging

日志事件级别

默认的级别是 “WARNING“，意味着只会追踪该级别及以上的事件，除非更改日志配置。所追踪事件可以以不同形式处理。最简单的方式是输出到控制台。另一种常用的方式是写入磁盘文件。

basicConfig()设置

# -*- coding:utf-8 -*-

import logging

#默认的warning级别，只输出warning以上的
#使用basicConfig()来指定日志级别和相关信息

logging.basicConfig(level=logging.DEBUG #设置日志输出格式
                    ,filename="demo.log" #log日志输出的文件位置和文件名
                    ,filemode="w" #文件的写入格式，w为重新写入文件，默认是追加
                    ,format="%(asctime)s - %(name)s - %(levelname)-9s - %(filename)-8s : %(lineno)s line - %(message)s" #日志输出的格式
                    # -8表示占位符，让输出左对齐，输出长度都为8位
                    ,datefmt="%Y-%m-%d %H:%M:%S" #时间输出的格式
                    )

logging.debug("This is  DEBUG !!")
logging.info("This is  INFO !!")
logging.warning("This is  WARNING !!")
logging.error("This is  ERROR !!")
logging.critical("This is  CRITICAL !!")

#在实际项目中，捕获异常的时候，如果使用logging.error(e)，只提示指定的logging信息，不会出现
#为什么会错的信息，所以要使用logging.exception(e)去记录。

try:
    3/0
except Exception as e:
    # logging.error(e)
    logging.exception(e)

输出日志如下：

2021-03-26 02:03:01 - root - DEBUG     - basiclogging : 16 line - This is  DEBUG !!
2021-03-26 02:03:01 - root - INFO      - basiclogging : 17 line - This is  INFO !!
2021-03-26 02:03:01 - root - WARNING   - basiclogging : 18 line - This is  WARNING !!
2021-03-26 02:03:01 - root - ERROR     - basiclogging : 19 line - This is  ERROR !!
2021-03-26 02:03:01 - root - CRITICAL  - basiclogging : 20 line - This is  CRITICAL !!

2021-03-26 03:16:47 - root - ERROR     - basiclogging : 27 line - division by zero
Traceback (most recent call last):
  File "E:/pycharm_project/examples-of-web-crawlers-master/logginng/basiclogging", line 24, in <module>
    3/0
ZeroDivisionError: division by zero

logging的高级应用

logging采用了模块化设计，主要包含四种组件：

Loggers:记录器，提供应用程序代码能直接使用的接口。（类似于笔，使用不同的笔记录不同的日志，例如一个项目里有很多功能模块，每个模块可以设置不同的Logger去记录，然后设置每只笔的不同格式）

Handlers:处理器，将记录器产生的日志发送到目的地。（输出到文件或者控制台或者邮件等，一个记录器可以对应多个处理器。）

Filters:过滤器，提供更好的粒度控制，决定哪些日志会被输出。

Formatters:格式化器，设置日志内容的组成结构和消息字段。

Loggers记录器

1. 提供应用程序的调用接口

logger = logging.getLogger(__name__)
#logger是单例的，也就是__name__不变，获取到的logger都是同一个

2.决定日志记录的级别

logger.setLevel()

3.将日志内容传递到相关联的handlers中

logger.addHandler()
logger.removeHandler()

Handler处理器

将日志发送到不同的地方

#常见的处理器
StreamHandler #屏幕输出
FileHandler #文件记录
BaseRotatingHandler #标准的分割文件日志
RotatingFileHandler #按文件大小记录日志
TimeRotatingFileHandler #按时间记录日志

StreamHandler

标准输出分发器，也就是屏幕显示

sh = logging.StreamHandler(stream=None)

FileHandler

将日志保存到文件中

fh = logging.FileHandler(filename,mode='a',encoding=None,delay=False)

setFormatter()

设置当前Handler对象使用的消息格式

Formatters格式

formatter对象用来最终设置日志信息的顺序，结构和内容

ft = logging.Formatter.__init__(fmt=None,datafmt=None)

logging编程方式代码demo

# -*- coding:utf-8 -*-

import logging

#编程的方式记录日志

#记录器
logger1 = logging.getLogger("logger1")
logger1.setLevel(logging.DEBUG)
print(logger1)
print(type(logger1))

logger2 = logging.getLogger("logger2")
logger2.setLevel(logging.INFO)
print(logger2)
print(type(logger2))


#处理器
#1.标准输出
sh1 = logging.StreamHandler()

sh1.setLevel(logging.WARNING)

sh2 = logging.StreamHandler()


# 2.文件输出
# 没有设置输出级别，将用logger1的输出级别(并且输出级别在设置的时候级别不能比Logger的低!!!)，设置了就使用自己的输出级别
fh1 = logging.FileHandler(filename="fh.log",mode='w')

fh2 = logging.FileHandler(filename="fh.log",mode='a')
fh2.setLevel(logging.WARNING)

# 格式器
fmt1 = logging.Formatter(fmt="%(asctime)s - %(levelname)-9s - %(filename)-8s : %(lineno)s line - %(message)s")

fmt2 = logging.Formatter(fmt="%(asctime)s - %(name)s - %(levelname)-9s - %(filename)-8s : %(lineno)s line - %(message)s"
                        ,datefmt="%Y/%m/%d %H:%M:%S")

#给处理器设置格式
sh1.setFormatter(fmt1)
fh1.setFormatter(fmt2)
sh2.setFormatter(fmt2)
fh2.setFormatter(fmt1)

#记录器设置处理器
logger1.addHandler(sh1)
logger1.addHandler(fh1)
logger2.addHandler(sh2)
logger2.addHandler(fh2)

#打印日志代码
logger1.debug("This is  DEBUG of logger1 !!")
logger1.info("This is  INFO of logger1 !!")
logger1.warning("This is  WARNING of logger1 !!")
logger1.error("This is  ERROR of logger1 !!")
logger1.critical("This is  CRITICAL of logger1 !!")

logger2.debug("This is  DEBUG of logger2 !!")
logger2.info("This is  INFO of logger2 !!")
logger2.warning("This is  WARNING of logger2 !!")
logger2.error("This is  ERROR of logger2 !!")
logger2.critical("This is  CRITICAL of logger2 !!")

控制台输出：

2021-03-26 02:38:56,370 - WARNING   - advancelogging : 56 line - This is  WARNING of logger1 !!
2021-03-26 02:38:56,370 - ERROR     - advancelogging : 57 line - This is  ERROR of logger1 !!
2021-03-26 02:38:56,370 - CRITICAL  - advancelogging : 58 line - This is  CRITICAL of logger1 !!
2021/03/26 02:38:56 - logger2 - INFO      - advancelogging : 61 line - This is  INFO of logger2 !!
2021/03/26 02:38:56 - logger2 - WARNING   - advancelogging : 62 line - This is  WARNING of logger2 !!
2021/03/26 02:38:56 - logger2 - ERROR     - advancelogging : 63 line - This is  ERROR of logger2 !!
2021/03/26 02:38:56 - logger2 - CRITICAL  - advancelogging : 64 line - This is  CRITICAL of logger2 !!
<Logger logger1 (DEBUG)>
<class 'logging.Logger'>
<Logger logger2 (INFO)>
<class 'logging.Logger'>

文件fh.log输出：

2021/03/26 02:38:56 - logger1 - DEBUG     - advancelogging : 54 line - This is  DEBUG of logger1 !!
2021/03/26 02:38:56 - logger1 - INFO      - advancelogging : 55 line - This is  INFO of logger1 !!
2021/03/26 02:38:56 - logger1 - WARNING   - advancelogging : 56 line - This is  WARNING of logger1 !!
2021/03/26 02:38:56 - logger1 - ERROR     - advancelogging : 57 line - This is  ERROR of logger1 !!
2021/03/26 02:38:56 - logger1 - CRITICAL  - advancelogging : 58 line - This is  CRITICAL of logger1 !!
2021-03-26 02:38:56,370 - WARNING   - advancelogging : 62 line - This is  WARNING of logger2 !!
2021-03-26 02:38:56,370 - ERROR     - advancelogging : 63 line - This is  ERROR of logger2 !!
2021-03-26 02:38:56,370 - CRITICAL  - advancelogging : 64 line - This is  CRITICAL of logger2 !!

过滤器在代码里的应用

#定义一个过滤器
flt1 = logging.Filter("logger1") #名字就是logger记录器的名字

#关联过滤器
#1.logger关联过滤器
logger.addFilter(flt1)

#2.处理器关联过滤器
sh1.addFilter(flt1)
#fh1.addFilter(flt1)

#过滤器定义在记录器上的时候，不管你设置了任何关于这个过滤器的任何设置，都不起作用。
#过滤器定义在哪个处理器上，哪个处理器就不起作用，也就可以控制日志的输出，想要还是不想要。
#特别是在项目调试的时候，不想让日志记录到文件里去，直接在屏幕显示，就过滤到fh
#代码上线后，日志记录到文件，不用在屏幕显示，就过滤掉sh

文件配置logging编程

上述的方法都写的很死板，在小工程或者单个文件还可以，但是当项目大了，我们就必须使用配置文件的方式配置logging的信息，从而来灵活使用，主要有两种方式去配置，一种是conf文件，一种是字典文件。

import logging.config
logging.config.fileConfig("/path/to/configfile")

logging.config.dictConfig("/path/to/configfile")

yaml配置文件：

version: 1
#是否覆盖掉已经存在的loggers
disable_existing_loggers: True

formatters:

  tostrout:
    format: "%(asctime)s - %(name)s - %(levelname)-9s - %(filename)-8s : %(lineno)s line - %(message)s"
    datefmt: "%Y/%m/%d %H:%M:%S"

  tofile:
    format: "%(asctime)s - %(name)s - %(levelname)-9s - %(filename)-8s : %(lineno)s line - %(message)s"

handlers:
  sh:
    class: logging.StreamHandler
    level: WARNING
    formatter: tostrout
    stream: ext://sys.stdout

  fh:
    class: logging.handlers.TimedRotatingFileHandler
    filename: logconfdd.log
    interval: 1
    backupCount: 2
    when: D
    level: INFO
    formatter: tofile

loggers:
  logger1:
    level: DEBUG
    handlers: [sh]
    #是否往上级Logger传递，如果为yes的话，root选择了两个logger，这里的日志也会在两个logger的配置中输出，会重复。所以选No,自己记录自己的日志。
    propagate: no

  logger2:
    level: INFO
    handlers: [fh]
    propagate: no

root:
  level: DEBUG
  handlers: [sh,fh]
  propagate: no

调用代码：

# -*- coding:utf-8 -*-

import logging
import logging.config
import yaml

with open("logconf.yml", "r") as f:
    dict_conf = yaml.safe_load(f)

logging.config.dictConfig(dict_conf)
root = logging.getLogger()
logger1 = logging.getLogger('logger1')
logger2 = logging.getLogger('logger2')

#打印日志代码

root.debug("This is  DEBUG of root !!")
root.info("This is  INFO of root !!")
root.warning("This is  WARNING of root !!")
root.error("This is  ERROR of root !!")
root.critical("This is  CRITICAL of root !!")

logger1.debug("This is  DEBUG of logger1 !!")
logger1.info("This is  INFO of logger1 !!")
logger1.warning("This is  WARNING of logger1 !!")
logger1.error("This is  ERROR of logger1 !!")
logger1.critical("This is  CRITICAL of logger1 !!")

logger2.debug("This is  DEBUG of logger2 !!")
logger2.info("This is  INFO of logger2 !!")
logger2.warning("This is  WARNING of logger2 !!")
logger2.error("This is  ERROR of logger2 !!")
logger2.critical("This is  CRITICAL of logger2 !!")

标准输出：

021/03/27 12:18:58 - root - WARNING   - loggingofconfing : 19 line - This is  WARNING of root !!
2021/03/27 12:18:58 - root - ERROR     - loggingofconfing : 20 line - This is  ERROR of root !!
2021/03/27 12:18:58 - root - CRITICAL  - loggingofconfing : 21 line - This is  CRITICAL of root !!
2021/03/27 12:18:58 - logger1 - WARNING   - loggingofconfing : 25 line - This is  WARNING of logger1 !!
2021/03/27 12:18:58 - logger1 - ERROR     - loggingofconfing : 26 line - This is  ERROR of logger1 !!
2021/03/27 12:18:58 - logger1 - CRITICAL  - loggingofconfing : 27 line - This is  CRITICAL of logger1 !!

文件输出(logconfdd.log):

2021-03-27 12:18:58,301 - root - INFO      - loggingofconfing : 18 line - This is  INFO of root !!
2021-03-27 12:18:58,301 - root - WARNING   - loggingofconfing : 19 line - This is  WARNING of root !!
2021-03-27 12:18:58,301 - root - ERROR     - loggingofconfing : 20 line - This is  ERROR of root !!
2021-03-27 12:18:58,301 - root - CRITICAL  - loggingofconfing : 21 line - This is  CRITICAL of root !!
2021-03-27 12:18:58,301 - logger2 - INFO      - loggingofconfing : 30 line - This is  INFO of logger2 !!
2021-03-27 12:18:58,301 - logger2 - WARNING   - loggingofconfing : 31 line - This is  WARNING of logger2 !!
2021-03-27 12:18:58,301 - logger2 - ERROR     - loggingofconfing : 32 line - This is  ERROR of logger2 !!
2021-03-27 12:18:58,301 - logger2 - CRITICAL  - loggingofconfing : 33 line - This is  CRITICAL of logger2 !!

本文转自知呼

为WordPress网站添加一个音乐播放器，网上大部分的教程都是使用各种插件，有的插件还需要花钱买授权，用着不爽。本文用纯代码为网站添加音乐播放器，安全可靠，可以任意修改。

1、Aplayer

其实很简单，Github有很多大神开源了相关的内容。用着最舒服的，当属Aplayer了，可以去官网体验一下：

​ ​https://aplayer.js.org/​​

文档手册也很详细：

​ ​https://github.com/MoePlayer/APlayer​​

方法很简单，加载Aplayer的js和css，在想要展先的位置调用即可。Aplayer支持很多模式，上图展示的效果为吸底模式，就是在网页的页面最左下角展示。本文以吸底模式为例进行说明，如果想采用其它模式，可以根据文档手册修改代码。

2、Meting

如果只使用Aplayer，那么需要指定音乐的图片地址，mp4地址，歌词等，用着不是很方便，这时就可以使用Meting作为辅助：

​ ​https://github.com/metowolf/MetingJS​​

Meting为Aplayer提供了网易云音乐的API接口，只要获得网易云音乐歌单的ID，就可以自动加载歌单里所有的歌曲，直接调用，方便很多，当然除了网易云音乐的API，还有其他的接口。

3、开工

如果上述这些说了都不懂，没关系，跟着接下来的步骤走即可。

首先下载为各位打包好的js和css文件（下载地址）

解压后，会看到三个文件APlayer.min.css、APlayer.min.js、Meting.min.js，将两个js文件放到主题的js文件夹中，将css文件放到主题的css文件夹中。

在主题目录下的footer.php中，添加如下代码：

将代码中的wp-content/themes/construction-base改为你的WordPress主题的根目录。保存好后，刷新网页就可以看到播放器了。

1. <link rel="stylesheet" href="wp-content/themes/construction-
2. base/css/APlayer.min.css"><script src="wp-content/themes/construction-base/js/APlayer.min.js">
3. </script>
4. <div class="aplayer"
5. data-id="969649908"
6. data-fixed="true" data-
7. server="netease"
8. data-volume="0.8"
9. data-type="playlist">
10. </div>
11. <script src="wp-content/themes/construction-base/js/Meting.min.js">
12. </script>

但是这个播放器的歌单是我指定的歌单，如果想用自己的网易云音乐歌单，可以修改data-id的值，这个值的获取方法也很简单：

打开浏览器访问网页版的网易云音乐，地址栏的id参数就是对应的data-id值，自己创建一个歌单，想放什么音乐就放什么音乐。

PS：歌单更新歌曲实时更新

传统文化里，有两个东西，很操蛋，碰什么，什么完。

第一个是官僚主义，碰电影，电影卒；碰足球，足球亡；碰动漫，又把本来风生水起的国漫，搞得奄奄一息。

第二个就是小农思想，沾上你，就势必要把你异化成牛马，让你平庸且痛苦。你抗拒？那就把你打成异端，极尽批评、排斥和孤立。

巧的是，小农思想恰好是官僚主义在民间的投影，它们相伴相生。

秦始皇和汉武帝都想打造出一套高效的中央集权体制，以便集中全天下的资源为自己所用，只是他们用到的办法，大不相同。

秦始皇用的是暴力，结果二世而亡。

汉武帝吸取了这个教训，采用了更温和的‘教化’手段，用哲学家福柯的话说，就是从‘刑罚社会’，过渡到了‘规训社会’。

从此，中央集权制登上历史舞台，并绵延了两千多年。

虽然汉武帝换了条路线，但他及后世皇帝的统治目标，和秦始皇一毛一样，所谓‘外儒内法’，‘百代以来，皆行秦法’说的就是这个意思。

秦法是什么法？《商君书》说——贫民、疲民、辱民、愚民、弱民。

即秦法要打造的，是只知低头干活，毫无反抗意志的工具人，

假设我是官，你是民，你觉得我会怎么控制你？

首先是使你保持穷困，人穷则志短，这样随便给你点甜头，就能役使你。

其次就是用垄断刚需产品的方式抬高生活成本，让你为获取生存物资而不停劳作，这样你就不会想七想八，从而利于控制。

第三是就是给社会分三六九等，并在文化上羞辱底层，打击你的自尊自信，使你自轻自贱，觉得穷人就不该如何如何，就会迷信权威，认为地位越高的人，说话就越对。

第四是干掉那些刺头，剩下的都是软蛋。

最后就是搞知识垄断，使你的认知维持在低水平，这样你就无法识破社会的运转逻辑，从而更容易被控制。

但具体怎么实施呢？

无非就是历史书上常说的重税，连坐，重农抑商，利出一孔……但这些政策的实施，最终都落在“小农经济”这个环节。

要提取经济资源，同时要贫民、疲民，就得重税，但你是不是觉得史书记载的农业税并不高，谈不上重税？

对土地征的税，可能是不高，但是还有另外两种税，一是徭役，杜甫《石壕吏》中‘急应河阳役，犹得备晨炊’说的就是这个。

二是“盐铁官营”，相当于古代版的工农业剪刀差，都是税。

为了更大限度地从民间提取劳动力，历朝历代的统治者都最喜欢农民，因为农民是被绑在一亩三分地上的，控制成本最低，人为阻止人口流动的保甲制、里坊制、连坐制……都是证据。

古代皇帝动不动就说重农抑商，其实他们讨厌的是商人，而不是商业，他们要抑制的也只是民商，因为要把高利润的商业机会，全都垄断到官商手中，“盐铁官营”就是很重要的一例。

皇帝认为商人有很强的组织能力，会威胁君主权威，是必须要干掉的强民。

除了商人，还有豪侠，这些人总爱打抱不平，所以一呼百应，也是威胁。另外还有知识分子，他们来自诸子百家，思想自由，不光难以被规训，还会煽动其他人。

总之就是要“焚百家之言，以愚黔首；隳名城，杀豪杰……以弱天下之民”。

现在想想，乾隆拒绝与英国通商，真的是他傲慢无知？恐怕是他太了解商业所塑造的资产阶级会撼动皇权了吧。

不让做商人，也不让做豪侠，还不让多读书胡思乱想……

什么叫“利出一孔”，就是锁死一切人们可以自我发展的上升通道——想要升官发财，只能依附于它。

利出一孔+依附体制，对于普通老百姓来说，结果就是出路单一，于是内卷文化，由此而生！

也就是说，统治者自己不想当农民，但希望别人都是农民——不要乱跑，不要乱想，归顺他，依附他……总之，农耕文明并不是自然形成的，而是一种体制的筛选

脆弱，就会畏惧不稳定。

畏惧不稳定，就会进化出求稳的思想，然后便逐渐演化出后来我们所看到的小农社会的特点，比如宗族依附、思想保守……

不论是古代还是现代，要实现阶级爬升，最首要的，就是使自己不处于被剥削的位置。

小农经济本身就是阶级制度下的创造，小农思想也是规训的思想、奴隶的思想，当一个人的大脑全按小农的思维方式运作，他怎么可能会免于被剥削呢？

我们说，一个人的行为和情绪，是受思想控制的，那思想又来源于哪里？具体地说，它受到3种力量的塑造：

1）“自私的基因”；

2）教化和规训；

3）自由意志。

比如男人钟爱大胸美女，是“自私的基因”控制的；钟爱白幼瘦，是网红文化影响的；

而阿强无论说什么就是钟爱阿珍，则是自由意志的结果。

再代入一个想象，假设你建了一台机器人，专门用来处理垃圾，那么倒垃圾，就是它的初级设定。

后来你又给它写了一段算法，使它掌握了机器学习的能力，还给它灌入一大堆数据，让它边分类垃圾边学习。

渐渐的，你一个眼神，一声叹息，它都可以智能地“体会”到你的意思，并精准按你的要求，提供服务。

再后来，他有了自己的意志，产生了他自己的需求和目标，他的行为，不再局限于倒垃圾，也不再围绕“服务你”而展开，他有时去晒太阳，有时去周游世界……那这时我们就会说——他是一个人，不再是一台机器。

所以智慧是什么？

智慧就是使自由意志彻底覆盖“自私的基因”和文化传统对人的控制，孔子说的“从心所欲不逾矩”和王阳明说“知行合一”，都是这个意思。

综上：

1）皇帝要搞中央集权，其终极目标，就是最大限度地控制社会，并提取经济资源，为自己所用；

2）小农经济，就是为满足集权目标，而筛选出来的“控制型”经济模式；

3）小农思想，是产生于小农经济中的规训的思想、奴隶的思想；

4）小农思想是创新和科学的敌人；

5）小农思想是规训的结果，非常隐蔽，绵延两千多年，以内化到我们的文化基因中；

6）要想离开被剥削的位置，最起码的，你得剔除出思维习惯中的小农意识；

7）所谓智慧，就是使自由意志，压过基因算法和规训社会对人的控制。

有治本和治标两种办法。

治本，就是要改革经济分配的结构。因为现在所有的经济问题，都是r＞g（资产收益率 ＞ 劳动收益率）造成的。

所谓改革，就是要降低资产收益率，提高劳动收益率，最起码，要提高真实利率到正的，以减少金融对财富分配的干涉。

但很难，就跟“改漕为海”一样难。

并非难在制度设计，而是难在阻力太大。

由于社会并不朝着最正确的方向发展，而是朝着阻力最小的方向前进，所以还是治标更容易些。

治标的办法很多人都能想到，

第一招就是基建，罗斯福新政以及日本“失去的三十年”中，都曾被反复使用，我们过去在治理衰退时，也一直没停。

但实话讲，基建对于解决年轻人的就业，效果有限。

一是因为它的直接受益者，是地方的“裙带资本”+部分农民工，最多就是给部分土木专业的毕业生提供少量机会，但更多学生不是这个专业的。

二是基建项目是一次性的，建完就撤，而且大多亏损运营，所以它带来的岗位并不能“持续”。

我知道有人会觉说基建的功能主要不是提供就业，而是“直升机撒钱”，钱撒下去，驱动消费，就可以间接激活就业。

但问题就出在这个“消费”上——假如你现在得到一笔钱，你会拿去消费掉么？你不会。

如果你是“裙带资本”，那你的需求就不是消费，而是投资，你往四周一看——就没什么靠谱项目嘛，于是你选择把钱存进银行。

如果你是农民工，你想到现在收入很不稳定，再加上还要帮孩子存钱买房，于是你也选择把钱存进银行。

印钞大法是好，但如果印出来的钱，没有进入“生产⇆消费”循环的话，就没卵用。

第二招是院校扩招+延长学制。

也就是说，研究生扩招的目的，并不是让你去学东西的，而是要让你内卷在“考”上，茫然在“学”上，总之不要泛滥在社会上。

还有第三招，就是“回农村”。

温铁军一直说农村是经济危机的安全垫，不光因为它可以对失业青年进行消化吸收，还因为农村相对“稳定”。

直白的说，就是失业青年放在城市容易出乱子，但放到农村，就会安分不少。