SpringBoot通过OSS实现大文件分片上传，2024年最新Java最全知识点整理

@DeleteMapping

@ApiOperation(“删除文件”)

public Response delete(@ApiParam(“文件代号”) @RequestParam(“code”) String code) {

ossService.delete(code);

return Response.success(true);

}

}

6、Service层接口代码

/**

• @author zhangzhixiang on 2020/8/5

*/

public interface SysFileService {

Response breakpointRegister(String fileMd5, String fileName, Long fileSize, String mimetype, String fileExt);

Response breakpointRenewal(MultipartFile file, String fileMd5, String uploadId, Integer chunk, String fileExt);

Response existsChunk(String fileMd5, Integer chunk, Integer chunkSize);

Response mergeChunks(String fileMd5, String uploadId, String fileName, Long fileSize, String mimetype, String fileExt);

}

7、Service层实现代码

下面代码中有用到redis保存分片信息，大家配置成自己的redis就可以了，我后面代码中会给出redis工具的代码

/**

• @author zhangzhixiang on 2020/8/5

*/

@Service

public class SysFileServiceImpl implements SysFileService {

@Resource

private RedisService redisService;

@Autowired

private OssService ossService;

@Value(“${file.biz.file.upload}”)

private String uploadDir;

@Value(“${file.biz.file.breakpoint}”)

private String breakpointDir;

@Value(“${file.oss.fsRootDir}”)

private String fsRootDir;

private String getFileFolderPath(String fileMd5) {

return getUploadFilePath(“/”) + fileMd5.substring(0, 1) + “/” + fileMd5.substring(1, 2) + “/”;

}

private String getFilePath(String fileMd5, String fileExt) {

return getFileFolderPath(fileMd5) + fileMd5 + “.” + fileExt;

}

private String getFileRelativePath(String fileMd5, String fileExt) {

return uploadDir + “/” + fileMd5.substring(0, 1) + “/” + fileMd5.substring(1, 2) + “/” + fileMd5 + “.” + fileExt;

}

private String getChunkFileFolderPath(String fileMd5) {

return breakpointDir + “/” + fileMd5 + “/”;

}

@Override

public Response breakpointRegister(String fileMd5, String fileName, Long fileSize, String mimetype, String fileExt) {

//检查文件是否存在于OSS，不存在则返回错误码，否则返回文件相关信息

String filePath = this.getFilePath(fileMd5, fileExt);

String ossCode = ossService.doesObjectExist(fsRootDir + filePath);

//若不存在则返回注册成功

if (!ObjectUtils.isEmpty(ossCode)) {

String url = ossService.getUrl(ossCode);

SysUploadItemVo sysUploadItemVo = new SysUploadItemVo(ossCode, fileMd5, url, “done”, fileName);

return Response.success(sysUploadItemVo).setMessage(“文件已存在”);

} else {

String uploadId = ossService.initMultiPartUpload(fileName, filePath);

return Response.success(uploadId).setMessage(“注册成功”);

}

}

@Override

public Response breakpointRenewal(

MultipartFile file,

String fileMd5,

String uploadId,

Integer chunk,

String fileExt

) {

try {

// 检查分块目录是否存在

String objectName = this.getFilePath(fileMd5, fileExt);

PartETag uploadPart = ossService.uploadPart(objectName, uploadId, file.getInputStream(),

(int) file.getSize(), (chunk + 1));

redisService.hset(RedisPrefixConst.BREAKPOINT_H_KEY_PREFIX + fileMd5, (chunk + 1) + “”,

JSONObject.toJSONString(uploadPart), 86400);

} catch (IOException e) {

e.printStackTrace();

redisService.hdel(RedisPrefixConst.BREAKPOINT_H_KEY_PREFIX + fileMd5, (chunk + 1) + “”);

}

return null;

}

@Override

public Response existsChunk(

String fileMd5,

Integer chunk,

Integer chunkSize

) {

//检查分块信息是否存在于redis中，若存在则返回true，否则false

String partMd5 = redisService.hget(RedisPrefixConst.BREAKPOINT_H_KEY_PREFIX + fileMd5, (chunk + 1) + “”);

if (StringUtils.isEmpty(partMd5)) {

return Response.success(false);

}

return Response.success(true);

}

@Override

public Response mergeChunks(

String fileMd5,

String uploadId,

String fileName,

Long fileSize,

String mimetype,

String fileExt

) {

//从redis中获取改文件的所有分块信息列表（ETag）

Map<String, String> dataMap = redisService.hscan(RedisPrefixConst.BREAKPOINT_H_KEY_PREFIX + fileMd5, null);

//调用oss合并文件方法，获取完整文件标识信息

List partETagList = Lists.newArrayList();

for (Map.Entry<String, String> entry : dataMap.entrySet()) {

partETagList.add(JSONObject.parseObject(entry.getValue(), PartETag.class));

}

//删除redis分块记录

redisService.delete(RedisPrefixConst.BREAKPOINT_H_KEY_PREFIX + fileMd5);

//组装文件

String objectName = this.getFilePath(fileMd5, fileExt);

CompleteMultipartUploadResult result = ossService.completeMultipartUpload(objectName, uploadId, partETagList);

//组装返回结果到前端

String url = ossService.getUrl(result.getKey());

SysUploadItemVo sysUploadItemVo = new SysUploadItemVo(result.getKey(), fileMd5, url, “done”, fileName);

return Response.success(sysUploadItemVo).setMessage(“文件上传成功”);

}

///

// private functions

///

private File mergeFile(List chunkFileList, File mergeFile) {

try {

// 有删 无创建

if (mergeFile.exists()) {

mergeFile.delete();

} else {

File newParentFile = mergeFile.getParentFile();

if (!newParentFile.exists()) {

newParentFile.mkdirs();

}

mergeFile.createNewFile();

}

// 排序

Collections.sort(chunkFileList, (o1, o2) -> {

if (Integer.parseInt(o1.getName()) > Integer.parseInt(o2.getName())) {

return 1;

}

return -1;

});

byte[] b = new byte[1024];

RandomAccessFile writeFile = new RandomAccessFile(mergeFile, “rw”);

for (File chunkFile : chunkFileList) {

RandomAccessFile readFile = new RandomAccessFile(chunkFile, “r”);

int len = -1;

while ((len = readFile.read(b)) != -1) {

writeFile.write(b, 0, len);

}

readFile.close();

}

writeFile.close();

return mergeFile;

} catch (IOException e) {

e.printStackTrace();

return null;

}

}

private String getUploadFilePath(String filePath) {

return uploadDir + filePath;

}

}

8、RedisService接口代码

/**

• @author chengmo on 2020/7/16

*/

public interface RedisService {

Long increment(String key);

boolean hasKey(String key);

String get(String key);

boolean delete(String key);

boolean set(String key, String value);

boolean set(String key, String value, Long timeout);

boolean setExpire(String key, Long expire);

long getExpire(String key);

String hget(String key, String hKey);

Map<String, String> hscan(String key, String pattern);

boolean hset(String key, String hKey, String hValue);

boolean hset(String key, String hKey, String hValue, long timeout);

boolean hdel(String key, String hKey);

boolean sadd(String key, String… value);

Set smembers(String key);

boolean szset(String key, String value, double score);

Long szdel(String key, String… value);

Set szrange(String key, long start, long end);

Set szdelAndGet(String key, long start, long end);

Double szscore(String key, String value);

Long lLeftPush(String key, String value);

Long lLeftPushAll(String key, Collection values);

String lRightPop(String key, long expire, TimeUnit unit);

RLock getLock(String key);

}

9、RedisServiceImpl代码

/**

• @author chengmo on 2020/7/16

*/

@Service

public class RedisServiceImpl implements RedisService {

private static final GLog LOG = LogFactory.getLogger(RedisServiceImpl.class);

@Autowired

private RedissonClient client;

@Autowired

private StringRedisTemplate stringRedisTemplate;

private final String namespace;

public RedisServiceImpl(@Value(“${spring.application.name}”) String namespace) {

this.namespace = Constants.GLZ + Constants.COLON +

StringUtils.replace(namespace, “-”, “_”) +

Constants.COLON;

}

public Long increment(String key) {

String redisKey = this.rebuildKey(key);

Long req = null;

try {

ValueOperations<String, String> op = stringRedisTemplate.opsForValue();

req = op.increment(redisKey);

} catch (Exception e) {

LOG.error(“increment [Key:{0}] from redis failed!”, e, redisKey);

}

return req;

}

@Override

public boolean hasKey(String key) {

String redisKey = this.rebuildKey(key);

try {

return stringRedisTemplate.hasKey(redisKey);

} catch (Exception e) {

LOG.error(“hasKey [Key:{0}] from redis failed!”, e, redisKey);

}

return false;

}

@Override

public String get(String key) {

String redisKey = this.rebuildKey(key);

String result;

try {

result = stringRedisTemplate.opsForValue().get(redisKey);

if (null == result) {

return null;

}

return result;

} catch (Exception e) {

LOG.error(“Get [Key:{0}] from redis failed!”, e, redisKey);

}

return null;

}

@Override

public boolean delete(String key) {

String redisKey = this.rebuildKey(key);

try {

stringRedisTemplate.delete(redisKey);

return true;

} catch (Exception e) {

LOG.error(“Delete [Key:{0}]from redis failed!”, e, redisKey);

}

return false;

}

@Override

public boolean set(String key, String value) {

String redisKey = this.rebuildKey(key);

try {

stringRedisTemplate.opsForValue().set(redisKey, value);

return true;

} catch (Exception e) {

LOG.error(“Set [Key:{0}][Value:{1}] into redis failed!”, e, redisKey, value);

}

return false;

}

@Override

public boolean set(String key, String value, Long timeout) {

String redisKey = this.rebuildKey(key);

try {

stringRedisTemplate.opsForValue().set(redisKey, value, timeout, TimeUnit.SECONDS);

return true;

} catch (Exception e) {

LOG.error(“Set [Key:{0}][Value:{1}][TimeOut:{2}] into redis failed!”, e, redisKey, value, timeout);

}

return false;

}

@Override

public boolean setExpire(String key, Long expire) {

String redisKey = this.rebuildKey(key);

try {

stringRedisTemplate.expire(redisKey, expire, TimeUnit.SECONDS);

return true;

} catch (Exception e) {

LOG.error(“setExpire [Key:{0}][handleAutoRenew:{1}] into redis failed!”, e, redisKey, expire);

}

return false;

}

@Override

public long getExpire(String key) {

String redisKey = this.rebuildKey(key);

try {

return stringRedisTemplate.getExpire(redisKey, TimeUnit.SECONDS);

} catch (Exception e) {

LOG.error(“getExpire [Key:{0}][handleAutoRenew:{1}] into redis failed!”, e, redisKey);

}

return 0l;

}

@Override

public String hget(String key, String hKey) {

String redisKey = this.rebuildKey(key);

try {

return (String) stringRedisTemplate.opsForHash().get(redisKey, hKey);

} catch (Exception e) {

LOG.error("hget key:[{0}] hkey:[{1}] fail ", e, redisKey, hKey);

}

return null;

}

@Override

public Map<String, String> hscan(String key, String pattern) {

String redisKey = this.rebuildKey(key);

Cursor<Map.Entry<Object, Object>> cursor = null;

try {

ScanOptions scanOptions = null;

if (StringUtils.isEmpty(pattern))

scanOptions = ScanOptions.NONE;

else

scanOptions = ScanOptions.scanOptions().match(pattern).build();

cursor = stringRedisTemplate.opsForHash().scan(redisKey, scanOptions);

Map<String, String> map = new HashMap<>();

while (cursor.hasNext()) {

Map.Entry<Object, Object> entry = cursor.next();

Object value = entry.getValue();

map.put(entry.getKey().toString(), null != value ? value.toString() : null);

}

return map;

} catch (Exception e) {

LOG.error("hscan key:[{0}] fail ", e, redisKey);

} finally {

if (null != cursor) {

try {

cursor.close();

} catch (IOException e) {

LOG.error("hscan close cursor fail ", e);

}

}

}

return null;

}

@Override

public boolean hset(String key, String hKey, String hValue) {

String redisKey = this.rebuildKey(key);

try {

stringRedisTemplate.opsForHash().put(redisKey, hKey, hValue);

return true;

} catch (Exception e) {

LOG.error("hset key:[{0}] hkey:[{1}] fail ", e, redisKey, hKey);

}

return true;

}

@Override

public boolean hset(String key, String hKey, String hValue, long timeout) {

String redisKey = this.rebuildKey(key);

try {

stringRedisTemplate.opsForHash().put(redisKey, hKey, hValue);

stringRedisTemplate.expire(redisKey, timeout, TimeUnit.SECONDS);

return true;

} catch (Exception e) {

LOG.error("hset key:[{0}] hkey:[{1}] fail ", e, redisKey, hKey);

}

return true;

}

@Override

public boolean hdel(String key, String hKey) {

String redisKey = this.rebuildKey(key);

try {

stringRedisTemplate.opsForHash().delete(redisKey, hKey);

return true;

} catch (Exception e) {

LOG.error("hdel key:[{0}] hkey:[{1}] fail ", e, redisKey, hKey);

}

return false;

}

@Override

public boolean sadd(String key, String… value) {

String redisKey = this.rebuildKey(key);

try {

Long add = stringRedisTemplate.opsForSet().add(redisKey, value);

return Objects.nonNull(add) && add > 0;

} catch (Exception e) {

LOG.error(“sadd value:[{0}] to key:[{1}] fail”, redisKey, value, e);

}

return false;

}

@Override

public Set smembers(String key) {

String redisKey = this.rebuildKey(key);

try {

return stringRedisTemplate.opsForSet().members(redisKey);

} catch (Exception e) {

LOG.error(“scard values from key:[{0}] fail”, redisKey, e);

}

return new HashSet();

}

@Override

public boolean szset(String key, String value, double score) {

String redisKey = this.rebuildKey(key);

try {

return stringRedisTemplate.opsForZSet().add(redisKey, value, score);

}catch (Exception e){

LOG.error(“szset value:[{0}] from key:[{1}] fail”, value, redisKey, e);

}

return false;

}

@Override

public Long szdel(String key, String… value) {

String redisKey = this.rebuildKey(key);

try {

return stringRedisTemplate.opsForZSet().remove(redisKey, value);

}catch (Exception e){

LOG.error(“szdel values:[{0}] from key:[{1}] fail”, value, redisKey, e);

}

return 0L;

}

@Override

public Set szrange(String key, long start, long end) {

String redisKey = this.rebuildKey(key);

try {

return stringRedisTemplate.opsForZSet().range(redisKey, start, end);

}catch (Exception e){

LOG.error(“szrange start:[{0}] end:[{1}] from key:[{2}] fail”, start, end, redisKey, e);

}

return null;

}

@Override

public Set szdelAndGet(String key, long start, long end) {

String redisKey = this.rebuildKey(key);

RLock lock = client.getLock(redisKey+“_Lock”);

try {

lock.lock();

ZSetOperations<String, String> operation = stringRedisTemplate.opsForZSet();

Set set = operation.range(redisKey, start, end);

if(null == set || set.size()==0)return set;

operation.remove(redisKey, set.toArray());

return set;

}catch (Exception e){

LOG.error(“szdelAndGet start:[{0}] end:[{1}] from key:[{2}] fail”, start, end, redisKey, e);

}finally {

lock.unlock();

}

return null;

}

@Override

public Double szscore(String key, String value) {

String redisKey = this.rebuildKey(key);

try {

return stringRedisTemplate.opsForZSet().score(redisKey, value);

}catch (Exception e){

LOG.error(“szscore value:[{0}] from key:[{1}] fail”, value, redisKey, e);

}

return null;

}

@Override

public Long lLeftPush(String key, String value) {

String redisKey = this.rebuildKey(key);

try {

return stringRedisTemplate.opsForList().leftPush(redisKey, value);

}catch (Exception e){

LOG.error(“lLeftPush value:[{0}] from key:[{1}] fail”, value, redisKey, e);

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以添加V获取：vip1024b （备注Java）

最后的话

无论是哪家公司，都很重视Spring框架技术，重视基础，所以千万别小看任何知识。面试是一个双向选择的过程，不要抱着畏惧的心态去面试，不利于自己的发挥。
同时看中的应该不止薪资，还要看你是不是真的喜欢这家公司，好了希望这篇文章对大家有帮助！

部分截图：

一个人可以走的很快，但一群人才能走的更远。不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎扫码加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

lue:[{0}] from key:[{1}] fail", value, redisKey, e);

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
[外链图片转存中…(img-9eXwnVy5-1712672415570)]
[外链图片转存中…(img-d6iystpn-1712672415571)]
[外链图片转存中…(img-WP6ZVYYI-1712672415571)]
[外链图片转存中…(img-fT76Exce-1712672415572)]
[外链图片转存中…(img-CAbaJVTG-1712672415572)]
[外链图片转存中…(img-9VvLztB5-1712672415572)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以添加V获取：vip1024b （备注Java）
[外链图片转存中…(img-WAo3S0UJ-1712672415573)]

最后的话

无论是哪家公司，都很重视Spring框架技术，重视基础，所以千万别小看任何知识。面试是一个双向选择的过程，不要抱着畏惧的心态去面试，不利于自己的发挥。
同时看中的应该不止薪资，还要看你是不是真的喜欢这家公司，好了希望这篇文章对大家有帮助！

部分截图：
[外链图片转存中…(img-yEC9jr8f-1712672415573)]

一个人可以走的很快，但一群人才能走的更远。不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎扫码加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
[外链图片转存中…(img-A6kp8PT9-1712672415573)]