Java常用应用

20230725更新

1 常用方法

List常用方法

List<Map<String, String>> 根据某个key排序

 List<BusinessProjectVO> records = Optional.ofNullable(businessProjectPage).orElse(new Page<>()).getRecords().stream().peek(e -> {
                R<Long> totalData = remoteSynchronizorService.getTotalData(e.getAppId());
                e.setTotalDate(totalData.getData());
            }).collect(Collectors.toList());
//根据totalDate字段排倒序
records = records.stream().sorted(Comparator.comparing(BusinessProjectVO::getTotalDate).reversed()).collect(Collectors.toList());

List过滤

List<Map<String, Object>> collectDataList = dataList.stream().filter(dataRow -> ("1".equals(String.valueOf(dataRow.get("group_bit"))))).collect(Collectors.toList());

stream方法

//List<Object> 转为 Map<String,Integer>
Map<String,Integer> allBoardNameMap = allDataBoards.stream().collect(Collectors.toMap(dataBoard->dataBoard.getBoardName(), dataBoard -> 1, (existingValue, newValue) -> newValue));

//List<Object> 转为 List<Long>
List<Long> reportIds = boardReportRelations.stream().map(boardReportRelation -> boardReportRelation.getReportId()).collect(Collectors.toList());

List<String> sqlQueryChartIds = boardReports.stream().filter(boardReport -> StringUtils.isNotBlank(boardReport.getChartId())).map(boardReport -> boardReport.getChartId()).collect(Collectors.toList());

判断List集合中是否存在相同元素

//校验是否存在相同资产
List<String> assetNoList = Lists.newArrayList();
beforeMergeAssetList.forEach( asset->{
    String assetNo = asset.getAssetInfo().getAssetNo();
    if (StringUtils.isBlank(assetNo)){throw new JeecgBootException("合并前资产编号不能为空");}
    assetNoList.add(assetNo);
});
Set assetNoSet=new HashSet<>(assetNoList);
if (assetNoList.size() != assetNoSet.size()) {throw new JeecgBootException("请选择不同的资产");}

判空

1 对象
if (Objects.isNull(assetMergeDTO)){ throw new JeecgBootException("请选择资产"); }
2 集合
CollectionUtils.isNotEmpty(records)
3 字符串
StringUtils.isBlank(assetMergeNo)

集合流方法使用

@AutoLog(value = "资产组合-组合日志查询")
    @ApiOperation(value = "资产组合-组合日志查询", notes = "资产组合-组合日志查询")
    @GetMapping("/getMergeLog")
    public Result<?> getMergeLog(@RequestParam(name = "assetNo", required = true) String assetNo) {
        List<AssetMerge> assetMergeList = iAssetMergeService.selectByAssetNo(assetNo);
        Map<String, List<AssetMerge>> listMap = assetMergeList.stream().collect(Collectors.groupingBy(AssetMerge::getAssetMergeNo));
        Set<Map.Entry<String, List<AssetMerge>>> entries = listMap.entrySet();
        JSONArray JSONArray = new JSONArray();
        for (Map.Entry<String, List<AssetMerge>> entry : entries) {
            JSONObject jsonObject = new JSONObject();
            String key = entry.getKey();
            List<AssetMerge> value = entry.getValue();
            List<JSONObject> list = value.stream()
                    .sorted((o1, o2) -> (int) (o1.getId() - o2.getId()))
                    .map(assetSplit -> {
                        JSONObject temp = new JSONObject();
                        temp.put("assetNo", assetSplit.getBeforeMergeAssetNo());
                        temp.put("assetName", assetSplit.getBeforeMergeAssetName());
                        return temp;
                    }).collect(Collectors.toList());
            AssetMerge assetMerge = value.get(0);
            String assetMergeNo = assetMerge.getAssetMergeNo();
            String afterMergeAssetNo = assetMerge.getAfterMergeAssetNo();
            String afterMergeAssetName = assetMerge.getAfterMergeAssetName();
            jsonObject.put("assetMergeNo", assetMergeNo);
            jsonObject.put("afterMergeAssetNo", afterMergeAssetNo);
            jsonObject.put("afterMergeAssetName", afterMergeAssetName);
            jsonObject.put("beforeMergeAssetList", list);
            jsonObject.put("mergeTime", assetMerge.getCreateTime());
            JSONArray.add(jsonObject);
        }
        return Result.ok(JSONArray);
    }

TryCatch基本使用

//参数校验
try {
    if (Objects.isNull(assetMergeDTO)){ throw new JeecgBootException("请选择资产"); }
    List<AssetInfoDTO> beforeMergeAssetList = assetMergeDTO.getBeforeMergeAssetList();
    if (Objects.isNull(beforeMergeAssetList) || beforeMergeAssetList.size() < 2){throw new JeecgBootException("请选择2个及2个以上资产");}
    AssetInfoDTO afterMergeAsset = assetMergeDTO.getAfterMergeAsset();
    if (Objects.isNull(afterMergeAsset)){throw new JeecgBootException("请输入合并后资产信息");}
} catch (JeecgBootException e) {
    e.printStackTrace();
    return Result.error(e.getMessage());
}

导入导出Excel

方法1

@Override
@Transactional(rollbackFor = Exception.class)
public Result<?> importBatchMaintainAssetExcel(HttpServletRequest request) throws IOException {
    MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
    Map<String, MultipartFile> fileMap = multipartRequest.getFileMap();
    LoginUser loginUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
    if(loginUser==null){throw new JeecgBootException("登录失效，请重新登录");}
    String username = loginUser.getUsername();
    Date date = new Date();
    // 错误信息
    List<String> errorMessage = new ArrayList<>();
    int successLines = 0, errorLines = 0;
    for (Map.Entry<String, MultipartFile> entity : fileMap.entrySet()) {
        MultipartFile file = entity.getValue();// 获取上传文件对象
        ImportParams params = new ImportParams();
        params.setHeadRows(1);
        params.setTitleRows(2);
        params.setNeedSave(true);
        try {
            List<AssetMaintainExcelImportDTO>  importAssetScraps = ExcelImportUtil.importExcel(file.getInputStream(), AssetMaintainExcelImportDTO.class, params);
            List<AssetMaintainDTO>  list = new ArrayList<>();
            int i=2;
            //先校验参数
            if(CollectionUtils.isEmpty(importAssetScraps)){throw new JeecgBootException("维修信息为空");}
            for (AssetMaintainExcelImportDTO importAssetScrap : importAssetScraps) {
                try {
                    i = i + 1;
                    String assetNo = importAssetScrap.getAssetNo();
                    String remark = importAssetScrap.getRemark();

                    if(StringUtils.isBlank(assetNo)){throw new JeecgBootException("第"+i+"行 资产编号为空");}

                    AssetInfo assetInfo = iAssetInfoService.getByAssetNo(assetNo);
                    if(assetInfo==null){throw new JeecgBootException("第"+i+"行 资产编号错误【"+assetNo+"】");}
                    if(!AssetStatusEnum.INSTORE.getValue().equals(assetInfo.getAssetStatus())){throw new JeecgBootException("第"+i+"行 资产【"+assetNo+"】不是库存状态");}
                    assetInfo.setAssetStatus(AssetStatusEnum.MAINTENANCE.getValue());
                    AssetInfoDTO assetInfoDTO = new AssetInfoDTO();
                    assetInfoDTO.setAssetInfo(assetInfo);
                    iAssetInfoService.assetInfoCheck(assetInfoDTO);
                    AssetMaintainDTO assetScrapDTO = new AssetMaintainDTO();
                    assetScrapDTO.setAssetInfoDTO(assetInfoDTO);
                    assetScrapDTO.setCreateTime(date);
                    assetScrapDTO.setRemark(remark);
                    assetScrapDTO.setCreateBy(username);

                    list.add(assetScrapDTO);
                }catch (JeecgBootException je){
                    throw new JeecgBootException("第"+i+"行数据错误，"+je.getMessage());
                }
            }
            //没有任何问题，再开始保存
            for (AssetMaintainDTO assetScrapDTO : list) {
                try {
                    this.saveMaintainAssetInfo(assetScrapDTO);
                } catch (JeecgBootException je) {
                    errorLines += 1;
                    errorMessage.add(je.getMessage());
                }catch (Exception e) {
                    errorLines += 1;
                    errorMessage.add(e.getMessage());
                }
            }
            successLines+=(importAssetScraps.size()-errorLines);
        }catch (JeecgBootException je){
            return Result.error("文件导入失败:" + je.getMessage());
        } catch (Exception e) {
            log.error(e.getMessage(), e);
            return Result.error("文件导入失败:" + e.getMessage());
        } finally {
            try {
                file.getInputStream().close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    return ImportExcelUtil.imporReturnRes(errorLines,successLines,errorMessage);
}

@AutoLog(value = "资产合并-导出")
@ApiOperation(value = "资产合并-导出", notes = "资产合并-导出")
@RequestMapping(value = "/exportAssetMergeXls")
public ModelAndView exportAssetMergeXls(AssetMergeReq req, HttpServletRequest request) {
    ModelAndView mv = new ModelAndView(new JeecgEntityExcelView());
    List<AssetMergeVO> assetMergeVOList = iAssetMergeService.getAssetMergeList(req);
    //导出文件名称
    mv.addObject(NormalExcelConstants.FILE_NAME, "资产合并列表");
    mv.addObject(NormalExcelConstants.CLASS, AssetMergeVO.class);
    LoginUser user = (LoginUser) SecurityUtils.getSubject().getPrincipal();
    mv.addObject(NormalExcelConstants.PARAMS, new ExportParams("资产合并列表", "导出人:" + user.getRealname(), "导出信息"));
    mv.addObject(NormalExcelConstants.DATA_LIST, assetMergeVOList);
    return mv;
}

方法2

依赖

        <!-- 阿里开源EXCEL -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>easyexcel</artifactId>
            <version>2.2.5</version>
        </dependency>

代码实现

  @PostMapping("/dailyData/export")
  public void exportDailyData(@Valid @RequestBody CustomBoardDailyDataReq req, HttpServletResponse response) {
    try {
      checkDailyDataParams(req);
      List<CustomBoardDailyDataVO> resultList = customBoardDailyDataService.dailyDataExport(req);

      response.setContentType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
      response.setCharacterEncoding("utf-8");
      String fileName = URLEncoder.encode("日报-"+ DateUtils.getCurrentTimeNoUnderline(), "UTF-8").replaceAll("\\+", "%20");
      response.setHeader("Content-disposition", "attachment;filename*=utf-8''" + fileName + ".csv");
      response.setHeader("file-name", fileName);

      ExcelWriter excelWriter = EasyExcel.write(response.getOutputStream()).build();
//      WriteSheet writeSheet0 = EasyExcel.writerSheet(0, "日报").head(CustomBoardDailyDataVO.class).build();
      //动态隐藏表头
      List<String> columnsList = Lists.newArrayList();
      String columns = req.getColumns();
      if (StringUtils.isNotBlank(columns)){
        columnsList = Arrays.asList(columns.split(","));
      }
      WriteSheet writeSheet0 = EasyExcel.writerSheet(0, "日报")
          .excludeColumnFiledNames(columnsList).head(CustomBoardDailyDataVO.class).build();
      excelWriter.write(resultList, writeSheet0);
      excelWriter.finish();
    }catch (CheckedException ce){
      log.error("error-日报-导出接口:{}", ce);
    } catch (Exception e) {
      log.error("error-日报-导出接口:{}", e);
    }
  }

Json字符串转换为对应类型

//Map、List<String>等等：

//数组String转成List<String>
String s = ["SITE_SET_KANDIAN","SITE_SET_QQ_MUSIC_GAME"]
List<String> parse = (List<String>)JSONArray.parse(siteSet);

//Map的String转换为Map
String s = {"image":"66159322","description":"殿堂级卡牌震撼公测，安卓抢先","video":"157776020","label":[{"type":1,"content":"挂机"},{"type":1,"content":"Q萌卡通"},{"type":1,"content":"二次元"}],"title":"告别假放置！下载领取超多福利","brand":{"brand_name":"冒险世界","brand_img":"66160154"}}
Map map = JSONObject.parseObject(adcreativeElements,Map.class);

后台post请求接口

/**
     * post请求
     *
     * @param url
     * @param jsonObject object
     * @return json object
     */
public static String doPost(String url, JSONObject jsonObject) throws IOException {
    HttpClient client = HttpClientBuilder.create().build();
    HttpPost post = new HttpPost(url);
    String result =  null;

    RequestConfig requestConfig = RequestConfig.custom()
        .setConnectTimeout(10000)
        .setConnectionRequestTimeout(10000)
        .setSocketTimeout(60000)
        .build();
    post.setConfig(requestConfig);
    post.addHeader("Content-type","application/json; charset=utf-8");
    post.setHeader("Accept", "application/json");
    StringEntity s = new StringEntity(jsonObject.toString(),"UTF-8");
    post.setEntity(s);
    HttpResponse res = client.execute(post);
    if (res.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
        HttpEntity entity = res.getEntity();
        result = EntityUtils.toString(entity);
    }
    return result;
}

/*
     * 测试 用户标签创建方式为 首末次特征
     * */
public static void main(String[] args) throws Exception{
    String url = "http://localhost:9201/useranalysis/saveUserLabelMeta";
    JSONObject json = new JSONObject();
    json.put("appId",1386652408108683264L);
    json.put("createMode",3);//首末次特征
    json.put("dataUpdate",1);
    json.put("conditionJson","{\"columnName\":\"#screen_width\",\"columnType\":\"DOUBLE\",\"eventName\":\"login\",\"filts\":[{\"columnName\":\"#account_id\",\"comparator\":\"notEqual\",\"ftv\":[\"444444\"],\"selectType\":\"STRING\",\"tableType\":\"user\"}],\"isFirstEvent\":true,\"isUserFilter\":true,\"recentDay\":\"0-7\",\"relation\":\"or\"}");
    json.put("labelName","标签_20210429_1002");
    json.put("labelNo","tag_20210429_2");
    json.put("userId",101);
    System.out.println(json.toString());
    String s = HttpUtil.doPost(url, json);
    System.out.println(s);
}

@Value注解读取配置属性值

assetInfo:
  deviceTypeID: "1402108939024203778"

@Value("${assetInfo.deviceTypeID}")
private String DEVICE_TYPE_ID;

正则匹配

package org.jeecg.modules.base.util;

import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * @description: 正则表达式工具类
 * @author: nml
 * @time: 2020/12/23 11:56
 **/
public final class RegexUtils {

	/**
	 * 获得匹配正则表达式的内容
	 * @param str 字符串
	 * @param reg 正则表达式
	 * @param isCaseInsensitive 是否忽略大小写，true忽略大小写，false大小写敏感
	 * @return 匹配正则表达式的字符串，组成的List
	 */
	public static List<String> getMatchList(final String str, final String reg, final boolean isCaseInsensitive) {
		ArrayList<String> result = new ArrayList<String>();
		Pattern pattern = null;
		if (isCaseInsensitive) {
			//编译正则表达式,忽略大小写
			pattern = Pattern.compile(reg, Pattern.CASE_INSENSITIVE);
		} else {
			//编译正则表达式,大小写敏感
			pattern = Pattern.compile(reg);
		}
		Matcher matcher = pattern.matcher(str);// 指定要匹配的字符串
		while (matcher.find()) { //此处find（）每次被调用后，会偏移到下一个匹配
			result.add(matcher.group());//获取当前匹配的值
		}
		result.trimToSize();
		return result;
	}

	/**
	 * 获取第一个匹配正则表达式的子串
	 * @param str 完整字符串
	 * @param reg 正则表达式
	 * @param isCaseInsensitive 是否忽略大小写，true表示忽略，false表示大小写敏感。
	 * @return 第一个匹配正则表达式的子串。
	 */
	public static String getFirstMatch(final String str, final String reg, final boolean isCaseInsensitive) {
		Pattern pattern = null;
		if (isCaseInsensitive) {
			//编译正则表达式,忽略大小写
			pattern = Pattern.compile(reg, Pattern.CASE_INSENSITIVE);
		} else {
			//编译正则表达式,大小写敏感
			pattern = Pattern.compile(reg);
		}
		Matcher matcher = pattern.matcher(str);// 指定要匹配的字符串
		if (matcher.find()) {
			return matcher.group();
		}
		return null;
	}

    //匹配：张三[101]。其中汉字2-4个，数字3-10个。
	public static boolean checkNameAndWorkNo(String dataStr) {
		String regFormat = "^[\\u4E00-\\u9FA5]{2,4}\\[\\d{3,10}\\]$";
		boolean isMatch = Pattern.matches(regFormat , dataStr);
		return isMatch;
	}


}

反射机制

Java反射机制是Java语言的一个特性，它可以在运行时获取类的结构信息，如类名、方法名、属性名等，并且可以动态地创建对象、调用方法、访问属性等。Java反射机制为程序员提供了更大的灵活性和编程能力，通常用于以下几个方面：

1. 动态加载类：Java反射机制可以在程序运行时根据类名称加载相应的类，实现类的动态加载。
2. 动态创建对象：Java反射机制可以通过调用Class对象的newInstance()方法动态地创建对象，有利于代码的扩展性和复用性。
3. 动态调用方法：Java反射机制可以在运行时动态调用方法，不需要事先知道方法名，极大地拓展了程序的功能性。
4. 访问私有属性和方法：Java反射机制可以通过设置setAccessible()方法来访问类的私有属性和方法，而不受访问修饰符的限制。
5. 实现泛型数组：Java反射机制可以实现泛型数组的创建和访问，提高了程序的可读性和可维护性。

总之，Java反射机制是Java语言中的一个重要机制，通过反射技术，程序员可以在运行时获取并操作类的结构信息，提高程序的灵活性和可扩展性。

1 获得Class：主要有三种方法：

（1）Object–>getClass

（2）任何数据类型（包括基本的数据类型）都有一个“静态”的class属性

（3）通过class类的静态方法：forName(String className)（最常用）

package fanshe;
 
public class Fanshe {
	public static void main(String[] args) {
		//第一种方式获取Class对象  
		Student stu1 = new Student();//这一new 产生一个Student对象，一个Class对象。
		Class stuClass = stu1.getClass();//获取Class对象
		System.out.println(stuClass.getName());
		
		//第二种方式获取Class对象
		Class stuClass2 = Student.class;
		System.out.println(stuClass == stuClass2);//判断第一种方式获取的Class对象和第二种方式获取的是否是同一个
		
		//第三种方式获取Class对象
		try {
			Class stuClass3 = Class.forName("fanshe.Student");//注意此字符串必须是真实路径，就是带包名的类路径，包名.类名
			System.out.println(stuClass3 == stuClass2);//判断三种方式是否获取的是同一个Class对象
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		
	}
}

注意，在运行期间，一个类，只有一个Class对象产生，所以打印结果都是true；

三种方式中，常用第三种，第一种对象都有了还要反射干什么，第二种需要导入类包，依赖太强，不导包就抛编译错误。一般都使用第三种，一个字符串可以传入也可以写在配置文件中等多种方法。

测试类

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

package com.idongyou.dongxin.thirdparty;

import com.alibaba.fastjson.JSON;
import com.idongyou.dongxin.thirdparty.dao.doris.CustomerAccountRoleInfoDao;
import com.idongyou.dongxin.thirdparty.model.CustomerAccountRoleInfo;
import com.idongyou.dongxin.thirdparty.model.dto.CustomerAccountRoleInfoDTO;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@Slf4j
@SpringBootTest
public class CustomerTest {

  @Autowired
  private CustomerAccountRoleInfoDao customerAccountRoleInfoDao;

  @Test
  public void testQueryOneByRole(){
    CustomerAccountRoleInfoDTO req = new CustomerAccountRoleInfoDTO();
    req.setAppMain(16);
    CustomerAccountRoleInfo customerAccountRoleInfo = customerAccountRoleInfoDao.queryOneByRole(req);
    log.info(JSON.toJSONString(customerAccountRoleInfo));
  }

}

多线程ThreadPoolExecutor

    //初始化一个线程池
protected final ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(Runtime.getRuntime().availableProcessors(),
            Runtime.getRuntime().availableProcessors(),
            0L,
            TimeUnit.SECONDS,
            new LinkedBlockingDeque<>(1024)
    );
    
    //查询时，多线程查询
        public ListResult<GameRolePayDTO> gameRolePayResult(RealTimeReq req) {
        //
        ListResult<GameRolePayDTO> result = new ListResult<>();

        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
            // 列表
            result.setList(gameRolePayList(req));
        }, threadPoolExecutor).thenRunAsync(() -> {
            // 汇总
            result.setSummary(gameRolePaySummary(req));
        }, threadPoolExecutor);
        try {
            future.get(30,TimeUnit.SECONDS);
        } catch (Exception e) {
            log.error("查询游戏角色付费失败..., {}",e);
        }
        return result;
    }

设计模式之单例模式

Java中的单例模式是一种常用的设计模式，它保证一个类在整个应用程序中只有一个实例，并提供一个全局访问点。

Java实现单例模式的方式有多种，其中比较常用的方法如下：

1.懒汉式：在首次使用时创建实例。代码如下：

Copy Codepublic class Singleton {
    private static Singleton instance = null;
    private Singleton() {}
    
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

2.饿汉式：在类加载时创建实例。代码如下：

Copy Codepublic class Singleton {
    private static final Singleton instance = new Singleton();
    private Singleton() {}
    
    public static Singleton getInstance() {
        return instance;
    }
}

3.双重校验锁：在多线程环境中保证单例实例的线程安全创建。代码如下：

Copy Codepublic class Singleton {
    private static volatile Singleton instance = null;
    private Singleton() {}
    
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

4.静态内部类：利用类加载器机制实现线程安全的延迟初始化。代码如下：

Copy Codepublic class Singleton {
    private Singleton() {}
    
    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }
    
    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

以上是常用的几种单例模式实现方式，开发人员可以根据具体场景选择适合自己的方式来实现单例模式，以保证系统的性能和安全性。

不可变map

Java中可以通过使Map的键和值都是不可变类型来实现不变Map。其中，可以使用Collections.unmodifiableMap()方法创建一个只读的Map视图，或者使用Guava中的ImmutableMap来创建一个完全不可变的Map。

以下是两种实现方式的示例代码：

1. 使用Collections.unmodifiableMap()方法创建只读的Map视图

Copy CodeMap<String, String> originalMap = new HashMap<>();
// 添加元素到原始Map
originalMap.put("key1", "value1");
originalMap.put("key2", "value2");

// 创建只读Map视图
Map<String, String> immutableMap = Collections.unmodifiableMap(originalMap);

// 试图修改只读Map视图的内容会抛出UnsupportedOperationException异常
immutableMap.put("key3", "value3"); // UnsupportedOperationException

1. 使用Guava中的ImmutableMap创建完全不可变的Map

Copy Code// 创建一个不可变Map
Map<String, String> immutableMap = ImmutableMap.of(
    "key1", "value1",
    "key2", "value2"
);

// 试图修改不可变Map的内容会抛出UnsupportedOperationException异常
immutableMap.put("key3", "value3"); // UnsupportedOperationException

以上两种方式都可以用来创建不变Map，但它们有一些差异。使用Collections.unmodifiableMap()方法创建的只读Map仍然可以通过原始Map来修改，而使用Guava中的ImmutableMap创建的完全不可变Map则没有这个问题。

ObjectMapper

ObjectMapper 类提供了一系列方法用于实现 Java 对象与 JSON 数据之间的转换。以下是一些常用的 ObjectMapper 方法：

1. writeValueAsString(Object value)：将指定的 Java 对象转换为 JSON 字符串。

ObjectMapper objectMapper = new ObjectMapper();
String jsonString = objectMapper.writeValueAsString(myObject);

1. writeValue(File file, Object value)：将指定的 Java 对象转换为 JSON，并写入到文件中。

ObjectMapper objectMapper = new ObjectMapper();
objectMapper.writeValue(new File("data.json"), myObject);

1. readValue(String content, Class<T> valueType)：将 JSON 字符串转换为指定类型的 Java 对象。

ObjectMapper objectMapper = new ObjectMapper();
MyObject myObject = objectMapper.readValue(jsonString, MyObject.class);

1. readValue(File file, Class<T> valueType)：从文件中读取 JSON 数据，并将其转换为指定类型的 Java 对象。

ObjectMapper objectMapper = new ObjectMapper();
MyObject myObject = objectMapper.readValue(new File("data.json"), MyObject.class);

1. convertValue(Object fromValue, Class<T> toValueType)：将一个对象转换为指定类型的对象。

ObjectMapper objectMapper = new ObjectMapper();
MyObject myObject = objectMapper.convertValue(map, MyObject.class);

1. setPropertyNamingStrategy(PropertyNamingStrategy naming)：设置命名策略，用于在序列化和反序列化过程中控制属性命名的转换方式。

ObjectMapper objectMapper = new ObjectMapper();
objectMapper.setPropertyNamingStrategy(PropertyNamingStrategy.SNAKE_CASE);

1. setSerializationInclusion(JsonInclude.Include include)：设置对象属性的序列化包含规则，用于控制哪些属性会被包含在生成的 JSON 中。

ObjectMapper objectMapper = new ObjectMapper();
objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);

这只是一小部分 ObjectMapper 提供的方法示例。ObjectMapper 还提供了许多其他方法，用于更高级的定制和操作。你可以根据具体需求查阅 ObjectMapper 类的官方文档以获取更详细的信息。

应用实例：

  // 保存数据JSON文件到指定目录
  public static void saveDataToFile(Object data,String fileStoragePath) throws Exception{
    ObjectMapper objectMapper = new ObjectMapper();
//    String dataJson = objectMapper.writeValueAsString(data);
    File file = new File(fileStoragePath);
    if (file.exists() && file.isFile()) {
      // 文件存在
      log.info("saveDataToFile:{}","文件存在，覆盖保存");
      objectMapper.writeValue(file,data);
    } else {
      // 文件不存在
      //直接保存
      objectMapper.writeValue(file,data);
    }
  }

Java生成唯一id

在 Java 中，可以使用以下几种方式生成唯一ID：

1. UUID（Universally Unique Identifier）：UUID 是一种由标准化的 128 位数字（32 个十六进制数）组成的唯一标识符。Java 提供了 java.util.UUID 类来生成 UUID。

   import java.util.UUID;
   
   // 生成随机的 UUID
   UUID uuid = UUID.randomUUID();
   String uniqueId = uuid.toString();
   

2. Snowflake 算法：Snowflake 是一种分布式唯一 ID 生成算法，通过结合时间戳、机器ID和序列号生成唯一的分布式ID。你可以借助一些第三方库或自行实现 Snowflake 算法。

3. 数据库自增列：在关系型数据库中，可以使用自增列来生成唯一的ID。在插入数据时，数据库会自动为该列生成一个唯一的递增值。

4. 第三方库：还有一些第三方库如 Twitter 的 Snowflake、Pinterest 的 IdGenerator 等，它们提供了更灵活的唯一 ID 生成方案。

选择哪种方式取决于你的具体需求和应用场景。如果只需要生成唯一的标识符，UUID 是一个简单且常用的选择。如果需要生成全局唯一且趋势递增的 ID，并且要求高性能和可扩展性，则 Snowflake 算法可能更适合。

希望以上信息对你有所帮助。如果你有任何其他问题，请随时提问。

File工具类

Java中的File流是一种用于读取和写入文件数据的流。它提供了一种简单而灵活的方式来进行文件的输入和输出操作。

Java中的File类表示文件或目录的抽象路径名，在使用File流时通常与InputStream（输入流）和OutputStream（输出流）结合使用，来实现对文件的读取和写入操作。

下面是使用FileInputStream和FileOutputStream读写文件的简单示例：

1. 使用FileInputStream读取文件：

try {
    File file = new File("path/to/file.txt");
    FileInputStream fis = new FileInputStream(file);
    
    int data;
    while ((data = fis.read()) != -1) {
        // 处理读取到的数据
        System.out.print((char) data);
    }
    
    fis.close();
} catch (IOException e) {
    e.printStackTrace();
}

上述代码中，通过创建FileInputStream对象并传入要读取的文件路径，然后使用read()方法逐个字节地读取文件内容，直到读取结束。

1. 使用FileOutputStream写入文件：

try {
    File file = new File("path/to/file.txt");
    FileOutputStream fos = new FileOutputStream(file);
    
    String content = "Hello, World!";
    fos.write(content.getBytes());
    
    fos.close();
} catch (IOException e) {
    e.printStackTrace();
}

上述代码中，通过创建FileOutputStream对象并传入要写入的文件路径，然后使用write()方法将字符串内容转换为字节数组并写入文件中。

需要注意的是，在使用File流进行文件读写操作时，需要适当处理异常并在操作完成后关闭流，以确保资源被正确释放。

除了FileInputStream和FileOutputStream，Java还提供了其他类型的File流，如BufferedInputStream、BufferedOutputStream，它们可以提供更高效的读写方式。

总结来说，Java的File流是一种用于读取和写入文件数据的功能强大的工具，在文件操作中起着重要的作用。通过File流，我们可以轻松地对文件进行读写，并根据需要进行处理和操作。

应用实例：

package com.idongyou.dongxin.system.util;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.google.gson.JsonParser;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.multipart.MultipartFile;
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardCopyOption;

@Slf4j
public class FileUtils {

  public static boolean isJsonFile(MultipartFile file) {
    try {
      String content = new String(file.getBytes());
      JsonParser parser = new JsonParser();
      parser.parse(content); // 尝试解析文件内容
      return true; // 格式正确
    } catch (Exception e) {
      log.error("error:",e);
      return false; // 格式错误
    }
  }

  // 保存文件到指定目录
  public static void saveMultipartFile(MultipartFile file, String fileDir) throws IOException {
    // 获取文件名
    String fileName = file.getOriginalFilename();
    // 在指定目录下创建一个空文件
    Path filePath = Path.of(fileDir, fileName);
    //如果文件不存在，就创建
    if (!Files.exists(filePath)){
      Files.createFile(filePath);
    }
    // 将上传的文件内容保存到指定目录下的文件中
    Files.copy(file.getInputStream(), filePath, StandardCopyOption.REPLACE_EXISTING);
  }

  // 保存数据JSON文件到指定目录
  public static void saveDataToFile(Object data,String fileStoragePath) throws Exception{
    ObjectMapper objectMapper = new ObjectMapper();
//    String dataJson = objectMapper.writeValueAsString(data);
    File file = new File(fileStoragePath);
    if (file.exists() && file.isFile()) {
      // 文件存在
      log.info("saveDataToFile:{}","文件存在，覆盖保存");
      objectMapper.writeValue(file,data);
    } else {
      // 文件不存在
      //直接保存
      objectMapper.writeValue(file,data);
    }
  }

}

时间工具类

在Java中，SimpleDateFormat是一个用于格式化和解析日期时间的类。它允许我们将日期时间对象转换为特定格式的字符串，以及将特定格式的字符串转换为日期时间对象。

下面是使用SimpleDateFormat进行日期时间格式化和解析的示例：

1. 将日期时间对象格式化为字符串：

import java.text.SimpleDateFormat;
import java.util.Date;

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

Date now = new Date();
String formattedDate = sdf.format(now);

System.out.println(formattedDate); // 输出：2023-07-21 02:10:03

上述代码中，首先创建了一个SimpleDateFormat对象，并指定了日期时间的格式模式（“yyyy-MM-dd HH:mm:ss”）。然后，使用format()方法将当前的Date对象按照指定的格式模式转换为字符串。

1. 将字符串解析为日期时间对象：

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

String dateString = "2023-07-21 02:10:03";
try {
    Date parsedDate = sdf.parse(dateString);
    System.out.println(parsedDate); // 输出：Thu Jul 21 02:10:03 GMT 2023
} catch (ParseException e) {
    e.printStackTrace();
}

上述代码中，首先创建了一个SimpleDateFormat对象，并指定了日期时间的格式模式（“yyyy-MM-dd HH:mm:ss”）。然后，使用parse()方法将字符串按照指定的格式模式解析为Date对象。

需要注意的是，在使用SimpleDateFormat进行日期时间格式化和解析时，格式模式的字符串必须与要处理的日期时间字符串保持一致，否则可能会抛出ParseException异常。

除了常见的日期时间格式模式（如"yyyy-MM-dd HH:mm:ss"），SimpleDateFormat还支持其他模式，如年份（“yyyy”）、月份（“MM”）、日（“dd”）、小时（“HH”）、分钟（“mm”）等，具体可参考Java文档中SimpleDateFormat的相关信息。

总结来说，SimpleDateFormat是Java中用于日期时间格式化和解析的类。通过它，我们可以将日期时间对象转换为特定格式的字符串，以及将特定格式的字符串转换为日期时间对象，非常方便实用。

应用实例：

package com.idongyou.dongxin.system.util;

import cn.hutool.core.date.DateUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.StringUtils;
import java.beans.PropertyEditorSupport;
import java.sql.Timestamp;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.List;
import java.util.Locale;
import java.util.Objects;
import java.util.TimeZone;

/**
 * DateUtils
 *
 * @author nml
 * @date 2021/7/21 14:58
 */
@Slf4j
public class DateUtils extends PropertyEditorSupport {

    public static ThreadLocal<SimpleDateFormat> date_sdf = new

            ThreadLocal<SimpleDateFormat>() {

                @Override
                protected SimpleDateFormat initialValue() {
                    return new SimpleDateFormat("yyyy-MM-dd");
                }


            };
    public static ThreadLocal<SimpleDateFormat> datetimeFormat = new

            ThreadLocal<SimpleDateFormat>() {

                @Override
                protected SimpleDateFormat initialValue() {
                    return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                }


            };
    // 以毫秒表示的时间
    private static final long DAY_IN_MILLIS = 24 * 3600 * 1000;
    private static final long HOUR_IN_MILLIS = 3600 * 1000;
    private static final long MINUTE_IN_MILLIS = 60 * 1000;
    private static final long SECOND_IN_MILLIS = 1000;
    public static final String YYYY_MM_DD = "yyyy-MM-dd";
    public static final String YYYY_MM_DD_HH_MM = "yyyy-MM-dd HH:mm";
    public static final String YYYY_MM_DD_HH_MM_SS = "yyyy-MM-dd HH:mm:ss";
    public static final String YYYYMMDD = "yyyyMMdd";
    public static final String YYMMDD = "yyMMdd";
    public static final String YYMMDDHHMMSS = "yyMMddHHmmss";
    public static final String YYYYMMDDHHMMSS = "yyyyMMddHHmmss";
    public static final String YYMMDDHHMMSSSSS = "yyMMddHHmmssSSS";
    public static final String YYYYMMDD_HH_MM_SS = "yyyy_MM_dd_HH_mm_ss";

    // 指定模式的时间格式
    private static SimpleDateFormat getSDFormat(String pattern) {
        return new SimpleDateFormat(pattern);
    }


    /**
     * 当前日历，这里用中国时间表示
     *
     * @return 以当地时区表示的系统当前日历
     */
    public static Calendar getCalendar() {
        return Calendar.getInstance();
    }
    
        /**
     * 获取时间字符串
     */
    public static String getDataString(SimpleDateFormat formatstr) {
        return formatstr.format(getCalendar().getTime());
    }


    /**
     * 日期字符串 转为 Calendar
     */
    public static Calendar dateStr2Calendar(String date, String pattern) {
        SimpleDateFormat format = getSDFormat(pattern);
        Calendar calendar = Calendar.getInstance();
        try {
            calendar.setTime(format.parse(date));
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return calendar;
    }


    /**
     * 指定毫秒数表示的日历
     *
     * @param millis 毫秒数
     * @return 指定毫秒数表示的日历
     */
    public static Calendar getCalendar(long millis) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(new Date(millis));
        return cal;
    }

    public static DateFormat getDateFormat(String dateFormat) {
        return new SimpleDateFormat(dateFormat);
    }


    /**
     * 取得某天所在周的第一天
     *
     * @param date
     * @return
     */
    public static Date getFirstDayOfWeek(Date date) {
        Calendar c = new GregorianCalendar();
        c.setFirstDayOfWeek(Calendar.MONDAY);
        c.setTime(date);
        c.set(Calendar.DAY_OF_WEEK, c.getFirstDayOfWeek());
        return c.getTime();
    }


    /**
     * 获取星期几
     *
     * @param date
     * @return
     */
    public static int getWeekDay(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        int dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK);
        return dayOfWeek - 1;
    }


    /**
     * 根据开始时间和结束时间返回时间段内的时间集合
     *
     * @param beginDateStr
     * @param endDateStr
     * @return List
     */
    public static List<String> getDateStrsBetweenTwoDate(String beginDateStr, String endDateStr) {
        List<String> lDate = new ArrayList<String>();
        lDate.add(beginDateStr);// 把开始时间加入集合
        Calendar cal = Calendar.getInstance();
        // 使用给定的 Date 设置此 Calendar 的时间
        Date beginDate = str2Date(beginDateStr, date_sdf.get());
        Date endDate = str2Date(endDateStr, date_sdf.get());
        cal.setTime(beginDate);
        boolean bContinue = true;
        while (bContinue) {
            // 根据日历的规则，为给定的日历字段添加或减去指定的时间量
            cal.add(Calendar.DAY_OF_MONTH, 1);
            // 测试此日期是否在指定日期之后
            if (endDate.after(cal.getTime())) {
                lDate.add(date2Str(cal.getTime(), date_sdf.get()));
            } else {
                break;
            }
        }
        lDate.add(endDateStr);// 把结束时间加入集合
        return lDate;
    }


    /**
     * 根据开始时间和结束时间返回时间段内的时间集合
     *
     * @param beginDate
     * @param endDate
     * @return List
     */
    public static List<Date> getDatesBetweenTwoDate(Date beginDate, Date endDate) {
        List<Date> lDate = new ArrayList<Date>();
        lDate.add(beginDate);// 把开始时间加入集合
        Calendar cal = Calendar.getInstance();
        // 使用给定的 Date 设置此 Calendar 的时间
        cal.setTime(beginDate);
        boolean bContinue = true;
        while (bContinue) {
            // 根据日历的规则，为给定的日历字段添加或减去指定的时间量
            cal.add(Calendar.DAY_OF_MONTH, 1);
            // 测试此日期是否在指定日期之后
            if (endDate.after(cal.getTime())) {
                lDate.add(cal.getTime());
            } else {
                break;
            }
        }
        lDate.add(endDate);// 把结束时间加入集合
        return lDate;
    }
    
    
}    

2 框架整合应用

MybatisPlus基本使用

//实体类
@Data
@TableName("asset_merge")
@Accessors(chain = true)
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="资产合并记录表", description="资产合并记录表")
public class AssetMerge implements Serializable {

  private static final long serialVersionUID = 1L;

  /**自增ID*/
  @Excel(name = "ID", width = 15)
  @ApiModelProperty(value = "ID")
  @TableId(type = IdType.AUTO)
  private Long id;
}

@Data
public class AssetMergeReq extends Page {
  /**合并编号*/
  private String assetMergeNo;
  /**合并后资产编号*/
  private String afterMergeAssetNo;
}

//Mapper
public interface AssetMergeMapper extends BaseMapper<AssetMerge> {
  IPage<AssetMergeVO> getAssetMergePage(AssetMergeReq req);
  List<AssetMerge> selectByAssetNo(String assetNo);
}

//Service
public interface IAssetMergeService extends IService<AssetMerge> {
...
}

@Service
@Slf4j
public class AssetMergeServiceImpl extends ServiceImpl<AssetMergeMapper, AssetMerge> implements IAssetMergeService {
    ...
}

//Controller
@AutoLog(value = "资产合并-导出")
@ApiOperation(value = "资产合并-导出", notes = "资产合并-导出")
@RequestMapping(value = "/exportAssetMergeXls")
public ModelAndView exportAssetMergeXls(AssetMergeReq req, HttpServletRequest request) {
    ModelAndView mv = new ModelAndView(new JeecgEntityExcelView());
    List<AssetMergeVO> assetMergeVOList = iAssetMergeService.getAssetMergeList(req);
    //导出文件名称
    mv.addObject(NormalExcelConstants.FILE_NAME, "资产合并列表");
    mv.addObject(NormalExcelConstants.CLASS, AssetMergeVO.class);
    LoginUser user = (LoginUser) SecurityUtils.getSubject().getPrincipal();
    mv.addObject(NormalExcelConstants.PARAMS, new ExportParams("资产合并列表", "导出人:" + user.getRealname(), "导出信息"));
    mv.addObject(NormalExcelConstants.DATA_LIST, assetMergeVOList);
    return mv;
}

应用实例：

package com.idongyou.dongxin.system.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.google.common.collect.ImmutableMap;
import com.idongyou.dongxin.common.core.constant.Constants;
import com.idongyou.dongxin.common.core.exception.BusinessException;
import com.idongyou.dongxin.common.security.utils.SecurityUtils;
import com.idongyou.dongxin.system.domain.SysImportExportFileInfo;
import com.idongyou.dongxin.system.domain.req.SysImportExportFileInfoReq;
import com.idongyou.dongxin.system.mapper.SysImportExportFileInfoMapper;
import com.idongyou.dongxin.system.rebuild.enums.ReturnCodeEnum;
import com.idongyou.dongxin.system.service.SysImportExportFileInfoService;
import com.idongyou.dongxin.system.util.DateUtils;
import org.apache.commons.lang.StringUtils;
import org.springframework.stereotype.Service;
import java.util.*;

@Service
public class SysImportExportFileInfoServiceImpl extends ServiceImpl<SysImportExportFileInfoMapper, SysImportExportFileInfo> implements SysImportExportFileInfoService {

  //字段名称映射关系的不变Map
  private static final Map<String, String> FILED_IMMUTABLE_MAP = ImmutableMap.<String, String>builder()
      .put("createTime", "create_time")
      .put("fileId", "file_id")
      .build();

  @Override
  public IPage<SysImportExportFileInfo> queryPage(SysImportExportFileInfoReq req) {
    long current = req.getCurrent();
    long size = req.getSize();
    Integer userId = SecurityUtils.getUserId();
    long startTime = req.getStartTime();
    long endTime = req.getEndTime();
    //分页
    Page<SysImportExportFileInfo> page = new Page<>(current, size);
    //筛选、排序
    QueryWrapper<SysImportExportFileInfo> queryWrapper = new QueryWrapper<>();
    //筛选
    queryWrapper.eq("del_flag", Constants.DEL_FLAG_0);
    queryWrapper.eq("app_id",req.getAppId());
    queryWrapper.eq("user_id",userId);
    queryWrapper.ge("create_time",DateUtils.getDateByLongMillis(startTime));
    queryWrapper.le("create_time",DateUtils.getDateByLongMillis(endTime));
    String fileName = req.getFileName();
    if (StringUtils.isNotBlank(fileName)){
      queryWrapper.like("file_name",fileName);
    }
    Integer status = req.getStatus();
    if (Objects.nonNull(status)){
      queryWrapper.eq("status",status);
    }
    Integer getOperationType = req.getOperationType();
    if (Objects.nonNull(getOperationType)){
      queryWrapper.eq("operation_type",getOperationType);
    }
    //排序
    String sortColumn = req.getSortColumn();
    String sortType = req.getSortType();
    Boolean isAsc = Boolean.FALSE;
    if (StringUtils.isBlank(sortColumn)){
      sortColumn = "fileId";
    }
    if (StringUtils.isNotBlank(sortType)){
      if ("asc".equalsIgnoreCase(sortType)){
        isAsc = Boolean.TRUE;
      }
    }
    queryWrapper.orderBy(Boolean.TRUE,isAsc,FILED_IMMUTABLE_MAP.get(sortColumn));
    //查询
    return this.page(page, queryWrapper);
  }

  @Override
  public boolean saveOne(SysImportExportFileInfo info) {
    if (Objects.isNull(info)){
      throw new BusinessException(ReturnCodeEnum.FILE_INFO_SAVE_PARAMS_IS_NULL);
    }
    return this.save(info);
  }

  @Override
  public boolean deleteBatch(List<Long> ids) {
    boolean isDelete = this.update(Wrappers.<SysImportExportFileInfo>lambdaUpdate()
        .eq(SysImportExportFileInfo::getDelFlag, Constants.DEL_FLAG_0)
        .in(SysImportExportFileInfo::getFileId, ids)
        .set(SysImportExportFileInfo::getDelFlag, Constants.DEL_FLAG_1)
    );
    return isDelete;
  }

}

SpringBoot服务替换tomcat

使用undertow

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <exclusions>
        <exclusion>
            <artifactId>spring-boot-starter-tomcat</artifactId>
            <groupId>org.springframework.boot</groupId>
        </exclusion>
    </exclusions>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-undertow</artifactId>
</dependency>

undertow:
  # HTTP post内容的最大大小。当值为-1时，默认值为大小是无限的
  max-http-post-size: -1
  # 以下的配置会影响buffer,这些buffer会用于服务器连接的IO操作,有点类似netty的池化内存管理
  # 每块buffer的空间大小,越小的空间被利用越充分
  buffer-size: 512
  # 是否分配的直接内存
  direct-buffers: true
  threads:
    # 设置IO线程数, 它主要执行非阻塞的任务,它们会负责多个连接, 默认设置每个CPU核心一个线程
    io: 8
    # 阻塞任务线程池, 当执行类似servlet请求阻塞操作, undertow会从这个线程池中取得线程,它的值设置取决于系统的负载
    worker: 256

SpringBoot数据源配置

MybatisPlusConfig

@Configuration
public class MybatisPlusConfig {
	/**
	 * 初始化MybatisPlusInterceptor
	 * */
	@Bean
	public MybatisPlusInterceptor mybatisPlusInterceptor() {
		MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
		interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
		return interceptor;
	}
}

DorisDataSourceConfig

@Configuration
//扫描dao层代码的包路径
@MapperScan(basePackages = "com.idongyou.dongxin.thirdparty.dao.doris",sqlSessionFactoryRef = "dorisSqlSessionFactory")
public class DorisDataSourceConfig {

	@Autowired
	private MybatisPlusInterceptor mybatisPlusInterceptor;

	@Bean(name = "dorisTemplate")
	public JdbcTemplate dorisJdbcTemplate(@Qualifier("dorisDataSource") DataSource dataSource) {
		return new JdbcTemplate(dataSource);
	}

	@Bean(name = "dorisDataSource")
    //读取nacos配置文件中的数据源值
	@ConfigurationProperties(prefix ="spring.datasource.druid.doris")
	public DataSource dorisDataSource() {
		return DataSourceBuilder.create().build();
	}

	@Bean(name = "dorisSqlSessionFactory")
	// 表示这个数据源是默认数据源
	// @Qualifier表示查找对象
	public MybatisSqlSessionFactoryBean cstSqlSessionFactory(@Qualifier("dorisDataSource") DataSource datasource) throws Exception {
		MybatisSqlSessionFactoryBean sqlSessionFactoryBean = new MybatisSqlSessionFactoryBean();
		sqlSessionFactoryBean.setDataSource(dorisDataSource());
		//这里如果用mybatis plus的话，要用mybatis-plus的configuration
		MybatisConfiguration configuration = new MybatisConfiguration();
		//configuration.setMapUnderscoreToCamelCase(false); 
		sqlSessionFactoryBean.setConfiguration(configuration);
        //mapper.xml文件的路径
		sqlSessionFactoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:/mapper/doris/**/*.xml"));

		//设置 MyBatis-Plus 分页插件
		Interceptor[] plugins = {mybatisPlusInterceptor};
		sqlSessionFactoryBean.setPlugins(plugins);
		return sqlSessionFactoryBean;
	}

	@Bean("dorisSqlSessionTemplate")
	public SqlSessionTemplate test1sqlsessiontemplate(
			@Qualifier("dorisSqlSessionFactory") SqlSessionFactory sessionfactory) {
		return new SqlSessionTemplate(sessionfactory);
	}
	
}

Nacos.yml

dev

spring:
  # 应用名称
  application:
    name: dongxin-third-party-invoking-dev
    

  # 数据源
  datasource: 
    druid: 
      #doris数据源
      doris: 
        driver-class-name: com.mysql.cj.jdbc.Driver
        url: jdbc:mysql:loadbalance://ip:9030/dc_dwd?autoReconnect=true&useUnicode=true&characterEncoding=UTF-8&useSSL=false
        username: dev
        password: dev
        type: com.alibaba.druid.pool.DruidDataSource
        initial-size: 3
        min-idle: 3
        max-wait-millis: 60000
        timeBetweenEvictionRunsMillis: 60000
        # 配置一个连接在池中最小生存的时间，单位是毫秒
        minEvictableIdleTimeMillis: 300000
        validationQuery: SELECT 1
        testWhileIdle: true
        testOnBorrow: true
        testOnReturn: false
        maxPoolPreparedStatementPerConnectionSize: 20
        # 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
        filters: stat,wall
        # 通过connectProperties属性来打开mergeSql功能；慢SQL记录
        connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000

prod

mysql8版本：数据源

spring:
  # 应用名称
  application:
    name: dongxin-third-party-invoking-dev
    
  # 数据源
  datasource: 
    druid: 
      #doris数据源
      doris: 
        driver-class-name: com.mysql.cj.jdbc.Driver
        url: jdbc:mysql:loadbalance://ip:port,ip:port,ip:port/dc_dwd?autoReconnect=true&useUnicode=true&characterEncoding=UTF-8&useSSL=false
        username: xxx
        password: xxx
        type: com.alibaba.druid.pool.DruidDataSource
        initial-size: 3
        min-idle: 3
        max-wait-millis: 60000
        timeBetweenEvictionRunsMillis: 60000
        # 配置一个连接在池中最小生存的时间，单位是毫秒
        minEvictableIdleTimeMillis: 300000
        validationQuery: SELECT 1
        testWhileIdle: true
        testOnBorrow: true
        testOnReturn: false
        maxPoolPreparedStatementPerConnectionSize: 20
        # 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
        filters: stat,wall
        # 通过connectProperties属性来打开mergeSql功能；慢SQL记录
        connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000

Docker-SpringBoot-Nginx

SpringBoot项目

bootstrap.yml

server:
  port: 9306
  # 上下文
  servlet:
    context-path: /dxThirdPartyApi

# Spring
spring:
  application:
    # 应用名称
    name: dongxin-third-party-invoking
  profiles:
    # 环境配置
    active: ${spring.profile:dev}
  cloud:
    nacos:
      discovery:
        # 服务注册地址
        server-addr: ${NACOS_SERVER:ip:8848}
#        namespace: 8dc7dc26-0992-407d-8a72-230a02d6212c   # nml
#        namespace: f95f20f9-c801-4801-a06e-0f8197dfc656  # dev
      config:
        # 配置中心地址
        server-addr: ${NACOS_SERVER:ip:8848}
        # 配置文件格式
        file-extension: yml
        # 共享配置
        shared-configs:
          - application-${spring.profiles.active}.${spring.cloud.nacos.config.file-extension}
#        namespace: f95f20f9-c801-4801-a06e-0f8197dfc656  # dev

docker配置

docker-compose.yml

version: "3.8"
networks:
  default:
    external:
      name: net_default
services:
  redis:
    image: redis:6.2.5
    restart: always
    ports:
      - "6379"
    environment:
      - TZ=Asia/Shanghai
    volumes:
      - ./redis.conf:/usr/local/etc/redis/redis.conf:rw
      - ./redis-data:/data:rw
    command:
      /bin/bash -c "redis-server /usr/local/etc/redis/redis.conf"
  nacos2:
    image: nacos/nacos-server:2.0.3
    command: ["/wait-for-it.sh", "mysql:3306", "-s", "--", "/home/nacos/bin/docker-startup.sh"]
    env_file:
      - ./env/nacos-standlone-mysql.env
    environment:
      - TZ=Asia/Shanghai
    volumes:
      - ./wait-for-it.sh:/wait-for-it.sh
      - ./nacos-data/logs:/home/nacos/logs
      - ./init.d/custom.properties:/home/nacos/init.d/custom.properties
    ports:
      - "8868:8848"
      - "9868:9848"
      - "9555"
    depends_on:
      - mysql
    restart: always
  mysql:
    image: mysql:8.0.25
    command: --default-authentication-plugin=mysql_native_password
    restart: always
    ports:
      - 3306
    env_file:
      - ./env/mysql.env
    environment:
      - TZ=Asia/Shanghai
    volumes:
      - ./mysql-data/mysql:/var/lib/mysql
      - ./nacos-data/sql:/docker-entrypoint-initdb.d
      
  thirdparty:
      image: openjdk:11.0.11-9-jdk-oracle
      command: ["/wait-for-it.sh", "nacos2:8848", "-s", "--", "java","-jar","dongxin-third-party-invoking.jar"]
      restart: always
      ports:
        - "9306:9306"
      working_dir: /opt/app
      environment:
        - TZ=Asia/Shanghai
        - spring.profiles.active=test
        - NACOS_SERVER=nacos2:8848
      volumes:
        - ./wait-for-it.sh:/wait-for-it.sh
        - ./jars/dongxin-third-party-invoking.jar:/opt/app/dongxin-third-party-invoking.jar
        - ./logs/dongxin-third-party-invoking:/home/data/dongXin-Cloud/logs/dongxin-third-party-invoking      

nginx

topsense.xx.com.conf

log_format topsense.test.dogamedata.com  '$remote_addr - $remote_user [$time_local] $request '
             '$status $body_bytes_sent $http_referer $request_body '
             '$http_user_agent $http_x_forwarded_for';

upstream self-api {
         server ip:9680 max_fails=2 fail_timeout=5s;
}
upstream http_thirdparty {
         server ip:9306 max_fails=2 fail_timeout=20s;
}


server {
   listen 80;
   server_name  topsense.test.dogamedata.com;
   root /home/dogamedata/wwwroot/topsense/dist;

        location ^~ /dxThirdPartyApi/ {
                proxy_pass http://http_thirdparty;
                proxy_redirect off;
                proxy_set_header Host $host;
                proxy_set_header X-Real-IP $remote_addr;
                proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        }
        # 前端代码中调用后台接口时，默认加上self-api/
        location ^~ /self-api/ {
                proxy_pass http://self-api/;
                proxy_redirect off;
                proxy_set_header Host $host;
                proxy_set_header X-Real-IP $remote_addr;
                proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        }

        access_log  /home/dogamedata/wwwlogs/topsense.test.dogamedata.com.log topsense.test.dogamedata.com;

}

备注

1 docker
./jars : jars目录的上一级目录；../jars : jars目录的上两级目录;
ports:- "9306:9306" ：将docker的内部端口9306和服务的端口9306映射否则在外部访问不到该docker服务;
查看当前服务器端口为9306的服务：[root@58-74 sbin]# netstat -anp|grep 9306

2 nginx
默认目录：/usr/local/nginx/conf/
配置文件目录：/usr/local/nginx/conf/vhosts
sbin目录：/usr/local/nginx/sbin
sbin目录下的命令：
核查配置文件是否合法：./nginx -t
重载配置文件：./nginx -s reload
nginx日志目录：文件里配置的,access_log  /home/dogamedata/wwwlogs/topsense.test.dogamedata.com.log topsense.test.dogamedata.com;

SpringBoot AOP实践

1、创建SpringBoot项目

https://blog.csdn.net/weixin_51309915/article/details/123349773

2、添加aop依赖

        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
            <scope>test</scope>
        </dependency>

3、业务代码块

示例：

public interface UserService {
  void addUser(String username, String password) throws Exception;
}

@Service
public class UserServiceImpl implements UserService{
  @Override
  public void addUser(String username, String password) throws Exception{
    System.out.println(" ...addUser... ");
    throw new Exception("throw new Exception:aop throw");
  }
}

4、aop代码块

package com.example.SpringBoot_demo2.handler;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;
import java.util.Arrays;

@Aspect
@Component
public class LogAspect {

  @Before("execution(* com.example.SpringBoot_demo2.*.*.*(..))")
  public void logBefore(JoinPoint joinPoint) {
    Object[] args = joinPoint.getArgs(); // 获取方法参数
    String methodName = joinPoint.getSignature().getName(); // 获取方法名
    System.out.println("Before: method " + methodName + " is called with args " + Arrays.toString(args));
  }

  @AfterReturning("execution(* com.example.SpringBoot_demo2.*.*.*(..))")
  public void logAfter(JoinPoint joinPoint) {
    String methodName = joinPoint.getSignature().getName(); // 获取方法名
    System.out.println("After: method " + methodName + " is finished");
  }

  @AfterThrowing(value = "execution(* com.example.SpringBoot_demo2.*.*.*(..))", throwing = "exception")
  public void logException(JoinPoint joinPoint, Throwable exception) {
    String methodName = joinPoint.getSignature().getName(); // 获取方法名
    System.out.println("Exception: method " + methodName + " throws exception: " + exception.getMessage());
  }

}

@Transactional

@Transactional 是一个注解，用于在 Spring Framework 中标记事务的边界。

通过在方法或类上添加 @Transactional 注解，可以指示 Spring 在方法执行期间管理事务。当标记为 @Transactional 的方法被调用时，Spring 将会创建一个事务，并在方法执行完毕后进行提交或回滚。

例如，在下面的示例中，doSomething() 方法将会在事务的边界内运行：

@Transactional
public void doSomething() {
    // 执行业务操作
}

在这个示例中，当调用 doSomething() 方法时，Spring 将会为该方法创建一个事务。如果方法执行成功，事务将会被提交。如果发生异常，事务将会被回滚，以保证数据的一致性。

@Transactional 注解还支持一些可选的属性，用于配置事务的传播行为、隔离级别、超时等。例如：

@Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.DEFAULT, timeout = 10)
public void doSomething() {
    // 执行业务操作
}

在上面的示例中，使用了一些额外的属性来定义事务的传播行为（Propagation.REQUIRED）、隔离级别（Isolation.DEFAULT）和超时时间（timeout = 10）。

值得注意的是，@Transactional 注解通常会在 Spring 管理的组件（如 Service 层或 DAO 层）中使用，以确保数据库操作的数据一致性和事务的正确管理。

希望能够解答你的问题！如果还有其他疑问，请随时提问。

如果事务仍然未生效，可能是由于事务配置不正确或存在其他细节问题。以下是一些可能导致事务未生效的原因和解决方法：

1. 检查是否正确配置了事务管理器。请确保在Spring配置文件中定义了事务管理器（例如DataSourceTransactionManager）。
2. 确保handleBoardData方法是通过依赖注入调用的。如果直接在同一个类中的另一个方法中调用handleBoardData，那么事务将不会生效。确保handleBoardData方法是通过注入的方式来调用的。
3. 检查异常的传播机制。如果在buildDataBoard、buildBoardReport等方法中抛出了异常，但没有被捕获或包装成其他异常，事务将无法回滚。请确保这些方法中的异常被正确捕获并进行处理。
4. 检查依赖注入是否正确。确保boardReportService、boardReportRelationService和sqlQueryChartService等依赖项已经正确注入。

代码示例：

package com.idongyou.dongxin.system.handler;
//import packages

@Slf4j
@Component
public class DataBoardHandler {

  @Autowired
  private DataBoardService dataBoardService;
  @Autowired
  private BoardReportService boardReportService;
  @Autowired
  private BoardReportRelationService boardReportRelationService;
  @Autowired
  private SqlQueryChartService sqlQueryChartService;
  @Autowired
  private Snowflake snowflake;

  @Transactional(rollbackFor = Exception.class)
  public void handleBoardData(Long appId, Integer userId, Map<String,Integer> allBoardNameMap, Map<String,Integer> allReportNameMap, List<DataBoard> boardList, List<BoardReport> reportList, List<BoardReportRelation> boardReportRelationList, List<SqlQueryChart> sqlQueryChartList){
    try {
      if (CollectionUtils.isEmpty(boardList)){
        return;
      }
      //重构board数据
      buildDataBoard(appId,userId,allBoardNameMap,boardList);
      //批量存储看板数据
      dataBoardService.saveBatch(boardList);
      if (CollectionUtils.isEmpty(reportList)){
        return;
      }
      //处理报表数据时，生成chartId的旧新映射关系
      Map<String,String> chartIdsMap = new HashMap<>();
      //重构report数据
      buildBoardReport(appId,userId,allReportNameMap,reportList,chartIdsMap);
      //批量存储报表数据
      boardReportService.saveBatch(reportList);

      //生成旧新id映射map
      Map<Long,Long> boardIdsMap = boardList.stream().collect(Collectors.toMap(DataBoard::getOldBoardId, DataBoard::getBoardId));
      Map<Long,Long> reportIdsMap = reportList.stream().collect(Collectors.toMap(BoardReport::getOldReportId,BoardReport::getReportId));
      //重构看板报表关系数据
      buildBoardReportRelation(boardIdsMap,reportIdsMap,boardReportRelationList);
      //批量存储看板报表关系数据
      boardReportRelationService.saveBatch(boardReportRelationList);

      if (CollectionUtils.isEmpty(sqlQueryChartList)){
        return;
      }
      //重构SqlQueryChart列表数据
      buildSqlQueryChart(appId,userId,sqlQueryChartList,reportIdsMap,chartIdsMap);
      //批量存储SqlQueryChart数据
      sqlQueryChartService.saveBatch(sqlQueryChartList);
    } catch (Exception e) {
      log.error("Exception error", e);
      throw new RuntimeException("操作失败");
    }
  }

  //重构SqlQueryChart对象数据
  public void buildSqlQueryChart(Long appId,Integer userId,List<SqlQueryChart> sqlQueryChartList,Map<Long,Long> reportIdsMap,Map<String,String> chartIdsMap){
    //do something
  }

  //重构BoardReportRelation数据
  public void buildBoardReportRelation(Map<Long,Long> boardIdsMap,Map<Long,Long> reportIdsMap,List<BoardReportRelation> boardReportRelationList){
    //do something
  }

  //重构BoardReport对象数据
  public void buildBoardReport(Long appId,Integer userId,Map<String,Integer> allReportNameMap,List<BoardReport> reportList,Map<String,String> chartIdsMap){
 	//do something
  }

  //重构DataBoard对象数据
  public void buildDataBoard(Long appId,Integer userId,Map<String,Integer> allBoardNameMap,List<DataBoard> boardList){
   //do something
  }

}

@Slf4j
@Service
public class DataBoardServiceImpl extends ServiceImpl<DataBoardMapper, DataBoard> implements DataBoardService {
    @Autowired
    private DataBoardHandler dataBoardHandler;
  
    @Override
    public void importBoardsData(MultipartFile file,Long appId) throws Exception{
        SysImportExportFileInfo sysImportExportFileInfo = new SysImportExportFileInfo();
        try {
        //do something
dataBoardHandler.handleBoardData(appId,userId,allBoardNameMap,allReportNameMap,boardList,reportList,boardReportRelationList,sqlQueryChartList);
            //保存文件上传成功记录
            sysImportExportFileInfo.setStatus(1);//成功
            sysImportExportFileInfoService.saveOne(sysImportExportFileInfo);
        }catch (IOException ioe){
            //保存文件上传失败记录
            sysImportExportFileInfo.setStatus(0);//失败
            sysImportExportFileInfoService.saveOne(sysImportExportFileInfo);
            throw ioe;
        }catch (Exception e) {
            //保存文件上传失败记录
            sysImportExportFileInfo.setStatus(0);//失败
            sysImportExportFileInfoService.saveOne(sysImportExportFileInfo);
            throw e;
        }
    }
}

@EnableTransactionManagement
@EnableScheduling
@SpringBootApplication(exclude = MongoAutoConfiguration.class)
@EnableDiscoveryClient
@EnableDongXinSwagger2
@EnableDongXinFeignClients
public class DongXinSystemApplication {
    public static void main(String[] args) {
        SpringApplication.run(DongXinSystemApplication.class, args);
    }
}

3 组件整合应用

Java消费Kafka

在Java中，Kafka消费数据有以下几种方式：

1. 手动提交偏移量并轮询

该方式需要在代码中明确管理和提交偏移量，并且需要轮询以获取新的消息。一般情况下，这种方式比较适用于需要更精细控制的场景。

while (true) {
    ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(100));
    for (ConsumerRecord<String, String> record : records) {
        // 处理收到的消息
    }
    consumer.commitSync();
}

1. 订阅模式（自动提交偏移量）

该方式是指定一个消费者组，让Kafka自动管理和提交偏移量，以及周期性地提交已接收到的消息的偏移量。使用这种方式可以更轻松地进行扩展和管理，但是需要注意的是，在某些失败情况下，可能会存在少量消息重复处理或者消息丢失的风险。

consumer.subscribe(Arrays.asList("topic1", "topic2"));
while (true) {
    ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(100));
    for (ConsumerRecord<String, String> record : records) {
        // 处理收到的消息
    }
}

1. 分配模式（手动提交偏移量）

该方式需要指定消费者分配所需的分区，并管理和提交偏移量。可以使用该方法来更精细控制分区处理。但是需要注意的是，在某些失败情况下，可能会存在少量消息重复处理或者消息丢失的风险。

TopicPartition partition0 = new TopicPartition("topic1", 0);
TopicPartition partition1 = new TopicPartition("topic1", 1);
consumer.assign(Arrays.asList(partition0, partition1));
while (true) {
    ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(100));
    for (ConsumerRecord<String, String> record : records) {
        // 处理收到的消息
    }
    consumer.commitSync();
}

以上就是在Java中Kafka消费数据的几种方式，您可以根据自己的需要进行选择。注意，在使用任意一种方式时，都要记得关闭消费者以释放资源。

应用实例：

1 实现MessageListener

定义抽象类实现MessageListener

示例：定义抽象类BaseConsumer实现MessageListener

import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.springframework.kafka.listener.MessageListener;

public abstract class BaConsumer implements MessageListener<String,String> {

  /**
   * kafka topic数据监听
   * */
  @Override
  public void onMessage(ConsumerRecord<String, String> stringStringConsumerRecord) {

    try {
      doConsumer("消费逻辑");
    } catch (Exception e) {
      e.printStackTrace();
    }

  }

  /**
   * kafka数据的消费逻辑
   * */
  public abstract void doConsumer(String s) throws Exception;
}

2 实现数据消费逻辑

继承抽象消费类实现数据消费逻辑

示例：

public class SynDataForMysqlWorker extends BaseConsumer {
    public SynDataForMysqlWorker(WorkerParam workerParam) {
        super(workerParam);
    }
    
    @Override
    public void doConsumer(MessageInfo messageInfo) throws Exception {
    //数据消费逻辑
    }
    
}

补充

kafka配置参数

示例：

@Configuration
@Getter
public class ApplicationYml {
    @Value("${warn-bootstrap-servers:192.168.0.177:9091,192.168.0.178:9091,192.168.0.179:9091}")
    private String warnBootstrapServers;
    @Value("${exception-collector.topic:topsense-exception}")
    private String exceptionTopic;
    @Value("${spring.datasource.druid.url}")
    private String dbUrl;
    //消费数据的来源
    @Value("${customize.consumer-type:DEBEZIUM}")
    private String consumerType;
    @Value("${customize.target-database-type:CLICKHOUSE}")
    private String targetDatabaseType;

    //kafka的topic、表名等相关配置
    @Value("${customize.kafka.topic_table_file}")
    private String topicTableFile;
    //源数据库相关配置
    @Value("${customize.kafka.source_db_file}")
    private String sourceDbFile;
    @Value("${customize.kafka.partition}")
    private int partition;
    @Value("${customize.kafka.groupId}")
    private String groupId;
    @Value("${customize.kafka.offset_file_dir}")
    private String kafkaOffsetFileDir;
 }   

整合mongoDb多数据源

在Spring Boot中实现MongoDB的多数据源配置，可以使用MongoClient和MongoTemplate来实现。以下是一种常见的多数据源配置方式：

1. 导入相关依赖： 在pom.xml文件中添加Spring Data MongoDB的依赖：

xmlCopy Code<dependencies>
    <!-- 其他依赖... -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-mongodb</artifactId>
    </dependency>
</dependencies>

1. 创建MongoDB配置类： 创建一个配置类来配置多个MongoDB数据源，例如：

import com.mongodb.ConnectionString;
import com.mongodb.client.MongoClients;
import com.mongodb.client.MongoClient;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.mongodb.core.MongoTemplate;

@Configuration
public class MongoConfig {
    @Value("${mongodb1.uri}")
    private String mongoUri1;

    @Value("${mongodb2.uri}")
    private String mongoUri2;

    @Bean(name = "mongoTemplate1")
    public MongoTemplate mongoTemplate1() {
        ConnectionString connectionString = new ConnectionString(mongoUri1);
        MongoClient mongoClient = MongoClients.create(connectionString);
        return new MongoTemplate(mongoClient, connectionString.getDatabase());
    }

    @Bean(name = "mongoTemplate2")
    public MongoTemplate mongoTemplate2() {
        ConnectionString connectionString = new ConnectionString(mongoUri2);
        MongoClient mongoClient = MongoClients.create(connectionString);
        return new MongoTemplate(mongoClient, connectionString.getDatabase());
    }
}

在上述示例中，我们通过@Value注解读取配置文件中的多个MongoDB连接URI，并创建不同的MongoTemplate对象。

1. 配置数据源连接信息： 在application.properties（或application.yml）文件中配置MongoDB连接信息，例如：

propertiesCopy Codemongodb1.uri=mongodb://localhost:27017/db1
mongodb2.uri=mongodb://localhost:27017/db2

或

yamlCopy Codemongodb1:
  uri: mongodb://localhost:27017/db1

mongodb2:
  uri: mongodb://localhost:27017/db2

1. 使用多个数据源： 在需要使用的地方注入对应的MongoTemplate，并使用它进行数据库操作。示例：

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.stereotype.Repository;

@Repository
public class UserRepository {
    private final MongoTemplate mongoTemplate1;
    private final MongoTemplate mongoTemplate2;

    public UserRepository(@Qualifier("mongoTemplate1") MongoTemplate mongoTemplate1,
                          @Qualifier("mongoTemplate2") MongoTemplate mongoTemplate2) {
        this.mongoTemplate1 = mongoTemplate1;
        this.mongoTemplate2 = mongoTemplate2;
    }

    public User saveUser1(User user) {
        return mongoTemplate1.save(user);
    }

    public User saveUser2(User user) {
        return mongoTemplate2.save(user);
    }

    // 其他操作方法...
}

在上述示例中，我们通过构造函数注入不同的MongoTemplate对象，并使用它们来执行对应的数据库操作。

通过以上步骤，您就可以在Spring Boot项目中实现MongoDB的多数据源配置和使用了。

整合mysql

package com.idongyou.dongxin.system.datasource;

import com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceBuilder;
import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean;
import org.apache.ibatis.plugin.Interceptor;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
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.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import javax.sql.DataSource;

@Configuration
//配置mybatis的接口类放的地方
@MapperScan(basePackages = "com.idongyou.dongxin.system.mapper", sqlSessionFactoryRef = "masterSqlSessionFactory")
public class MysqlDataSourceConfig {

	@Autowired
	private MybatisPlusInterceptor mybatisPlusInterceptor;

	@Primary
	// 将这个对象放入Spring容器中
	@Bean(name = "masterDataSource")
	// 表示这个数据源是默认数据源
	// 读取application.properties中的配置参数映射成为一个对象
	// prefix表示参数的前缀
	@ConfigurationProperties(prefix = "spring.datasource.dynamic.datasource.master")
	public DataSource getDateSource1() {
		return DruidDataSourceBuilder.create().build();
	}

	@Bean(name = "masterSqlSessionFactory")
	// 表示这个数据源是默认数据源
	// @Qualifier表示查找Spring容器中名字为masterDataSource的对象
	public MybatisSqlSessionFactoryBean iProcessSqlSessionFactory(
			@Qualifier("masterDataSource") DataSource datasource) throws Exception {
		MybatisSqlSessionFactoryBean sqlSessionFactoryBean = new MybatisSqlSessionFactoryBean();
		sqlSessionFactoryBean.setDataSource(getDateSource1());
		MybatisConfiguration configuration = new MybatisConfiguration();
		//configuration.setMapUnderscoreToCamelCase(false);
		sqlSessionFactoryBean.setConfiguration(configuration);
		sqlSessionFactoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:/mapper/system/**/*.xml"));

		//设置 MyBatis-Plus 分页插件
		Interceptor[] plugins = {mybatisPlusInterceptor};
		sqlSessionFactoryBean.setPlugins(plugins);

		return sqlSessionFactoryBean;

	}

	@Bean(name = "masterTransactionManager")
	public DataSourceTransactionManager getTransactionManager(@Qualifier("masterDataSource") DataSource dataSource) {
		return new DataSourceTransactionManager(dataSource);
	}

	@Bean("masterSqlSessionTemplate")
	// 表示这个数据源是默认数据源
	public SqlSessionTemplate test1sqlsessiontemplate(
			@Qualifier("masterSqlSessionFactory") SqlSessionFactory sessionfactory) {
		return new SqlSessionTemplate(sessionfactory);
	}
}

整合doris

package com.idongyou.dongxin.system.datasource;

import com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceBuilder;
import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean;
import org.apache.ibatis.plugin.Interceptor;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.jdbc.core.JdbcTemplate;
import javax.sql.DataSource;

@Configuration
@MapperScan(basePackages = "com.idongyou.dongxin.system.dao.doris",sqlSessionFactoryRef = "dorisSqlSessionFactory")
public class DorisDataSourceConfig {

	@Autowired
	private MybatisPlusInterceptor mybatisPlusInterceptor;

	@Bean(name = "dorisTemplate")
	public JdbcTemplate dorisJdbcTemplate(@Qualifier("dorisDataSource") DataSource dataSource) {
		return new JdbcTemplate(dataSource);
	}

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

	@Bean(name = "dorisSqlSessionFactory")
	// 表示这个数据源是默认数据源
	// @Qualifier表示查找对象
	public MybatisSqlSessionFactoryBean cstSqlSessionFactory(@Qualifier("dorisDataSource") DataSource datasource) throws Exception {
		MybatisSqlSessionFactoryBean sqlSessionFactoryBean = new MybatisSqlSessionFactoryBean();
		sqlSessionFactoryBean.setDataSource(dorisDataSource());
		//这里如果用mybatis plus的话，要用mybatis-plus的configuration
		MybatisConfiguration configuration = new MybatisConfiguration();
		//configuration.setMapUnderscoreToCamelCase(false); 
		sqlSessionFactoryBean.setConfiguration(configuration);
		sqlSessionFactoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:/mapper/doris/*.xml"));

		//设置 MyBatis-Plus 分页插件
		Interceptor[] plugins = {mybatisPlusInterceptor};
		sqlSessionFactoryBean.setPlugins(plugins);
		return sqlSessionFactoryBean;
	}

	@Bean("dorisSqlSessionTemplate")
	public SqlSessionTemplate test1sqlsessiontemplate(
			@Qualifier("dorisSqlSessionFactory") SqlSessionFactory sessionfactory) {
		return new SqlSessionTemplate(sessionfactory);
	}
	
}

整合clickhouse

package com.idongyou.dongxin.system.datasource;

import com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceBuilder;
import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean;
import org.apache.ibatis.plugin.Interceptor;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.jdbc.core.JdbcTemplate;
import javax.sql.DataSource;


@Configuration
@MapperScan(basePackages = "com.idongyou.dongxin.system.dao.clickhouse",sqlSessionFactoryRef = "clickhouseSqlSessionFactory")
public class ClickhouseDataSourceConfig {

	@Autowired
	private MybatisPlusInterceptor mybatisPlusInterceptor;

	@Bean(name = "clickhouseTemplate")
	public JdbcTemplate clickhouseJdbcTemplate(@Qualifier("clickhouseDataSource") DataSource dataSource) {
		return new JdbcTemplate(dataSource);
	}

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

	@Bean(name = "clickhouseSqlSessionFactory")
	// 表示这个数据源是默认数据源
	// @Qualifier表示查找对象
	public MybatisSqlSessionFactoryBean cstSqlSessionFactory(@Qualifier("clickhouseDataSource") DataSource datasource) throws Exception {
		MybatisSqlSessionFactoryBean sqlSessionFactoryBean = new MybatisSqlSessionFactoryBean();
		sqlSessionFactoryBean.setDataSource(clickhouseDataSource());
		//这里如果用mybatis plus的话，要用mybatis-plus的configuration
		MybatisConfiguration configuration = new MybatisConfiguration();
		//configuration.setMapUnderscoreToCamelCase(false); 
		sqlSessionFactoryBean.setConfiguration(configuration);
		sqlSessionFactoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath*:/mapper/clickhouse/*.xml"));

		//设置 MyBatis-Plus 分页插件
		Interceptor[] plugins = {mybatisPlusInterceptor};
		sqlSessionFactoryBean.setPlugins(plugins);
		return sqlSessionFactoryBean;
	}

	@Bean("clickhouseSqlSessionTemplate")
	public SqlSessionTemplate sqlsessiontemplate(
			@Qualifier("clickhouseSqlSessionFactory") SqlSessionFactory sessionfactory) {
		return new SqlSessionTemplate(sessionfactory);
	}
	
}