大数据开发 – 第32页

shardingsphere 2月 6,2021

shardingsphere4.0+Springboot+Mybatis+druid动态多数据源

首先Springboot+Mybatis+druid动态多数据源的配置是这样的

@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})
@MapperScan(basePackages = "com.xxx.xxx.mapper")
@Import({DynamicDataSourceConfig.class})
public class BootApplication {

	public static void main(String[] args) {
		TimeZone.setDefault(TimeZone.getTimeZone("Asia/Shanghai"));
		SpringApplication.run(BootApplication.class, args);
	}

}

application.pro的关键配置如下：

spring:

datasource:
type: com.alibaba.druid.pool.DruidDataSource
druid:
# 配置监控服务器：http://ip:端口/druid/index.html
stat-view-servlet:
login-username: admin
login-password: kisen@123
reset-enable: false
url-pattern: /druid/*

  master: # 主数据源
    driverClassName: com.mysql.cj.jdbc.Driver
    username: root
    password: root
    url: jdbc:mysql://167.1.6.163:53306/master?serverTimezone=Asia/Shanghai&useSSL=false&allowMultiQueries=true

  slave: # 从数据源
    #        driverClassName: org.postgresql.Driver
    #        username: postgres
    #        password: postgres
    #        url: jdbc:postgresql://192.168.30.22:5432/slave_db
    driverClassName: com.mysql.cj.jdbc.Driver
    username: root
    password: root
    url: jdbc:mysql://157.1.6.134:53

动态切换的配置文件如下：


import java.lang.annotation.*;

@Target({ElementType.METHOD,ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface DataSource {
    String name() default "";
}

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

@Aspect
@Component
public class DataSourceAspect {

    @Pointcut("@annotation(DataSource)")
    public void dataSourcePointCut() {

    }


    @Around("dataSourcePointCut()")
    public Object around(ProceedingJoinPoint point) throws Throwable {
        MethodSignature signature = (MethodSignature) point.getSignature();
        Method method = signature.getMethod();


        DataSource dataSource = method.getAnnotation(DataSource.class);
        if(dataSource == null){
            DynamicDataSource.setDataSource("master");
        }else {
            System.out.println("dataSource.name()===="+dataSource.name());
            DynamicDataSource.setDataSource(dataSource.name());
        }

        try {
            return point.proceed();
        } finally {
            DynamicDataSource.clearDataSource();
        }
    }
}

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

public class DynamicDataSource  extends AbstractRoutingDataSource {

    private static final ThreadLocal<String> contextHolder = new ThreadLocal<>();

    private static Logger log = LoggerFactory.getLogger(DynamicDataSource.class);

    @Override
    protected Object determineCurrentLookupKey() {
     //   log.info("getDataSource()===================="+getDataSource());
        return getDataSource();
    }

    public static void setDataSource(String dataSource) {
        contextHolder.set(dataSource);
        log.info("切换到{"+dataSource+"}数据源");
        log.info("切换到{"+dataSource+"}数据源");
    }

    public static String getDataSource() {
        return contextHolder.get();
    }

    public static void clearDataSource() {
        contextHolder.remove();
    }
}

下面是最关键的地方，要对普通的druid多数据源动态切换做如下修改


import com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceBuilder;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;

import javax.sql.DataSource;
import java.util.HashMap;
import java.util.Map;

@Configuration
public class DynamicDataSourceConfig {


    @Bean(name = "master")
    @ConfigurationProperties("spring.datasource.druid.master")
    public DataSource  masterDataSource(){
        return DruidDataSourceBuilder.create().build();
    }



    @Bean(name = "slave")
    @ConfigurationProperties("spring.datasource.druid.slave")
    public DataSource  anjianSlaveDataSource(){
        return DruidDataSourceBuilder.create().build();
    }

@Bean(name = "sharding")
public DataSource getShardingDataSource() throws SQLException {
		ShardingRuleConfiguration shardingRuleConfig = new ShardingRuleConfiguration();
 
		//  分库分表逻辑，在这里不做代码展示
 
		return ShardingDataSourceFactory.createDataSource(createDataSourceMap(), shardingRuleConfig,new ConcurrentHashMap(), properties);
	}

 public  Map<String, DataSource> createDataSourceMap() {
	   Map<String, DataSource> dataSourceMap = new HashMap<String, DataSource>(4);
	   // 配置第一个数据源
       DruidDataSource data1 = new DruidDataSource();
       data1.setDriverClassName("数据源驱动");
       data1.setUrl("数据库链接1");
       data1.setUsername("用户名");
       data1.setPassword("密码");
       dataSourceMap.put("data1 ", data1 );
 
       // 配置第二个数据源
       DruidDataSource data2 = new DruidDataSource();
       data2.setDriverClassName("数据源驱动");
       data2.setUrl("数据库链接2");
       data2.setUsername("用户名");
       data2.setPassword("密码");
       dataSourceMap.put("data2 ", data2 );
 
       // 配置第三个数据源
       DruidDataSource data3 = new DruidDataSource();
       data3.setDriverClassName("数据源驱动");
       data3.setUrl("数据库链接3");
       data3.setUsername("用户名");
       data3.setPassword("密码");
       dataSourceMap.put("data3", data3);
       
       // 配置第四个数据源
       DruidDataSource data4 = new DruidDataSource();
       data4.setDriverClassName("数据源驱动");
       data4.setUrl("j数据库链接4");
       data4.setUsername("用户名");
       data4.setPassword("密码");
       dataSourceMap.put("data4", data4);
       
       return dataSourceMap;
   }
 
}



    @Bean(name = "dynamicDataSource")
    @Primary
    public DynamicDataSource dynamicDataSource() {
        DynamicDataSource dynamicDataSource = new DynamicDataSource();
        // 默认数据源
        dynamicDataSource.setDefaultTargetDataSource(masterDataSource());
        // 配置多数据源
        Map<Object, Object> dsMap = new HashMap();
        dsMap.put("master", masterDataSource());
        dsMap.put("slave-anjian", anjianSlaveDataSource());

        dynamicDataSource.setTargetDataSources(dsMap);
        return dynamicDataSource;
    }

    /**
     * 配置@Transactional注解事物
     * @return
     */
    @Bean
    public PlatformTransactionManager transactionManager() {
        return new DataSourceTransactionManager(dynamicDataSource());
    }

}

作者 east

Elasticsearch 1月 31,2021

ES的内存xms和xmx设置不一致导致启动失败

问题背景与现象

ES启动失败：

1. 页面显示ES实例启动失败，查看详情是Xms和Xmx大小不一致；

ES的内存xms和xmx设置不一致导致启动失败

2. 查看ES后台日志，报错如下，初始化内存和最大内存不一致，导致启动失败

/var/log/Bigdata/elasticsearch/esnode1/elasticsearch_cluster.log

2018-12-11T17:21:49,670][INFO ][o.e.b.BootstrapChecks    ] [EsNode1] bound or publishing to a non-loopback address, enforcing bootstrap checks
[2018-12-11T17:21:49,673][ERROR][o.e.b.Bootstrap          ] [EsNode1] node validation exception
[1] bootstrap checks failed
[1]: initial heap size [536870912] not equal to maximum heap size [1073741824]; this can cause resize pauses and prevents mlockall from locking the entire heap
[2018-12-11T17:21:49,677][INFO ][o.e.n.Node               ] [EsNode1] stopping ...
[2018-12-11T17:21:49,708][INFO ][o.e.n.Node               ] [EsNode1] stopped
[2018-12-11T17:21:49,708][INFO ][o.e.n.Node               ] [EsNode1] closing ...
[2018-12-11T17:21:49,721][INFO ][o.e.n.Node               ] [EsNode1] closed

原因分析

如果JVM以不等的初始(Xms)和最大(Xmx)堆(heap)大小启动，则可能会在系统使用期间调整JVM堆的大小，因此可能会暂停。为了避免这些调整大小的停顿，需要使初始(Xms)堆(heap)大小等于最大Xms堆(heap)大小启动JVM。另外，启用了bootstrap.memory_lock，JVM将在启动时锁定堆(heap)的初始(Xms)大小。如果初始堆大小不等于最大堆大小，在重新调整大小之后，将不会将所有JVM堆锁定在内存中。

因此是ES的内核限制，要求ES的启动参数的初始(Xms)和最大(Xmx)内存相等。

作者 east

Elasticsearch 1月 31,2021

Elasticsearch(ES)运维常用命令

集群检查常用命令

1. 查询集群状态命令：

curl -XGET "http://ip:port/_cluster/health?pretty"

2. 查询Es全局状态：

curl -XGET "http://ip:port/_cluster/stats?pretty"

3. 查询集群设置

curl -XGET "http://ip:port/_cluster/settings?pretty"

4. 查看集群文档总数

curl -XGET "http://ip:port/_cat/count?v"

4. 查看集群文档总数

curl -XGET "http://ip:port/_cat/count?v"

5. 查看集群别名组

curl -XGET "http://ip:port/_cat/aliases"

6.查看当前集群索引分片信息

curl -XGET "http://ip:port/_cat/shards?v"   注：查看某一个索引可用shards/索引名?v

7.查看集群实例存储详细信息

curl -XGET "http://ip:port/_cat/allocation?v"

8.查看当前集群的所有实例

curl -XGET "http://ip:port/_cat/nodes?v"

9.查看某索引分片转移进度

curl -XGET "http://ip:port/_cat/recovery/索引名?v"

10.查看当前集群等待任务

curl -XGET "http://ip:port/_cat/pending_tasks?v"

11.查看集群写入线程池任务

curl -XGET "http://ip:port/_cat/thread_pool/bulk?v"

12.查看集群查询线程池任务

curl -XGET "http://ip:port/_cat/thread_pool/search?v"

13.查看分片未分配的原因

curl -XGET "http://127.0.0.1:24100/_cat/shards?v&h=index,shard,prirep,state,node,unassigned.reason" | grep UNASSIGNED

集群设置常用命令

1. 设置集群分片恢复参数

curl -XPUT   "http://ip:httpport/_cluster/settings"  -H  'Content-Type: application/json' -d' 
{ 
"transient": { 
   "cluster.routing.allocation.node_initial_primaries_recoveries":60,
   "cluster.routing.allocation.node_concurrent_recoveries":30,
   "cluster.routing.allocation.cluster_concurrent_rebalance":30
   } 
}'

2. 根据实例名称使EsNodeX实例下线：

curl -XPUT  "http://ip:httpport/_cluster/settings" -H 'Content-Type: application/json' -d' 
{ 
    "transient": { 
        "cluster.routing.allocation.exclude._name": "EsNode2@ip" 
     } 
}'

3. 根据ip使ES数据节点下线：

curl -XPUT  "http://ip:httpport/_cluster/settings" -H 'Content-Type: application/json' -d' 
{ 
    "transient": { 
          "cluster.routing.allocation.exclude._ip": "ip1,ip2,ip3" 
     } 
}'

4. 设置分片恢复过程中的最大带宽速度：

curl -XPUT "http://127.0.0.1:24100/_cluster/settings" -H 'Content-Type: application/json' -d
'{
 "transient":{
     "indices.recovery.max_bytes_per_sec":"500mb"
  }
}'

5. 重新分片为空的主分片

 curl -XPOST  "http://127.0.0.1:24100/_cluster/reroute?pretty" -H 'Content-Type:application/json' -d '
{
   "commands": [{
                "allocate_empty_primary": {		
                                      "index": "indexname",			
                                      "shard": 2,
                                      "node": "EsNode1@81.20.5.24",
                                      "accept_data_loss":true
                                           }
               }]
}'

6. 重新分配主分片，会尝试将过期副本分片分片为主。

curl -XPOST "http://127.0.0.1:24100/_cluster/reroute?pretty" -H 'Content-Type:application/json' -d '
{
   "commands": [{
               "allocate_stale_primary": {
                                        "index": "index1",
                                        "shard": 2,
			                "node": "EsNode1@189.39.172.103",
                                        "accept_data_loss":true
                                          }
               }]
}'

7. 清理ES所有缓存

curl -XPOST "http://ip:port/_cache/clear"

8.关闭分片自动平衡

curl -XPUT
 "http://ip:port/_cluster/settings" -H 'Content-Type:application/json' -d '
{
   "transient":{   "cluster.routing.rebalance.enable":"none" }
}'

9.手动刷新未分配的分片

curl -XPOST "http://127.0.0.1:24100/_cluster/reroute?retry_failed=true"

索引查看常用命令

1. 查询索引mapping和settings

curl -XGET_{--tlsv1.2  --negotiate -k -u : 'https://ip:port/my_index_name?pretty'}

2. 查询索引settings

curl -XGET--tlsv1.2  --negotiate -k -u : 'https://ip:port/my_index_name/_settings?pretty'

3.查看分片未分配详细命令

curl -XGET "http://127.0.0.1:24100/_cluster/allocation/explain?pretty" -H 'Content-Type:application/json' -d '
{"index": "indexname","shard": 17,"primary": true}'

4.修改索引只读字段属性为null，放开写入

curl -XPUT  "http://127.0.0.1:24100/*/_settings" -H 'Content-Type: application/json' -d '{"index.blocks.read_only_allow_delete": null}'

索引设置常用命令

1.关闭索引

curl -XPOST 'http://ip:port/my_index/_close?pretty'

2.打开索引

curl -XPOST 'http://ip:port/my_index/_open?pretty'

3.修改索引刷新时间：

curl -XPUT 'http://ip:port/my_index/_settings?pretty' -H 'Content-Type: application/json' -d'{"refresh_interval" : "60s"}'

4.修改translog文件保留时长，默认为12小时

curl -XPUT 'http://ip:port/my_index/_settings?pretty' -H 'Content-Type: application/json' -d'{"index.translog.retention.age" : "30m"}'

5.设置索引副本：

curl -XPUT 'http://ip:port/my_index/_settings?pretty' -H 'Content-Type: application/json' -d'{"number_of_replicas" : 1}'

6.执行refresh，将内存数据刷新到磁盘缓存

curl -XPOST 'http://ip:port/myindex/_refresh'

7.执行flush，将磁盘缓存刷新到文件系统

curl -XPOST 'https://ip:port/myindex/_flush'

8.执行synced flush，生成syncid

curl -XPOST  'http://ip:port/_flush/synced'

9. 强制执行段合并

curl -XPOST 'http://ip:httpport/myindex/_forcemerge?only_expunge_deletes=false&max_num_segments=1&flush=true&pretty'

10.设置索引在每个esnode上的分片个数

curl -XPUT 'http://ip:httpport/myindex/_settings?pretty' -H 'Content-Type: application/json' -d'{"index.routing.allocation.total_shards_per_node" : "2"}'

11. 配置控制段合并的refresh、merge线程数等

curl -XPUT  "http://ip:port/my_index/_settings?pretty" -H 'Content-Type: application/json' -d'
{"refresh_interval": "60s",
 "merge":{"scheduler"：{"max_merge_count" : "100",
                        "max_thread_count" : "1"},
          "policy":{"segments_per_tier" : "100",
                    "floor_segment" : "1m",
                    "max_merged_segment" : "2g"}
          }
}'

12.设置索引的刷新时间和translog配置参数

注意：设置translog参数，必须先关闭索引，设置完成后再打开

*代表设置所有索引，如果要设置具体某个索引，可以将*替换为具体的索引名称

curl -XPUT "http://ip:httpport/*/_settings" -H 'Content-Type: application/json' -d'
{ "index": 
          { "refresh_interval" : "60s",
            "translog": 
                      { "flush_threshold_size": "1GB", "sync_interval": "120s", "durability": "async" 
                      } 
          } 
}'

13.限制每个索引在每个实例上的分片个数

curl -XPUT  'http://ip:httpport/myindex/_settings?pretty' -H 'Content-Type:application/json' -d '{"index.routing.allocation.total_shards_per_node":"2"}'

实例检查常用命令

1.查看实例安装插件

curl -XGET "http://ip:port/_cat/aliases"

2.查询指定ES实例的jvm参数：

curl -XGET 'http://ip:port/_nodes/EsNode1*/stats/jvm?pretty'
curl -XGET 'http://ip:port/_nodes/EsNode1@12.40.16.156/stats/jvm?pretty'

作者 east

Elasticsearch 1月 31,2021

Elasticsearch规划及性能规格

影响因子分析

Elasticsearch组件的索引和查询性能主要受到物理资源（内存、磁盘、CPU、网络）和逻辑资源（数据类型、数据长度、分词类别）的影响。

物理资源

影响因子如：

内存：内存大小会影响到写入数据的速度、缓存的多少。
磁盘：磁盘的性能影响到索引数据写入磁盘的速度。
CPU：CPU的性能影响到分词的速度、处理倒排索引的速度等。
网络：影响到分布式索引和查询消息处理的速度。

逻辑资源

影响因子如：

数据类型：字符串、整型、浮点型，不同的数据类型对资源的消耗程度不同。
数据长度：字段的大小对资源的消耗程度不同。
分词类别：采用不同的分词器对资源的消耗程度不同。
shard个数划分：根据数据量的不同应当对index赋予不同的shard个数。

物理资源规划

频繁的请求下，Elasticsearch对内存、CPU、网络与磁盘的性能有较高的要求，一般情况下，建议Elasticsearch独占这些物理资源，尽量不与其他耗资源的组件合布。

磁盘使用必须使用SAS盘，不建议使用SATA盘进行存储。

内存配置

FusionInsight Elasticsearch单节点（node）默认分配的HeapSize为4GB，若机器内存的50%>实例数*31G，设置为31G，否则设置为机器内存的50%/实例数。资源允许的情况下，单个实例可以分配的最大HeapSize不要超过31GB。

另外，需要留下一半的物理内存作为Lucene缓存使用。如果不按照此建议设置，将会影响索引与查询的性能。

示例

如果系统为128GB物理内存，那么建议留下64GB预留给Lucene缓存，剩下的64GB可以分配2个Elasticsearch节点（nodes）。每个节点分配31GB内存。
如果系统为256GB物理内存，安装上面的计算实际上我们可以设置4个EsNode但是不建议安装4个。说明： 256G及以上内存的机器只建议安装3个EsNode实例。虽然内存满足要求，但是由于受CPU核数的限制集群性能不会有太大提升。多余的内存Lucene也会全部利用了。

磁盘挂载

Elasticsearch单索引数据目前可以较优支持到TB级别，数据量庞大，建议Elasticsearch按照实例（nodes）进行单独挂盘。

示例

用户某个物理机上分配了两个Elasticsearch nodes，分别是EsNode1和EsNode2，一个实例对应写一个固定磁盘。需要为这两个实例挂载两个磁盘，挂载目录分别为“/srv/BigData/elasticsearch/esnode1/”和“/srv/BigData/elasticsearch/esnode2/”。

说明：

磁盘类型不同，性能也相差巨大。如：SSD读写速度大约是SAS盘的50倍，而SAS盘读写速度可以达到SATA盘的2倍以上。
Elasticsearch的总实例数在500以上时，EsMaster必须使用SSD盘，且EsMaster可使用的CPU资源要大于等于32核。

shard个数规划

一个index可以被分为多个shards，从而分布到不同的物理机上。Shard的划分结果也会影响索引和查询速度。

每个分片都可以处理数据写入和查询请求，在设置索引分片数时，可从以下几个方面考虑：

每个shard包含的数据条数越多，查询性能会降低（建议1亿条左右，最多建议不超过4亿）。
建议单个分片保存的数据量在20GB左右，最大不超过30GB。
根据索引预计承载的最大数据容量和单个分片容量确定主分片个数。一般来说，预计存储的数据量越大，应当分配的shard越多，分布式查询的优势越明显。如果确认某个index的数据量非常少（如一年不到1GB），那么过多的分配shard，反而可能不如单shard的性能好
为了提升数据可靠性，合理设置副本分片个数，至少设置为1，如果集群的存储空间足够，推荐设置为2。
每个node可以支撑的shards个数是有限的，node是物理资源分配的对象，随着shards中数据的增大，shards中的数据在查询时被不断加载到内存，达到一定量时，将会把HeapSize耗尽，导致频繁GC，系统将不能正常工作。推荐1GB内存管理15个shard，以一个Elasticsearch实例内存最大31G为例，单实例管理的shard数保持在500以内。
当Elasticsearch集群实例数大于500时，请确保Elasticsearch集群的总shard数小于等于50000个。过多的shard数会导致EsMaster压力过大，Elasticsearch集群不稳定。

shard个数规划

一个index可以被分为多个shards，从而分布到不同的物理机上。Shard的划分结果也会影响索引和查询速度。

每个分片都可以处理数据写入和查询请求，在设置索引分片数时，可从以下几个方面考虑：

每个shard包含的数据条数越多，查询性能会降低（建议1亿条左右，最多建议不超过4亿）。
建议单个分片保存的数据量在20GB左右，最大不超过30GB。
根据索引预计承载的最大数据容量和单个分片容量确定主分片个数。一般来说，预计存储的数据量越大，应当分配的shard越多，分布式查询的优势越明显。如果确认某个index的数据量非常少（如一年不到1GB），那么过多的分配shard，反而可能不如单shard的性能好
为了提升数据可靠性，合理设置副本分片个数，至少设置为1，如果集群的存储空间足够，推荐设置为2。
每个node可以支撑的shards个数是有限的，node是物理资源分配的对象，随着shards中数据的增大，shards中的数据在查询时被不断加载到内存，达到一定量时，将会把HeapSize耗尽，导致频繁GC，系统将不能正常工作。推荐1GB内存管理15个shard，以一个Elasticsearch实例内存最大31G为例，单实例管理的shard数保持在500以内。
当Elasticsearch集群实例数大于500时，请确保Elasticsearch集群的总shard数小于等于50000个。过多的shard数会导致EsMaster压力过大，Elasticsearch集群不稳定。

作者 east

bug清单, Java 1月 4,2021

SpringBoot 接口返回的 JSON 数据的时间与数据存储时间有误差

在做一个项目，接入数据存到数据库，在图层上展示今天、昨天的数据。但是发现展示的时间有误差。

 
使用MySQL57，（程序中打印的时间字段）查询出的时间字段总是和数据库存储的相差两个小时。
最后是通过修改数据库连接解决了这个问题。添加了下面这个属性。
&serverTimezone=Asia/Shanghai
接着又出现问题了。
默认情况下使用 @ResponseBody ，项目返回的JSON数据，返回对象会自动转为JSON格式，但是对象中的日期格式Date字段转换的时候相差了八小时，程序内打印时间没有问题，如果将 Date 改为 String 类型的话，也不会出现这种情况了。
所以问题应该出在返回结果格式化为JSON的这个过程中。
原因是spring转json的默认实现jackson中会根据时区去转换时间，而jackson的默认时区跟国内应该是相差8小时，所以在时间换算上自动减去了8小时。
可以通过jackson 的注解 @JsonFormat 解决问题
    @JsonFormat(pattern="yyyy-MM-dd HH:mm:ss" ,timezone = "GMT+8")     private Date createTime;     @JsonFormat(pattern="yyyy-MM-dd HH:mm:ss" ,timezone = "GMT+8")     private Date updateTime;
也可以在 SpringBoot 配置文件中统一配置，推荐使用这种方式：
　　spring.jackson.date-format=yyyy-MM-dd HH:mm:ss 　　spring.jackson.time-zone=GTM+8

作者 east

bug清单, Java 1月 4,2021

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

在线上环境容易出现一些开发环境没遇到的问题。就像这个问题，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
二 修改tomcat临时存放文件位置（不建议）
application.properties 文件中添加 （此方法会讲所有tomcat临时文件放在指定目录，新目录没有定时清理功能，不建议）
  server.tomcat.basedir=/data/ops/app/cms/cache 2
三 修改centos定时清理功能（不建议)
vim /etc/cron.daily/tmpwatch
#! /bin/sh flags=-umc /usr/sbin/tmpwatch "$flags" -x /tmp/.X11-unix -x /tmp/.XIM-unix \         -x /tmp/.font-unix -x /tmp/.ICE-unix -x /tmp/.Test-unix \         -X '/tmp/hsperfdata_*' 10d /tmp \         -X '/tmp/tomcat.*' 10d /tmp /usr/sbin/tmpwatch "$flags" 30d /var/tmp for d in /var/{cache/man,catman}/{cat?,X11R6/cat?,local/cat?}; do     if [ -d "$d" ]; then         /usr/sbin/tmpwatch "$flags" -f 30d "$d"     fi done 24681012141618202224
其中添加一行
-X '/tmp/tomcat.*' 10d /tmp

作者 east

Java 1月 4,2021

springboot使用 @scheduled 多任务并发

springboot的@scheduled，并不是默认并发的，想给方法添加@Scheduled注解，实现两个定时任务。可是运行发现，两个task并没有并发执行，而是执行完一个task才会执行另外一个。

要给类添加注解@EnableAsync，并给方法添加注解@Async。

 
@Component
@Configurable
@EnableScheduling
@EnableAsync
public class DemoTask {
@Async
@Scheduled(cron = "0/5 * *  * * ? ")
public void startSchedule() {
System.out.println("===========1=>");
try {
for(int i=1;i<=10;i++){
System.out.println("=1==>"+i);
Thread.sleep(1000);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
 
@Async
@Scheduled(cron = "0/5 * *  * * ? ")
public void startSchedule2() {
for(int i=1;i<=10;i++){
System.out.println("=2==>"+i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}

在这个类或启动类BootApplication添加@EnableScheduling标注

作者 east

bug清单, Java 1月 4,2021

Spring Boot Maven项目使用SystemPath引用线上部署遇到的问题

使用了第三方Jar包，最先考虑的是不使用Maven仓库，便于离线开发。首先采用了方案：

 <dependency>
        <groupId>com.tievd.third</groupId>
        <artifactId>arcvideo</artifactId>
        <version>1.0</version>
        <scope>system</scope>
        <systemPath>${basedir}/lib/face-api-1.0.jar</systemPath>
    </dependency>

但很多人讲到这里就没讲了，你会发现在IDE里会运行的非常好，一旦部署在线上环境，就会出现莫名其妙的问题。比如我遇到的不会抛异常，会一直卡在对象创建上。后来一直找不到问题出现在哪里，就改用了私服，发现问题解决，所以定位在问题肯定出现在打包上：第一步：确认解压之前的Jar包发现确实没有把第三方包打入进去第二步：在build节点加入一下语句使包正确的导入

   <resources>
            <resource>
                <directory>${project.basedir}/lib</directory>
                <targetPath>BOOT-INF/lib/</targetPath>
                        <includes>
                           <include>**/*.jar</include>
                        </includes>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
                <targetPath>BOOT-INF/classes/</targetPath>
            </resource>
</resources>

重新打包发现可以在线上环境正常部署了。

作者 east

Spark 1月 4,2021

Idea配置Scala开发环境注意事项

使用maven方式，注意切注意spark与scala有版本对应关系，详情参考Spark官网相关说明：https://spark.apache.org/docs/latest/index.htmlscala版本还要跟工程配置Library添加的Scala版本一致，才不会出现“Cannot find Main Class”在pom.xml中添加maven 依赖包时，我就发现不管是否用了翻墙，下载速度都好慢，就1M的东西能下半天，很是苦恼，于是到网上搜资料，然后让我查到了。说是使用阿里的maven镜像就可以了。我于是亲自试了下，速度快的飞起！！！右键项目选中maven选项，然后选择“open settings.xml”或者 “create settings.xml”，然后把如下代码粘贴进去就可以了。重启IDE，感受速度飞起来的感觉吧！！！

<?xml version="1.0" encoding="UTF-8"?>
<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0 http://maven.apache.org/xsd/settings-1.0.0.xsd">
    <mirrors>
        <!-- mirror
         | Specifies a repository mirror site to use instead of a given repository. The repository that
         | this mirror serves has an ID that matches the mirrorOf element of this mirror. IDs are used
         | for inheritance and direct lookup purposes, and must be unique across the set of mirrors.
         |
        <mirror>
          <id>mirrorId</id>
          <mirrorOf>repositoryId</mirrorOf>
          <name>Human Readable Name for this Mirror.</name>
          <url>http://my.repository.com/repo/path</url>
        </mirror>
         -->

        <mirror>
            <id>alimaven</id>
            <name>aliyun maven</name>
            <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
            <mirrorOf>central</mirrorOf>
        </mirror>

        <mirror>
            <id>uk</id>
            <mirrorOf>central</mirrorOf>
            <name>Human Readable Name for this Mirror.</name>
            <url>http://uk.maven.org/maven2/</url>
        </mirror>

        <mirror>
            <id>CN</id>
            <name>OSChina Central</name>
            <url>http://maven.oschina.net/content/groups/public/</url>
            <mirrorOf>central</mirrorOf>
        </mirror>

        <mirror>
            <id>nexus</id>
            <name>internal nexus repository</name>
            <!-- <url>http://192.168.1.100:8081/nexus/content/groups/public/</url>-->
            <url>http://repo.maven.apache.org/maven2</url>
            <mirrorOf>central</mirrorOf>
        </mirror>

    </mirrors>
</settings>

作者 east

数据仓库 1月 3,2021

数据采集与同步经验之谈

根据埋点位置，可分为客户端埋点、服务端埋点，实际各有利弊，比如服务端埋点对后台请求的用户无法捕获，而客户端埋点可能会由于用户的环境问题存在数据丢包，客户端可能无法获取全部的数据等，所以在无特殊情况下，建议采用服务端埋点方案。

埋点要把一切用户操作行为都看做事件，覆盖事件的核心要素，包括人、时间、事、地点、方式。

埋点的数据格式，要确保灵活、可扩展性，上报数据采用json格式，不要太深的嵌套。

作者 east

分类归档大数据开发