实战篇-git

submodule

1
2
3
4
5
6
git submodule add url path
git commit -m 'add module xxx'          # 增加子模块
git submodule update                    # 更新子模块
git submodule update --init --recursive # clone带有子模块的工程后执行

展开全文 >>

实战篇-运维之日志

根据日志查问题是工作中不可避免的，但是当服务器不止一台时，此时查日志成为了问题。一台一台的看，效率很低，而且做很多重复性的动作。下面推荐一个同时查询多台机器的日志工具: polysh

下载地址

1
2
3
unzip polysh-0.4.zip
python setup.py install
python setup.py install --home=~/xxx  # 在没有安装权限的时候，指定安装目录

注意:机器之间需要免密登录

展开全文 >>

实战篇-python编程之各种库

内置库

1
types python支持的所有类型

glob

功能: 查找符合特定规则的文件路径名
使用: 利用简单的正则符号匹配文件

1
2
3
4
5
6
*    # 匹配0个或多个字符
?    # 匹配1个字符
[]   # 匹配指定范围内的字符 比如[0-9]
glob.glob("*.xxx") # 返回以xxx结尾的文件组成的列表
glob.iglob("*.xxx") # 返回迭代器

functiontools

函数 功能
partial 预设部分参数
wraps 将被包装函数的属性赋值给包装函数，方便调试 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import functools
def add(a, b):
    return a + b
print(add(1, 2))
plus1 = functools.partial(add, 1)
print(plus1(2))
plus1_2 = functools.partial(add, 1, 2)
print(plus1_2())
plus1_2_3 = functools.partial(add, 1, 2, 3)
print(plus1_2_3())
----output----
3
3
3
Traceback (most recent call last):
  File "functiontools_test.py", line 12, in <module>
    print(plus1_2_3())
TypeError: add() takes exactly 2 arguments (3 given)

数据库相关

MySQLdb

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
import MySQLdb
conn = MySQLdb.connect(host='',user='',passwd='',db='',port=5002)
cur = conn.cursor()
# insert
# delete
# update
cur.execute("update ...")
conn.commit()
# query
cur.execute("select ...")
for doc in cur:
    pass
    
# 事务
conn.commit()
conn.rollback()  # 回滚到上次commit
try:
    cur = conn.cursor()
    cur.execute("xxx1")
    cur.execute("xxx2")
    cur.close()
    conn.commit()
except Exception, e:
    cur.close()
    conn.rollback()

展开全文 >>

实战篇-rpc之thrift

安装

1
yum install thrift

使用

编写idl文件

shared.thrift

1
2
3
4
5
6
7
8
9
10
11
namespace java shared
namespace php shared
struct SharedStruct {
    1: i32 key,
    2: string value
}
service SharedService {
    SharedStruct getStruct(1: i32 key)
}

tutorial.thrift

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
include "shared.thrift"
namespace java tutorial
namespace php tutorial
typedef i32 MyInteger
const i32 INT32CONSTANT = 9853
const map<string, string> MAPCONSTANT = {'hello':'world'}
enum Operation {
    ADD = 1,
    SUB,
    MUL,
    DIV
}
struct Work {
    1: i32 num1 = 0,
    2: i32 num2,
    3: Operation op,
    4: optional string comment
}
exception InvalidOperation {
    1: i32 whatOp,
    2: string why
}
service Calculator extends shared.SharedService {
    void ping(),
    i32 add(1:i32 num1, 2:i32 num2),
    i32 calculate(1:i32 logid, 2:Work w) throws (1:InvalidOperation ouch),
    oneway void sub(1:i32 num1, 2:i32 num2)
}

生成特定语言的包

1
thrift -r -gen py tutorial.thrift

展开全文 >>

理论篇-rpc之thrift

RPC(Remote Procedure Call Protocol)远程过程调用协议。该协议允许运行于一台计算机上的程序调用另一台计算机上的子程序，而程序员无需为这个额外的交互过程编程。

thrift是众多rpc框架中的一个。本文主要介绍下thrift。

thrift的结构

1
2
3
4
5
6
7
服务器层: 单线程，事件驱动等
-----------------------
处理器层: 特定服务的实现
-----------------------
协议层:  json binary compact
---------------------------
传输层:  基于tcp协议或者http协议传输数据

传输层

传输层提供了一个从网络上读写的简单抽象。有两个接口Transport和ServerTransport。

1
2
Transport: open close read write flush
ServerTransport: open listen accept close

协议层

协议层定义了内存数据结构映射为线性结构的机制。简单的说就是将内存里的数据转换成可以在传输层收发的格式。比如json、xml、plain text、compact binary等

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
writeMessageBegin(name, type, seq)
writeMessageEnd()
writeStructBegin(name)
writeStructEnd()
writeFieldBegin(name, type, id)
writeFieldEnd()
writeFieldStop()
writeMapBegin(ktype, vtype, size)
writeMapEnd()
writeListBegin(etype, size)
writeListEnd()
writeSetBegin(etype, size)
writeSetEnd()
writeBool(bool)
writeByte(byte)
writeI16(i16)
writeI32(i32)
writeI64(i64)
writeDouble(double)
writeString(string)
name, type, seq = readMessageBegin()
                  readMessageEnd()
name = readStructBegin()
       readStructEnd()
name, type, id = readFieldBegin()
                 readFieldEnd()
k, v, size = readMapBegin()
             readMapEnd()
etype, size = readListBegin()
              readListEnd()
etype, size = readSetBegin()
              readSetEnd()
bool = readBool()
byte = readByte()
i16 = readI16()
i32 = readI32()
i64 = readI64()
double = readDouble()
string = readString()

处理器层

特定的服务实现特定的处理器

1
2
3
interface TProcessor {
    bool process(TProtocol in, TProtocol out) throws TException
}

服务器层

服务器层负责将所有功能组装起来

  • 创建一个传输层
  • 为传输层创建输入/输出协议
  • 基于协议创建一个处理器
  • 等待一个连接，然后将连接分发到处理器

实现

py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
传输层:
thrift.transport.THttpClient
thrift.transport.TSocket
thrift.transport.TSSLSocket
thrift.transport.TTransport.TBufferedTransport
thrift.transport.TTransport.TFramedTransport
协议层:
thrift.protocol.TBinaryProtocol
thrift.protocol.TCompactProtocol
服务器层:
thrift.server.TServer                   # 接口
thrift.server.THttpServer               # 基于http协议的服务
thrift.server.TNonblockingServer.TNonblockingServer  # 基于事件的服务器模型
thrift.server.TProcessPoolServer.TProcessPoolServer  # 进程池服务器模型
thrift.server.TServer.TForkingServer    # 为每个请求创建一个新进程
thrift.server.TServer.TSimpleServer     # 单线程
thrift.server.TServer.TThreadPoolServer # 线程池服务器模型
thrift.server.TServer.TThreadedServer   # 每个连接产生一个新的线程

参考

测试代码
TThreadedServer VS TNonblockingServer

展开全文 >>

理论篇-网络安全之重放攻击

重放攻击是指攻击者发送一个目的主机已经接收过的包来达到欺骗系统的目的，主要用于身份认证的过程，破坏认证的正确性。

例子

当你在咖啡厅里，悠闲地喝着咖啡，蹭着网(咖啡厅里的公共网络)。这时你登录某个网站时，被第三方劫持到你发给服务器的请求，此时第三方可以将这个请求重新发给服务器，使用你的账号登录了网站，第三方可以替你买很多东西，你却浑然不知。

防御手段

  • 随机数+数字签名
  • 时间戳+数字签名

随机数+数字签名

客户端发送请求到服务端，服务端生成一个与id对应的随机数，然后返还给客户端。客户端利用该随机数+盐作为密钥对参数进行数字签名，再次请求服务端。

优点: 不依赖时钟同步
缺点: 需要两次请求

时间戳+数字签名

客户端利用时间戳+盐作为密钥对参数进行数字签名，请求服务端。服务端设置一个时间窗口，该窗口内请求有效，其他请求无效。

优点: 请求一次
缺点: 依赖时钟同步，时间窗口内，扔可重放攻击

展开全文 >>

java编程之各种坑

比较大小

在java的世界里，会对[-128, 127]之间的Integer做一个缓存。而==比较的引用。所以会出现如下现象:

1
2
3
4
5
6
7
8
9
10
11
12
Integer a_I = 100;
Integer b_I = 100;
Integer c_I = 200;
Integer d_I = 200;
int a_i = 100, b_i = 100, c_i = 200, d_i = 200;
System.out.println(a_I == b_I);       # true
System.out.println(c_I == d_I);       # false
System.out.println(c_I.equals(d_I));  # true
System.out.println(c_I >= d_I);       # true
System.out.println(a_i == b_i);       # true
System.out.println(c_i == d_i);       # true
System.out.println(c_i >= d_i);       # true

解决办法: 尽量使用equals()方法。

展开全文 >>

理论篇-java编程之spring

记得第一次接触java是在2010年，当时在读大二，当时只是学习java的基础语法。由于那时候对网络等知识的欠缺再加上java web的复杂性，所以一直也没弄明白java web开发到底是什么东西。

前置知识

java世界中，还有一个很明显的特点，就是专业术语特别的多，很容易让新学者摸不着头脑。下面就将学习过程中遇到的专业术语尽可能简单的介绍给大家。

javabean简单的说就是只拥有属性及其对应的get set方法的java类。

pojo(plain old java object)就是指简单的javabean，为了避免与EJB混淆所创造的简称。

EJB(enterprise javabean)是一个用来构筑企业级应用的服务器端可被管理组件。个人理解就是实现了服务器端一些通用功能的java类。spring就是用来代替EJB的。

spring

spring是一个模块化的框架。spring的本质是依赖注入(dependency injection, DI)和面向切面编程(aspect-oriented programming, AOP)。

spring的核心理念:

  • 基于pojo的轻量级和最小侵入性编程
  • 通过依赖注入和面向接口编程实现松耦合
  • 基于切面和惯例实现声明式编程
  • 通过切面和模板减少样板式代码

侵入编程指的是在使用某些框架时，在写业务代码的时候需要继承框架的某些类以利用框架的某些功能。

DI

写代码的时候，我们一直在追求低耦合高内聚。没有耦合的代码意味着一点关系也没有，如果需要多个类配合完成一个任务时肯定是不行的。如果耦合过高，代码将难扩展难测试。spring是如何解决低耦合问题的呢？

创建应用组件之间协作的行为称为装配(wiring)。

spring装配应用组件的方式有三种。

  • 在xml中进行显式配置
  • 在java中进行显式配置
  • 隐式的bean发现机制(组件扫描(component scanning))和自动装配

当使用第三方组件时，需要通过java或xml显式的配置。

通过xml文件如下:

1
2
3
4
5
6
7
8
9
<?xml version="1.0" encoding="UTF-8">
<beans>
    <bean id="knight" class="com.xxx.BraveKnight">
        <constructor-arg ref="quest">
    </bean>    
    <bean id="quest" class="com.xxx.SlayDragonKnight">
        <constructor-arg value="#{T(System).out}">
    </bean>
</beans>

通过java如下:
bean的id与方法名一致。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
@Configuration
public class KnightConfig {
    @Bean
    public Knight knight() {
        return new BraveKnight(quest());
    }
    
    @Bean
    public CompactDisc sgtPeppers() {
        return new SgtPeppers();
    }
    
    # 以下两种方法等价
    @Bean
    public CDPlayer cdPlayer() {
        return new CDPlayer(sgtPeppers());
    }
    
    @Bean
    pubilc CDPlayer cdPlayer(CompactDisc compactDisc) {
        return new CDPlayer(compactDisc);
    }
}
@Configuration
@Bean
    * name="xxx"

组件扫描和自动装配:

1
2
3
4
5
6
7
8
@Component
@ComponentScan()  # 从哪些包中扫描
    * basePackages={"xxx1", "xxx2"}
    * basePackageClasses={XXX1.class, XXX2.class}
@ContextConfiguration()      # 配置类
    * classes=XXX.class
@Autowired
    * required=false

java注解

1
2
@Named
@Inject

spring应用上下文(Application Context)全权负责对象的创建的装配。

spring中的每个bean都有一个ID，可指定可不指定，若不指定，则类名第一个字母小写即为ID。

AOP

面向切面编程可以让很多功能性代码(比如日志)脱离核心业务代码，使核心业务代码保持简单。实现方式如下:

  • 通过xml文件实现AOP
  • 通过注解实现(本质是基于代理的AOP)

通过xml文件实现AOP:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<?xml version="1.0" encoding="UTF-8">
<beans>
    <bean id="knight" class="com.xxx.BraveKnight">
        <constructor-arg ref="quest">
    </bean>    
    <bean id="quest" class="com.xxx.SlayDragonKnight">
        <constructor-arg value="#{T(System).out}">
    </bean>
    <bean id="minstrel" class="com.xxx.Minstrel">
        <constructor-arg value="#{T(System).out}">
    </bean>
    
    <aop:config>
        <aop:aspect ref="minstrel">
            <aop:pointcut id="embark" expression="execution(* *.embarkOnQuest(..))">   # 定义切点
            <aop:before pointcut-ref="embark" method="singBeforeQuest">
            <aop:after pointcut-ref="embark" method="singAfterQuest">
        </aop:aspect>
    </aop:config>
</beans>

容器

spring容器负责创建对象，装配它们，配置它们并管理它们的整个生命周期。

spring容器有多种实现。BeanFactory和ApplicationContext是其中的两种实现。

bean的生命周期

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
实例化
填充属性
调用BeanNameAware的setBeanName()方法
调用BeanFactoryAware的setBeanFactory方法
调用ApplicationContextAware的setApplicationContext()方法
调用BeanPostProcessor的与初始化方法
调用InitializingBean的afterPropertiesSet()方法
调用自定义的初始化方法
调用BeanPostProcessor的初始化方法
-----------------------
      bean创建完成
-----------------------
容器关闭
调用DisposableBean的destroy()方法
调用自定义的销毁方法

展开全文 >>

理论篇-洗牌

之前面试的时候被问到该问题，今天看到了一个不错的算法。所以写下来纪念下。

洗牌定义如下: 将一组数尽可能的打乱。

  • 方案一: 任意选中两张，做交换处理，执行多次。
  • 方案二: 在一个不易发生碰撞的随机数区间内生成n个随机数，每个随机数对应一张牌，然后将随机数排序。

很明显，方案二要优于方案一。当时面试时只想到了方案一，汗颜。

展开全文 >>

tag:

    缺失模块。
    1、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    2、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: true
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

王彪<br>计算机科学与技术专业<br>email:841824090@qq.com<br>2009-2013 苏州大学<br>2013-2015 苏州思必驰信息科技有限公司<br>2016-2017 美团<br>2017-至今 搜狗