lua复制代码                                1
黄金数 = ------------------------------
                                 1
                1 + ---------------------
                                    1
                       1 + -------------
                                      1
                             1 + -------
                                   1 + ...

                       

这个连分数计算的“层数”越多，它的值越接近黄金分割数。

请你利用这一特性，求出黄金分割数的足够精确值，要求四舍五入到小数点后100位。

小数点后3位的值为：0.618
小数点后4位的值为：0.6180
小数点后5位的值为：0.61803
小数点后7位的值为：0.6180340

csharp复制代码public static void main(String[] args) {
        //定义大范围数值
        BigDecimal bt=new BigDecimal(1);
        //循环操作1000次
        //这里的一千可以是其他数，只要实验一个数几次发现结果不在发生变化就可以
        for (int i=0;i<1000;i++){
            //前头加一的操作（注意大数的加减乘除方式)
            bt=bt.add(BigDecimal.ONE);
            //大数值类型的除法操作
            // ONE表示1，作被除数
            // bt为除数
            // 100位小数点后保留的位数
            // BigDecimal.ROUND_HALF_DOWN为小数值取舍类型，使用的这个类型为：四舍五入，2.35保留1位，变成2.3
            //HALF_DOWN意思是一半的向下取，所以2.35变为2.3，同样的如果是HALF_UP，就是一半的向上取，2.35变为2.4
            bt=BigDecimal.ONE.divide(bt,100,BigDecimal.ROUND_HALF_DOWN);
        }
        System.out.println(bt);
    }

ini复制代码public static void main(String[] args) {
        BigInteger firNum=BigInteger.ONE;
        BigInteger secNum=BigInteger.ONE;
        BigInteger res=BigInteger.ZERO;

        //斐波那契数列找到合适除数与被除数（尽可能的大）
        for (int i=0;i<1000;i++){
            res=firNum.add(secNum);
            firNum=secNum;
            secNum=res;
        }

        System.out.print("0.");
        //模拟实现手动除法
        for (int i=0;i<102;i++){
            BigInteger b=firNum.divide(secNum);
            BigInteger Ten=BigInteger.TEN;
            firNum=(firNum.mod(secNum).multiply(Ten));
            //要进行结尾进位的考虑
            if(i!=0&&i!=100){
                System.out.print(b);
            }
            else if(i==100){
                BigInteger temp=b;
                b=firNum.divide(secNum);
                if(b.intValue()>5){
                    System.out.print(temp.intValue()+1);
                }
                else
                    System.out.print(temp);
                break;
            }
        }
    }

ini复制代码public static void main(String[] args) {
        res=f(500);
        res=res.setScale(100,BigDecimal.ROUND_HALF_UP);
        System.out.println(res);
    }
    public static BigDecimal res=new BigDecimal(1);
    public static BigDecimal res1=new BigDecimal(0);

    public static BigDecimal f(int n){
        if(n==1){
            return res;
        }
        BigDecimal a=new BigDecimal(1);
        return res1=a.divide((a.add(f(n-1))),1000,BigDecimal.ROUND_HALF_DOWN);
    }

vbscript复制代码    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {   
        this.preHandle(request, (HttpServletResponse) response);
        chain.doFilter(request, response);
        this.afterCompletion((HttpServletRequest) request, (HttpServletResponse) response);
    }
​
    private void preHandle(HttpServletRequest request, HttpServletResponse response) {
            try {
                RequestWrapper requestWrapper = new RequestWrapper((HttpServletRequest) request);
                log.info("request params：{}", JSON.toJSON(requestWrapper.getBody()));
            } catch (Exception e) {
                log.info("log error ignore", e);
            }
    }
​

java复制代码@Slf4j
public class RequestWrapper extends HttpServletRequestWrapper {
​
    private final String body;
​
    public RequestWrapper(HttpServletRequest request) {
        super(request);
        StringBuilder stringBuilder = new StringBuilder();
        BufferedReader bufferedReader = null;
        InputStream inputStream = null;
        try {
            inputStream = request.getInputStream();
            if (inputStream != null) {
                bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
                char[] charBuffer = new char[128];
                int bytesRead = -1;
                while ((bytesRead = bufferedReader.read(charBuffer)) > 0) {
                    stringBuilder.append(charBuffer, 0, bytesRead);
                }
            } else {
                stringBuilder.append("");
            }
        } catch (IOException ex) {
​
        } finally {
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    log.error("inputStream close error", e);
                }
            }
            if (bufferedReader != null) {
                try {
                    bufferedReader.close();
                } catch (IOException e) {
                    log.error("bufferedReader close error", e);
                }
            }
        }
        body = stringBuilder.toString();
    }
​
    @Override
    public ServletInputStream getInputStream() throws IOException {
        final ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(body.getBytes());
        ServletInputStream servletInputStream = new ServletInputStream() {
            @Override
            public boolean isFinished() {
                return false;
            }
​
            @Override
            public boolean isReady() {
                return false;
            }
​
            @Override
            public void setReadListener(ReadListener readListener) {
            }
​
            @Override
            public int read() throws IOException {
                return byteArrayInputStream.read();
            }
        };
        return servletInputStream;
​
    }
​
    @Override
    public BufferedReader getReader() throws IOException {
        return new BufferedReader(new InputStreamReader(this.getInputStream()));
    }
​
    public String getBody() {
        return this.body;
    }
​
}

vbscript复制代码    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        RequestWrapper requestWrapper = new RequestWrapper((HttpServletRequest) request);
        this.preHandle(requestWrapper, (HttpServletResponse) response);
        //此处传封装后的HttpServletRequest
        chain.doFilter(requestWrapper, response);
        this.afterCompletion((HttpServletRequest) request, (HttpServletResponse) response);
    }

java复制代码​
    public synchronized void reset() throws IOException {
        throw new IOException("mark/reset not supported");
    }
​
    /**
     * Tests if this input stream supports the <code>mark</code> and
     * <code>reset</code> methods. Whether or not <code>mark</code> and
     * <code>reset</code> are supported is an invariant property of a
     * particular input stream instance. The <code>markSupported</code> method
     * of <code>InputStream</code> returns <code>false</code>.
     *
     * @return  <code>true</code> if this stream instance supports the mark
     *          and reset methods; <code>false</code> otherwise.
     * @see     java.io.InputStream#mark(int)
     * @see     java.io.InputStream#reset()
     */
    public boolean markSupported() {
        return false;
    }

java复制代码<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-seata</artifactId>
    <exclusions>
        <!-- 要与seata服务端版本一直,所以把自带的替换掉 -->
        <exclusion>
            <groupId>io.seata</groupId>
            <artifactId>seata-spring-boot-starter</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<!--使用1.4.2版本，对配置可以使用data-id一个配置文件包含其他所有的配置信息-->
<dependency>
    <groupId>io.seata</groupId>
    <artifactId>seata-spring-boot-starter</artifactId>
    <version>${seata.version}</version>
</dependency>

java复制代码store {
  ## store mode: file、db、redis
  mode = "db"
  ## rsa decryption public key
  publicKey = ""
 
  ## database store property
  db {
    ## the implement of javax.sql.DataSource, such as DruidDataSource(druid)/BasicDataSource(dbcp)/HikariDataSource(hikari) etc.
    datasource = "druid"
    ## datasource = "dbcp"
    ## mysql/oracle/postgresql/h2/oceanbase etc.
    dbType = "mysql"
    ## mysql 5.xx
    ## driverClassName = "com.mysql.jdbc.Driver"
    ## mysql 8.0
    driverClassName = "com.mysql.cj.jdbc.Driver"
    ## if using mysql to store the data, recommend add rewriteBatchedStatements=true in jdbc connection param
    url = "jdbc:mysql://ip:port/umapp_appcenter?rewriteBatchedStatements=true"
    ## url = "jdbc:mysql://ip:port/umapp_appcenter?useUnicode=true&characterEncoding=utf-8&useSSL=false&nullCatalogMeansCurrent=true&serverTimezone=Asia/Shanghai"
    user = "appcenter"
    password = "123456"
    minConn = 5
    maxConn = 100
    globalTable = "global_table"
    branchTable = "branch_table"
    lockTable = "lock_table"
    queryLimit = 100
    maxWait = 5000
  }
}

java复制代码registry {
  # file 、nacos 、eureka、redis、zk、consul、etcd3、sofa
  type = "nacos"
 
  nacos {
    application = "seata-server"
    serverAddr = "127.0.0.1:7500"
    group = "SEATA_GROUP"
    namespace = "public"
    cluster = "default"
    username = "nacos"
    password = "nacos"
  }
}
 
config {
  # file、nacos 、apollo、zk、consul、etcd3
  type = "nacos"
 
  nacos {
    serverAddr = "127.0.0.1:7500"
    namespace = "public"
    group = "SEATA_GROUP"
    username = "nacos"
    password = "nacos"
    dataId = "seataServer.properties"
  }
}

bash复制代码transport.type=TCP
transport.server=NIO
transport.heartbeat=true
transport.enableClientBatchSendRequest=true
transport.threadFactory.bossThreadPrefix=NettyBoss
transport.threadFactory.workerThreadPrefix=NettyServerNIOWorker
transport.threadFactory.serverExecutorThreadPrefix=NettyServerBizHandler
transport.threadFactory.shareBossWorker=false
transport.threadFactory.clientSelectorThreadPrefix=NettyClientSelector
transport.threadFactory.clientSelectorThreadSize=1
transport.threadFactory.clientWorkerThreadPrefix=NettyClientWorkerThread
transport.threadFactory.bossThreadSize=1
transport.threadFactory.workerThreadSize=default
transport.shutdown.wait=3
transport.serialization=seata
transport.compressor=none
# server
server.recovery.committingRetryPeriod=1000
server.recovery.asynCommittingRetryPeriod=1000
server.recovery.rollbackingRetryPeriod=1000
server.recovery.timeoutRetryPeriod=1000
server.undo.logSaveDays=7
server.undo.logDeletePeriod=86400000
server.maxCommitRetryTimeout=-1
server.maxRollbackRetryTimeout=-1
server.rollbackRetryTimeoutUnlockEnable=false
server.distributedLockExpireTime=10000
# store
#model改为db
store.mode=db
store.lock.mode=file
store.session.mode=file
# store.publicKey=""
store.file.dir=file_store/data
store.file.maxBranchSessionSize=16384
store.file.maxGlobalSessionSize=512
store.file.fileWriteBufferCacheSize=16384
store.file.flushDiskMode=async
store.file.sessionReloadReadSize=100
store.db.datasource=druid
store.db.dbType=mysql
store.db.driverClassName=com.mysql.cj.jdbc.Driver
# 改为上面创建的seata服务数据库
store.db.url=jdbc:mysql://ip:port/umapp_appcenter?useUnicode=true&rewriteBatchedStatements=true
# 改为自己的数据库用户名
store.db.user=appcenter
# 改为自己的数据库密码
store.db.password=123456
store.db.minConn=5
store.db.maxConn=30
store.db.globalTable=global_table
store.db.branchTable=branch_table
store.db.distributedLockTable=distributed_lock
store.db.queryLimit=100
store.db.lockTable=lock_table
store.db.maxWait=5000
store.redis.mode=single
store.redis.single.host=127.0.0.1
store.redis.single.port=6379
# store.redis.sentinel.masterName=""
# store.redis.sentinel.sentinelHosts=""
store.redis.maxConn=10
store.redis.minConn=1
store.redis.maxTotal=100
store.redis.database=0
# store.redis.password=""
store.redis.queryLimit=100
# log
log.exceptionRate=100
# metrics
metrics.enabled=false
metrics.registryType=compact
metrics.exporterList=prometheus
metrics.exporterPrometheusPort=9898
# service
# 自己命名一个vgroupMapping
service.vgroupMapping.my_test_tx_group=default
service.default.grouplist=ip:port
service.enableDegrade=false
service.disableGlobalTransaction=false
# client
client.rm.asyncCommitBufferLimit=10000
client.rm.lock.retryInterval=10
client.rm.lock.retryTimes=30
client.rm.lock.retryPolicyBranchRollbackOnConflict=true
client.rm.reportRetryCount=5
client.rm.tableMetaCheckEnable=false
client.rm.tableMetaCheckerInterval=60000
client.rm.sqlParserType=druid
client.rm.reportSuccessEnable=false
client.rm.sagaBranchRegisterEnable=false
client.rm.tccActionInterceptorOrder=-2147482648
client.tm.commitRetryCount=5
client.tm.rollbackRetryCount=5
client.tm.defaultGlobalTransactionTimeout=60000
client.tm.degradeCheck=false
client.tm.degradeCheckAllowTimes=10
client.tm.degradeCheckPeriod=2000
client.tm.interceptorOrder=-2147482648
client.undo.dataValidation=true
client.undo.logSerialization=jackson
client.undo.onlyCareUpdateColumns=true
client.undo.logTable=undo_log
client.undo.compress.enable=true
client.undo.compress.type=zip
client.undo.compress.threshold=64k

mysql复制代码--全局事务表--
CREATE TABLE IF NOT EXISTS `global_table`
(
    `xid`                       VARCHAR(128) NOT NULL,
    `transaction_id`            BIGINT,
    `status`                    TINYINT      NOT NULL,
    `application_id`            VARCHAR(32),
    `transaction_service_group` VARCHAR(32),
    `transaction_name`          VARCHAR(128),
    `timeout`                   INT,
    `begin_time`                BIGINT,
    `application_data`          VARCHAR(2000),
    `gmt_create`                DATETIME,
    `gmt_modified`              DATETIME,
    PRIMARY KEY (`xid`),
    KEY `idx_gmt_modified_status` (`gmt_modified`, `status`),
    KEY `idx_transaction_id` (`transaction_id`)
    ) ENGINE = INNODB
    DEFAULT CHARSET = utf8;
 
-- 分支表
CREATE TABLE IF NOT EXISTS `branch_table`
(
    `branch_id`         BIGINT       NOT NULL,
    `xid`               VARCHAR(128) NOT NULL,
    `transaction_id`    BIGINT,
    `resource_group_id` VARCHAR(32),
    `resource_id`       VARCHAR(256),
    `branch_type`       VARCHAR(8),
    `status`            TINYINT,
    `client_id`         VARCHAR(64),
    `application_data`  VARCHAR(2000),
    `gmt_create`        DATETIME(6),
    `gmt_modified`      DATETIME(6),
    PRIMARY KEY (`branch_id`),
    KEY `idx_xid` (`xid`)
    ) ENGINE = INNODB
    DEFAULT CHARSET = utf8;
 
-- 锁定表
CREATE TABLE IF NOT EXISTS `lock_table`
(
    `row_key`        VARCHAR(128) NOT NULL,
    `xid`            VARCHAR(128),
    `transaction_id` BIGINT,
    `branch_id`      BIGINT       NOT NULL,
    `resource_id`    VARCHAR(256),
    `table_name`     VARCHAR(32),
    `pk`             VARCHAR(36),
    `gmt_create`     DATETIME,
    `gmt_modified`   DATETIME,
    PRIMARY KEY (`row_key`),
    KEY `idx_branch_id` (`branch_id`)
    ) ENGINE = INNODB
    DEFAULT CHARSET = utf8;
 
--seata新版本加的锁表
CREATE TABLE IF NOT EXISTS `distributed_lock`
(
    `lock_key`       CHAR(20) NOT NULL,
    `lock_value`     VARCHAR(20) NOT NULL,
    `expire`         BIGINT,
    PRIMARY KEY (`lock_key`)
    ) ENGINE = INNODB
    DEFAULT CHARSET = utf8mb4;
 
INSERT INTO `distributed_lock` (lock_key, lock_value, expire) VALUES ('AsyncCommitting', ' ', 0);
INSERT INTO `distributed_lock` (lock_key, lock_value, expire) VALUES ('RetryCommitting', ' ', 0);
INSERT INTO `distributed_lock` (lock_key, lock_value, expire) VALUES ('RetryRollbacking', ' ', 0);
INSERT INTO `distributed_lock` (lock_key, lock_value, expire) VALUES ('TxTimeoutCheck', ' ', 0);

mysql复制代码--日志文件表--
CREATE TABLE IF NOT EXISTS `undo_log`
(
    `branch_id`     BIGINT       NOT NULL COMMENT 'branch transaction id',
    `xid`           VARCHAR(128) NOT NULL COMMENT 'global transaction id',
    `context`       VARCHAR(128) NOT NULL COMMENT 'undo_log context,such as serialization',
    `rollback_info` LONGBLOB     NOT NULL COMMENT 'rollback info',
    `log_status`    INT(11)      NOT NULL COMMENT '0:normal status,1:defense status',
    `log_created`   DATETIME(6)  NOT NULL COMMENT 'create datetime',
    `log_modified`  DATETIME(6)  NOT NULL COMMENT 'modify datetime',
    UNIQUE KEY `ux_undo_log` (`xid`, `branch_id`)
    ) ENGINE = INNODB
    AUTO_INCREMENT = 1
    DEFAULT CHARSET = utf8 COMMENT ='AT transaction mode undo table';

java复制代码seata:
  enabled: true
  enable-auto-data-source-proxy: true #是否开启数据源自动代理,默认为true
  tx-service-group: my_test_tx_group  #要与配置文件中的vgroupMapping一致
  registry:  #registry根据seata服务端的registry配置
    type: nacos #默认为file
    nacos:
      application: seata-server #配置自己的seata服务
      server-addr: #根据自己的seata服务配置
      username: nacos #根据自己的seata服务配置
      password: nacos #根据自己的seata服务配置
      namespace:  #根据自己的seata服务配置
      cluster: default # 配置自己的seata服务cluster, 默认为 default
      group: SEATA_GROUP #根据自己的seata服务配置
  config:
    type: nacos #默认file,如果使用file不配置下面的nacos,直接配置seata.service
    nacos:
      server-addr: #配置自己的nacos地址
      group: SEATA_GROUP #配置自己的dev
      username: nacos #配置自己的username
      password: nacos #配置自己的password
      namespace:  #配置自己的namespace
      dataId: seataServer.properties #配置自己的dataId,由于搭建服务端时把客户端的配置也写在了seataServer.properties,所以这里用了和服务端一样的配置文件,实际客户端和服务端的配置文件分离出来更好

java复制代码@EnableAutoDataSourceProxy
@EnableDiscoveryClient
@SpringBootApplication
public class UmappCloudServiceAppcenterApplication {
 
    public static void main(String[] args) {
        SpringApplication.run(UmappCloudServiceAppcenterApplication.class, args);
    }
 
}

java复制代码@ApiOperation("添加测试数据")
@PostMapping("/addUmappTestSeata")
@GlobalTransactional
@GlobalLock
public Result<UmappTest> addUmappTestSeata(String name,Integer age,String sex) {
    Result<UmappTest> result = umappTestService.addUmappTest(name,age,sex);
    Result temp = seataTestFeign.addSeataTest();//添加seata测试数据
    //int i = 1/0;
    return result;

go复制代码// 安装项目脚手架
go install github.com/panco95/go-garden/tools/garden@v1.1.4

// 创建项目
garden new my-gateway gateway
garden new my-service service

// 修改服务配置和路由配置
......

// 启动网关
go run my-gateway/main.go
// 启动服务
go run my-service/main.go

python复制代码
# -*- coding: utf-8 -*-
import scrapy
from liepin_spider.items import LiepinSpiderItem
from sql import MyMysql


class LiepinSpider(scrapy.Spider):
    name = 'liepin'
    custom_settings = {
        'ITEM_PIPELINES': {
            'liepin_spider.pipelines.LiepinSpiderPipeline': 200,
        },
        'DOWNLOADER_MIDDLEWARES': {
            # 'liepin_spider.middlewares.LiepinSpiderDownloaderMiddleware': 100,
            'scrapy.downloadermiddlewares.retry.RetryMiddleware': None,
            # 'liepin_spider.middlewares.MyRetryMiddleware': 110,
        },
        'CONCURRENT_REQUESTS': 1, # 请求并发数
        'DOWNLOAD_DELAY': 1,      # 请求延时
        'DOWNLOAD_TIMEOUT' : 5,   # 请求超时
    }

    def __init__(self, s_type=None, c_type=None, *args, **kwargs): #传参选取爬取模式
        super(LiepinSpider, self).__init__(*args, **kwargs)
        self.c_type = c_type #爬取时间类型 1:每天 2:每月
        self.s_type = s_type #爬取关键词类型


    def start_requests(self):
        mysql = MyMysql()
        if self.c_type == '1':
            keys = mysql.read_many('select zwmc from lp_job_names where type = 0')# 获取数据库关键词,爬取部分
        else:
            keys = mysql.read_many('select zwmc from lp_job_names ')# 获取数据库关键词，全部爬取
        
        if self.s_type=='0':
            quyu_info = mysql.read_many('select dqs,city from lp_job_areas')  # 爬取全部地区数据
        else:
            quyu_info = mysql.read_many('select dqs,city from lp_job_areas where type = {}'.format(self.s_type))# 爬取部分地区数据

        for key in keys:
            for quyu in quyu_info:
                print("搜索关键词为：" + key[0] + "  当前搜索地区为："+quyu[1])
                params = (
                    ('dqs', quyu[0]),  # 地区参数
                    ('key', key[0]),#搜索关键词
                    ('curPage', '0'),
                    ('pubTime','1'),#一天以内
                    ('jobKind','2')#职位类型
                )
                url = 'https://www.liepin.com/zhaopin/'
                yield scrapy.FormRequest(url=url,method='GET',formdata=params,callback=self.parse,meta={"key_info":key[0],"diqu_info":quyu[1]},dont_filter=True)
            # 当前关键词请求完毕，修改数据库状态
            print("职位："+key[0]+"查询完毕")
            mysql.update("UPDATE lp_job_names set type = '1' WHERE zwmc = '%s' " % key[0])
        #重置职位状态
        mysql.update("UPDATE lp_job_names set type = '0' WHERE type = '1'")


    def parse(self, response):
        urls = response.xpath('//div[@class="job-info"]/h3/a/@href').getall() # 所有招聘链接
        key = response.meta["key_info"]
        diqu = response.meta["diqu_info"]
        if len(urls) == 0:
            print(diqu+"没有职位："+key)
            pass # 查询不到数据则跳过
        else:
            for url in urls: # 循环获取招聘信息
                if 'https://www.liepin.com' not in url:
                    url = 'https://www.liepin.com'+ url
                yield scrapy.Request(url=url,callback=self.get_data,meta={"key_info":key,"diqu_info":diqu},dont_filter=True )

            next_url = 'https://www.liepin.com' + response.xpath('//div[@class="pagerbar"]/a/@href').getall()[-2] # 下一页地址

            if 'javascript:' in next_url: # 判断是否有下一页
                pass
            else:
                print(diqu+"岗位："+key+" 下一页地址",next_url)
                yield scrapy.Request(url=next_url,meta={"key_info":key,"diqu_info":diqu},callback=self.parse,dont_filter=True )

    def get_data(self,response):
        items = LiepinSpiderItem()
        items['key_word'] = response.meta["key_info"]#搜索关键词
        items['diqu']= response.meta["diqu_info"]#搜索地区
        items['c_type']= self.c_type
        items['zhiwei']= response.xpath('//h1/text()').get()#职位
        if items['zhiwei'] is None:
            pass
        else:
            items['company'] = response.xpath('//div[@class="title-info"]/h3/a/text()').get()#公司名称
            items['salary']= ''.join(response.xpath('//p[@class="job-item-title"]/text()').getall()).strip()#薪资
            try:
                items['fb_time']= response.xpath('//p[@class="basic-infor"]/time/@title').get() + response.xpath('//p[@class="basic-infor"]/time/text()').get().strip() #发布时间
            except:
                items['fb_time'] = ''
            items['requirement']= '#'.join(response.xpath('//div[@class="job-title-left"]/div[@class="job-qualifications"]/span/text()').getall()) #要求
            items['welfare']= '#'.join(response.xpath('//div[@class="comp-tag-box"]/ul/li/span/text()').getall()) #福利
            items['job_description']= ''.join(response.xpath('//div[@class="content content-word"]/text()').getall()).strip() #职位描述
            items['log_url']= response.xpath('//div[@class="company-logo"]/a/@href').get() #公司logo地址
            items['industry']= response.xpath('//ul[@class="new-compintro"]/li[1]/a/text()').get() #行业
            company_info = response.xpath('//ul[@class="new-compintro"]/li//text()').getall()
            items['company_size'] = items['company_addr'] = ''
            for num in range(3,len(company_info)):
                if '公司规模' in company_info[num]:
                    items['company_size']= company_info[num].replace('公司规模：','') #公司规模
                else:
                    items['company_addr']= company_info[num].replace('公司地址：','') #公司地址
            # yield items
            print(items)

python复制代码# -*- coding: utf-8 -*-
import pymysql


class MyMysql:
    def __init__(self):
        self.host = 'xxxxx' # ip
        self.port = 3306             # 端口
        self.user = 'xxxx'            # 用户名
        self.password = 'xxxx'  # 密码
        self.dbname = 'xxxx'          # 数据库名
        self.charset = 'utf8mb4'     # 字符类型

        # 链接数据库
        self.connect()

    def connect(self):
        # 链接数据库和获取游标
        self.db = pymysql.connect(host=self.host, port=self.port, user=self.user, password=self.password,
                                  db=self.dbname, charset=self.charset)
        self.cursor = self.db.cursor()

    def run(self, sql):
        ret = None
        try:
            ret = self.cursor.execute(sql)
            self.db.commit()
        except Exception as e:
            self.db.rollback()
        # finally:
        #     self.close()
        return ret

    def rollback(self):
        self.db.rollback()
        self.close()

    def close(self):
        self.cursor.close()
        self.db.close()

    def insert(self, sql):
        try:
            self.cursor.execute(sql)
            self.db.commit()
        except pymysql.err.IntegrityError:
            pass

    def commit(self):
        self.db.commit()
        self.close()

    def update(self, sql):
        return self.run(sql)

    def delete(self, sql):
        return self.run(sql)

    def read_one(self, sql):
        ret = None
        try:
            self.cursor.execute(sql)
            # 获取得到数据
            ret = self.cursor.fetchone()
        except Exception as e:
            # print('查询失败')
            pass
        # finally:
        #     self.close()
        return ret

    def read_many(self, sql):
        ret = None
        try:
            self.cursor.execute(sql)
            # 获取得到数据
            ret = self.cursor.fetchall()
        except Warning as e:
            print('查询失败')
        finally:
            pass
        return ret

python复制代码
# -*- coding: utf-8 -*-
import scrapy


class LiepinSpiderItem(scrapy.Item):
    key_word = scrapy.Field()#搜索关键词
    zhiwei = scrapy.Field()#招聘职位
    company = scrapy.Field()#公司名称
    salary =  scrapy.Field()#薪资
    diqu = scrapy.Field()#地区
    fb_time = scrapy.Field()#发布时间
    requirement = scrapy.Field()#要求
    welfare = scrapy.Field()#福利
    job_description = scrapy.Field()#职位描述
    log_url = scrapy.Field()#公司logo地址
    industry = scrapy.Field()#行业
    company_size = scrapy.Field()#公司规模
    company_addr = scrapy.Field()#公司地址
    c_type = scrapy.Field()#爬取时间类型

python复制代码# -*- coding: utf-8 -*-

import emoji
import pymysql
from pymongo import MongoClient
from twisted.enterprise import adbapi
import copy

adbparams_info = dict(
            host='xxxx',	# ip
            db='xxxx',		 # 数据库名
            user='xxxx',		# 用户名
            password='xxxx',	  # 密码
            charset='utf8',
            cursorclass=pymysql.cursors.DictCursor  # 指定cursor类型
        )

class LiepinSpiderPipeline(object):
    '''异步写入'''
    def __init__(self,dbpool):
        self.dbpool = dbpool
        self.conn = MongoClient('xxxx', 27017) # mongo的链接，可以不用

    @classmethod
    def from_settings(cls,settings):
        # 先将setting中连接数据库所需内容取出，构造一个地点
        adbparams = adbparams_info
        dbpool = adbapi.ConnectionPool('pymysql', **adbparams)
        # 返回实例化参数
        return cls(dbpool)

    def process_item(self,item,spider):
        # 使用Twisted异步的将Item数据插入数据库
        item1 = copy.deepcopy(item)
        # 存入mysql
        self.dbpool.runInteraction(self.do_insert, item1)  # 指定操作方法和操作数据
        # 存入mongo,获取的职位
        self.mongo_insert(item['zhiwei'])

    def mongo_insert(self,job):
        db = self.conn.crawlab_test  # 连接mongo数据库
        my_set = db.jobs # 存入集合
        data_test1 = {
            'job': job
        }
        my_set.insert_one(data_test1)

    def handle_error(self,failure,item):
        # 打印异步插入异常
        print(failure,"数据库异常")

    def do_insert(self, cursor, item):
        insert_sql = """insert into lp_job_data(key_word,zhiwei,company,salary,diqu,fb_time,requirement,welfare,
                                                  job_description,logo_url,industry,company_size,company_addr,type,c_type)
                             VALUES('%s','%s','%s','%s','%s','%s','%s','%s','%s','%s','%s','%s','%s','5','%s')
                             """% (
            item['key_word'],item['zhiwei'],item['company'],item['salary'],item['diqu'],
            item['fb_time'],item['requirement'],item['welfare'],item['job_description'].replace("'",'"'),item['log_url'],
            item['industry'],item['company_size'],item['company_addr'],item['c_type'])
        try:
            cursor.execute(insert_sql)
        except:
            insert_sql = emoji.demojize(insert_sql)#替换emoj
            cursor.execute(insert_sql)

    def close_spider(self, spider):
        self.conn.close()

python复制代码# -*- coding: utf-8 -*-

import json,time
import random
import requests
from liepin_spider import settings


class LiepinSpiderDownloaderMiddleware(object):
    def process_request(self, request, spider):
        # 设置随机请求头
        ua_random = random.choice(settings.USER_AGENT_LIST)
        request.headers['User-Agent'] = ua_random
        
        --设置代理请自行添加

    def process_exception(self, request, exception, spider):
		--异常捕捉，需重新加代理请求
        ua_random = random.choice(settings.USER_AGENT_LIST)
        request.headers['User-Agent'] = ua_random
        return request

python复制代码import os

def start_all():
    os.system('scrapy crawl liepin -a s_type="0" -a c_type="2"') #爬取全部地区数据

# def start_type1():
#     os.system('scrapy crawl liepin -a s_type="1" ') # 一天爬一次  （一线城市 + 新一线城市）
#
# def start_type2():
#     os.system('scrapy crawl liepin -a s_type="2"') # 一周爬一次   （二线城市）
#
# def start_type3():
#     os.system('scrapy crawl liepin -a s_type="3"') # 剩下的一月一次

def new_type():
    os.system('scrapy crawl liepin -a s_type="4" -a c_type="1"')  # 5个城市，部分岗位

if __name__ == '__main__':
    # start_type1()
    # start_type2()
    # start_type3()
    new_type()

sh复制代码# 搜索openssh-server
$ apt search openssh-server
Sorting... Done
Full Text Search... Done
openssh-server/focal-updates,now 1:8.2p1-4ubuntu0.3 amd64 [installed]
  secure shell (SSH) server, for secure access from remote machines
# 安装 openssh-server
$ sudo apt install openssh-server

sh复制代码# 查看sshd服务状态
sudo service ssh status
# 启动sshd服务
sudo service ssh start
# 停止sshd服务
sudo service ssh sttop
# 重新启动sshd服务
sudo service ssh restart

sh复制代码# 添加wsl端口转发
$wsl_ip = (wsl hostname -I).trim()
Write-Host "WSL Machine IP: ""$wsl_ip"""
netsh interface portproxy add v4tov4 listenport={对外端口} connectport={wsl-ssh-port} connectaddress=$wsl_ip

sh复制代码ssh -p {对外端口} wsl-username@windows-ip

sh复制代码export ALL_PROXY="http://{windows-ip}:{代理端口}"

sh复制代码$ ssh pc-win-ssh
ljc43026@10.181.24.27: Permission denied (publickey,keyboard-interactive).

javascript=复制代码if(msg.payload.result == true){
    msg.payload.note = "test"
}
return msg;

javascript=复制代码var new_msg = {payload:msg.payload.length}
msg.payload = new_msg
return msg;

c=复制代码switch(msg.payload){
        case 1:
        /*do something*/
        break;
        
        case 2:
        /*do something*/
        break;
        
        ...
}

htmlembedded=复制代码<!DOCTYPE html>
<html>
    <head>
        <meta charset="utf-8">
        <title>Hello~</title>
    </head>
    <body>
            <h2>This is Node-RED<h2>
    </body>
</html>

json=复制代码{"id":"device0","result":true}
{"id":"device1","result":false}

javascript=复制代码if(msg.payload.result == true){
    msg.payload.note = "test"
}
return msg;