20220812

1.前端

vertical-align属性值和作用

• 线类，如 baseline、top、middle、bottom；
• 文本类，如 text-top、text-bottom；
• 上标下标类，如 sub、super；
• 数值百分比类，如 10px、1em、5%；

作用：https://segmentfault.com/a/1190000015366749

2.后端

2.1 sql

-- SQL架构
-- 给定一个表 tree，id 是树节点的编号， p_id 是它父节点的 id 。
--
-- +----+------+
-- | id | p_id |
-- +----+------+
-- | 1  | null |
-- | 2  | 1    |
-- | 3  | 1    |
-- | 4  | 2    |
-- | 5  | 2    |
-- +----+------+
-- 树中每个节点属于以下三种类型之一：
--
-- 叶子：如果这个节点没有任何孩子节点。
-- 根：如果这个节点是整棵树的根，即没有父节点。
-- 内部节点：如果这个节点既不是叶子节点也不是根节点。
--
--
-- 写一个查询语句，输出所有节点的编号和节点的类型，并将结果按照节点编号排序。上面样例的结果为：
--
--
--
-- +----+------+
-- | id | Type |
-- +----+------+
-- | 1  | Root |
-- | 2  | Inner|
-- | 3  | Leaf |
-- | 4  | Leaf |
-- | 5  | Leaf |
-- +----+------+
--
--
-- 解释
--
-- 节点 '1' 是根节点，因为它的父节点是 NULL ，同时它有孩子节点 '2' 和 '3' 。
-- 节点 '2' 是内部节点，因为它有父节点 '1' ，也有孩子节点 '4' 和 '5' 。
-- 节点 '3', '4' 和 '5' 都是叶子节点，因为它们都有父节点同时没有孩子节点。
-- 样例中树的形态如下：

结果

-- 需要有一个中间表 id，pid，sid的结构

select a.id as id,a.p_id as pid,min(b.id) as sid from tree a left join tree b on a.id = b.pid group by a.id

-- 通过判断id对应的pid和sid的个数判断是什么节点类型
select id, if(pid is null, "Root", if(sid is null, "Leaf", "Inner")) as Type
from (select a.id as id,a.p_id as pid,min(b.id) as sid from tree a left join tree b on a.id = b.p_id group by a.id) temp

2.2 python中的函数

在Python中，定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用return语句返回。

def add(a,b):
    return a+b;
# 空函数，用来占位
def nop():
    pass

if __name__ == "__main__":
    print(add(3,4))

2.3 框架

mybatis中的getMapper做了什么

// DefaultSqlSession#getMapper
public <T> T getMapper(Class<T> type) {
    return configuration.<T>getMapper(type, this);
  }

如果方法返回值是一个泛型的话可以在方法前加个<t>方法</t>

// protected final MapperRegistry mapperRegistry = new MapperRegistry(this);
public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
    return mapperRegistry.getMapper(type, sqlSession);
  }

// MapperRegistry#getMapper
// 用于注册Mapper接口Class对象，和MapperProxyFactory对象对应关系
private final Map<Class<?>, MapperProxyFactory<?>> knownMappers = new HashMap<Class<?>, MapperProxyFactory<?>>();

public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
    final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type);
    if (mapperProxyFactory == null) {
      throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
    }
    try {
      return mapperProxyFactory.newInstance(sqlSession);
    } catch (Exception e) {
      throw new BindingException("Error getting mapper instance. Cause: " + e, e);
    }
  }

这里的mapperProxyFactory.newInstance不是一个静态类，所以是哪里有初始化这个factory，这个是存储在knownMappers中的一个映射关系，所以MapperRegistry中一定会有注册的方法。这里的factory中为什么是需要一个初始化后的类呢？可以看到factory中的属性，这里的每个type(Class)创建了一个factory，factory中存储了Method和MapperMethod的映射，如果是静态方法的话，不同生成变量之间的公共属性就没法共用了。这里把后面生成的MapperProxy中共用的方法放在了factory中，这样同一个个类型中就可以复用这些方法了。

  private final Class<T> mapperInterface;
  private final Map<Method, MapperMethod> methodCache = new ConcurrentHashMap<Method, MapperMethod>();

// 根据Mapper接口Class对象，创建MapperProxyFactory对象，并注册到knownMappers属性中
  public <T> void addMapper(Class<T> type) {
    if (type.isInterface()) {
      if (hasMapper(type)) {
        throw new BindingException("Type " + type + " is already known to the MapperRegistry.");
      }
      boolean loadCompleted = false;
      try {
        knownMappers.put(type, new MapperProxyFactory<T>(type));
        // It's important that the type is added before the parser is run
        // otherwise the binding may automatically be attempted by the
        // mapper parser. If the type is already known, it won't try.
        MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type);
        parser.parse();
        loadCompleted = true;
      } finally {
        if (!loadCompleted) {
          knownMappers.remove(type);
        }
      }
    }
  }

protected T newInstance(MapperProxy<T> mapperProxy) {
    return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
  }

  public T newInstance(SqlSession sqlSession) {
    final MapperProxy<T> mapperProxy = new MapperProxy<T>(sqlSession, mapperInterface, methodCache);
    return newInstance(mapperProxy);
  }