阅读笔记
- sql中各种 count
- 结论
- 不同存储引擎计算方式
- 区别
- count() 类型
- 责任链模式
- 常见场景
- 例子（闯关游戏）
sql中各种 count
结论
- innodb
count(*) ≈ count(1) > count(主键id) > count(普通索引列) > count(未加索引列)
-
myisam
有专门字段记录全表的行数，直接读这个字段就好了（innodb则需要一行行去算） -
如果确实需要获取行数，且可以接受不那么精确的行数（只需要判断大概的量级） 的话，那可以用explain里的rows，这可以满足大部分的监控场景，实现简单
-
如果要求行数准确 ，可以建个新表，里面专门放表行数的信息
-
如果对实时性要求比较高 的话，可以将更新行数的sql放入到对应事务里，这样既能满足事务隔离性，还能快速读取到行数信息
-
如果对实时性要求不高 ，接受一小时或者一天的更新频率，那既可以自己写脚本遍历全表后更新行数信息。也可以将通过监听binlog将数据导入hive，需要数据时直接通过hive计算得出
不同存储引擎计算方式
- count()方法的目的是计算当前sql语句查询得到的非NULL的行数
- 虽然在server层都叫count()方法，但在不同的存储引擎下，它们的实现方式是有区别的
-
- 比如同样是读全表数据
select count(*) from table (where *** )；
当数据表小的时候，这是没问题的，但当数据量大的时候，比如未发送的短信到了百万量级 的时候，你就会发现，上面的sql查询时间会变得很长，最后timeout报错，查不出结果了 。
-
- 使用 myisam引擎 的数据表里有个记录当前表里有几行数据的字段，直接读这个字段返回就好了，因此速度快得飞起
-
- 使用innodb引擎 的数据表，则会选择体积最小的索引树 ，然后通过遍历叶子节点的个数挨个加起来，这样也能得到全表数据
区别
为什么innodb不能像myisam那样实现count()方法
-
最大的区别在于myisam不支持事务，而innodb支持事务
而事务，有四层隔离级别，其中默认隔离级别就是可重复读隔离级别（RR） -
- innodb引擎通过MVCC实现了可重复隔离级别 ，事务开启后，多次执行同样的select快照读 ，要能读到同样的数据。
-
- 对于两个事务A和B，一开始表假设就2条 数据，那事务A一开始确实是读到2条数据。事务B在这期间插入了1条数据，按道理数据库其实有3条数据了，但由于可重复读的隔离级别，事务A依然还是只能读到2条数据。
-
- 因此由于事务隔离级别的存在，不同的事务在同一时间下，看到的表内数据行数是不一致的 ，因此innodb，没办法，也没必要像myisam那样单纯的加个count字段信息在数据表上。
count() 类型
count方法的大原则是server层会从innodb存储引擎里读来一行行数据，并且只累计非null的值 。但这个过程，根据count()方法括号内的传参，有略有不同。
- count（*）
server层拿到innodb返回的行数据，不对里面的行数据做任何解析和判断 ，默认取出的值肯定都不是null，直接行数+1 - count(1)
server层拿到innodb返回的行数据，每行放个1进去，默认不可能为null，直接行数+1. -
- InnoDB 引擎遍历整张表，但不取值。server 层对于返回的每一行，放一个数字“1”进去，判断是不可能为空的，按行累加
- count(字段）
count(字段)是不统计，字段值为null的值 -
- count(主键 id) 来说，InnoDB 引擎会遍历整张表，把每一行的 id 值都取出来，返回给 server 层。server 层拿到 id 后，判断是不可能为空的，就按行累加
-
-
count(字段)，server要字段，就返回字段，如果字段为空，就不做统计，字段的值过大，都会造成效率低下
由于指明了要count某个字段，innodb在取数据的时候，会把这个字段解析出来 返回给server层，所以会比count(1)和count(*)多了个解析字段出来的流程
-
文
责任链模式
- 责任链模式是一种行为设计模式， 允许你将请求沿着处理者链进行发送。收到请求后， 每个处理者均可对请求进行处理， 或将其传递给链上的下个处理者。
常见场景
- 多条件的流程判断（如导入文件校验条件较多，且需逐层校验成功的；或类似闯关游戏，必须达到一定分数/条件才能开始下一关）
导入功能可能【模板方法】更适合
-
- 模板方法可以提供大部分相同的【模板】，根据不同的导入场景做小部分调整，实现各自独立的业务，大体上导入功能差不多
-
- 一次性实现一个算法的不变部分，并将可变的行为留给子类来实现
-
- 各子类中公共的行为被提取出来并集中到一个公共父类中，从而避免代码重复
- 各子类中公共的行为被提取出来并集中到一个公共父类中，从而避免代码重复
- ERP 系统流程审批：总经理、人事经理、项目经理
- Java 过滤器的底层实现 Filter
例子（闯关游戏）
-
假设现在有一个闯关游戏，进入下一关的条件是上一关的分数要高于 xx：
-
游戏一共 3 个关卡
进入第二关需要第一关的游戏得分大于等于 80
进入第三关需要第二关的游戏得分大于等于 90
简易版（多层 if 逐层判断是否满足条件）
//第一关
public class FirstPassHandler {public int handler(){System.out.println("第一关-->FirstPassHandler");return 80;}
}//第二关
public class SecondPassHandler {public int handler(){System.out.println("第二关-->SecondPassHandler");return 90;}
}//第三关
public class ThirdPassHandler {public int handler(){System.out.println("第三关-->ThirdPassHandler，这是最后一关啦");return 95;}
}//客户端
public class HandlerClient {public static void main(String[] args) {FirstPassHandler firstPassHandler = new FirstPassHandler();//第一关SecondPassHandler secondPassHandler = new SecondPassHandler();//第二关ThirdPassHandler thirdPassHandler = new ThirdPassHandler();//第三关int firstScore = firstPassHandler.handler();//第一关的分数大于等于80则进入第二关if(firstScore >= 80){int secondScore = secondPassHandler.handler();//第二关的分数大于等于90则进入第二关if(secondScore >= 90){thirdPassHandler.handler();}}}
}
- 实际上的 handle() 根据业务来传参及计算分数
- 缺点
当关数越多/条件越多时代码会变得很长，无限月读（if 嵌套）
if(第1关通过){// 第2关 游戏if(第2关通过){// 第3关 游戏if(第3关通过){// 第4关 游戏if(第4关通过){// 第5关 游戏if(第5关通过){// 第6关 游戏if(第6关通过){//...}}} }}
}
升级（责任链链表拼接每一关）
- 可以通过链表将每一关连接起来，形成责任链的方式，第一关通过后是第二关，第二关通过后是第三关… （减少客户端代码过多的 if 嵌套）
public class FirstPassHandler {/*** 第一关的下一关是 第二关*/private SecondPassHandler secondPassHandler;public void setSecondPassHandler(SecondPassHandler secondPassHandler) {this.secondPassHandler = secondPassHandler;}//本关卡游戏得分private int play(){return 80;}public int handler(){System.out.println("第一关-->FirstPassHandler");if(play() >= 80){//分数>=80 并且存在下一关才进入下一关if(this.secondPassHandler != null){return this.secondPassHandler.handler();}}return 80;}
}public class SecondPassHandler {/*** 第二关的下一关是 第三关*/private ThirdPassHandler thirdPassHandler;public void setThirdPassHandler(ThirdPassHandler thirdPassHandler) {this.thirdPassHandler = thirdPassHandler;}//本关卡游戏得分private int play(){return 90;}public int handler(){System.out.println("第二关-->SecondPassHandler");if(play() >= 90){//分数>=90 并且存在下一关才进入下一关if(this.thirdPassHandler != null){return this.thirdPassHandler.handler();}}return 90;}
}public class ThirdPassHandler {//本关卡游戏得分private int play(){return 95;}/*** 这是最后一关，因此没有下一关*/public int handler(){System.out.println("第三关-->ThirdPassHandler，这是最后一关啦");return play();}
}public class HandlerClient {public static void main(String[] args) {FirstPassHandler firstPassHandler = new FirstPassHandler();//第一关SecondPassHandler secondPassHandler = new SecondPassHandler();//第二关ThirdPassHandler thirdPassHandler = new ThirdPassHandler();//第三关firstPassHandler.setSecondPassHandler(secondPassHandler);//第一关的下一关是第二关secondPassHandler.setThirdPassHandler(thirdPassHandler);//第二关的下一关是第三关//说明：因为第三关是最后一关，因此没有下一关//开始调用第一关 每一个关卡是否进入下一关卡 在每个关卡中判断firstPassHandler.handler();}
}
- 缺点
从代码中可以看到，每一关的处理逻辑中都有一个 set**PassHandler() 方法，只是参数类型不一样，但是作用其实是一样的，只是用来判断是否有下一关
每个关卡中都有下一关的成员变量并且是不一样的，形成链很不方便，代码扩展性不行
进化（责任链改造—抽象）
- 每个关卡中都有下一关的成员变量并且是不一样的，那么我们可以在关卡上抽象出一个父类或者接口，然后每个具体的关卡去继承或者实现，将参数合并成一个，不再需要在各自的 set**PassHandler 中传递不同的参数
- 责任链设计模式的基本组成
-
- 抽象处理者（Handler）角色： 定义一个处理请求的接口，包含抽象处理方法和一个后继连接
-
- 具体处理者（Concrete Handler）角色： 实现抽象处理者的处理方法，判断能否处理本次请求，如果可以处理请求则处理，否则将该请求转给它的后继者
-
- 客户类（Client）角色： 创建处理链，并向链头的具体处理者对象提交请求，它不关心处理细节和请求的传递过程
- 客户类（Client）角色： 创建处理链，并向链头的具体处理者对象提交请求，它不关心处理细节和请求的传递过程
public abstract class AbstractHandler {/*** 下一关用当前抽象类来接收*/protected AbstractHandler next;public void setNext(AbstractHandler next) {this.next = next;}public abstract int handler();
}public class FirstPassHandler extends AbstractHandler{private int play(){return 80;}@Overridepublic int handler(){System.out.println("第一关-->FirstPassHandler");int score = play();if(score >= 80){//分数>=80 并且存在下一关才进入下一关if(this.next != null){return this.next.handler();}}return score;}
}public class SecondPassHandler extends AbstractHandler{private int play(){return 90;}public int handler(){System.out.println("第二关-->SecondPassHandler");int score = play();if(score >= 90){//分数>=90 并且存在下一关才进入下一关if(this.next != null){return this.next.handler();}}return score;}
}public class ThirdPassHandler extends AbstractHandler{private int play(){return 95;}public int handler(){System.out.println("第三关-->ThirdPassHandler");int score = play();if(score >= 95){//分数>=95 并且存在下一关才进入下一关if(this.next != null){return this.next.handler();}}return score;}
}public class HandlerClient {public static void main(String[] args) {FirstPassHandler firstPassHandler = new FirstPassHandler();//第一关SecondPassHandler secondPassHandler = new SecondPassHandler();//第二关ThirdPassHandler thirdPassHandler = new ThirdPassHandler();//第三关// 和上面没有更改的客户端代码相比，只有这里的set方法发生变化，其他都是一样的firstPassHandler.setNext(secondPassHandler);//第一关的下一关是第二关secondPassHandler.setNext(thirdPassHandler);//第二关的下一关是第三关//说明：因为第三关是最后一关，因此没有下一关//从第一个关卡开始firstPassHandler.handler();}
}
- 从代码中可以看到，此次进化引入了一个 抽象处理者，让每一关的具体处理者都继承该类，后续在设置下一关对象的时候就不必各自编写各自的set**PassHandler() 方法，而是直接使用相同的处理方法，只需要编写各自的 handler() 得分方法，进一步简化了代码
终极进化（责任链工厂改造）
public enum GatewayEnum {// handlerId, 拦截者名称，全限定类名，preHandlerId，nextHandlerIdAPI_HANDLER(new GatewayEntity(1, "api接口限流", "cn.dgut.design.chain_of_responsibility.GateWay.impl.ApiLimitGatewayHandler", null, 2)),BLACKLIST_HANDLER(new GatewayEntity(2, "黑名单拦截", "cn.dgut.design.chain_of_responsibility.GateWay.impl.BlacklistGatewayHandler", 1, 3)),SESSION_HANDLER(new GatewayEntity(3, "用户会话拦截", "cn.dgut.design.chain_of_responsibility.GateWay.impl.SessionGatewayHandler", 2, null)),;GatewayEntity gatewayEntity;public GatewayEntity getGatewayEntity() {return gatewayEntity;}GatewayEnum(GatewayEntity gatewayEntity) {this.gatewayEntity = gatewayEntity;}
}public class GatewayEntity {private String name;private String conference;private Integer handlerId;private Integer preHandlerId;private Integer nextHandlerId;
}public interface GatewayDao {/*** 根据 handlerId 获取配置项* @param handlerId* @return*/GatewayEntity getGatewayEntity(Integer handlerId);/*** 获取第一个处理者* @return*/GatewayEntity getFirstGatewayEntity();
}public class GatewayImpl implements GatewayDao {/*** 初始化，将枚举中配置的handler初始化到map中，方便获取*/private static Map<Integer, GatewayEntity> gatewayEntityMap = new HashMap<>();static {GatewayEnum[] values = GatewayEnum.values();for (GatewayEnum value : values) {GatewayEntity gatewayEntity = value.getGatewayEntity();gatewayEntityMap.put(gatewayEntity.getHandlerId(), gatewayEntity);}}@Overridepublic GatewayEntity getGatewayEntity(Integer handlerId) {return gatewayEntityMap.get(handlerId);}@Overridepublic GatewayEntity getFirstGatewayEntity() {for (Map.Entry<Integer, GatewayEntity> entry : gatewayEntityMap.entrySet()) {GatewayEntity value = entry.getValue();// 没有上一个handler的就是第一个if (value.getPreHandlerId() == null) {return value;}}return null;}
}public class GatewayHandlerEnumFactory {private static GatewayDao gatewayDao = new GatewayImpl();// 提供静态方法，获取第一个handlerpublic static GatewayHandler getFirstGatewayHandler() {GatewayEntity firstGatewayEntity = gatewayDao.getFirstGatewayEntity();GatewayHandler firstGatewayHandler = newGatewayHandler(firstGatewayEntity);if (firstGatewayHandler == null) {return null;}GatewayEntity tempGatewayEntity = firstGatewayEntity;Integer nextHandlerId = null;GatewayHandler tempGatewayHandler = firstGatewayHandler;// 迭代遍历所有handler，以及将它们链接起来while ((nextHandlerId = tempGatewayEntity.getNextHandlerId()) != null) {GatewayEntity gatewayEntity = gatewayDao.getGatewayEntity(nextHandlerId);GatewayHandler gatewayHandler = newGatewayHandler(gatewayEntity);tempGatewayHandler.setNext(gatewayHandler);tempGatewayHandler = gatewayHandler;tempGatewayEntity = gatewayEntity;}// 返回第一个handlerreturn firstGatewayHandler;}/*** 反射实体化具体的处理者* @param firstGatewayEntity* @return*/private static GatewayHandler newGatewayHandler(GatewayEntity firstGatewayEntity) {// 获取全限定类名String className = firstGatewayEntity.getConference(); try {// 根据全限定类名，加载并初始化该类，即会初始化该类的静态段Class<?> clazz = Class.forName(className);return (GatewayHandler) clazz.newInstance();} catch (ClassNotFoundException | IllegalAccessException | InstantiationException e) {e.printStackTrace();}return null;}}public class GetewayClient {public static void main(String[] args) {GetewayHandler firstGetewayHandler = GetewayHandlerEnumFactory.getFirstGetewayHandler();firstGetewayHandler.service();}
}
- 待深究
文
![[足式机器人]Part2 Dr. CAN学习笔记 - Ch02动态系统建模与分析](https://img-blog.csdnimg.cn/direct/630219cc3a314904ba754366a8add31b.png#pic_center)
