bug清单, spring 6月 26,2020

springboot内嵌tomcat文件上传路径不存在bug解决

在开发上传功能时，发现在开发环境正常，在线上环境出现问题，经过定位发现tomcat临时目录导致的问题。

springboot内嵌tomcat，上传文件时会存放到tomcat临时文件目录（停止时删除/重启时新建），如：/tmp/tomcat.1046709481715876128.17301/work/Tomcat/localhost/cms

可知文件保存在/tmp目录下，/tmp目录在centos下会定时清理，大约10天未使用将会删除目录，（当tomcat未重启，但centos删除相应目录，tomcat获取相应目录却获取不到会报错）

解决方案：

配置multipartFile上传路径

1.application.properties 文件中添加

spring.http.multipart.location=${tmp.file.path} 注意：tmp.file.path 如果不存在，spring会认为是相对路径，对应根路径是tomcat临时文件目录
2

2.配置相应bean

/**
* 文件上传临时路径
*/
@Bean
MultipartConfigElement multipartConfigElement() {
  MultipartConfigFactory factory = new MultipartConfigFactory();
factory.setLocation("/data/ops/app/cms/cache");
return factor
246810121416

作者 east

Java 6月 25,2020

shardingsphere 4.0的2种配置格式

首先配置pom.xml


        <!-- shardingsphere最新版本 -->
        <dependency>
            <groupId>org.apache.shardingsphere</groupId>
            <artifactId>sharding-jdbc-spring-boot-starter</artifactId>
            <version>4.0.0-RC1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.shardingsphere</groupId>
            <artifactId>sharding-jdbc-spring-namespace</artifactId>
            <version>4.0.0-RC1</version>
        </dependency>

yml格式只分表，不分库的写法

Spring:
  shardingsphere:
    datasource:
      names: master
      master:
        type: com.alibaba.druid.pool.DruidDataSource
        driver-class-name: com.mysql.cj.jdbc.Driver
        url: jdbc:mysql://197.1.26.138:53306/test?serverTimezone=Asia/Shanghai&useSSL=false&allowMultiQueries=true
        username: root
        password: root
#数据分表规则
#指定所需分的表
    sharding:
      tables:
        test_user:
          actual-data-nodes: master.test_user$->{0..2}
          table-strategy:
            inline:
              sharding-column: night_id
              algorithm-expression: test_user$->{night_id % 3}
    props:
      sql:
        show: false

properties分库分表的写法


#指定mybatis信息
mybatis.config-location=classpath:mybatis-config.xml

#数据库
spring.shardingsphere.datasource.names=master0,slave0

spring.shardingsphere.datasource.master0.type=com.alibaba.druid.pool.DruidDataSource
spring.shardingsphere.datasource.master0.driver-class-name=com.mysql.jdbc.Driver
spring.shardingsphere.datasource.master0.url=jdbc:mysql://localhost:3306/master?characterEncoding=utf-8
spring.shardingsphere.datasource.master0.username=root
spring.shardingsphere.datasource.master0.password=123456

spring.shardingsphere.datasource.slave0.type=com.alibaba.druid.pool.DruidDataSource
spring.shardingsphere.datasource.slave0.driver-class-name=com.mysql.jdbc.Driver
spring.shardingsphere.datasource.slave0.url=jdbc:mysql://localhost:3306/slave?characterEncoding=utf-8
spring.shardingsphere.datasource.slave0.username=root
spring.shardingsphere.datasource.slave0.password=root

#数据分表规则
#指定所需分的表
spring.shardingsphere.sharding.tables.tab_user.actual-data-nodes=master0.tab_user$->{0..1}
#指定主键
spring.shardingsphere.sharding.tables.tab_user.table-strategy.inline.sharding-column=id
#分表规则为主键除以2取模
spring.shardingsphere.sharding.tables.tab_user.table-strategy.inline.algorithm-expression=tab_user$->{id % 2}

# 读写分离
spring.shardingsphere.masterslave.load-balance-algorithm-type=round_robin
spring.shardingsphere.masterslave.name=ms
#这里配置读写分离的时候一定要记得添加主库的数据源名称 这里为master0
spring.shardingsphere.sharding.master-slave-rules.master0.master-data-source-name=master0
spring.shardingsphere.sharding.master-slave-rules.master0.slave-data-source-names=slave0

#打印sql
spring.shardingsphere.props.sql.show=true

作者 east

Spark, 大数据开发 6月 25,2020

大数据利用基站或GPS推断是家和工作地

如果有某个手机用户的GPS轨迹或基站，是可以利用大数据来推断他的家和工作地。

思路应该从时空2个维度进行考虑：

1、从时间上考虑：对于一般人来说，一天最早的出发地通常是家，晚上最后的目的地通常是家。而上班的地方，普通是6-10点出发的，在17点到22点后回来的，工作地通常是停留时间很长。（可以把轨迹按天归类，并按每天时间排序，从而计算最早、最晚、白天停留时间最长的地点）

2、从空间上考虑：家和工作点应该是2个不同的聚类中心。可以利用轨迹绘制集群中每个集群中GPS或基站数据点的时间分布。应该可以推断出从早上9点到晚上18点，用户停留在集群1区域，而在午夜到早上8点，用户倾向于留在集群2。从而大概率推断出集群1是家，集群2是工作地（可以用 DBSCAN算法来识别此数据集中的聚类。 DBSCAN是一种聚类算法，对于聚类具有许多异常值的空间数据特别有用）

作者 east

spring 6月 10,2020

Springboot读取excel工具类

public List<DeviceInfo> readXls() throws IOException {
    InputStream is = new FileInputStream(EXCEL_PATH);
    XSSFWorkbook hssfWorkbook = new XSSFWorkbook(is);
    DeviceInfo student = null;
    List<DeviceInfo> list = new ArrayList<DeviceInfo>();
    // 循环工作表Sheet
    for (int numSheet = 0; numSheet < hssfWorkbook.getNumberOfSheets(); numSheet++) {
        XSSFSheet hssfSheet = hssfWorkbook.getSheetAt(numSheet);
        if (hssfSheet == null) {
            continue;
        }
        // 循环行Row
        for (int rowNum = 1; rowNum <= hssfSheet.getLastRowNum(); rowNum++) {
            XSSFRow hssfRow = hssfSheet.getRow(rowNum);
            if(CheckRowNull(hssfRow)){
                continue;
            }
            if (hssfRow != null) {
                student = new DeviceInfo();
                XSSFCell no = hssfRow.getCell(0);
                no.setCellType(no.CELL_TYPE_STRING);
                XSSFCell name = hssfRow.getCell(3);
                XSSFCell longitude = hssfRow.getCell(1);
                XSSFCell latitude = hssfRow.getCell(2);
                student.setDeviceId(getValue(no));
                student.setDeviceName(getValue(name));
                student.setLongitude(new BigDecimal(getValue(longitude)));
                student.setLatitude(new BigDecimal(getValue(latitude)));
                list.add(student);
            }
        }
    }
    return list;
}

@SuppressWarnings("static-access")
private String getValue(XSSFCell hssfCell) {
    if (hssfCell.getCellType() == hssfCell.CELL_TYPE_BOOLEAN) {
        // 返回布尔类型的值
        return String.valueOf(hssfCell.getBooleanCellValue());
    } else if (hssfCell.getCellType() == hssfCell.CELL_TYPE_NUMERIC) {
        // 返回数值类型的值
        return String.valueOf(hssfCell.getNumericCellValue());
    } else if (hssfCell.getCellType() == hssfCell.CELL_TYPE_FORMULA) {
        return String.valueOf(hssfCell.getCellFormula());
    } else {
        // 返回字符串类型的值
        return String.valueOf(hssfCell.getStringCellValue());
    }
}

//判断行为空
private boolean CheckRowNull(XSSFRow hssfRow){
    Iterator<Cell> cellItr =hssfRow.iterator();
    while(cellItr.hasNext()){
        Cell c =cellItr.next();
        if(c != null && c.getCellType() !=XSSFCell.CELL_TYPE_BLANK){
            return false;
        }
    }
    return true;
}

作者 east

大数据开发 6月 10,2020

ShardingSphere不支持的SQL操作（having等复杂统计及子查询）

在大数据时代，面对海量数据存储和处理，除了nosql方案外，很多时候还是需要关系型数据库。mysql单表在千万级别时性能就明显下降，这时靠加索引等也难根本性解决，这时需要分库分表。shardingshpere是一款轻巧绿色的分库分表利器。不是它也是有局限性，下面是它不支持的sql操作。

路由至多数据节点

不支持CASE WHEN、HAVING、UNION (ALL)，有限支持子查询。

除了分页子查询的支持之外(详情请参考分页)，也支持同等模式的子查询。无论嵌套多少层，ShardingSphere都可以解析至第一个包含数据表的子查询，一旦在下层嵌套中再次找到包含数据表的子查询将直接抛出解析异常。

例如，以下子查询可以支持：

SELECT COUNT(*) FROM (SELECT * FROM t_order o)

以下子查询不支持：

SELECT COUNT(*) FROM (SELECT * FROM t_order o WHERE o.id IN (SELECT id FROM t_order WHERE status = ?))

简单来说，通过子查询进行非功能需求，在大部分情况下是可以支持的。比如分页、统计总数等；而通过子查询实现业务查询当前并不能支持。

由于归并的限制，子查询中包含聚合函数目前无法支持。

不支持包含schema的SQL。因为ShardingSphere的理念是像使用一个数据源一样使用多数据源，因此对SQL的访问都是在同一个逻辑schema之上。

对分片键进行操作

运算表达式和函数中的分片键会导致全路由。

假设create_time为分片键，则无法精确路由形如SQL：

SELECT * FROM t_order WHERE to_date(create_time, 'yyyy-mm-dd') = '2019-01-01';

由于ShardingSphere只能通过SQL字面提取用于分片的值，因此当分片键处于运算表达式或函数中时，ShardingSphere无法提前获取分片键位于数据库中的值，从而无法计算出真正的分片值。

当出现此类分片键处于运算表达式或函数中的SQL时，ShardingSphere将采用全路由的形式获取结果。

示例

支持的SQL

SQL	必要条件
SELECT * FROM tbl_name
SELECT * FROM tbl_name WHERE (col1 = ? or col2 = ?) and col3 = ?
SELECT * FROM tbl_name WHERE col1 = ? ORDER BY col2 DESC LIMIT ?
SELECT COUNT(*), SUM(col1), MIN(col1), MAX(col1), AVG(col1) FROM tbl_name WHERE col1 = ?
SELECT COUNT(col1) FROM tbl_name WHERE col2 = ? GROUP BY col1 ORDER BY col3 DESC LIMIT ?, ?
INSERT INTO tbl_name (col1, col2,…) VALUES (?, ?, ….)
INSERT INTO tbl_name VALUES (?, ?,….)
INSERT INTO tbl_name (col1, col2, …) VALUES (?, ?, ….), (?, ?, ….)
UPDATE tbl_name SET col1 = ? WHERE col2 = ?
DELETE FROM tbl_name WHERE col1 = ?
CREATE TABLE tbl_name (col1 int, …)
ALTER TABLE tbl_name ADD col1 varchar(10)
DROP TABLE tbl_name
TRUNCATE TABLE tbl_name
CREATE INDEX idx_name ON tbl_name
DROP INDEX idx_name ON tbl_name
DROP INDEX idx_name
SELECT DISTINCT * FROM tbl_name WHERE col1 = ?
SELECT COUNT(DISTINCT col1) FROM tbl_name

不支持的SQL

SQL	不支持原因
INSERT INTO tbl_name (col1, col2, …) VALUES(1+2, ?, …)	VALUES语句不支持运算表达式
INSERT INTO tbl_name (col1, col2, …) SELECT col1, col2, … FROM tbl_name WHERE col3 = ?	INSERT .. SELECT
SELECT COUNT(col1) as count_alias FROM tbl_name GROUP BY col1 HAVING count_alias > ?	HAVING
SELECT * FROM tbl_name1 UNION SELECT * FROM tbl_name2	UNION
SELECT * FROM tbl_name1 UNION ALL SELECT * FROM tbl_name2	UNION ALL
SELECT * FROM ds.tbl_name1	包含schema
SELECT SUM(DISTINCT col1), SUM(col1) FROM tbl_name	详见DISTINCT支持情况详细说明
SELECT * FROM tbl_name WHERE to_date(create_time, ‘yyyy-mm-dd’) = ?	会导致全路由

DISTINCT支持情况详细说明

支持的SQL

SQL
SELECT DISTINCT * FROM tbl_name WHERE col1 = ?
SELECT DISTINCT col1 FROM tbl_name
SELECT DISTINCT col1, col2, col3 FROM tbl_name
SELECT DISTINCT col1 FROM tbl_name ORDER BY col1
SELECT DISTINCT col1 FROM tbl_name ORDER BY col2
SELECT DISTINCT(col1) FROM tbl_name
SELECT AVG(DISTINCT col1) FROM tbl_name
SELECT SUM(DISTINCT col1) FROM tbl_name
SELECT COUNT(DISTINCT col1) FROM tbl_name
SELECT COUNT(DISTINCT col1) FROM tbl_name GROUP BY col1
SELECT COUNT(DISTINCT col1 + col2) FROM tbl_name
SELECT COUNT(DISTINCT col1), SUM(DISTINCT col1) FROM tbl_name
SELECT COUNT(DISTINCT col1), col1 FROM tbl_name GROUP BY col1
SELECT col1, COUNT(DISTINCT col1) FROM tbl_name GROUP BY col1

不支持的SQL

SQL	不支持原因
SELECT SUM(DISTINCT col1), SUM(col1) FROM tbl_name	同时使用普通聚合函数和DISTINCT聚合函数

作者 east

Java 6月 10,2020

千万级别数据实时复杂统计效率优化

有个业务需求：千万级别数据，要根据位置、白天出现时间、晚上不出现时间，出现次数大于某个范围的复杂组合统计。

mysql在千万级别的数据时，查询效率就有明细的下降。而时间数据从上千万级上升到上亿级，查询效率很慢，等待很久。

除了加索引等常规优化，想到用
shardingsphere 来分库分表，调研之后，发现
shardingsphere 不支持having等统计查询，对子查询支持也不是非常友好。后来发现这些数据，大部分数据其实是很难用到到，因为业务要统计大于多少次的，并按次数倒序，于是把那些出现次数少的进行删除，数据一下降到百万级别的，查询效率明细提升。

优化不光是考虑技术上的，一些技术难做到的，还要结合业务进行优化。

作者 east

spring 6月 10,2020

Mybatis的and拼接问题

在具体业务开发中，有些业务涉及到多个可选的查询条件，例如要查询白天出现的时间段，晚上不出现时间段，这就涉及多个and拼接问题。

<select id="listSelectAll">
        select * from ***
        where 
        <if test="a!= null">
            a = #{a}
        </if>
        <if test="b!= null">
            and b = #{b}
            </foreach>
        </if>
        <if test="c!= null">
            and c = #{c}
        </if>
            order by id desc
            limit #{limit} offset #{page}
</select>

这样写的错误是如果a==null那么第二个条件中就会多一个and，语句会变成select * from *** where and b =#{b}，而如果条件全都不满足的话SQL会变成select * from *** where order by id desc limit…解决办法：加上<where>标签，如下：

<select id="listSelectAll">
        select * from ***
       <where>
        <if test="a!= null">
            a = #{a}
        </if>
        <if test="b!= null">
            and b = #{b}
            </foreach>
        </if>
        <if test="c!= null">
            and c = #{c}
        </if>
        </where>
            order by id desc
            limit #{limit} offset #{page}
</select>

如上代码所示，加上一个<where>标签即可，where标签会自动识别，如果前面条件不满足的话，会自己去掉and。

作者 east

Java, spring 5月 31,2020

分库分表利器sharding-sphere入门学习资料

当mysql达到单表1千万数据以上时，性能就下降得厉害，添加索引等方式还是不能根本解决问题，需要进行分库分表。sharding-sphere是开源的分布式数据库中间件解决方案，只需要开发人员像添加普通jar依赖一样添加依赖，不需要运维人员额外配置。是一个轻量级、性能较好的解决方案。但sharding-sphere学习资料较少，下面推荐一下入门学习资料。

学习视频https://www.bilibili.com/video/BV1rJ411n7QH

官网

官网是必须要学习的一手材料。

http://shardingjdbc.io/

Github

https://github.com/sharding-sphere

很好入门例子：https://github.com/yudiandemingzi/spring-boot-sharding-sphere

作者 east

Java 5月 30,2020

springboot如何多线程异步执行定时任务

在后台开发时，经常需要执行后台任务，相比使用quartz等复杂定时框架，使用springboot自带定时框架，能简单轻松满足大部分定时任务。

工具/原料

已经配置好springboot依赖

方法/步骤

创建一个后台定时任务的类，并标明@Component标注。创建一个普通方式，加上@Scheduled标注，例如：@Scheduled(cron = “0 27 10 * * ?”)

2.在Scheduled标注加上cron的定时标注。cron的6或7个字段从前到后对应的是: 秒分钟小时日期月份星期年例如：要每天10点27分执行 @Scheduled(cron = “0 27 10 * * ?”)每小时执行1次 @Scheduled(cron = “0 0 0/1 * * ?”)

3.在启动类BootApplication添加@EnableScheduling标注，这时定时任务就可以执行了。完成了上面3步，如果有多个定时任务，这时是串行的，只有前面1个定时任务执行完，后面的定时任务才能执行。要异步执行，首先在在启动类BootApplication添加@EnableAsync标注

4.在定时任务执行方法上添加@Async标注

5.添加多线程配置类，设置线程池并发个数等。


@Configuration
@EnableAsync
public class SpringAsycConfigurer implements AsyncConfigurer {

    @Override
    public Executor getAsyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(12);
        executor.setMaxPoolSize(20);
        executor.setWaitForTasksToCompleteOnShutdown(true);
        executor.setAwaitTerminationSeconds( 60 * 15);
        executor.setThreadNamePrefix("MyAsync-");
        executor.initialize();
        return executor;
    }

    @Override
    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
        return null;
    }
}

作者 east