我的树莓派作为旁路由，代理所有经过的流量，包括自己发出的请求。
编辑 /etc/sysctl.conf 文件，将 net.ipv4.ip_forward=0 修改为 net.ipv4.ip_forward=1，然后执行 sysctl -p 以使配置生效
docker中开启privileged: true，并且clash中开启tun模式
version: '3'services: clash: image: dreamacro/clash-premium:latest container_name: clash volumes: - ./clash:/root/.config/clash restart: unless-stopped network_mode: "host" # or "host" on Linux privileged: true environment: - TZ=Asia/Shanghai另一个Linux主机不对内部应用进行代理。
开启网卡混杂模式
ip link set enp3s0 promisc on
创建macvlan网络
docker network create -d macvlan \ --subnet=192.168.1.0/24 \--gateway=192.168.1.1 \-o parent=enp3s0 \macvlan142version: '3'services: clash: image: dreamacro/clash-premium:latest container_name: clash_tun volumes: - ./clash:/root/.config/clash restart: unless-stopped networks: macvlan142: ipv4_address: 192.168.1.220 privileged: true environment: - TZ=Asia/Shanghainetworks: macvlan142: external: true 其他设备将网关改为192.168.1.220即可使用。
更改plugin/redirect_to_custom_server.py文件
class RedirectToCustomServerPlugin(HttpProxyBasePlugin): def before_upstream_connection( self, request: HttpParser, ) -> Optional[HttpParser]: # 原服务器地址 old_server = 'http://xxx:8088' # 新服务器地址 new_server = 'http://yyy:8088' url = str(request._url) if not request.is_https_tunnel and old_server in url : url = url.replace(old_server,new_server) request.set_url(url.encode('utf_8')) # Update Host header too, otherwise upstream can reject our request if request.has_header(b'Host') : request.del_header(b'Host') request.add_header( b'Host', urlparse.urlsplit( new_server.encode(), ).netloc, ) return request启动proxy.py服务
proxy --enable-web-server --plugins proxy.plugin.RedirectToCustomServerPlugin --hostname 0.0.0.0 --port 1080最后在Android端设置代理为当前服务即可实现IP地址的变更。
]]>查看可升级的版本yum --showduplicates list openssh先开启telnet防止网络问题导致远程连接失败，无法补救。
yum install telnet-server -yyum install telnet -ysystemctl enable telnet.socketsystemctl start telnet.socket编辑/etc/securetty文件，允许终端使用root用户登录
echo 'pts/0' >>/etc/securettyecho 'pts/1' >>/etc/securetty先备份配置文件
mv /etc/ssh/sshd_config /etc/ssh/sshd_config.$(date +%Y%m%d)编译的脚本可以参考boypt/openssh-rpms，在rpm包所在的目录执行rpm -ivh --force --nodeps --replacepkgs --replacefiles openssh-*.rpm
升级成功后，重启sshd服务，使用另外一个终端尝试是否能正常登录。
dnf -y install https://download1.rpmfusion.org/free/fedora/rpmfusion-free-release-$\(rpm -E %fedora).noarch.rpmintel核显也可以直接使用支持qsv的dockerffmpeg-qsv
ffmpeg -v error -i file.avi -f null - 输出到日志
ffmpeg -v error -i file.avi -f null - 2>error.logffmpeg -i file.mp4ffmpeg -i A.mp4 -vcodec libx264 -b:v 1500k -vf scale=1280:720 B.mp4ffmpeg -i 1.mp4 -vf scale=640:480 output.mp4ffmpeg -i 1.mp4 -vf scale=640:-2 output.mp4创建一个文本文件，列出要合并的视频文件。以下是一个示例：
首先，创建一个文本文件，比如 input.txt，内容如下：
file 'input1.mp4'file 'input2.mp4'可使用脚本生成
Windows:
(for %i in (*.wmv) do @echo file '%i') > input.txtLinux:
printf "file '%s'\n" *.wmv > input.txt然后，使用以下命令将这两个视频文件合并成一个：
ffmpeg -f concat -i input.txt -c copy output.mp4在这个例子中，input.txt 包含了要合并的视频文件列表。-f concat 告诉 FFmpeg 使用 concat 协议，-i input.txt 指定了输入文件，-c copy 告诉 FFmpeg 只进行复制而不重新编码，这样可以加快处理速度并且保持视频质量，最后的 output.mp4 是合并后的输出文件名。
ffmpeg -i input.iso -map 0:v:0 -map 0:a:0 -c copy output.mp4ffmpeg -ss 00:12:39.0 -i input.wmv -frames:v 1 /share/media/output.jpgffmpeg -ss 00:45:35 -to 00:57:47 -i input.mp4 -c copy test.mp4ffmpeg -i 视频地址 -c copy -bsf:a aac_adtstoasc output.mp4ffmpeg毕竟不是下载工具，下载也可以使用m3u8-downloader，支持更多参数。
推荐使用外挂字幕形式，合并成mkv格式
ffmpeg -i input.mp4 -i sub.srt -c copy output.mkv也可以使用mkvmerge进行处理
参考MKVToolNix 26.0.0 Released, How to Install it in Ubuntu进行安装
sudo sh -c 'echo "deb https://mkvtoolnix.download/ubuntu/ $(lsb_release -sc) main" >> /etc/apt/sources.list.d/bunkus.org.list'wget -q -O - https://mkvtoolnix.download/gpg-pub-moritzbunkus.txt | sudo apt-key add -sudo apt-get updatesudo apt-get install mkvtoolnix合并字幕，并且设置默认字幕为中文
mkvmerge -o merge/Game.of.Thrones.S02E08.mkv Game.of.Thrones.S02E08.mkv --language 0:chi Game.of.Thrones.S02E08.ass 隔行扫描的视频可以在转码阶段进行反交错处理
ffmpeg -i input.mp4 -vf yadif output.mp4若视频包含大量快速运动场景可使用mdeint、bwdif、mcdeint滤镜
VMAF是Netflix开发的视频质量评估算法，VMAF分值在0~100之间，越大越好，20分对应极差，100分对应极好。
查看libvmaf支持的参数
ffmpeg -h filter=libvmafn_threads为线程数，n_subsample抽样帧的间隔
ffmpeg -i '硬编码.mp4' -i '2023-10-10 17-06-09.mp4' -lavfi "[0:v][1:v]libvmaf=n_threads=4:n_subsample=10:log_fmt=json:log_path=vmaf_report.json" -f null -间隔五分钟
ffmpeg -skip_frame nokey -i input.mp4 -vf "fps=1/300,scale=320:-1,tile=4x4" -frames:v 1 output.jpg批量生成
for i in .mp4; do ffmpeg -skip_frame nokey -i “$i” -vf “fps=1/300,scale=320:-1,tile=4x4” -frames:v 1 “${i%.}-thumb.jpg”; done
单体应用，可以使用Jvm的锁，高效简单。
stackoverflow上有人提出了简单的解决方案：simple-java-name-based-locks
All those answers I see are way too complicated. Why not simply use:
public void executeInNamedLock(String lockName, Runnable runnable) { synchronized(lockName.intern()) { runnable.run(); }}The key point is the method intern: it ensures that the String returned is a global unique object, and so it can be used as a vm-instance-wide mutex. All interned Strings are held in a global pool, so that’s your static cache you were talking about in your original question. Don’t worry about memleaks; those strings will be gc’ed if no other thread references it. Note however, that up to and including Java6 this pool is kept in PermGen space instead of the heap, so you might have to increase it.
There’s a problem though if some other code in your vm locks on the same string for completely different reasons, but a) this is very unlikely, and b) you can get around it by introducing namespaces, e.g. executeInNamedLock(this.getClass().getName() + “_” + myLockName);
public void internLock(Integer id) { synchronized (String.valueOf(id).intern()) { biz(id); }}使用Java自带的synchronized进行锁ID，由于synchronized是基于对象进行加锁，不能保证同一个ID是一个Java对象，我们需要将ID转换为String，并放入常量池中，保证每个ID都是对应一个唯一的对象。关于intern的详细介绍，可以看美团技术团队写的深入解析String#intern
完整代码：
List<Integer> list = ImmutableList.of(10001, 10002, 10003, 10004, 10005, 10001, 10003, 10003); /** * 模拟5秒钟耗时操作 */ public void biz(Integer id) { try { Thread.sleep(5000); log.info("id:{}", id); } catch (InterruptedException e) { e.printStackTrace(); } } /** * 使用 String.intern * * @param id */ public void internLock(Integer id) { synchronized (String.valueOf(id).intern()) { biz(id); } } @Test public void testStringIntern() { log.info("使用 String.intern"); list.forEach(it -> new Thread(() -> internLock(it)).start()); }运行结果:
15:15:31.355 [Test worker] INFO LockTest - 使用 String.intern15:15:36.369 [Thread-21] INFO LockTest - id:1000215:15:36.369 [Thread-23] INFO LockTest - id:1000415:15:36.369 [Thread-27] INFO LockTest - id:1000315:15:36.369 [Thread-20] INFO LockTest - id:1000115:15:36.369 [Thread-24] INFO LockTest - id:1000515:15:41.377 [Thread-25] INFO LockTest - id:1000115:15:41.377 [Thread-22] INFO LockTest - id:1000315:15:46.387 [Thread-26] INFO LockTest - id:10003可以看出list中的前五个元素10001, 10002, 10003, 10004, 10005没有被阻塞，15:15:36时出的结果，第6个和第7个元素10001,100003被阻塞，耗时5秒钟。最后一个100003又被前一个100003阻塞，耗时5秒钟。从结果上看符合我们的预期。
使用 intern()有性能问题,可以用 guava 的 Interners.newWeakInterner()一个弱引用的内部常量池
具体代码:
Interner<Integer> pool = Interners.newWeakInterner();public void guavaInternLock(Integer id) { synchronized (pool.intern(id)) { biz(id); }}运行结果
15:15:11.339 [Test worker] INFO LockTest - 使用 Guava Interners15:15:16.357 [Thread-12] INFO LockTest - id:1000115:15:16.357 [Thread-13] INFO LockTest - id:1000215:15:16.358 [Thread-14] INFO LockTest - id:1000315:15:16.360 [Thread-15] INFO LockTest - id:1000415:15:16.360 [Thread-16] INFO LockTest - id:1000515:15:21.372 [Thread-19] INFO LockTest - id:1000315:15:21.372 [Thread-17] INFO LockTest - id:1000115:15:26.385 [Thread-18] INFO LockTest - id:10003如果想实现更细力度的锁，可以使用 JUC中的Lock，但是单纯使用Lock是无法区分id的，需要我们自己实现判重逻辑。可以使用Guava Striped很轻松实现该功能。
final Striped<Lock> striped = Striped.lock(10);public void stripedLock(Integer id) { Lock lock = striped.get(id); lock.lock(); try { biz(id); } finally { lock.unlock(); }}运行结果
15:14:51.323 [Test worker] INFO LockTest - 使用 Guava Striped15:14:56.339 [Thread-5] INFO LockTest - id:1000215:14:56.339 [Thread-7] INFO LockTest - id:1000415:14:56.339 [Thread-8] INFO LockTest - id:1000515:14:56.339 [Thread-4] INFO LockTest - id:1000115:14:56.339 [Thread-6] INFO LockTest - id:1000315:15:01.354 [Thread-9] INFO LockTest - id:1000115:15:01.354 [Thread-10] INFO LockTest - id:1000315:15:06.357 [Thread-11] INFO LockTest - id:10003由于分布式环境中，需要部署多个节点，上文提到的锁是基于单个JVM，不能保证同一时间某个资源只有一个线程访问，所以需要借助其他中间件。
关于Redis加锁的原理可以看我之前写的Redis进阶，我这里直接使用redisson封装好的工具。redisson借助lua脚本，实现了可重入锁、读写锁等多种锁。具体可参考分布式锁和同步器
private void redisLock(Integer id) { final RLock lock = RedisClient.INSTANCE.getLock(id.toString()); lock.lock(); try { biz(id); } finally { lock.unlock(); }}运行结果
2022-07-05 09:45:33 INFO (Thread-6 LockTest:76)- id:100032022-07-05 09:45:33 INFO (Thread-9 LockTest:76)- id:100012022-07-05 09:45:33 INFO (Thread-8 LockTest:76)- id:100052022-07-05 09:45:33 INFO (Thread-5 LockTest:76)- id:100022022-07-05 09:45:33 INFO (Thread-7 LockTest:76)- id:100042022-07-05 09:45:38 INFO (Thread-4 LockTest:76)- id:100012022-07-05 09:45:38 INFO (Thread-10 LockTest:76)- id:100032022-07-05 09:45:43 INFO (Thread-11 LockTest:76)- id:10003使用Pandas的read_sql方法通过sqlalchemy连接Clickhouse，需要安装clickhouse-sqlalchemy
使用pandahouse直接读取，返回DataFrame
推荐使用第一种方式，因为与我们平时连接数据库方式一致，无缝衔接，而且clickhouse-sqlalchemy一直在维护，pandahouse已经很久没更新了。
pip install clickhouse-sqlalchemyfrom sqlalchemy import create_engineimport pandas as pdclick_url = f'clickhouse+http://admin:paswd@localhost:8123/pro'engine = create_engine(click_url)fin_sql = '''select count(code) from finished'''pd.read_sql(fin_sql,con=engine)pip install pandahousefrom pandahouse import read_clickhouseconnection = dict(database='pro', host='localhost:8123', user='admin', password='paswd')df = read_clickhouse(fin_sql,connection=connection)2022-01-25 11:57:38,074 ERROR (AgentOutboundController.java:126)- nulljava.lang.NullPointerException: null查看日志时我以为代码中没有打印异常的详细信息，又查看了一遍代码
try { ...} catch (Exception ex) { log.error(ex.getMessage(), ex); return new Result<>(ex);}发现代码写的没什么问题，那么问题出在哪？
原来JVM对一些特定的异常类型做了Fast Throw优化，如果检测到在代码里某个位置连续多次抛出同一类型异常的话，异常栈信息会被清空。
在启动时配置-XX:-OmitStackTraceInFastThrow参数，即可关闭此优化。
配置好参数重启服务，日志恢复了正常：
2022-01-25 12:53:37,167 ERROR (AgentOutboundController.java:126)- nulljava.lang.NullPointerException: nullat com.example.production.api.service.AgentOutboundService.lambda$addOutboundCode$0(AgentOutboundService.java:388)at java.util.ArrayList.forEach(ArrayList.java:1259)将异常栈信息打印出来就可以看到到底是那行代码出现了问题了。
作为测试，我用Docker启动一个临时的容器
docker run --rm -it -p 1935:1935 -p 1985:1985 -p 8080:8080 \ ossrs/srs:3 ./objs/srs -c conf/srs.conf1935是rtmp协议的默认端口，视频推流时需要使用这个端口。
8080是HTTP协议的接口。
启动成功之后，我使用OBS进行推流测试。
推流成功后，可以使用VLC进行测试。
我这里使用的是rtmp协议获取数据，SRS也支持其他协议。
HTTP-FLV
http://192.168.1.200:8080/live/key.flv
HLS
http://192.168.1.200:8080/live/key.m3u8
流媒体协议 RTMP, HTTP-FLV, HLS 简单对比
paramiko正适合，看了看文档，不错，说干就干。先安装paramiko包
pip install paramiko密钥忘生成了，我这里使用git-bash带的命令进行生成，切记不要忘记备份原密钥。
ssh-keygen -o下面是对应的脚本，paramiko使用起来还是比较优雅的，简单看看就能理解。
import paramikoold_key = r'D:\tmp\id_rsa'new_key = r'C:\Users\ROOT\.ssh\id_rsa'new_pub_key = r'C:\Users\ROOT\.ssh\id_rsa.pub'def ssh_key(host:str): # 密钥 pkey = paramiko.RSAKey.from_private_key_file(old_key) # 使用transport实现执行多个操作 trans = paramiko.Transport((host, 22)) trans.connect(username='root', pkey=pkey) ssh = paramiko.SSHClient() # 将sshclient的对象的transport指定为以上的trans ssh._transport = trans # 使用sftp上传文件 sftp = paramiko.SFTPClient.from_transport(trans) sftp.put(localpath=new_pub_key, remotepath='/root/.ssh/authorized_keys') sftp.put(localpath=new_key, remotepath='/root/.ssh/id_rsa') stdin, stdout, stderr = ssh.exec_command('systemctl restart sshd') print(stdout.read().decode()) trans.close()if __name__ == '__main__': ssh_key('192.168.1.200')脚本运行之后，试试能不能登录上，登不上去那就。。。
数据样本
import pandas as pddf = pd.read_csv(r'tmp\draw.csv')df| draw_date | weixin_id | |
|---|---|---|
| 0 | 2021-05-25 | 751478029716439040 |
| 1 | 2021-05-28 | 751478029716439040 |
| 2 | 2021-06-08 | 751478029716439040 |
| 3 | 2021-06-09 | 751478029716439040 |
| 4 | 2021-06-15 | 639062248681259008 |
| 5 | 2021-06-16 | 639062248681259008 |
| 6 | 2021-06-17 | 639062248681259008 |
| 7 | 2021-06-18 | 639062248681259008 |
| 8 | 2021-06-19 | 639062248681259008 |
| 9 | 2021-06-21 | 639062248681259008 |
样本中数据是字符串，我先将日期转成对应的格式
df['draw_date'] = pd.to_datetime(df['draw_date'])我这里使用shift将日期下移一位，再加上一天和相邻数据进行比较，目的是判断前后两条时间间隔是否相差1天，不相等记为True反之为False
import datetimefor name,group in df.groupby('weixin_id'): check = ((group['draw_date'].shift(1) + datetime.timedelta(1)) != group['draw_date']) print(check)4 True5 False6 False7 False8 False9 TrueName: draw_date, dtype: bool0 True1 True2 True3 FalseName: draw_date, dtype: bool用cumsum窗口函数，对上文提到的标记按照行累加，标记为False的情况不会计算
for name,group in df.groupby('weixin_id'): check = ((group['draw_date'].shift(1) + datetime.timedelta(1)) != group['draw_date']) cumsum = check.cumsum() print(cumsum)4 15 16 17 18 19 2Name: draw_date, dtype: int320 11 22 33 3Name: draw_date, dtype: int32用value_counts对上文累计的数据进行分组计数，可以算出每段时间的间隔天数，按照我们的需求取最大的即可
for name,group in df.groupby('weixin_id'): check = ((group['draw_date'].shift(1) + datetime.timedelta(1)) != group['draw_date']) cumsum = check.cumsum() value_counts = cumsum.value_counts() print(value_counts) 1 52 1Name: draw_date, dtype: int643 22 11 1Name: draw_date, dtype: int64上边的循环代码可以用agg替代
import datetimedf.groupby('weixin_id').agg( lambda group: ((group.shift(1) + datetime.timedelta(1)) != group).cumsum().value_counts().max())| draw_date | |
|---|---|
| weixin_id | |
| 639062248681259008 | 5 |
| 751478029716439040 | 2 |
前后数据比较也可直接使用diff函数，该函数可算出前后两条数据相减的结果
df.groupby('weixin_id').agg( lambda group : group.diff(1).map( lambda d:d.days - 1).fillna(0).cumsum().value_counts().max() )| draw_date | |
|---|---|
| weixin_id | |
| 639062248681259008 | 5 |
| 751478029716439040 | 2 |
项目用到ES做统计，需要同步Mysql数据到ES中，我们使用Logstash进行同步，Logstash安装需要依赖的包比较多，我为了方便直接使用Docker进行操作。
首先要编写同步数据的配置文件，从Mysql同步数据到ElasticSearch中，使用jdbc里连接数据库作为input，ouput为ES。
input { stdin { } jdbc { #注意mysql连接地址一定要用ip，不能使用localhost等 jdbc_connection_string => "jdbc:mysql://192.168.1.200:3308/test" jdbc_user => "test" jdbc_password => "test" #这个jar包的地址是容器内的地址 jdbc_driver_library => "/usr/share/logstash/pipeline/mysql-connector-java-8.0.11.jar" jdbc_driver_class => "com.mysql.jdbc.Driver" jdbc_paging_enabled => "true" jdbc_page_size => "5000" statement => "SELECT * FROM base_areas where id > :sql_last_value" tracking_column => id use_column_value => true last_run_metadata_path => "/usr/share/logstash/pipeline/area" schedule => "* * * * *" } } output { stdout { codec => json_lines } elasticsearch { hosts => "192.168.1.200:9200" index => "area" document_type => "_doc" document_id => "%{id}" }}重点在于 use_column_value 和 tracking_column 这两个参数，当use_column_value为true时，可以用 :sql_last_value 这个变量来获取tracking_column对应的字段的最新值，默认即第一次启动时为 0 。我的示例中tracking_column对应id，即Logstash都会记录每次查询结果id的最大值，供下一次查询使用。
Logstash将tracking_column的最新值记录到last_run_metadata_path配置的文件，启动时读取该文件
docker run -it -v $PWD/pipeline/:/usr/share/logstash/pipeline -v $PWD/logstash.yml:/usr/share/logstash/config/logstash.yml -v $PWD/pipelines.yml:/usr/share/logstash/config/pipelines.yml logstash:6.4.3 bash先安装jdbc和es的插件
bash-4.2$ ~/bin/logstash-plugin install logstash-input-jdbcValidating logstash-input-jdbcInstalling logstash-input-jdbcInstallation successfulbash-4.2$ ~/bin/logstash-plugin install logstash-output-elasticsearchValidating logstash-output-elasticsearchInstalling logstash-output-elasticsearchInstallation successful由于是在容器内部连接服务，所以ES的连接不要使用localhost和127.0.0.1，更改为实际IP地址
bash-4.2$ cat ~/config/logstash.yml http.host: "0.0.0.0"xpack.monitoring.elasticsearch.url: http://192.168.1.200:9200运行同步脚本可手动执行也可以配置调度执行
~/bin/logstash -f ***.config
调度任务可读取配置文件config/pipelines.yml，默认有一个main，/usr/share/logstash/pipeline为pipeline的存放路径，该文件夹内的pipeline都会被执行。
可手动更改该文件，添加id和config即可。
bash-4.2$ cat ~/config/pipelines.yml - pipeline.id: main path.config: "/usr/share/logstash/pipeline"好，配置已完成，运行/usr/local/bin/docker-entrypoint启动调度任务
logstash是ES官方提供的工具，支持扩展多，配置灵活，但是只能同步增量数据，对于源数据删除和修改的情况，logstash无能为力，还有基于定时任务同步无法保证实时，对实时性要求高的场景要考虑其他方案。
关于RabbitMQ配置和对接可以看我之前写的一篇Canal推送Mysql增量数据至RabbitMQ。
编辑adapter/conf/application.yml,配置rabbitMQ信息
canal.conf: mode: rabbitMQ #tcp kafka rocketMQ rabbitMQ consumerProperties: # rabbitMQ consumer rabbitmq.host: 127.0.0.1 rabbitmq.virtual.host: / rabbitmq.username: root rabbitmq.password: root rabbitmq.resource.ownerId: srcDataSources: defaultDS: url: jdbc:mysql://remote:3306/test?useUnicode=true username: root password: root编辑adapter/conf/application.yml,配置canalAdapters同步es6，队列使用canal.es
canalAdapters: - instance: canal.es # canal instance Name or mq topic name groups: - groupId: g1 outerAdapters: - name: es6 hosts: 127.0.0.1:9200 # 127.0.0.1:9200 for rest mode properties: mode: rest # or rest # security.auth: test:123456 # only used for rest mode cluster.name: elasticsearchcanal会扫描adapter/conf/es6/下的所有配置文件，其中信息要和adapter/conf/application.yml匹配
cat ./adapter/conf/es6/scan_log.yml
dataSourceKey: defaultDSdestination: canal.esgroupId: g1esMapping: _index: scan_log _type: _doc _id: id sql: "select id, code, casecode from scan_log" commitBatch: 3000新版ES提倡使用_doc作为_type，我们这里使用Mysql表名作为ES的index，建立mapping
PUT /scan_log { "mappings":{ "_doc":{ "properties":{ "code":{ "type":"long" }, "casecode" : { "type" : "text", "fields" : { "keyword" : { "type" : "keyword", "ignore_above" : 256 } } } } } }}我们也可以通过Logstash帮我们自动创建mapping,Logstash可以根据json格式创建mapping，关于Logstash可以看我之前写的文章使用Logstash同步Mysql数据到Elasticsearch
使用generator方式生成json
cat logstash-sample.conf input { generator { count => 1 message => ' { "id": 628247969266810880, "code": 2199023788471, "casecode": "999STZPMDDV" }' codec => json }}output { elasticsearch { hosts => ["http://localhost:9200"] index => "scan_log" document_type => "_doc" document_id => "%{id}" }}mapping创建完成后，我们启动项目，日志中发现这个错误
Load canal adapter: es6 failed出现问题的不只我一个，#3466中有人提出解决方案，使用canal.adapter-1.1.5-SNAPSHOT.tar.gz版本中的client-adapter.es6x-1.1.5-SNAPSHOT-jar-with-dependencies.jar替换现版本中的client-adapter.es6x-1.1.5-jar-with-dependencies.jar，完美解决。
adapter支持通过REST接口的方式导入全量数据
# 先暂停同步curl http://127.0.0.1:8081/syncSwitch/canal.escurl http://127.0.0.1:8081/syncSwitch/canal.es/off -X PUT# 全量导入curl http://127.0.0.1:8081/etl/es6/scan_log.yml -X POST# 恢复同步curl http://127.0.0.1:8081/syncSwitch/canal.es/on -X PUT路径中的scan_log.yml为adapter/conf/es6/下的配置
Canal提供了对关系型数据库的支持，虽然ClickHouse不是关系型数据库，但是可以兼容部分SQL语句(select,insert等)，我很可以对增量数据进行同步。由于提供的包内不包含ClickHouse的JDBC驱动，我们去下载必要的jar包(lz4-1.3.0.jar,clickhouse-jdbc-0.2.4.jar,httpclient-4.3.3.jar,httpcore-4.4.13.jar)并放入canal/adapter/lib内。
我将数据分别同步到Mysql和ClickHouse中，防止相互干扰我这里使用了两个队列，两个instance分别从不同的队列中消费消息。
编辑 adapter/conf/application.yml
canalAdapters: - instance: canal.mysql # canal instance Name or mq topic name groups: - groupId: g1 outerAdapters: - name: rdb key: mysql1 properties: jdbc.driverClassName: com.mysql.jdbc.Driver jdbc.url: jdbc:mysql://localhost:3306/test?useUnicode=true&serverTimezone=Asia/Shanghai jdbc.username: root jdbc.password: root - instance: canal.clickhouse # canal instance Name or mq topic name groups: - groupId: g1 outerAdapters: #- name: logger - name: rdb key: clickhouse properties: jdbc.driverClassName: ru.yandex.clickhouse.ClickHouseDriver jdbc.url: jdbc:clickhouse://127.0.0.1:8123/pro jdbc.username: jdbc.password:编辑MySQL的配置文件 adapter/conf/rdb/scan_log.yml
dataSourceKey: defaultDSdestination: canal.mysqlgroupId: g1outerAdapterKey: mysql1concurrent: truedbMapping: database: pro table: scan_log targetTable: scan_log targetPk: id: id mapAll: true编辑ClickHouse的配置文件 adapter/conf/rdb/ch_scan_log.yml
dataSourceKey: defaultDSdestination: canal.clickhousegroupId: g1outerAdapterKey: clickhouseconcurrent: truedbMapping: database: pro table: scan_log targetTable: scan_log targetPk: id: id mapAll: truedatax Unknown system variable 'tx_read_only'The connection property 'zeroDateTimeBehavior' acceptable values are: 'CONVERT_TO_NULL', 'EXCEPTION' or 'ROUND'. The value 'convertToNull' is not acceptable.由于我使用的是Mysql8，需要更新mysql驱动8.0.13以上版本。
下载mysql-connector-java-8.0.22.jar放入lib中即可
还有同步clickhouse时，update和delete语句会报错，因为clickhouse的语法并不是完全兼容关系型数据库，我这里只对增量表进行了同步。
Mysql通过REST接口的方式导入全量数据
curl http://127.0.0.1:8081/etl/rdb/mysql1/scan_log.yml由于语法兼容性问题ClickHouse不能使用这种方式，同步全量数据我使用的是DataX，细节方面可以参考DataX同步全量Mqsql数据到Elasticsearch这篇。
工作原理
从v1.1.5版本开始，Canal新增对RabbitMQ的支持。
canal需要Mysql端开启二进制日志同步，我使用的阿里云的Mysql，默认已开启binlog dump。
RabbitMQ我使用Docker部署，注意镜像要使用带management版本的，方便在界面操作。
docker run --name rabbitmq -d -p 15672:15672 -p 5672:5672 -e RABBITMQ_DEFAULT_USER=root -e RABBITMQ_DEFAULT_PASS=root rabbitmq:3.8.2-managementRabbitMQ的Exchange,Queue,Binding也要优先配置好，我的需求是canal解析完Mysql的binlog后，将信息分别推送到3个队列中，我这里为了隔离环境建3个队列，分别是同步Elasticsearch的canal.es，同步ClickHouse的canal.clickhouse和同步Mysql的canal.mysql。因为是无差别投放，我只创建了一个交换机canal。将3个队列canal.es、canal.clickhouse、canal.mysql绑定到交换机canal上。
编辑deployer/conf/example/instance.properties
# 我这里使用了gtid日志进行同步canal.instance.gtidon=truecanal.instance.master.address=localhost:3306canal.instance.dbUsername=rootcanal.instance.dbPassword=root# 这里配置发送消息的主题，由于3队列接收全部数据，所以此处主题我没有用到，使用的默认值canal.mq.topic=example编辑deployer/conf/canal.properties
# 此处更改为rabbitmq模式canal.serverMode = rabbitmqrabbitmq.host = 127.0.0.1rabbitmq.virtual.host = /rabbitmq.exchange = canalrabbitmq.username = rootrabbitmq.password = root# 消息持久化rabbitmq.deliveryMode = 2运行 bin/startup.sh ，服务便开始运行了
由于三个队列需要同步的数据库不同，无差别投放会造成不必要的性能浪费，可开启dynamicTopic功能，根据topic将数据投放至不同的队列。
编辑deployer/conf/example/instance.properties
canal.mq.dynamicTopic=pro\\..*投递的topic为库名_表名
Exchanges和Queues的绑定关系在RebbitMQ的后台配置即可，模式选择Topic模式。
XPath基于XML的树状结构，提供在数据结构树中找寻节点的能力。起初XPath的提出的初衷是将其作为一个通用的、介于XPointer与XSL间的语法模型。但是XPath很快的被开发者采用来当作小型查询语言。
| 表达式 | 描述 |
|---|---|
| nodename | 选取此节点的所有子节点 |
| / | 从根节点选取 |
| // | 从匹配选择的当前节点选择文档中的节点，而不考虑它们的位置 |
| . | 选取当前节点 |
| .. | 选取当前节点的父节点 |
| @ | 选取属性 |
python使用lxml进行解析
from lxml import etreehtml=etree.parse('d:/github.html',etree.HTMLParser(encoding="utf-8"))result = html.xpath('''//*[@id="org-repositories"]/div[1]/div/ul/li[1]/div[1]/div[1]/h3/a/@href''')for row in result: print(row)scrapy框架也支持xpath解析
proxy = {'http': 'http://dev:7890','https': 'http://dev:7890'}resp = requests.get(base_url,verify=False,proxies=proxy)# %%print(resp.text)# %%from scrapy.selector import Selectorfrom scrapy.http import HtmlResponseresponse = Selector(text=resp.text)for elem in response.xpath('//*[@id="main"]/article'): title = elem.xpath('string(./header/h1/a)').extract_first() url = elem.xpath('./header/h1/a/@href').extract_first()next = response.xpath('//a[@rel="next"]/@href').extract_first()Java可以使用htmlcleaner解析HTML
<dependency> <groupId>net.sourceforge.htmlcleaner</groupId> <artifactId>htmlcleaner</artifactId> <version>2.6.1</version></dependency>我这里代码使用Groovy写的，和Java写法有点差异
HtmlCleaner hc = new HtmlCleaner()def node = hc.clean(new File("d:/github.html"))println node.getElementsByName("title",true)println node.evaluateXPath("//*[@id=\"org-repositories\"]/div[1]/div/ul/li[*]/div[1]/div[1]/h3/a/@href")我们可以通过Chrome的开发这工具来获取xpath，但这种方式获取的xpath不是很友好，只是单纯的将所有的路径都显示出来。
可以安装
EasySelect这个Chrome扩展，可以很方便取到我们想要的数据。
再安利一个小工具，可根据curl命令生成代码。
Convert curl syntax to Python
Apache Curator是Netflix公司开源的一个Zookeeper客户端，与Zookeeper提供的原生客户端相比，Curator的抽象层次更高，简化了Zookeeper客户端的开发量。Patrixck Hunt（Zookeeper committer）以一句 Guava is to Java what Curator is to Zookeeper 给予高度评价。
Watcher watcher = new Watcher() { @Override public void process(WatchedEvent watchedEvent) { log.info("监听到的变化 watchedEvent = " + watchedEvent); }};byte[] content = curatorFramework.getData() .usingWatcher(watcher).forPath('/path');log.info("监听节点内容：" + new String(content));// 变更节点数据curatorFramework.setData().forPath(workerPath, "Change".getBytes());Thread.sleep(Integer.MAX_VALUE);Watcher监听器是一次性的，可以在事件触发之后重复订阅
Watcher watcher = null;watcher = new Watcher() { @Override public void process(WatchedEvent watchedEvent) { curatorFramework.getData() .usingWatcher(watcher).forPath('/path') log.info("监听到的变化 watchedEvent = " + watchedEvent); }};Curator引入了Cache来方便我们订阅事件。
我这里用NodeCache举例子
NodeCache nodeCache = new NodeCache(curatorFramework, workerPath);nodeCache.start();NodeCacheListener listener = new NodeCacheListener() { @Override public void nodeChanged() throws Exception { ChildData childData = nodeCache.getCurrentData(); log.info("ZNode Change, data={}", new String(childData.getData(), "Utf-8")); }};nodeCache.getListenable().addListener(listener);// 变更节点数据curatorFramework.setData().forPath(workerPath, "Change1".getBytes());Thread.sleep(1000L)curatorFramework.setData().forPath(workerPath, "Change2".getBytes());Thread.sleep(1000L)curatorFramework.setData().forPath(workerPath, "Change3".getBytes());Thread.sleep(10_000L);我们项目使用微服务技术对原有服务进行拆分，将接口分散到不同服务中，并将网关独立出来。服务端一部分接口需要登录才可以访问，网关需要对这部分接口和TOKEN进行校验。但是我们对需登录的接口的标记是基于注解的，方便切面拦截。拆分服务后网关是不知道哪些接口是需要校验的，最后我们借助了ZK来实现，下游服务发布时扫描代码中的接口，将需要登录的接口set到ZK中，网关启动时从ZK节点中取数据保存到内存中并订阅该节点，每次下游服务发布时触发事件，更新网关中的数据。
Python2和Python3很多语法不兼容，开发环境难免安装多个版本的Python，即使使用同一个版本Python不同项目使用不同版本的第三方包也会导致各种问题，所以开发Python都会使用虚拟环境，不同项目使用不同的环境，其实我们也可以使用Docker将不同的环境进行区分。.├── app.py├── Dockerfile|── .gitignore└── requirements.txt这是一个简单的python项目目录，只有一个app.py，运行一个基于Flask编写的web服务，requirements.txt是运行该项目所需要的依赖。启动项目前我们先通过pip install -r requirements.txt安装必要依赖，python3 app.py启动项目。
app.py
from flask import Flaskapp = Flask(__name__)@app.route('/')def hello_world(): return 'Hello, World!'if __name__ == "__main__": app.run(debug=True,host='0.0.0.0',port=80) 现在我们创建一个容器，在容器内完成以上步骤。
FROM python:3.6# 设置工作目录WORKDIR /app# 将当前目录的所有文件复制到工作目录内ADD . /app# 安装依赖RUN pip install -r requirements.txt -i https://mirrors.aliyun.com/pypi/simple/# 启动CMD ["python", "app.py"]构建镜像
docker build -t py-test .运行
docker run -p 9089:80 --name=py-test py-test* Serving Flask app "app" (lazy loading)* Environment: production WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead.* Debug mode: on* Running on http://0.0.0.0:80/ (Press CTRL+C to quit)好了，容器启动成功，但是这种部署方式有一个不灵活的点就是我们的代码是在容器构建的时候COPY到容器内部的，导致我们更新代码时需要重新构建容器。其实我们还可以通过volume将我们的代码挂载在容器内部，容器执行的其实是宿主机上的代码。
FROM python:3.6# 设置工作目录WORKDIR /app# 将requirements.txt复制到工作目录，方便操作ADD ./requirements.txt /app/requirements.txt# 安装依赖RUN pip install -r requirements.txt -i https://mirrors.aliyun.com/pypi/simple/# 启动CMD ["python", "app.py"]启动容器时指定挂载路径，将我们当前目录挂载到/app
docker run -p 9089:80 -v $PWD/:/app -d --name=py-test py-test;我是以DEBUG方式启动的web服务，如代码有变更，服务会自动加载，我们现在更改一下app.py的代码保存一下，可以看到服务器自动重启了
* Detected change in '/app/app.py', reloading* Restarting with stat* Debugger is active!* Debugger PIN: 286-043-277sshtunnel这个库来实现。from sshtunnel import SSHTunnelForwarderimport recordswith SSHTunnelForwarder( ('jump-server', 22), ssh_username="root", ssh_pkey=r"C:\Users\LH\.ssh\id_rsa", remote_bind_address=('target-server', 3306), local_bind_address=('127.0.0.1', 3306) ) as server: db = records.Database(f'mysql+pymysql://root:pwd@{server.local_bind_address[0]}:{server.local_bind_address[1]}/code') result = db.query('select name from base_areas limit 3') print(result.as_dict())@Autowiredprivate DataSourceTransactionManager dstManager;@Autowiredprivate UserDao userDao;public void updateTest(){ DefaultTransactionDefinition def = new DefaultTransactionDefinition(); def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW); TransactionStatus transaction= dstManager.getTransaction(def); try{ userDao.updateTest(); }catch(Exception e){ log.error(e.toString(),e); dstManager.rollback(transaction); } dstManager.commit(transaction);}DataSourceTransactionManager是PlatformTransactionManager的一个实现。PlatformTransactionManager是Spring事务处理抽象层中的管理器。
统一一致的事务抽象是Spring框架的一大优势，无论是全局事务还是本地事务，JTA、JDBC、Hibernate还是JPA，Spring都使用统一的编程模型，使得应用程序可以很容易地在全局事务与本地事务，或者不同的事务框架之间进行切换。下图是Spring事务抽象的核心类图：
PlatformTransactionManager：事务管理器
getTransaction方法：事务获取操作，根据事务属性定义，获取当前事务或者创建新事物；
commit方法：事务提交操作，注意这里所说的提交并非直接提交事务，而是根据当前事务状态执行提交或者回滚操作；
rollback方法：事务回滚操作，同样，也并非一定直接回滚事务，也有可能只是标记事务为只读，等待其他调用方执行回滚。
TransactionDefinition：事务属性定义
getPropagationBehavior方法：返回事务的传播属性，默认是PROPAGATION_REQUIRED；
getIsolationLevel方法：返回事务隔离级别，事务隔离级别只有在创建新事务时才有效，也就是说只对应传播属性PROPAGATION_REQUIRED和PROPAGATION_REQUIRES_NEW；
getTimeout方法：返回事务超时时间，以秒为单位，同样只有在创建新事务时才有效；
isReadOnly方法：是否优化为只读事务，支持这项属性的事务管理器会将事务标记为只读，只读事务不允许有写操作，不支持只读属性的事务管理器需要忽略这项设置，这一点跟其他事务属性定义不同，针对其他不支持的属性设置，事务管理器应该抛出异常。
getName方法：返回事务名称，声明式事务中默认值为“类的完全限定名.方法名”。
TransactionStatus：当前事务状态
isNewTransaction方法：当前方法是否创建了新事务（区别于使用现有事务以及没有事务）；
hasSavepoint方法：在嵌套事务场景中，判断当前事务是否包含保存点；
setRollbackOnly和isRollbackOnly方法：只读属性设置（主要用于标记事务，等待回滚）和查询；
flush方法：刷新底层会话中的修改到数据库，一般用于刷新如Hibernate/JPA的会话，是否生效由具体事务资源实现决定；
isCompleted方法：判断当前事务是否已完成（已提交或者已回滚）。
public final TransactionStatus getTransaction(@Nullable TransactionDefinition definition) throws TransactionException { // 创建DataSourceTransactionObjectObject transaction = doGetTransaction();// Cache debug flag to avoid repeated checks.boolean debugEnabled = logger.isDebugEnabled();if (definition == null) {// Use defaults if no transaction definition given.definition = new DefaultTransactionDefinition();} // 已有事务逻辑，通过handleExistingTransaction方法处理if (isExistingTransaction(transaction)) {// Existing transaction found -> check propagation behavior to find out how to behave.return handleExistingTransaction(definition, transaction, debugEnabled);}// Check definition settings for new transaction.if (definition.getTimeout() < TransactionDefinition.TIMEOUT_DEFAULT) {throw new InvalidTimeoutException("Invalid transaction timeout", definition.getTimeout());} // 以下是当前无事务的情况 // - PROPAGATION_MANDATORY：当前事务不存在，抛出异常// No existing transaction found -> check propagation behavior to find out how to proceed.if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_MANDATORY) {throw new IllegalTransactionStateException("No existing transaction found for transaction marked with propagation 'mandatory'");} // 无事务便创建事务else if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRED ||definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW ||definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {SuspendedResourcesHolder suspendedResources = suspend(null);if (debugEnabled) {logger.debug("Creating new transaction with name [" + definition.getName() + "]: " + definition);}try {boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);DefaultTransactionStatus status = newTransactionStatus(definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);doBegin(transaction, definition);prepareSynchronization(status, definition);return status;}catch (RuntimeException | Error ex) {resume(null, suspendedResources);throw ex;}} // 无事务不需创建else {// Create "empty" transaction: no actual transaction, but potentially synchronization.if (definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT && logger.isWarnEnabled()) {logger.warn("Custom isolation level specified but no actual transaction initiated; " +"isolation level will effectively be ignored: " + definition);}boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);return prepareTransactionStatus(definition, null, true, newSynchronization, debugEnabled, null);}}org.springframework.jdbc.datasource.DataSourceTransactionManager#doGetTransactionprotected Object doGetTransaction() {DataSourceTransactionObject txObject = new DataSourceTransactionObject();txObject.setSavepointAllowed(isNestedTransactionAllowed());ConnectionHolder conHolder =(ConnectionHolder) TransactionSynchronizationManager.getResource(obtainDataSource());txObject.setConnectionHolder(conHolder, false);return txObject;}org.springframework.jdbc.datasource.DataSourceTransactionManager#isExistingTransactionprotected boolean isExistingTransaction(Object transaction) {DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;return (txObject.hasConnectionHolder() && txObject.getConnectionHolder().isTransactionActive());}TransactionSynchronizationManager 是事务同步管理器，TransactionSynchronizationManager通过ThreadLocal对象在当前线程记录了resources和synchronizations属性。resources是一个HashMap，用于记录当前参与事务的事务资源，方便进行事务同步，在DataSourceTransactionManager的例子中就是以dataSource作为key，保存了数据库连接，这样在同一个线程中，不同的方法调用就可以通过dataSource获取相同的数据库连接，从而保证所有操作在一个事务中进行。
org.springframework.transaction.support.AbstractPlatformTransactionManager#handleExistingTransaction
private TransactionStatus handleExistingTransaction(TransactionDefinition definition, Object transaction, boolean debugEnabled)throws TransactionException { // PROPAGATION_NEVER 直接抛出异常if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NEVER) {throw new IllegalTransactionStateException("Existing transaction found for transaction marked with propagation 'never'");} // PROPAGATION_NOT_SUPPORTED suspend挂起当前事务，当前方法不使用事务if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NOT_SUPPORTED) {if (debugEnabled) {logger.debug("Suspending current transaction");}Object suspendedResources = suspend(transaction);boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);return prepareTransactionStatus(definition, null, false, newSynchronization, debugEnabled, suspendedResources);} // PROPAGATION_REQUIRES_NEW suspend挂起当前事务，doBegin创建一个新事务if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW) {if (debugEnabled) {logger.debug("Suspending current transaction, creating new transaction with name [" +definition.getName() + "]");}SuspendedResourcesHolder suspendedResources = suspend(transaction);try {boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);DefaultTransactionStatus status = newTransactionStatus(definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);doBegin(transaction, definition);prepareSynchronization(status, definition);return status;}catch (RuntimeException | Error beginEx) {resumeAfterBeginException(transaction, suspendedResources, beginEx);throw beginEx;}} // PROPAGATION_NESTED 嵌套事务if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {if (!isNestedTransactionAllowed()) {throw new NestedTransactionNotSupportedException("Transaction manager does not allow nested transactions by default - " +"specify 'nestedTransactionAllowed' property with value 'true'");}if (debugEnabled) {logger.debug("Creating nested transaction with name [" + definition.getName() + "]");}if (useSavepointForNestedTransaction()) {// Create savepoint within existing Spring-managed transaction,// through the SavepointManager API implemented by TransactionStatus.// Usually uses JDBC 3.0 savepoints. Never activates Spring synchronization.DefaultTransactionStatus status =prepareTransactionStatus(definition, transaction, false, false, debugEnabled, null);status.createAndHoldSavepoint();return status;} // PROPAGATION_REQUIRED、PROPAGATION_SUPPORTS、PROPAGATION_MANDATORY 使用当前事务else {// Nested transaction through nested begin and commit/rollback calls.// Usually only for JTA: Spring synchronization might get activated here// in case of a pre-existing JTA transaction.boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);DefaultTransactionStatus status = newTransactionStatus(definition, transaction, true, newSynchronization, debugEnabled, null);doBegin(transaction, definition);prepareSynchronization(status, definition);return status;}}// Assumably PROPAGATION_SUPPORTS or PROPAGATION_REQUIRED.if (debugEnabled) {logger.debug("Participating in existing transaction");}if (isValidateExistingTransaction()) {if (definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT) {Integer currentIsolationLevel = TransactionSynchronizationManager.getCurrentTransactionIsolationLevel();if (currentIsolationLevel == null || currentIsolationLevel != definition.getIsolationLevel()) {Constants isoConstants = DefaultTransactionDefinition.constants;throw new IllegalTransactionStateException("Participating transaction with definition [" +definition + "] specifies isolation level which is incompatible with existing transaction: " +(currentIsolationLevel != null ?isoConstants.toCode(currentIsolationLevel, DefaultTransactionDefinition.PREFIX_ISOLATION) :"(unknown)"));}}if (!definition.isReadOnly()) {if (TransactionSynchronizationManager.isCurrentTransactionReadOnly()) {throw new IllegalTransactionStateException("Participating transaction with definition [" +definition + "] is not marked as read-only but existing transaction is");}}}boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);return prepareTransactionStatus(definition, transaction, false, newSynchronization, debugEnabled, null);}我们先进行一个必要的bean配置。
@Configuration@MapperScan(basePackages = { "com.xxx.goods.dao" }, sqlSessionFactoryRef = "goodsSqlSessionFactory")public class GoodsDataSourceConfig { @Resource private Environment env; @Bean(name = "goodsDataSource") @ConfigurationProperties(prefix = "spring.datasource.goods") public DataSource initDataSource() { return DataSourceBuilder.create().build(); } @Bean(name = "goodsTransactionManager") @Primary public DataSourceTransactionManager transactionManager(DataSource dataSource) { return new DataSourceTransactionManager(dataSource); } @Bean(name = "goodsSqlSessionFactory") @Primary public SqlSessionFactory initSqlSessionFactory(DataSource dataSource) throws Exception { final SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean(); sessionFactory.setDataSource(dataSource); sessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver() .getResources(env.getProperty("mybatis.goods.mapper-locations"))); return sessionFactory.getObject(); }}我这里引用Mybatis官方文档中的说明
SqlSessionFactory SqlSessionFactory 一旦被创建就应该在应用的运行期间一直存在，没有任何理由丢弃它或重新创建另一个实例。 使用 SqlSessionFactory 的最佳实践是在应用运行期间不要重复创建多次，多次重建 SqlSessionFactory 被视为一种代码“坏习惯”。因此 SqlSessionFactory 的最佳作用域是应用作用域。 有很多方法可以做到，最简单的就是使用单例模式或者静态单例模式。SqlSession 每个线程都应该有它自己的 SqlSession 实例。SqlSession 的实例不是线程安全的，因此是不能被共享的，所以它的最佳的作用域是请求或方法作用域。 绝对不能将 SqlSession 实例的引用放在一个类的静态域，甚至一个类的实例变量也不行。 也绝不能将 SqlSession 实例的引用放在任何类型的托管作用域中，比如 Servlet 框架中的 HttpSession。 如果你现在正在使用一种 Web 框架，考虑将 SqlSession 放在一个和 HTTP 请求相似的作用域中。 换句话说，每次收到 HTTP 请求，就可以打开一个 SqlSession，返回一个响应后，就关闭它。 这个关闭操作很重要，为了确保每次都能执行关闭操作，你应该把这个关闭操作放到 finally 块中。 下面的示例就是一个确保 SqlSession 关闭的标准模式：try (SqlSession session = sqlSessionFactory.openSession()) { // 你的应用逻辑代码}Mapper 映射器是一些绑定映射语句的接口。映射器接口的实例是从 SqlSession 中获得的。虽然从技术层面上来讲，任何映射器实例的最大作用域与请求它们的 SqlSession 相同。但方法作用域才是映射器实例的最合适的作用域。 也就是说，映射器实例应该在调用它们的方法中被获取，使用完毕之后即可丢弃。 映射器实例并不需要被显式地关闭。尽管在整个请求作用域保留映射器实例不会有什么问题，但是你很快会发现，在这个作用域上管理太多像 SqlSession 的资源会让你忙不过来。 因此，最好将映射器放在方法作用域内。就像下面的例子一样：try (SqlSession session = sqlSessionFactory.openSession()) { BlogMapper mapper = session.getMapper(BlogMapper.class); // 你的应用逻辑代码}依赖注入框架可以创建线程安全的、基于事务的 SqlSession 和映射器，并将它们直接注入到你的 bean 中，因此可以直接忽略它们的生命周期。
@Servicepublic class UserService { @Autowired private UserMapper userMapper;}我们分析一下Mybatis-Spring如何做到的
Mybatis配置时我们使用了@MapperScan注解，底层会使用MapperScannerConfigurer进行扫描并将Mapper注册到Spring容器中，核心代码要看org.mybatis.spring.mapper.ClassPathMapperScanner#processBeanDefinitions这个方法。
private void processBeanDefinitions(Set<BeanDefinitionHolder> beanDefinitions) { GenericBeanDefinition definition; for (BeanDefinitionHolder holder : beanDefinitions) { definition = (GenericBeanDefinition) holder.getBeanDefinition(); // 这两句代码时关键，这里将 beanClass 进行了重新设置，设置为了 MapperFactoryBean，并且将原来接口 class 设置为构造方法参数 definition.getConstructorArgumentValues().addGenericArgumentValue(definition.getBeanClassName()); // issue #59 definition.setBeanClass(this.mapperFactoryBean.getClass()); definition.getPropertyValues().add("addToConfig", this.addToConfig); // 设置 sqlSessionFactory，如果有配置 boolean explicitFactoryUsed = false; if (StringUtils.hasText(this.sqlSessionFactoryBeanName)) { definition.getPropertyValues().add("sqlSessionFactory", new RuntimeBeanReference(this.sqlSessionFactoryBeanName)); explicitFactoryUsed = true; } else if (this.sqlSessionFactory != null) { definition.getPropertyValues().add("sqlSessionFactory", this.sqlSessionFactory); explicitFactoryUsed = true; } // 设置 sqlSessionTemplate，如果有配置 if (StringUtils.hasText(this.sqlSessionTemplateBeanName)) { definition.getPropertyValues().add("sqlSessionTemplate", new RuntimeBeanReference(this.sqlSessionTemplateBeanName)); explicitFactoryUsed = true; } else if (this.sqlSessionTemplate != null) { definition.getPropertyValues().add("sqlSessionTemplate", this.sqlSessionTemplate); explicitFactoryUsed = true; } // 如果 sqlSessionFactory & sqlSessionTemplate 都没有指定，那么启用类型自动注入 if (!explicitFactoryUsed) { definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE); } }}方法中this.mapperFactoryBean.getClass()会固定返回org.mybatis.spring.mapper.MapperFactoryBean，definition.getBeanClassName()返回的Mapper的类名作为MapperFactoryBean的属性。
Spring初始化进行装配时会调用MapperFactoryBean的getObject()。
public SqlSession getSqlSession() { return this.sqlSession;} @Overridepublic T getObject() throws Exception { return getSqlSession().getMapper(this.mapperInterface);}看到这，就知道了怎么将Mapper声明成bean，但是getSqlSession()返回的是属性中的sqlSession，Mybatis原生的写法中sqlSession不是线程安全的，那Mybatis-Spring如何做到用一个sqlSession处理多个线程的请求？我们继续看这个sqlSession有什么特别的。
public void setSqlSessionFactory(SqlSessionFactory sqlSessionFactory) { if (!this.externalSqlSession) { this.sqlSession = new SqlSessionTemplate(sqlSessionFactory); }}此处使用的sqlSession并非是Mybatis的DefaultSqlSession，而是Mybatis-Spring提供的SqlSessionTemplate。
public SqlSessionTemplate(SqlSessionFactory sqlSessionFactory, ExecutorType executorType, PersistenceExceptionTranslator exceptionTranslator) { notNull(sqlSessionFactory, "Property 'sqlSessionFactory' is required"); notNull(executorType, "Property 'executorType' is required"); this.sqlSessionFactory = sqlSessionFactory; this.executorType = executorType; this.exceptionTranslator = exceptionTranslator; this.sqlSessionProxy = (SqlSession) newProxyInstance( SqlSessionFactory.class.getClassLoader(), new Class[] { SqlSession.class }, new SqlSessionInterceptor());}@Overridepublic <T> T selectOne(String statement) { return this.sqlSessionProxy.<T> selectOne(statement);}SqlSessionTemplate虽然是SqlSession的实现，但内部真正调用并非是他自己，而是生成了一个代理类，我们再看一下代理。
private class SqlSessionInterceptor implements InvocationHandler { @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { SqlSession sqlSession = getSqlSession( SqlSessionTemplate.this.sqlSessionFactory, SqlSessionTemplate.this.executorType, SqlSessionTemplate.this.exceptionTranslator); try { Object result = method.invoke(sqlSession, args); if (!isSqlSessionTransactional(sqlSession, SqlSessionTemplate.this.sqlSessionFactory)) { // force commit even on non-dirty sessions because some databases require // a commit/rollback before calling close() sqlSession.commit(true); } return result; } catch (Throwable t) { Throwable unwrapped = unwrapThrowable(t); if (SqlSessionTemplate.this.exceptionTranslator != null && unwrapped instanceof PersistenceException) { // release the connection to avoid a deadlock if the translator is no loaded. See issue #22 closeSqlSession(sqlSession, SqlSessionTemplate.this.sqlSessionFactory); sqlSession = null; Throwable translated = SqlSessionTemplate.this.exceptionTranslator.translateExceptionIfPossible((PersistenceException) unwrapped); if (translated != null) { unwrapped = translated; } } throw unwrapped; } finally { if (sqlSession != null) { closeSqlSession(sqlSession, SqlSessionTemplate.this.sqlSessionFactory); } } }}sqlSessionProxy运行时，每次都会判断当前事务中是否有SqlSession，没有就重新创建，这样可以保证多线程访问不会出现问题，也可以保证事务的传递。
Mybatis-Spring代码量不大，但实现比较巧妙，如果对Mapper注入和Spring事务感兴趣可以深入了解一下。