


### 1. qtablewidget增加选择框？

```
cb = QtWidgets.QTableWidgetItem()
# item 转为checkbox，样式受checkbox样式影响
cb.setFlags(QtCore.Qt.ItemIsUserCheckable | QtCore.Qt.ItemIsEnabled)
# 居中
cb.setTextAlignment(QtCore.Qt.AlignCenter)
# 选中状态
cb.setCheckState(QtCore.Qt.Unchecked if not row.checked else QtCore.Qt.Checked)
# i：第i行，0：第0列，
self._table_widget.setItem(i, 0, cb)
```

样式：

```qss
/*---------qcheckbox-----------*/
QCheckBox {
}

QCheckBox::indicator {
    /* 选择框尺寸 */
}

QCheckBox::indicator::checked:pressed {
    image:url(:/resource/checkbox-checked.png);
}
QCheckBox::indicator::checked {
    image:url(:/resource/checkbox-checked.png);
}
```

效果：![qtablewidget-checkbox](/images/blog/1/pyqt/assert/qtablewidget-checkbox.png)



### 2. QTableWidget设置进度条QProgressBar

```python
bar = QtWidgets.QProgressBar()
bar.setMinimum(0)
bar.setMaximum(100)
bar.setValue(100)
bar.setTextVisible(True)
self._table_widget.setCellWidget(0, 4, bar)
```

样式

```css
QProgressBar {
    text-align: right;
    vertical-align: center;
    padding-right: 40px;
    color: $selectBackground;
}

QProgressBar::chunk {
    background-color: $selectBackground;
    width: 10px;
    margin: 0.5px;
    text-align: center;
}
```

效果![qtablewidget_qprocessbar](../../../../Desktop/qtablewidget_qprocessbar.png)



### QTableWidget导出excel

https://blog.csdn.net/weixin_41882459/article/details/108394548

qtablewidget增加选择框|QTableWidget设置进度条QProgressBar

pyqt5 qtablewidget用法总结

Title: "pyqt5异步批量下载"
Keywords: "pyqt5,aysnc,asyncio,pasync,aiohttp,windows,mac"
Description: "异步批量下载和多线程还是有区别，就是协程和线程的区别"
Label: "pyqt5异步批量"
```

# 批量下载视频文件，不影响GUI运行，GUI展示相应的进度

版本

- 平台
  - mac 11
  - windows 10

- QT：5.15.7

- aiohttp: 3.8.3
- qasync: 0.23.0

**思路一：**

启动一个线程QThread后台去执行，下载任务和下载进度 都是 通过pyqtSignal进行交互

```python
class DownloadThread(QtCore.QThread):
    def __init__(self):
        super(DownloadThread, self).__init__()

    def run(self) -> None:
        loop = qasync.QEventLoop(self)
        asyncio.set_event_loop(loop)
        loop.run_forever()


class Download(QtCore.QObject):
    url_signal = pyqtSignal(str)
    progress_signal = pyqtSignal(str)

    def __init__(self):
        super(Download, self).__init__()
        self.url_signal.connect(self.schedule)

		@asyncSlot(str)
    async def schedule(self, data):
        if data == "":
            return
        video = json.loads(data, object_hook=decodeVideo)
        loop = asyncio.get_event_loop()
        loop.set_exception_handler(self.exception_handle)
        session_timeout = aiohttp.ClientTimeout(total=None, sock_connect=10)
        async with aiohttp.ClientSession(loop=loop, timeout=session_timeout) as session:
            cwlist = [loop.create_task(self.fetch_limit(semaphore, session, video, dir)) for video in videos]
            await asyncio.gather(*cwlist)
          
    async def fetch(self, video):
      	filename = video.title if video.title else video.id
        file = path.join(dir, filename + ".mp4")
        try:
            with open(file, "wb+") as fd:
                logging.info("%s\t%s\t%s" % (video.title, video.video_url, file))
                # 在windows上这里会被卡住，不再仅需运行，替换使用requests都可以正常返回
                async with session.get(video.video_url, headers=self.getHeaders()) as resp:
                    video.content_length = resp.headers["Content-Length"]
                    logging.info("content-length: " + video.content_length)
                    logging.info("file: " + file)
                    async for chunk in resp.content.iter_chunked(chunk_size):
                        fd.write(chunk)
                        video.size += len(chunk)
                        video.progress = int(video.size / int(video.content_length) * 100)
                        self.progress_signal.emit(json.dumps(video, default=encodeVideo))
        except asyncio.exceptions.TimeoutError as e:
            print("fetch timeout: ", e)
                        
 class Batch(QtWidgets.QWidget):
    def __init__(self, context: Context):
        super(IndexBatch, self).__init__()
        self.context = context
        self.thread = DownloadThread()
        self.download = Download()
        self.download.moveToThread(self.thread)
        self.thread.start()
        self.setUi()                       
		
    def onDownload(self):
        for video in self._videos:
            if video.checked:
                self.download.url_signal.emit(json.dumps(video, default=encodeVideo),
                                              path.join(self.save_dir, self._author_nickname))
```

问题：

思路一的代码在mac上可以运行，session请求是可以响应的，但是在win10上，`async with session.get(video.video_url) as resp` 会被卡住不再执行，解决思路

- 使用`reqeusts.get(video.video_url)`是可以正常响应的
- aiohttp设置sock_connect没有收到`asyncio.exceptions.TimeoutError` 异常打印，可能是`async with session.get`没有进入到执行队列中去～

**思路二**

尝试去掉DownloadThread执行下载任务的思路，直接将下载任务放到异步执行队列(loop)中去

```python
class Download(QtCore.QObject):
    progress_signal = pyqtSignal(str)

    def __init__(self):
        super(Download, self).__init__()

    async def schedule(self, videos, dir: str):
        logging.info("download count: %d" % (len(videos)))
        loop = asyncio.get_event_loop()
        loop.set_exception_handler(self.exception_handle)
        session_timeout = aiohttp.ClientTimeout(total=None, sock_connect=10)
        async with aiohttp.ClientSession(loop=loop, timeout=session_timeout) as session:
            cwlist = [loop.create_task(self.fetch(semaphore, session, video, dir)) for video in videos]
            await asyncio.gather(*cwlist)

    def exception_handle(self, *args):
        logging.info("asyncio.exception.handle: {}" % args)

    async def fetch(self, session, video, dir):
        filename = video.title if video.title else video.id
        file = path.join(dir, filename + ".mp4")
        with open(file, "wb+") as fd:
          logging.info("%s\t%s\t%s" % (video.title, video.video_url, file))
          async with session.get(video.video_url, headers=self.getHeaders()) as resp:
            video.content_length = resp.headers["Content-Length"]
            async for chunk in resp.content.iter_chunked(chunk_size):
              fd.write(chunk)
              video.size += len(chunk)
              video.progress = int(video.size / int(video.content_length) * 100)
              self.progress_signal.emit(json.dumps(video, default=encodeVideo))
              
class Batch(QtWidgets.QWidget):
    def __init__(self, context: Context):
        super(IndexBatch, self).__init__()
        self.context = context
        self.download = Download()
        self.setUi()                       
		
    def onConnect(self):
        self._ui.download_btn.clicked.connect(self.onDownload)
        self.download.progress_signal.connect(self.onDownloadProcess)

    # 订阅Download下载进度更新进度条
    def onDownloadProcess(self, data):
        vd = json.loads(data, object_hook=decodeVideo)
        bar = self._progress_bar_dict[vd.id]
        bar.setValue(vd.progress)
        
    @asyncSlot()
    async def onDownload(self):
        videos = []
        for video in self._videos:
            if video.checked and video.progress == 0:
                videos.append(video)
        await self.download.schedule(videos, self.save_dir)
        
async def main():
    def close_future(future, loop):
        loop.call_later(10, future.cancel)
        future.cancel()

    loop = asyncio.get_event_loop()
    future = asyncio.Future()

    app = QApplication.instance()
    if hasattr(app, "aboutToQuit"):
        getattr(app, "aboutToQuit").connect(
            functools.partial(close_future, future, loop)
        )
    m = MainWindow()
    m.run()
    await future


if __name__ == '__main__':
    logging.basicConfig(level=logging.INFO)
    QtCore.QCoreApplication.setAttribute(QtCore.Qt.AA_EnableHighDpiScaling)
    try:
        qasync.run(main())
    except asyncio.exceptions.CancelledError:
        sys.exit(1)
```

**效果截图**

![pyqt5-asyncio-download](/images/blog/1/pyqt/assert/pyqt5-asyncio-download.png)



# 异步加载图片，不影响GUI运行





异步批量下载和多线程还是有区别，就是协程和线程的区别

pyqt5异步批量下载


[toc]

# 全局锁

对整个数据实例加锁，FTWRL

```sql
flush table with read lock
```

使用这个语句后其他线程的语句会阻塞：数据更新语句，数据表定义语句和更新事务的提交语句

**使用场景**：全库逻辑备份，mysqldump导出的时候使用MVCC的一致性保证innodb导出数据，但是对于MyISAM来说是不支持的，备份只能通过FTWRL来保证

**为什么不用 set global readonly = true**

1.  readonly的值，一般被用作判断一个库是主库还是从库，修改global变量的方式影响面大，不建议使用
2.  异常处理机制上，如果执行FTWRT由于客户端发生异常断开，mysql会自动释放这个全局锁，而设置全局readonly后，如果客户端发生异常，则数据库会一直保持readonly状态，导致整个库事件处于不可写状态，风险较高

# 表级锁

mysql表级锁有两种: 

**表锁**

与FTWRL类似，可以用unlock tables主动释放锁，也可以在客户端断开的时候自动释放

```sql
lock tables t1 read, t2 write;
```

其他线程写t1，读写t2都会被阻塞，该线程也只能读t1，读写t2

不推荐使用，粒度太大，目前很少见到了

**MDL（元数据锁，meta data lock）**

MDL不需要显示使用，在访问一个表的时候会自动加上，MDL的作用是，保证读写的正确性，防止在一个查询在执行期间另一线程对这个表结构做变更，删除了一列，导致查询线程的结果和表结构对不上。

对表做CURD时，加MDL读锁；对表结构做变更操作时，加MDL写锁；

-   MDL读锁之间不互斥，可以并发读写
-   MDL写锁互斥，两个线程同时修改，只能等拿到锁的线程执行完成

| 时间点 | 会话A                                | 会话B                        | 会话C                             | 会话D                                                |
| ------ | ------------------------------------ | ---------------------------- | --------------------------------- | ---------------------------------------------------- |
| 1      | begin; <br />Select count(*) from t; |                              |                                   |                                                      |
| 2      |                                      | Select * from t where id =2; |                                   |                                                      |
| 3      |                                      |                              | alter  table t add column c3 int; |                                                      |
| 4      |                                      |                              |                                   | Show  processlist；B：copy to tmp table              |
| 5      |                                      |                              | 阻塞                              | Show  processlist;B：Waiting for table metadata lock |
| 6      | A：执行完毕                          |                              |                                   |                                                      |
| 7      |                                      | B: 执行完成                  |                                   | Show  processlist; B：rename table                   |
| 8      | Select  count(*) from t;             |                              |                                   |                                                      |
| 9      |                                      |                              | C：执行完毕                       |                                                      |
| 10     |                                      |                              |                                   | Show  processlist; A: Sending data                   |
| 11     | A:执行完毕                           |                              |                                   |                                                      |

session A先启动，这是会对t加一个MDL读锁，session B需要的也是加MDL读锁。读锁不互斥可以正常执行

而session C需要MDL写锁，而之后所有要在表t上申请MDL读锁的请求也会被session C阻塞。等于现在这个表t完全不可读写了，而客户端超时会有重试机制，新的session请求，这个库的线程很快就爆满。

**如何安全的进行表结构变更**

如果是热表的话，就麻烦了，虽然数据量不大，但是请求频繁。这时候kill掉未必管用，因为新的请求马上就来了，一般能遇到这种情况的公司都是有点实力的了，必定会有DBA的支撑了，很幸运和DBA聊了一下

一般表结构变更直接执行就好了，如果遇到一直拿不到MDL锁的情况, 考虑

-   处理慢查询，商量能不能kill
-   解决长事务，会一直占着MDL锁，[长事物解决方案](innodb事务#长事务)
-   对于热表的话，因为查询很频繁，会一直拿不到MDL写锁，考虑晚上执行，到这就很头疼了。
-   如果是上亿数据的大表（数据几千万，甚至过亿）的话, 或者说一直拿不到MDL写锁的话，推荐方案：
    -   [pt-online-schema-change](https://www.percona.com/doc/percona-toolkit/LATEST/pt-online-schema-change.html)
    -   [gh-ost](https://github.com/github/gh-ost)
    -   [阿里云-不锁表结构变更](https://help.aliyun.com/document_detail/98373.html)

主要原理：

-   1、创建临时表：CREATE TABLE tmp_table_table LIKE table_name
-   2、变更临时表结构： ALTER TABLE tmp_table_table XXXX
-   3、全量拷贝数据：INSERT IGNORE INTO tmp_table_table (SELECT %s FROM table_name FORCE INDEX (%s) WHERE xxx
-   4、增量数据binlog同步： UPDATA/INSRT/DELETE tmp_table_name
-   5、切换新旧表： RENAME TABLE table_name to old_tmp_table_table, tmp_table_name to table_name



# 行锁

**两阶段锁协议**

解锁阶段：事务提交或者回滚

加锁阶段：第一个变更开始

在innodb事务中，行锁是在需要的时候才加上的，但并不是不需要了就立即释放，而是要等到事务结束时才释放，这个就是两阶段锁协议

**加锁原则**

1.  原则1：加锁的基本单位是next-key lock。next-key lock是前开后闭区间。
2.  原则2：查找过程中访问到的对象才会加锁。
3.  优化1：索引上的等值查询，给唯一索引加锁的时候，next-key lock退化为行锁。
4.  优化2：索引上的等值查询，向右遍历时且最后一个值不满足等值条件的时候，next-key lock退化为间隙锁。
5.  一个bug：唯一索引上的范围查询会访问到不满足条件的第一个值为止。

## 三种算法

**幻像读**

innodb事物默认的隔离级别是REPEATBLE RRAD， 

幻想读是指在同一事物下，连续执行两次相同的sql，会有不同的结果，第二次sql可能会返回之前不存在的行。

next key lock是如何解决的?

```sql
select * from t where key > 20 for update;
```

next key lock会锁住(20, ∞]区间，在此事物未提交期间，key > 20记录都是不能插入的。

- Record Lock

单个行记录上锁，总是锁住索引记录。如果表在建立是并没有建立索引，innodb会使用隐式的主键来锁

索引可以是主键、唯一、普通索引

- Gap lock

间隙锁，锁定一个范围，但不包含记录本身。

- Next key lock

gap lock + record lock 锁定范围并锁定记录本身。

innodb对于行的查询采用的是这种方式，eg. 有一个索引，有10、11、13、20四个值，那么该索引被Next key lock的区间是

- (-∞, 10)
- [10, 11)
- [11, 13)
- [13, 20)
- [20, +∞)

**等值间隙锁**

```sql
CREATE TABLE `t` (
  `id` int(11) NOT NULL,
  `c` int(11) DEFAULT NULL,
  `d` int(11) DEFAULT NULL,
  PRIMARY KEY (`id`),
  KEY `c` (`c`)
) ENGINE=InnoDB;

insert into t values(0,0,0),(5,5,5),(10,10,10),(15,15,15),(20,20,20),(25,25,25);
```



| session A                             | session B                                | session C                             |
| ------------------------------------- | ---------------------------------------- | ------------------------------------- |
| begin;                                |                                          |                                       |
| update t set  d = d + 1 where id = 7; |                                          |                                       |
|                                       | insert into t  values(8,8,8);     block; |                                       |
|                                       |                                          | update t set d = d + 1 where id = 10; |

Session B 会被block，因为session A的加锁区间是(5,10]; 因为id=7不存在，退化为间隙锁。session B会被阻塞，10是开区间，这行是可以修改的。

**非唯一索引等值锁**

| session A                                         | session B                                     | session C                                   |
| ------------------------------------------------- | --------------------------------------------- | ------------------------------------------- |
| begin;                                            |                                               |                                             |
| select id from t where c = 5 lock in  share mode; |                                               |                                             |
|                                                   | update t set d = d + 1 where id = 5;          |                                             |
|                                                   | update t set d = d + 1 where c =  5; (block); |                                             |
|                                                   |                                               | insert into t values  (7,7,7);     (block); |

1. `update t set d = d + 1 where id = 5;` 为什么不会阻塞？

where条件是id = 5，session A `select id from t where c = 5 lock in  share mode;` 

lock in share mode只锁**覆盖索引**，不会影响主键索引。for update 就不一样了，系统会认为接下来会更新数据，顺便会对主键索引上满足条件的索引加锁。

如果session A查询是 `select d from t where c = 5 lock in share mode;`  session B的`update t set d = d + 1 where id = 5;`  就会被阻塞了。

2. `update t set d = d + 1 where c = 5; ` 为什么会阻塞？

加锁原则中的优化2: 索引上等值查询，向右遍历时且最后一个值不满足等值条件的时候，next-key lock退化为间隙锁。加锁的范围会变为 (c, 10];  session c `insert into t values  (7,7,7);`  也会被阻塞



## 死锁

并发线程出现循环资源依赖，涉及的线程都在等待别的线程释放资源时，就会导致这几个线程都进入等待的状态。超时以后客户端会又重试机制，这时mysql的连接数就上来了，负载飙升。

**死锁处理策略**：

- 超时策略：`innodb_lock_wait_timeout` 默认50s
- 死锁检测：`innodb_deadlock_detect` 默认时开启的

**避免死锁的建议**：

- 通过两阶段锁协议我们知道：行锁是在事务提交的时候才会释放锁，要把最可能造成锁冲突、最可能影响并发度的锁尽量往后放
- 控制访问相同资源的并发事务量，比如：抢购商品分成10条记录，或放入队列

## 乐观锁

[乐观锁应用场景](https://segmentfault.com/a/1190000008935924)

总是假设最好的情况，每次去拿数据的时候都认为别人不会修改，不会上锁，但是更新时会判断在此期间有没有人更新这个数据。实现方式有两种：

- 使用数据版本(version)记录机制实现
- 使用时间戳

```sql
SELECT * FROM table_name WHERE ... FOR UPDATE。
```

select： 读锁，共享锁
update \ insert \ delete : 每次都会自己加排他锁

一个商品A, 库存有10个， 一百人来抢，不要超卖
update table set num=num-1 where num=10;

select num from table;
update table set num=num-1 where num=9;

## 悲观锁: 

锁的是索引， 如果没有索引，直接锁表。

总是假设最坏的情况，每次去拿数据时总会假设别人会修改，所以每次在拿数据时都会加锁。别人想拿这条数据就会阻塞直到他拿到锁，

### 共享锁

读取的任何行上设置共享模式锁定，其他会话可以读取行，但是在事务提交之前不能修改它们，如果这些行中的任何一个被尚未提交的另一个事务修改，则查询等待直到该事务结束，然后使用最新职

```sql
-- 5.7
SELECT * FROM table_name WHERE ... lock in share mode
-- 8.0
SELECT * FROM table_name WHERE ... for share
```

### 排他锁 

排他锁也叫写锁，简称x锁，原理：一个事务获取了一个数据行的排他锁，其他事务就不能再获取该行的其他锁（排他锁或者共享锁），即一个事务在读取一个数据行的时候，其他事务不能对该数据行进行增删改查。

子查询中的行不会被锁定，除非在子查询中也指定了锁

```sql
SELECT * FROM table_name WHERE ... FOR UPDATE。
```

注意点:
- 对于select语句，innodb不会加任何锁，也就是可以多个并发去进行select的操作，不会有任何的锁冲突，因为根本没有锁。
- 对于insert，update，delete操作，innodb会自动给涉及到的数据加排他锁，只有查询select需要我们手动设置排他锁。
- 共享锁和排他锁都是锁的行记录，意向共享锁和意向排他锁锁定的是表。

悲观锁，每次在拿数据都会上锁，其他session想拿这个数据就会被阻塞知道它拿到锁

**脏读**

脏数据：未提交的数据

脏读：一个事物读取到了另一个事物未提交的数据

脏读违背了事物的隔离性，关注一下innodb是如何隔离事务的。

现在不会见到脏读了，数据隔离级别要设置成 READ UNCOMMITTED级别才可以，现在默认级别是READ REAPEATABLE

那么READ UNCOMMITTED只有特殊场景才会遇到，如：slave

**不可重复读**

不可重读读是指：在一个事物内多次读取同一数据集合，在这个事物还没有结束时，另一个事物对该数据集合做了一些DML操作。这样就发生了同一事物内两次读取同一数据集合，数据不一致。

不可重复读和脏读的区别是，脏读是读未提交，而不可重复读的已经提交

next key lock算法下，不仅锁住扫描到的索引，还锁住了这些索引覆盖的范围，这个范围内的插入是不允许的，这样就避免了另外一个事物在这个范围内插入数据，导致多次读取数据不一致。

**阻塞**

一个事物中的锁需要等待另一个事物中的锁释放他所占的资源，这就是阻塞

**innodb_lock_wait_timeout** 用来控制等待的时间默认50秒

**innodb_rollback_on_timeout** 用来设置在等待超时是否对进行中的事物进行回滚。



为啥数据库CPU会飙升，真的是业务上涨导致的吗，考虑过死锁吗？如何避免死锁？ 什么是MDL锁？

mysql锁

# go-struct-excel

1. struct支持导出为excel
2. excel导入为struct
3. 表头支持扩展，如：日期表头不确定长度
4. excel第一行为备注
5. excel表头进行汇总
6. 标记某行为特殊颜色
7. 如果字段为空，就不生成该表头
8. 支持http响应
9. 支持grpc响应

> 表头不支持重复

实际效果：

![](/images/blog/1/golang/assert/go-struct-excel.png)



# 安装

```shell
go get github.com/douyacun/go-struct-excel
```

# 导出 excel

```go
package main

type foo struct {
	Name    string          `excel:"姓名" json:"name"`
	Age     *int            `excel:"年龄,allowempty" json:"age"`
	Height  int             `excel:"身高,font{color:ff0000 size:16}" json:"height"`
	Holiday map[string]bool `excel:"假期,expand:regexp(^\\d{4}-\\d{2}-\\d{2}$)" json:"holiday"`
}

func (f foo) GatherHeaderRows() int {
	return 1
}

func (f foo) GatherHeader(sheet *Sheet) error {
	style, _ := sheet.GetCenterStyle()

	headerLine := "7"

	sheet.Excel.SetCellValue(sheet.SheetName, "A"+headerLine, "个人信息")
	sheet.Excel.MergeCell(sheet.SheetName, "A"+headerLine, "C"+headerLine)
	sheet.Excel.SetCellStyle(sheet.SheetName, "A"+headerLine, "C"+headerLine, style)
	sheet.Excel.SetCellValue(sheet.SheetName, "D"+headerLine, "假期信息")
	sheet.Excel.MergeCell(sheet.SheetName, "D"+headerLine, "I"+headerLine)
	return nil
}

func (f foo) Remarks() (string, int, int) {
	return `.特别注意：导入数值加逗号格式，很经常被Excel带成数值，可在前面加个'号，或设置单元格格式为文本			
			
.导入规则：
.全局名称不允许重复			
.各种包含类型枚举：可为空表示不定向，或输入：不限、包含、不包含			
`, 6, 9
}
```

测试：

```go
package main

func TestNewExcel(t *testing.T) {
  excel := NewExcel("helloworld.xlsx")
  defer excel.File.Close()
  data := make([]*foo, 0)
  age := 28
  data = append(data, &foo{
    Name:   "h",
    Age:    &age,
    Height: 181,
    Holiday: map[string]bool{
      "2022-01-27": false,
      "2022-01-28": true,
      "2022-01-29": true,
    },
  }, &foo{
    Name:   "o",
    Age:    &age,
    Height: 182,
    Holiday: map[string]bool{
      "2022-01-27": true,
      "2022-01-28": true,
      "2022-01-30": true,
      "2022-02-09": true,
      "2022-12-09": true,
    },
  })

  if err := excel.AddSheet("hello").AddData(data); err != nil {
    t.Error(err)
    return
  }

  if err := excel.SaveAs(); err != nil {
    t.Errorf("文件保存失败: %s", err.Error())
    return
  }
  dir, _ := os.Getwd()
  fmt.Println("当前路径：", dir)
  return
}

```

http访问直接下载excel:

```shell
if err := excel.Response(ctx.Writer); err != nil {
  ctx.JSON(http.StatusOK, gin.H{"code": http.StatusBadRequest, "message": err.Error()})
}
```

grpc响应:

```protobuf
// 定义protobuf
syntax = "proto3";
option go_package = "douyacun/proto/common;common";

package common;

message ExcelFile {
  string filename = 1;
  bytes raw = 2;
}

message ExcelResponse {
  int32 code = 1;
  string error_message = 2;
  ExcelFile data = 3;
}
```

如果是http代理grpc服务，可以通过类型断言：`ExcelResponse`

```go
package main

import "context"

func handler(ctx context.Context) error {
  switch resp.(type) {
  case *commonProto.ExcelResponse:
    return response(ctx.writer, resp.(*commonProto.ExcelResponse))
  default:
    return defaultHandle(ctx, req, resp)
  }
}

func response(w http.ResponseWriter) error {
  header := w.Header()

  byt, err := e.Bytes()
  if err != nil {
    return err
  }
  header["Accept-Length"] = []string{strconv.Itoa(len(byt))}
  header["Content-Type"] = []string{"application/vnd.ms-excel"}
  header["Access-Control-Expose-Headers"] = []string{"Content-Disposition"}
  header["Content-Disposition"] = []string{fmt.Sprintf("attachment; filename=\"%s\"", e.Filename)}
  w.Write(byt)
  return nil
}
```

excel tag说明：

- tag英文逗号分隔，第一个作为表头名称，其他没有顺序要求
- `allowempty`: 表头在场景一中需要展示，其他不需要。字段为指针类型，tag标记为 `allowmepty`
- `font`: 设定此列富文本样式，支持 `{color:ff0000 size:16 italic:true blod:true underline:true}`
- `expand`: 自动扩展表头，支持正则匹配表头，`expand:regexp(^\\d{4}-\\d{2}-\\d{2}$)"`， 其中内置正则
    + `expand:date`: 2022-06-18
    + `expand:datetime`: 2022-06-18 08:27:39
    + `expand:month`: 2022-06

表头备注：

```go
type ExcelRemarks interface {
Remarks() (remark string, row, col int) // 占用几行几列
}
```

汇总表头

```go
package main

type ExcelGatherHeader interface {
    GatherHeaderRows() int // 汇总表头占几行，不包括字段行
    GatherHeader(sheet *Sheet) error // 汇总表头合并单元格，单元格样式需要自己实现
}
```

## 导入用法

```go
package main

func TestReadData(t *testing.T) {
  excel, err := OpenExcel("helloword.xlsx")
  if err != nil {
    t.Error(err)
  }
  sheet, err := excel.OpenSheet("hello")
  if err != nil {
    t.Error(err)
  }
  if data, err := sheet.ReadData(foo{}); err != nil {
    t.Error(err)
  } else if d, ok := data.([]*foo); ok {
    if str, err := json.Marshal(d); err != nil {
      t.Error(err)
    } else {
      fmt.Println(string(str))
    }
  }
}
```

输出：

```shell
=== RUN   TestReadData
[{"name":"h","age":28,"height":181,"holiday":{"2022-01-27":false,"2022-01-28":true,"2022-01-29":true}},{"name":"o","age":28,"height":182,"holiday":{"2022-01-27":true,"2022-01-28":true,"2022-01-29":false,"2022-01-30":true,"2022-02-09":true,"2022-12-09":true}}]
--- PASS: TestReadData (0.00s)
PASS
```

1. struct支持导出为excel, 2. excel导入为struct, 3.表头支持扩展，如：日期表头不确定长度, 4. excel第一行为备注, 5. excel表头进行汇总, 6. 标记某行为特殊颜色, 7. 如果字段为空，就不生成该表头

go语言struct结构体支持导入导出excel


叫大家如何去除 wps word导出来的pdf文件水印  "WPS PDF编辑试用" ,

![WPSPDF编辑试用](/images/blog/1/tools/assert/WPSPDF编辑试用.png)



一、通过网站去除"WPS PDF编辑试用"水印

1. 打开网站: https://www.douyacun.com/pdf/remove-watermark

2. 选择PDF文件，分析PDF文件，勾选 `WPS PDF编辑试用` 水印图片

![勾选WPSPDF编辑试用.png](/images/blog/1/tools/assert/勾选WPSPDF编辑试用.png)

3. 预览去除"WPS PDF编辑试用"水印的效果，点击下载文件即可

![预览WPSPDF编辑试用.png](/images/blog/1/tools/assert/预览WPSPDF编辑试用.png)

二、PDF工具箱使用教程

下载地址：

mac: [https://www.douyacun.com/s/pdftools](https://www.douyacun.com/s/pdftools)

windows: [https://www.douyacun.com/s/pdf_tools.exe](https://www.douyacun.com/s/pdf_tools.exe)

选择文件

图片水印：勾选“WPS PDF编辑试用”水印图片

![pdf工具箱-WPSPDF编辑试用.png](/images/blog/1/tools/assert/pdf工具箱-WPSPDF编辑试用.png)

文字水印：搜索并选中文字水印，取消其他不是水印的文字

预览保存：

![pdf工具箱-WPSPDf编辑试用-预览保存.png](/images/blog/1/tools/assert/pdf工具箱-WPSPDf编辑试用-预览保存.png)

PDF工具箱专业去除'wps pdf编辑试用'

wps pdf编辑试用—去水印/移除水印/删除水印/隐藏水印


**下载地址**：

- [windows](https://www.douyacun.com/s/pdf_tools.exe)
- [mac](https://www.douyacun.com/s/pdftools)



PDF工具箱功能：

[toc]

# 一、PDF去水印-专业版

**先介绍常见的PDF水印：**

- 文字水印，可以选中，并且文字可以复制出来（空空说考研）的，就是文字水印，此类水印一般是在正文图层下方

![pdf去水印-选中文字.png](/images/blog/1/tools/assert/pdf去水印-选中文字.png)

- 图片水印，此类水印需要分为2种
  - 正文中嵌入水印图片，典型的像是扫描全能王的水印

      ![pdf去水印-选中图片.png](/images/blog/1/tools/assert/pdf去水印-选中图片.png)

  - 正文和水印是一张图片，这种水印是需要图片去水印的，目前PDF还不支持图片去水印

- 图形水印，将unicode文字用贝尔曲线画出来的图形（画图工具嵌入的文字就是贝尔曲线），可以选中但是文字复制不出来，这种水印是难以识别的，文字转图形以后就无法在转回来了。不过软件可以将这块内容标记出来，供大家判别是否为水印。

    ![pdf去水印-选中图形.png](/images/blog/1/tools/assert/pdf去水印-选中图形.png)



**去水印步骤（windows与mac一致）：**



1. 选择PDF文件

选择文件以后软件会分析PDF文件中的文字水印、图片水印、图形水印

2. 图片水印

![pdf去水印-图片水印.png](/images/blog/1/tools/assert/pdf去水印-图片水印.png)

软件会提取嵌入在正文中的图片，如上图，像这种水印是和正文分开的，是可以去掉的。

但如果像是下面这种，正文文字和水印在同一张图片上是去不掉的。常见的就是扫描版的图书

3. 文字水印

选择文件后软件分析PDF最多前10页的所有文字段落并统计出现次数：

![pdf去水印-文字水印.png](/images/blog/1/tools/assert/pdf去水印-文字水印.png)

大家可以用这个功能来删除文字

4. 图形水印

选择文件后会分析PDF中的文字图形水印，然后将其截图标记出来，如下图：

![pdf去水印-图形水印](/images/blog/1/tools/assert/pdf去水印-图形水印.png)

5. 预览保存

预览保存，会将判别为水印的文字移除掉，可以预览去水印效果是否能去掉水印，预览效果只会处理一次，再次预览不会二次处理，需要重选文件后预览。

![pdf去水印-预览](/images/blog/1/tools/assert/pdf去水印-预览.png)

# 二、PDF转Word

使用步骤：

1. 选择文件

2. 保存为docx

控制台会显示处理进度：

![pdf转word-控制台](/images/blog/1/tools/assert/pdf转word-控制台.png)

# 三、PDF批量加密文件

PDF批量加密功能，选择目录会遍历目录下的所有PDF文件，展示在下方表格中。可以取消勾选来取消加密文件

![pdf批量加密-选择目录](/images/blog/1/tools/assert/pdf批量加密-选择目录.png)

加密选项：

**用户密码：** 只有使用用户密码才可以打开PDF文件，否则无法访问，加密方式默认使用res_256（原美国军方）加密。此加密比较安全，难以破解。

**所有者秘密：** 此项用作限制用户复制、打印、修改、添加备注、添加表单的权限，没有密码也是可以访问文件内容。

![pdf批量机密-加密选项](/images/blog/1/tools/assert/pdf批量机密-加密选项.png)

用户密码 和 所有者密码 可以同时设置不同的密码，

填写所有者密码以后，默认是禁止打印、禁止修改文档、禁止合并文档、禁止复制/提取内容、禁止添加备注、禁止添加表单。

# 四、PDF转图片

文档待补充～

**软件截图**

![image-20211229153634052](/images/blog/1/tools/assert/pdf转图片-截图.png)

**参数介绍**

页数：从 x - y 生成图片，比如: 1-10 表示会生成 从第一页到第十页 11张图片， 此项与页码互不影响。

页码：特殊指定某页，比如: 1,2,4,8,9

图片格式：支持png、jpeg、webp

dpi：像素点，会影响打印效果，超过300dpi，人眼是分辨不出来的

保存：建议选择一个空文件夹，图片以页码作为文件名

# TODO

## PDF强力水印

## 

## 图片合成PDF


PDF工具箱有PDF去水印、PDF转Word功能，支持windows、mac的桌面工具类软件

PDF工具箱教程


## 概要

- Q&A
- 多目录多文件编译
- Goland配置支持proto

### Q&A

1. 如何安装protobuf 以及相应的依赖

protoc 是protobuf提供的命令行工具

通过 [github protoc release](https://github.com/protocolbuffers/protobuf/releases/tag/v3.17.3) 下载

mac 可以通过 `brew install protobuf`

go 语言使用protobuf 需要安装插件： `go install google.golang.org/protobuf/cmd/protoc-gen-go`

go 语言推荐安装插件：`go get github.com/gogo/protobuf/protoc-gen-gogofaster`

> gogofast 可以减少指针的使用，减少垃圾回收的时间
>
> Fields without pointers cause less time in the garbage collector. More code generation results in more convenient methods.

2. grpc和protobuf是什么关系，如何配合使用

protobuf 是协议定义的是结构体，方便不同语言之间的参数转换。

grpc是网络通信框架，可以用json、thrift、protobuf作为结构体

grpc不是go语言专有，go语言使用grpc需要安装:  `go get -u google.golang.org/grpc`

go语言grpc配合protobuf使用，需要安装protobuf插件: `go install google.golang.org/grpc/cmd/protoc-gen-go-grpc`

如何编译protobuf后面说。



### 多目录多文件编译

多目录结构：

```shell
➜  protobuf-compile tree
.
├── Makefile
└── proto
    ├── article
    │   ├── article.pb.go
    │   ├── article.proto
    │   ├── message.pb.go
    │   └── message.proto
    └── user
        └── author.proto
```

有多个微服务，用户中心/文章中心/审核中心 不同的团队服务通过grpc接口提供基础数据访问。这时候都是直接下发protobuf文件来方便传递数据

拆分多个目录，多个包相对来说就比较好维护protobuf文件。万一对方改了多个proto文件，直接丢给我们一个目录。我们也直接将目录覆盖

message 需要关联article的信息。同时还需要关联user包中的author。

到这需要先弄明白protobuf是如何import其他文件的。

1. protobuf支持相同目录下的文件直接import

```protobuf
syntax = "proto3";
option go_package = "protobuf-compile/proto/article;article";

package article;

import "article.proto";

message Message {
  int32 id = 1;
  string title = 2;
  string content = 3;
  string articleId = 4;
  article.Article article = 6;
}
```

artitle和message是在同一个包下面的，可以直接import即可。

2. 如果是多个目录，需要指定相对的根路径

--proto_path 指定根路径

推荐直接以项目路径作为根路径的：

```protobuf
syntax = "proto3";
option go_package = "protobuf-compile/proto/article;article";

package article;

import "protobuf-compile/proto/article/article.proto";
import "protobuf-compile/proto/user/author.proto";

message Message {
  int32 id = 1;
  string title = 2;
  string content = 3;
  string articleId = 4;
  user.Author author = 5;
  article.Article article = 6;
}
```

此时的import就都是绝对路径，这是就不能即有相对路径，又有绝对路径了，否则会报错：

```protobuf
syntax = "proto3";
option go_package = "protobuf-compile/proto/article;article";

package article;

import "article.proto";
import "protobuf-compile/proto/user/author.proto";

message Message {
  int32 id = 1;
  string title = 2;
  string content = 3;
  string articleId = 4;
  user.Author author = 5;
  article.Article article = 6;
}
```

```shell
protoc /Users/admin/Documents/github.com/protobuf-compile/proto/article/*.proto \
                --proto_path=/Users/admin/Documents/github.com \
                --proto_path=/Users/admin/Documents/github.com/protobuf-compile/proto/article \
                --go_out=plugins=grpc:/Users/admin/Documents/github.com
article.proto:10:9: "article.Article.id" is already defined in file "protobuf-compile/proto/article/article.proto".
article.proto:11:10: "article.Article.title" is already defined in file "protobuf-compile/proto/article/article.proto".
article.proto:12:10: "article.Article.content" is already defined in file "protobuf-compile/proto/article/article.proto".
article.proto:13:15: "article.Article.author" is already defined in file "protobuf-compile/proto/article/article.proto".
article.proto:9:9: "article.Article" is already defined in file "protobuf-compile/proto/article/article.proto".
article.proto:17:9: "article.SearchArticleResponse.code" is already defined in file "protobuf-compile/proto/article/article.proto".
article.proto:18:10: "article.SearchArticleResponse.error_message" is already defined in file "protobuf-compile/proto/article/article.proto".
article.proto:24:8: "article.SearchArticleResponse.data" is already defined in file "protobuf-compile/proto/article/article.proto".
article.proto:20:11: "article.SearchArticleResponse.Data.page" is already defined in file "protobuf-compile/proto/article/article.proto".
article.proto:21:11: "article.SearchArticleResponse.Data.page_size" is already defined in file "protobuf-compile/proto/article/article.proto".
article.proto:22:11: "article.SearchArticleResponse.Data.count" is already defined in file "protobuf-compile/proto/article/article.proto".
article.proto:19:11: "article.SearchArticleResponse.Data" is already defined in file "protobuf-compile/proto/article/article.proto".
article.proto:16:9: "article.SearchArticleResponse" is already defined in file "protobuf-compile/proto/article/article.proto".
article.proto:24:3: "article.SearchArticleResponse.Data" seems to be defined in "protobuf-compile/proto/article/article.proto", which is not imported by "article.proto".  To use it here, please add the necessary import.
protobuf-compile/proto/article/message.proto:6:1: Import "article.proto" was not found or had errors.
protobuf-compile/proto/article/message.proto:15:3: "article.Article" seems to be defined in "protobuf-compile/proto/article/article.proto", which is not imported by "protobuf-compile/proto/article/message.proto".  To use it here, please add the necessary import.
```

**多目录，多文件如何编译**

推荐设置根目录，以绝对路径import文件。protoc编译如何写?

但对对某个目录下的proto文件进行编译：

```shell
# 当前makefile所在目录
CurDir=$(shell pwd)
# 当前项目所在目录 - 根目录
PROJECT_PATH=$(shell cd "../$(dirname "$0")"; pwd)


.PHONY: proto
proto:
	protoc ${PROJECT_PATH}/protobuf-compile/proto/article/*.proto \
		--proto_path=${PROJECT_PATH} \
		--go_out=plugins=grpc:${PROJECT_PATH}

	protoc ${PROJECT_PATH}/protobuf-compile/proto/user/*.proto \
		--proto_path=${PROJECT_PATH} \
		--go_out=plugins=grpc:${PROJECT_PATH}
```

编译后：

```
.
├── Makefile
└── proto
    ├── article
    │   ├── article.pb.go
    │   ├── article.proto
    │   ├── message.pb.go
    │   └── message.proto
    └── user
        ├── author.pb.go
        └── author.proto
```

### Goland配置支持protobuf

需要安装插件： Protocol Buffers Editor

配置：Preferences > Languages & Frameworks >Protocol Buffers

取消： Configure automatically

添加：根目录所在目录

![protobuf-compile](/images/blog/1/golang/assert/protobuf-compile.png)



微服务之间的protobuf文件如何优雅的维护

grpc protobuf插件安装,多目录(多包)编译


### 背景：

数据库是联合主键，取出数据后存在map里面按主键直接取数据，以 date + campaign_id + adgroup_id + ad_id 作为唯一索引。以 struct做为map key是可以的，但是struct中有 time.time 不确定是否可行。

官方给出的答案是：key1 == key2 ，能否可以比较

实践了几种需要作为hash map key的情形：

1. pointer
2. struct
3. channel
4. slice



### 实践：

**struct 作为map key**

struct包含time、int64 ，2者都是可以相互比较的，struct就是可比较的。

```go
type TimeStruct struct {
	Date time.Time
	Id   int64
}

func main() {
	dat, _ := time.Parse("2006-01-02", "2021-06-22")

	t1 := TimeStruct{
		Date: dat,
		Id:   1,
	}

	t2 := TimeStruct{
		Date: dat,
		Id:   1,
	}

	mapList := map[TimeStruct]int64{
		TimeStruct{
			Date: dat,
			Id:   1,
		}: 1,
		TimeStruct{
			Date: dat,
			Id:   2,
		}: 2,
	}

	fmt.Println("> 输出：", mapList[t1], mapList[t2])
}

> 输出：1 1
```

在试一下结构体中包含 sync.mutex

```go
type TimeStruct struct {
  Date time.Time
  Id   int64
  mu   sync.Mutex
}
fmt.Println("> 输出：", mapList[t1], mapList[t2])
> 输出： 1 1
```

mutex 同样是一个结构体, 里面包含state，sema都是可以比较的。所以包含mutex也是可以比较。

```go
type Mutex struct {
	state int32
	sema  uint32
}
```



**pointer作为map key**

指针在go中是可以进行比较的，但是不能运算，理论上也是可以作为map key。但是不太建议作为map key取值。

指针指向的是内存地址。内存地址一样才是相同的。即使结构体的值一样，如果属于2个不同的变量，那么内存地址就是不一样的无法作为取到 map value的。

t2就是直接变量指针作为key，t2可以取到对应的值，t1与map 第一个key内存地址不一致无法取到对应的值。

```go
type TimeStruct struct {
		Date time.Time
		Id   int64
		mu   sync.Mutex
	}
	dat, _ := time.Parse("2006-01-02", "2021-06-22")
	t1 := TimeStruct{
		Date: dat,
		Id:   1,
		mu:   sync.Mutex{},
	}
	t2 := &TimeStruct{
		Date: dat,
		Id:   2,
		mu:   sync.Mutex{},
	}
	mapList := map[*TimeStruct]int64{
		&TimeStruct{
			Date: dat,
			Id:   1,
			mu:   sync.Mutex{},
		}: 1,
		t2: 2,
	}
	fmt.Println("> 输出：", mapList[&t1], mapList[t2])

> 输出： 0 2
```



**channel struct作为map key**

go make(chan string) 以后返回的是指针。channel作为map key 可以和 指针结构体作为map key 看作是同一个问题:

```go
fmt.Printf("%+v", make(chan string, 0))

0xc00008c060
```



**slice struct 作为map key**

看了make chan返回指针以后，make slice也是返回的指针？不是

slice不能作为map key，slice 无法进行相等比较的

Invalid operation: t1 == t2 (the operator == is not defined on []string)

数据库有联合主键，取出数据后存在map里面按主键直接取数据

go语言struct能否作为map的key


网站地址：[https://www.douyacun.com/image/ocr-to-docx](https://www.douyacun.com/image/ocr-to-docx)

**功能特点：**

1. 识别图片上的文字
2. 按照图片文字样式进行格式化
3. 导出为word文档
4. 2算法实现：googel-tesseract-ocr / easyocr
5. 借助开源库实现，功能免费

**背景：**

几天前媳妇给了我一张图片，让我把图片上的内容导出来为可以编辑，识别图片文字的软件有挺多的了，不过能相对格式化的不多，借这次东风就顺便了解了一下文字识别（OCR）相关的技术，经过一段时间摸底之后找到了3种比较靠谱的方式

最先接触到的第一个开源工具Tesseract，大家说的比较多是Tesseract对于中文不是很友好，识别率不高。在我多次调试配置之下发现他们都是没有用心学习Tessract，实践下来发现：中文识别率较高，中文标点准确。cpu识别速度可以接受。

第二个了解到的工具请教了一下搞算法的同学，他告诉我用百度云的接口，中文识别率较高，速度快，API可享每天1000次免费调用，对于我来说尝鲜足够了。要是做成一个功能就比较费钱了。

第三个工具是在逛Github途中发现的，easyocr，尝试下来总结：中文识别  率较高，中文符号识别率不高，有人提过issue，作者也在3.0.1的版本进行了修复，实验了几次还是不准。CPU速度较慢，没有GPU所以没有尝试GPU的速度如何。

测试用例1:

![douyacun-tesseract-测试](/images/blog/1/tools/assert/tesseract-demo1.png)

Tesseract-or识别结果：

![douyacun-免费文字识别](/images/blog/1/tools/assert/tesseract-demo1-result.png)

**技术实现：**

- tesseract-ocr（40.4k star）: https://github.com/tesseract-ocr/tesseract  c++ 语言实现
  - pytesseract（3.7k star）: https://github.com/madmaze/pytesseract  python对tesseract-ocr的包装
  - goesseract （1.5k star）：https://github.com/otiai10/gosseract go语言对tesseract-ocr的包装
- easyocr （1.7k star）: https://github.com/JaidedAI/EasyOCR python语言实现

最终选择 pytesseract + easyocr 来实现的功能，2个包都是python实现，可以多一种替代方案。python-docx来保存docx

easyocr 返回的只是bbox位置信息

```json
([[462, 162], [1376, 162], [1376, 264], [462, 264]], '会议签到小程序 MRD 文档', 0.6382400515609702)
# （左上 右上 左下 右下），内容，可信度
([[177, 473], [435, 473], [435, 539], [177, 539]], '1.行业背景', 0.8461557775997883)
```

判断上下2行文本是否属于同一行的内容就需要根据bbox x、y信息判断。

而pytesseract 提供了hocr的方式，Block/TextBlock/line 可以比较方便判断是否为同一段落的内容，甚至可以区分左右分页段落

```xml
<ComposedBlock ID="cblock_0" HPOS="467" VPOS="175" WIDTH="900" HEIGHT="75">
  <TextBlock ID="block_0" HPOS="467" VPOS="175" WIDTH="900" HEIGHT="75">
    <TextLine ID="line_0" HPOS="467" VPOS="175" WIDTH="900" HEIGHT="75">
      <String ID="string_0" HPOS="476" VPOS="175" WIDTH="133" HEIGHT="75" WC="0.93" CONTENT="会"/><SP WIDTH="15" VPOS="175" HPOS="609"/>
      <String ID="string_1" HPOS="624" VPOS="176" WIDTH="51" HEIGHT="70" WC="0.92" CONTENT="议"/><SP WIDTH="30" VPOS="176" HPOS="675"/>
      <String ID="string_2" HPOS="705" VPOS="177" WIDTH="116" HEIGHT="72" WC="0.88" CONTENT="签到"/><SP WIDTH="7" VPOS="177" HPOS="821"/>
      <String ID="string_3" HPOS="828" VPOS="177" WIDTH="105" HEIGHT="72" WC="0.95" CONTENT="小"/><SP WIDTH="5" VPOS="177" HPOS="933"/>
      <String ID="string_4" HPOS="938" VPOS="171" WIDTH="108" HEIGHT="106" WC="0.91" CONTENT="程序"/><SP WIDTH="-7" VPOS="171" HPOS="1046"/>
      <String ID="string_5" HPOS="1039" VPOS="191" WIDTH="154" HEIGHT="50" WC="0.91" CONTENT="MRD"/><SP WIDTH="25" VPOS="191" HPOS="1193"/>
      <String ID="string_6" HPOS="1218" VPOS="176" WIDTH="149" HEIGHT="73" WC="0.96" CONTENT="文档"/>
    </TextLine>
  </TextBlock>
</ComposedBlock>
```

- HPOS: 横向距离 X轴
- VPOS: 竖向距离 Y轴
- WIDTH: 宽度
- HEIGHT: 高端

使用这4个参数可以计算出像bbox一样的位置信息。

相应的代码实现在github：https://github.com/douyacun/ocr-to-docx



识别图片上的文字，格式化导出word

如何识别图片文字格式化导出为word


特点：

1. 支持传参IP定位，如果不传参数IP，默认使用当前客户端的IP地址定位

2. 支持前端jsonp调用，避免跨域

    

# 接口调用


**接口地址:**

 `https://www.douyacun.com/api/openapi/geo/location`

**请求方法:**  

`HTTP GET`

**参数：**

- `ip` :  `118.28.8.8`

**header:**

- `token` : `eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJBY2NvdW50SWQiOiJlZWQ4ZmQ1ODBmYTRmNjkyIn0.d7qF_mjdXMC0R5M6f04Lnh6x61kaU4lqHT0Axt9xUOY`

> 此token仅用于测试使用，限流 1次/s，大家共享此token

**限流**

- 开通接口权限 <a name="token"></a>
    - 关注微信公众号，私信说明开通 **开通IP定位API**, 自动创建并回复token

- QPS 默认 5/s, 最大并发10/s, 10万次/天， 
- QPS 可以增加到 10/s，最大并发20/s, 100万次/天，够用了。。。。
- 更大频次需要支付流量费用，100元长期支持，不限频次


![douyacun](https://www.douyacun.com/static/image/douyacun%E5%BE%AE%E4%BF%A1%E5%85%AC%E4%BC%97%E5%8F%B7.png)

**示例1:**

 `curl "https://www.douyacun.com/api/openapi/geo/location?ip=178.252.91.188&token=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJBY2NvdW50SWQiOiJlZWQ4ZmQ1ODBmYTRmNjkyIn0.d7qF_mjdXMC0R5M6f04Lnh6x61kaU4lqHT0Axt9xUOY"`

**响应：**

```json
{
    "code": 0,
    "message": "success",
    "data": {
        "countryCode": "CN",
        "country": "中国",
        "province": "浙江",
        "city": "杭州",
        "ip": "47.98.208.18",
        "latitude": "30.29365",
        "longitude": "120.16142",
        "zipcode": "310099",
        "timezone": "+08:00",
        "refer": "douyacun.com"
    }
}
```

**示例2:**

 `curl "https://www.douyacun.com/api/openapi/geo/location?ip=178.252.91.188&token=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJBY2NvdW50SWQiOiJlZWQ4ZmQ1ODBmYTRmNjkyIn0.d7qF_mjdXMC0R5M6f04Lnh6x61kaU4lqHT0Axt9xUOY"`

**响应:**

```json
{
    "code": 0,
    "message": "success",
    "data": {
        "countryCode": "RU",
        "country": "Russian Federation",
        "province": "Sankt-Peterburg",
        "city": "Saint Petersburg",
        "ip": "178.252.91.188",
        "latitude": "59.89444",
        "longitude": "30.26417",
        "zipcode": "196240",
        "timezone": "+03:00",
        "refer": "douyacun.com"
    }
}
```

# jsonp调用

**接口地址：**

`https://www.douyacun.com/api/geo/location?callback=__jp0&&token=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJBY2NvdW50SWQiOiJlZWQ4ZmQ1ODBmYTRmNjkyIn0.d7qF_mjdXMC0R5M6f04Lnh6x61kaU4lqHT0Axt9xUOY`

**示例:**

 `curl "https://www.douyacun.com/api/geo/location?callback=__jp0&&token=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJBY2NvdW50SWQiOiJlZWQ4ZmQ1ODBmYTRmNjkyIn0.d7qF_mjdXMC0R5M6f04Lnh6x61kaU4lqHT0Axt9xUOY"`

**响应:**

```
__jp0(
{
    "code": 0,
    "message": "success",
    "data": {
        "countryCode": "CN",
        "country": "中国",
        "province": "天津",
        "city": "天津",
        "ip": "118.28.8.8",
        "latitude": "39.14222",
        "longitude": "117.17667",
        "zipcode": "300120",
        "timezone": "+08:00",
        "refer": "douyacun.com"
    }
}
)
```



关键字