springboot与ssm架构文件分片上传，FastDFS文件分片上传，断点续传方法

最新推荐文章于 2024-05-13 19:33:16 发布
最新推荐文章于 2024-05-13 19:33:16 发布
阅读量1.9k 收藏 10
点赞数 6
分类专栏： java 文章标签： java spring boot spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44728024/article/details/110388771
版权

ssm架构文件分片上传

首先导入两个依赖的jar

  <dependency>
	  <groupId>cn.hutool</groupId>
	  <artifactId>hutool-all</artifactId>
	  <version>4.0.12</version>
	</dependency>

  <dependency>
	  <groupId>com.github.tobato</groupId>
	  <artifactId>fastdfs-client</artifactId>
	  <version>1.26.2</version>
  </dependency>

前端需要把文件分成片段上传，每一个片段都有一个id
在正式上传文件服务器fastdfs之前还要有一次检查功能，就是检查你这个上传的文件是否之前存在或者上传过。
如果是之前上传过没上传完成，就会给前端返回一个上一次中断在哪里的片段id

public RestResponse<CheckFileResult> checkFile(@RequestParam Map<String, Object> paramMap,HttpServletRequest request) throws BusinessException  {

	String fileMd5 = (String) paramMap.get("fileMd5");
	Long userId = Optional.ofNullable(request.getHeader("userId")).map(Long::valueOf).orElse(1L);
	if (StrUtil.isEmpty(fileMd5)) {
		return new RestResponse<>(RestRespCode.PARAM_ERROR_md5, message(MessageKeys.PARAM_ERROR_md5), null);
	}
	CheckFileResult checkFileResult = new CheckFileResult();
	//查询上传过的数据
    List<String> fileList= jedisClusterTemplate.lrange(UpLoadConstant.completedList,0,-1);
    if (CollUtil.isNotEmpty(fileList)){
        for (String e:fileList){
            JSONObject obj= JSONUtil.parseObj(e);
            if (obj.get("md5").equals(fileMd5)){
                checkFileResult.setTotalSize(obj.getLong("lenght"));
                checkFileResult.setViewPath(obj.getStr("url"));
                return new RestResponse<CheckFileResult>(RestRespCode.OK, message(MessageKeys.SYSTEM_SUCCESS), checkFileResult);
            }
        }
    }
	// 查询锁占用
	String lockName = UpLoadConstant.currLocks + fileMd5;
	Long lock = jedisClusterTemplate.incrBy(lockName, 1);
	String lockOwner = UpLoadConstant.lockOwner + fileMd5;
	String chunkCurrkey = UpLoadConstant.chunkCurr + fileMd5;
	if (lock > 1) {
		checkFileResult.setLock(1);
		//检查是否为锁的拥有者,如果是放行
		String oWner = jedisClusterTemplate.get(lockOwner);

		if (StrUtil.isEmpty(oWner)) {
			return new RestResponse<>(RestRespCode.UNABLE_TO_OBTAIN_FILE_LOCK_OWNER, message(MessageKeys.UNABLE_TO_OBTAIN_FILE_LOCK_OWNER), null);
		} else {
			if ( Long.valueOf(oWner).equals(userId)) {
				String chunkCurr = jedisClusterTemplate.get(chunkCurrkey);
				if (StrUtil.isEmpty(chunkCurr)) {
					return new RestResponse<>(RestRespCode.NOT_GET_CURRENT_FILE_CHUNKCURR, message(MessageKeys.NOT_GET_CURRENT_FILE_CHUNKCURR), null);
				}
				checkFileResult.setChunkCurr(Convert.toInt(chunkCurr));
				return new RestResponse<CheckFileResult>(RestRespCode.OK, message(MessageKeys.SYSTEM_SUCCESS),
						checkFileResult);
			} else {
				return new RestResponse<>(RestRespCode.PARAM_ERROR, message(MessageKeys.SYS_ERROR), null);
			}
		}
	} else {
		// 初始化锁.分块

		saveRedisDataToJedis(lockOwner, String.valueOf(userId));
		saveRedisDataToJedis(chunkCurrkey, "0");
		checkFileResult.setChunkCurr(0);
		return new RestResponse<CheckFileResult>(RestRespCode.OK, message(MessageKeys.SYSTEM_SUCCESS), checkFileResult);
	}

}

文件分片上传功能需要依赖redis来记录文件上传的片数，防止重复上传，

public RestResponse<List<Map<String, Object>>> upload_do(@RequestParam Map<String, Object> paramMap,
		HttpServletRequest request) throws BusinessException  {

    List<Map<String, Object>> resultMap = new ArrayList<Map<String, Object>>();

    String noGroupPath;//存储在fastdfs不带组的路径
    String fileMd5= (String) paramMap.get("fileMd5");
    String chunklockName= UpLoadConstant.chunkLock+fileMd5;

    String temOwner= RandomUtil.randomUUID();
    //真正的拥有者
    boolean currOwner=false;
    try {
        if (!paramMap.containsKey("chunk")){
            paramMap.put("chunk","0");
        }

        if (!paramMap.containsKey("chunks")){
            paramMap.put("chunks","1");
        }
      Long lock= jedisClusterTemplate.incrBy(chunklockName,1);
        if (lock>1){
            return new RestResponse<>(RestRespCode.PARAM_ERROR, message(MessageKeys.SYS_ERROR), null);
        }
        //写入锁的当前拥有者
        currOwner=true;

        List<MultipartFile> files = ((MultipartHttpServletRequest) request).getFiles("file");
        MultipartFile file = null;
        BufferedOutputStream stream = null;
        String chunk= (String) paramMap.get("chunk");
        String chunkCurrkey= UpLoadConstant.chunkCurr+fileMd5; //redis中记录当前应该穿第几块(从0开始)
        String  chunkCurr=  jedisClusterTemplate.get(chunkCurrkey);
        noGroupPath = "";
        Integer chunkSize= Convert.toInt(paramMap.get("chunkSize"));
        if (StrUtil.isEmpty(chunkCurr)){

            return new RestResponse<>(RestRespCode.NOT_GET_CURRENT_FILE_CHUNKCURR, message(MessageKeys.NOT_GET_CURRENT_FILE_CHUNKCURR), null);
        }
        Integer chunkCurr_int= Convert.toInt(chunkCurr);
        Integer chunk_int= Convert.toInt(chunk);


        if (chunk_int<chunkCurr_int){
            return new RestResponse<>(RestRespCode.REPEAT_UPLOAD, message(MessageKeys.REPEAT_UPLOAD), null);
        }else if (chunk_int>chunkCurr_int){
            return new RestResponse<>(RestRespCode.WAIT_A_MOMENT, message(MessageKeys.WAIT_A_MOMENT), null);

		}
		StorePath path = null;
		String name =null;
		// 暂时不支持多文件上传
		for (int i = 0; i < files.size(); ++i) {
			Map<String, Object> map = new HashMap<String, Object>();
			file = files.get(i);
			String originalFilename = file.getOriginalFilename();
			if (!file.isEmpty()) {
				try {

					// 获取已经上传文件大小
					Long historyUpload = 0L;
					String historyUploadStr = jedisClusterTemplate.get(UpLoadConstant.historyUpload + fileMd5);
					if (StrUtil.isNotEmpty(historyUploadStr)) {
						historyUpload = Convert.toLong(historyUploadStr);
					}
					LOG.debug("historyUpload大小:" + historyUpload);
					if (chunk_int == 0) {
						String s = Convert.toStr(chunk_int + 1);

						saveRedisDataToJedis(chunkCurrkey, Convert.toStr(chunkCurr_int+1));
                        LOG.debug(chunk+":redis块+1");
                        try {

                            name = FileUtil.extName((String) paramMap.get("fileName"));

                         path = appendFileStorageClient.uploadAppenderFile(UpLoadConstant.DEFAULT_GROUP, file.getInputStream(),
                                    file.getSize(), name);
                            LOG.debug(chunk+":更新完fastdfs");
                            if (path== null ){
                                jedisClusterTemplate.get(chunkCurrkey, Convert.toStr(chunkCurr_int));
                                return new RestResponse<>(RestRespCode.ERROR_GETTING_REMOTE_FILE_PATH, message(MessageKeys.ERROR_GETTING_REMOTE_FILE_PATH), null);
                            }

						} catch (Exception e) {
							jedisClusterTemplate.get(chunkCurrkey, Convert.toStr(chunkCurr_int));
							// 还原历史块
							LOG.error("初次上传远程文件出错", e);
							return new RestResponse<>(RestRespCode.FILE_FOR_THE_FIRST_TIME_ERROR, message(MessageKeys.FILE_FOR_THE_FIRST_TIME_ERROR),
									null);

						}
						noGroupPath = path.getPath();
						saveRedisDataToJedis(UpLoadConstant.fastDfsPath + fileMd5, path.getPath());
						LOG.debug("上传文件 result={}", noGroupPath);
					} else {
						saveRedisDataToJedis(chunkCurrkey,  Convert.toStr(chunkCurr_int + 1));
						LOG.debug(chunk + ":redis块+1");
						noGroupPath = jedisClusterTemplate.get(UpLoadConstant.fastDfsPath + fileMd5);
						if (noGroupPath == null) {
							return new RestResponse<>(RestRespCode.UPLOADED_REMOTE_SERVER_FILE_ERROR, message(MessageKeys.UPLOADED_REMOTE_SERVER_FILE_ERROR),
									null);
						}

						  try {
						  	//追加方式实际实用如果中途出错多次,可能会出现重复追加情况,这里改成修改模式,即时多次传来重复文件块,依然可以保证文件拼接正确
						  appendFileStorageClient.modifyFile(UpLoadConstant.DEFAULT_GROUP, noGroupPath,
						  file.getInputStream(), file.getSize(),historyUpload);
						  LOG.debug(chunk+":更新完fastdfs"); }
						  catch (Exception e) {
							  saveRedisDataToJedis(chunkCurrkey, Convert.toStr(chunkCurr_int));
						  	LOG.error("更新远程文件出错", e);
							  return new RestResponse<>(RestRespCode.ERROR_UPDATING_REMOTE_FILE, message(MessageKeys.ERROR_UPDATING_REMOTE_FILE),
									  null);
						  }

					}
					// 修改历史上传大小
					historyUpload = historyUpload + file.getSize();
					saveRedisDataToJedis(UpLoadConstant.historyUpload + fileMd5, Convert.toStr(historyUpload));
					// 最后一块,清空upload,写入数据库

					String fileName = (String) paramMap.get("name");
					Long size = Convert.toLong(paramMap.get("size"));
					Integer chunks_int = Convert.toInt(paramMap.get("chunks"));
					if (chunk_int + 1 == chunks_int) {

						// 持久化上传完成文件,也可以存储在mysql中
						FileResult fileResult = new FileResult();
						fileResult.setMd5(fileMd5);
						fileResult.setName(fileName);
						fileResult.setLenght(size);
						fileResult.setUrl(UpLoadConstant.DEFAULT_GROUP+"/"+noGroupPath);
						// todo
						jedisClusterTemplate.lpush(UpLoadConstant.completedList, JSONUtil.toJsonStr(fileResult));


						jedisClusterTemplate.del(UpLoadConstant.chunkCurr + fileMd5);
						jedisClusterTemplate.del(UpLoadConstant.fastDfsPath + fileMd5);
						jedisClusterTemplate.del(UpLoadConstant.currLocks + fileMd5);
						jedisClusterTemplate.del(UpLoadConstant.lockOwner + fileMd5);

					}
					map.put("originalFilename", originalFilename);
					map.put("url", UpLoadConstant.DEFAULT_GROUP+"/"+noGroupPath);

					resultMap.add(map);

				} catch (Exception e) {
					LOG.error("上传文件错误", e);
					return new RestResponse<>(RestRespCode.ERROR_UPLOADING_FILE, message(MessageKeys.ERROR_UPLOADING_FILE), null);
				}
			}
			break;
		}
	} finally {
		// 锁的当前拥有者才能释放块上传锁
		if (currOwner) {
			saveRedisDataToJedis(chunklockName,"0");
		}

	}
	return new RestResponse<List<Map<String, Object>>>(RestRespCode.OK, message(MessageKeys.SYSTEM_SUCCESS),
			resultMap);

}

文件分片上传所依赖的工具类

public class CheckFileResult {
    private String fileMd5;
    //0:锁未占用,1:锁占用
    private Integer lock;
    //文件分块数量
    private Integer chunkNum;
    //每块文件大小
    private Integer chunkSize;
    //当前已传输到第几块
    private Integer chunkCurr;
    //当前文件总大小
    private Long totalSize;
    //访问路径
    private  String viewPath;
  }

public class FileResult {
    //文件名
    private String url;
    //文件md5
    private String md5;
    //文件名称
    private String name;

    //文件大小
    private Long lenght;
    }

 public class UpLoadConstant {
        private UpLoadConstant() {

        }

        private  final static  String uploading="Uploading:";
        private final  static  String lock=uploading+"lock:";
        private  final  static String file=uploading+"file:";
        //当前所有锁(用在不同用户的上传前或重传前对整个文件的锁)
        public  final static  String  currLocks=lock+"currLocks:";
        //当前锁的拥有者
        public  final static  String  lockOwner=lock+"lockOwner:";

        //当前文件传输到第几块
        public final  static  String chunkCurr=file+"chunkCurr:";

        //当前文件上传到fastdfs路径
        public final static String fastDfsPath=file+"fastDfsPath:";

        //默认分组
        public final static  String DEFAULT_GROUP = "group1";

        //全部上传成功已完成
        public final static String completedList=uploading+"completedList";

        //文件块锁(解决同一个用户正在上传时并发解决,比如后端正在上传一个大文件块,前端页面点击删除按钮,
        // 继续添加删除的文件,这时候要加锁来阻止其上传,否则会出现丢块问题,
         /*因为fastdfs上传不像迅雷下载一样,下载时会创建一个完整的文件,如果上传第一块时,
        服务器能快速创建一个大文件0填充,那么这样可以支持并发乱序来下载文件块,上传速度会成倍提升,
        要实现乱序下载文件块,估计就得研究fastdfs源码了)*/
        public  final static String chunkLock=lock+"chunkLock:";

        public final static  String historyUpload="historyUpload:";

}

如果是springboot的项目就不需要下面这个工具，ssm架构的配置文件加载和springboot的配置加载不一样，如果ssm架构的项目在这个文件分片上传的代码里是读取不到你的fastdfs文件服务器的位置的，所以下面这个文件就是写个工具类让它帮你加载你的文件服务器的ip，如果有多台直接在list集合里面添加

@Configuration
@Import(FdfsClientConfig.class)
// 解决jmx重复注册bean的问题
@EnableMBeanExport(registration = RegistrationPolicy.IGNORE_EXISTING)
//类名无特定限制
@Component
public class FastClient implements BeanPostProcessor , InitializingBean, ApplicationContextAware {


    @Override
    public Object postProcessBeforeInitialization(Object o, String s) throws BeansException {

        if (o instanceof TrackerConnectionManager){
            List list=new ArrayList();
          String ip="106.52.47.126:22122";
          list.add(ip);
          ((TrackerConnectionManager) o).setTrackerList(list);

        }

        return o;
    }

    @Override
    public Object postProcessAfterInitialization(Object o, String s) throws BeansException {
        return o;
    }

    @Override
    public void afterPropertiesSet() throws Exception {

    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {

    }
}
匆忙博客
关注
  • 6
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Springboot 断点续传大文件
07-01
本人测试上传3G多的文件，未发现问题，但是还有优化空间。 原理 曾经上传过：前端通过计算，拿到整个文件的md5,请求后台是否曾经已经上传过，如果曾经上传过，直接返回成功 曾经没有上传过：后台返回前端，表示从未上传过此文件，前端通过技术，将大文件分隔成无数个小文件，一一上传 曾经上传一部分：前端在上传每个模块之前，先请求后台，判断此模块是否已经上传过，如果已经上传过，则不需要再上传，否则上传。 注：启动以后直接访问http://localhost:9002/demo/largeUpload/open,如果本地运行需要修改maven私服地址 ，使用idea首先需要安装Lombok插件，压缩包包含数据库表脚本文件，数据库名称需要自己创建，使用mysql demo测试网站： http://118.89.41.69:9002/demo/largeUpload/open
fastdfs分片上传和断点续传
qq_48243698的博客
07-16 1960
断点续传是在下载或上传时，将下载或上传任务（⼀个⽂件或⼀个压缩包）⼈为的划分为⼏个部分，每⼀个部分采⽤⼀个线程进⾏上传或下载，如果碰到⽹络故障，可以从已经上传或下载的部分开始继续上传或者下载未完成的部分，⽽没有必要从头开始上传或者下载。为了避免客户端在上传之后的进度数据被删除⽽导致重新开始从头上传的问题，服务端也可以提供相应的接⼝便于客户端对已经上传的分⽚数据进⾏查询，从⽽使客户端知道已经上传的分⽚数据，从⽽从下⼀个分⽚数据开始继续上传。如果上传的文件比较大，在快上传完的时候出了错，需要重新上传。...
SpringBoot 实现大文件断点续传（前端基于WebUploader实现，1G文件上传只需5s）
2301_82243539的博客
05-13 903
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年Web前端开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点！
FASTDFS 文件系统分布式 支持断点续传
CnNoter
07-02 1606
文件上传系统 最近公司在做分布式的文件存储系统,但问题出现了,文件系统使用哪一款? 最后决定用fastdfs在做,但是在springboot集成的时候出现了问题,前端使用vue组件在上传时候,因为并发比较高,直接将服务器给搞死了.原本打算将文件一块块的分片上传后再合并,然后在到fastdfs中,但集群的时候,文件上传到不同的服务器中.则没有办法在一个服务其中合并.所以最后决定将文件块直接向fastdfs中写,但是问题又来了,fastdfs创建一个文件,不能创建一块空间,只能在后边进行追加.这样的话,我们在
FastDFS 系统架构和功能原理
自律给我自由
08-22 536
文章来源：拉勾教育Java高薪训练营第3期，程道老师 1、架构详解
一个程序员的重启-解决大文件上传采用fastDFS分布式文件存储，实现文件分片上传、断点续传，超详细的编码
weixin_46330385的博客
08-15 1691
大文件上传 分片上传 断点续传 java 最近实习，碰到一个大文件上传的难题，然后公司用的也是使用fastDFS进行存储文件，所以博主这两天一直在学习这方面的知识现在跟大家分享一波。liunx的centos7系统（用于安装FastDFS，因为FastDFS没有window的安装程序）redis。2.后端通过相关获取相关值进行业务处理（例如：判断断点，是否重复传），并把file存进fdfs的文件存储位置。1.前端首先要将文件分片，并获取关键数据，例如。......
fastdfs断点续传
热门推荐
kaka20099527的专栏
06-23 1万+
fastdfs支持断点续传需要客户进行切片上传，并且切片字节大小小于等于storage配置的buff_size，默认是256k。当fastdfs storage接收客户端上传数据时，如果出现超时的情况会对文件offset和接收时记录的start、end进行比较，当offset>start 并且 offset < end时即写入文件的数据是应接收的一部分数据时，会truncate。所以当切片大小小于
springboot ssm 分模块微服务
12-17
springboot ssm分模块，整合了mysql，shiro，redis，jwttoken，swagger，访问日志，验证框架等，微架构层级，代码层级规范，里面有登录，注册，密码，短信验证码，动态定时任务等基本的例子，可以按照这个框架去搭建...
webuploader+springMVC实现大文件上传.zip
05-30
特别适合用于前端文件上传的需求，因为它支持多文件选择、拖拽上传、文件类型过滤以及断点续传等功能。 2. **大文件分片上传**： 当上传的文件过大时，传统的整文件上传方式可能会导致超时或网络中断问题。大文件...
使用SpringBoot整合ssm项目的实例详解
08-26
使用 Spring Boot 整合 SSM 项目的实例详解 Spring Boot 是由 Pivotal 团队提供的全新框架，其设计目的是用来简化新 Spring 应用的初始搭建以及开发过程。 Spring Boot 现在已经成为 Java 开发领域的一颗璀璨明珠，...
毕业设计&课设-SpringBoot结合分布式文件系统FastDFS.zip
最新发布
06-16
该资源内项目源码是个人的课程设计、毕业设计，代码都测试ok，都是运行成功后才上传资源，答辩评审平均分达到96分，放心下载使用！ ## 项目备注 1、该资源内项目代码都经过测试运行成功，功能ok的情况下才上传的，请...
fastDFS断点续传实例
11-08
fastDFS断点续传的一个小Demo，用maven构建的项目。之前在网上找了好久关于断点续传的实例，没有找到，特意分享出来了。
fastDFS文件服务客户端, 支持断点续传, 分块上传, 文件秒传, 稳定的前后端组件(前端H5)
10-13
fastDFS文件服务客户端, 支持断点续传, 分块上传, 文件秒传, 稳定的前后端组件(前端H5), 支持多用户并发上传文件校验(文件锁), 可以快速集成fastDFS文件服务, 免去繁琐的配置, 拿来即用, 目前暂时仅支持springboot开发环境.zip
fastdfs断点续传代码
06-24
通过封装fastdfs java client的代码实现断点续传功能,FileService.upload_file
fastdfs断点续传源码.rar
07-28
fastdfs断点续传，一般网上都是通用的上传，断点续传例子缺失，FastDfsUtilMain，提供了单类运行续传，通过main方法调用续传块下标，即可实现，传输完成下载即可。
springboot SSM整合
12-22
**SpringBoot SSM整合** SpringBoot以其简洁的配置和快速的开发能力，逐渐成为Java Web开发的主流框架。然而在实际项目中，我们往往需要与传统的SSM（Spring、Struts、MyBatis）框架进行整合，以充分利用各自的优势...
FastDfs大文件分片上传和断点续传
Curtisjia的博客
04-22 6029
前言 其实之前在大文件分片上传与极速秒传实现文章中我写过一次关于分片上传和断点续传, 但其实那个时候对断点续传的理解及其有限. 最近在项目里需要对大文件进行分片上传, 所以开始重新研究. 不过我觉得对于这个我只想讲下核心的思想. 分片上传思想 根据之前的文章, 我说过, 假如我们对500M的文件进行分片上传, 每片大小是5M, 那么总共就是100M分片. 前端主要就是通过文件大小和设置的分片的大小计算出分片的数量, 将这些必要参数传给后端, 后端通过分片的数量一次一次的将每个分片传到后台, 后台也同样一次次
大文件分片上传与断点续传
qq_55723647的博客
10-25 1291
由于java天生缺陷 但是项目需要上传大文件，所以做了一个分片上传，话不多说..UploadFileUtil.java 工具包 utils层。UpLoadConstant.java constant层。RedisUtil.java 同为utils层。controller层。
关于fastDFS断点续传的问题
weixin_42554373的博客
07-02 3286
这个困扰了很久,一大半原因是前端分片的问题,因为用的是百度的webupload去分片,而度娘的团队在api说明上简直让人无力吐槽,导致我们调试了很久.前端分片大小与后台保持一致,上传前获取文件MD5,然后分片后每次上传前都要获取分片的MD5,这些都是必传的参数(看实际需求,分片MD5其实可以省略但最好不省),后台就是接收一系列的参数和文件实体,注意:在使用fs的时候文件是一片一片append到上一...
springboot与ssm的比较
06-03
Spring Boot和SSM都是Java Web开发中常用的框架，但它们有一些不同点： 1. 架构风格 Spring Boot是基于Spring框架的快速开发框架，采用的是微服务架构风格。而SSM是传统的MVC架构风格。 2. 配置方式 Spring Boot采用约定大于配置的方式，简化了配置过程，使得开发人员可以更加专注于业务逻辑的实现。而SSM则需要开发人员手动进行配置。 3. 整合度 Spring Boot已经将常用的第三方框架（如Spring Data JPA、Spring Security等）整合到了自己的框架中，使得开发人员可以更加方便地进行开发。而SSM需要开发人员手动进行整合。 4. 依赖管理 Spring Boot采用了Maven和Gradle等依赖管理工具，可以自动处理依赖关系，方便了开发人员的项目管理。而SSM则需要开发人员手动配置依赖。 5. 适用场景 Spring Boot适用于微服务开发，可以快速开发RESTful API、Web应用、批处理应用等。而SSM适用于传统Web应用的开发，如电商网站、博客等。 总的来说，Spring Boot的开发效率更高，更适合快速开发小型应用或者微服务。而SSM则更加灵活，适用于大型应用的开发。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值