阿里云实现文件上传

1.首先引入项目依赖

    <dependency>
        <groupId>com.aliyun.oss</groupId>
        <artifactId>aliyun-sdk-oss</artifactId>
        <version>2.8.2</version>
    </dependency>

我这里提供了3个工具类 方便快速实现功能

@PostMapping("/common/uploadFile2Cos")
@ApiOperation("文件上传")
public AjaxResult uploadFile2Cos(@RequestParam("file") MultipartFile[] files) {
    StringBuilder fileUrl = new StringBuilder();
    for (MultipartFile file : files) {
        try {
            InputStream inputStream = file.getInputStream();
            DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
            String dateString = dateTimeFormatter.format(LocalDateTime.now());
            String key = aliOSSUtil.uploadFile(inputStream, "weChat", dateString + "-" + CommonUtil.randomCode(6) + file.getOriginalFilename());
            String singleFileUrl = aliOSSUtil.getFileUrl(key);
            if (StringUtils.isEmpty(fileUrl.toString())) {
                fileUrl.append(singleFileUrl);
            } else {
                fileUrl.append(",").append(singleFileUrl);
            }

        } catch (Exception e) {
            e.printStackTrace();
            return AjaxResult.error("上传失败");
        }
    }
    return AjaxResult.success("获取成功", fileUrl);
}

下面是业务层实现代码

工具类

package com.linkwechat.common.utils;

import com.aliyun.oss.OSSClient;
import com.aliyun.oss.model.OSSObject;
import com.aliyun.oss.model.ObjectMetadata;
import com.aliyun.oss.model.PutObjectResult;
import com.linkwechat.common.exception.BaseException;
import lombok.Data;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.ObjectUtils;

import java.io.;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;
import java.util.;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

@Component
public class AliOSSUtil {

@Autowired
private RedisUtils redisUtils;


private static String[] contentTypes = {
		".load:text/html", 
		".123:application/vnd.lotus-1-2-3", 
		".3ds:image/x-3ds", 
		".3g2:video/3gpp", 
		".3ga:video/3gpp", 
		".3gp:video/3gpp", 
		".3gpp:video/3gpp", 
		".602:application/x-t602", 
		".669:audio/x-mod", 
		".7z:application/x-7z-compressed", 
		".a:application/x-archive", 
		".aac:audio/mp4", 
		".abw:application/x-abiword", 
		 ".abw.crashed:application/x-abiword", 
		".abw.gz:application/x-abiword", 
		".ac3:audio/ac3", 
		".ace:application/x-ace", 
		".adb:text/x-adasrc", 
		".ads:text/x-adasrc", 
		".afm:application/x-font-afm", 
		".ag:image/x-applix-graphics", 
		".ai:application/illustrator", 
		".aif:audio/x-aiff", 
		".aifc:audio/x-aiff", 
		".aiff:audio/x-aiff", 
		".al:application/x-perl", 
		".alz:application/x-alz", 
		".amr:audio/amr", 
		".ani:application/x-navi-animation", 
		".anim[1-9j]:video/x-anim", 
		".anx:application/annodex", 
		".ape:audio/x-ape", 
		".arj:application/x-arj", 
		".arw:image/x-sony-arw", 
		".as:application/x-applix-spreadsheet", 
		".asc:text/plain", 
		".asf:video/x-ms-asf", 
		".asp:application/x-asp", 
		".ass:text/x-ssa", 
		".asx:audio/x-ms-asx", 
		".atom:application/atom+xml", 
		".au:audio/basic", 
		".avi:video/x-msvideo", 
		".aw:application/x-applix-word", 
		".awb:audio/amr-wb", 
		".awk:application/x-awk", 
		".axa:audio/annodex", 
		".axv:video/annodex", 
		".bak:application/x-trash", 
		".bcpio:application/x-bcpio", 
		".bdf:application/x-font-bdf", 
		".bib:text/x-bibtex", 
		".bin:application/octet-stream", 
		".blend:application/x-blender", 
		".blender:application/x-blender", 
		".bmp:image/bmp", 
		".bz:application/x-bzip", 
		".bz2:application/x-bzip", 
		".c:text/x-csrc", 
		".c++:text/x-c++src", 
		".cab:application/vnd.ms-cab-compressed", 
		".cb7:application/x-cb7", 
		".cbr:application/x-cbr", 
		".cbt:application/x-cbt", 
		".cbz:application/x-cbz", 
		".cc:text/x-c++src", 
		".cdf:application/x-netcdf", 
		".cdr:application/vnd.corel-draw", 
		".cer:application/x-x509-ca-cert", 
		".cert:application/x-x509-ca-cert", 
		".cgm:image/cgm", 
		".chm:application/x-chm", 
		".chrt:application/x-kchart", 
		".class:application/x-java", 
		".cls:text/x-tex", 
		".cmake:text/x-cmake", 
		".cpio:application/x-cpio", 
		".cpio.gz:application/x-cpio-compressed", 
		".cpp:text/x-c++src", 
		".cr2:image/x-canon-cr2", 
		".crt:application/x-x509-ca-cert", 
		".crw:image/x-canon-crw", 
		".cs:text/x-csharp", 
		".csh:application/x-csh", 
		".css:text/css", 
		".cssl:text/css", 
		".csv:text/csv", 
		".cue:application/x-cue", 
		".cur:image/x-win-bitmap", 
		".cxx:text/x-c++src", 
		".d:text/x-dsrc", 
		".dar:application/x-dar", 
		".dbf:application/x-dbf", 
		".dc:application/x-dc-rom", 
		".dcl:text/x-dcl", 
		".dcm:application/dicom", 
		".dcr:image/x-kodak-dcr", 
		".dds:image/x-dds", 
		".deb:application/x-deb",  
		".der:application/x-x509-ca-cert",  
		".desktop:application/x-desktop", 
		".dia:application/x-dia-diagram", 
		".diff:text/x-patch", 
		".divx:video/x-msvideo", 
		".djv:image/vnd.djvu", 
		".djvu:image/vnd.djvu", 
		".dng:image/x-adobe-dng", 
		".doc:application/msword", 
		".docbook:application/docbook+xml", 
		".docm:application/vnd.openxmlformats-officedocument.wordprocessingml.document", 
		".docx:application/vnd.openxmlformats-officedocument.wordprocessingml.document", 
		".dot:text/vnd.graphviz", 
		".dsl:text/x-dsl", 
		".dtd:application/xml-dtd", 
		".dtx:text/x-tex", 
		".dv:video/dv", 
		".dvi:application/x-dvi", 
		".dvi.bz2:application/x-bzdvi", 
		".dvi.gz:application/x-gzdvi",  
		".dwg:image/vnd.dwg", 
		".dxf:image/vnd.dxf", 
		".e:text/x-eiffel", 
		".egon:application/x-egon", 
		".eif:text/x-eiffel", 
		".el:text/x-emacs-lisp", 
		".emf:image/x-emf", 
		".emp:application/vnd.emusic-emusic_package", 
		".ent:application/xml-external-parsed-entity", 
		".eps:image/x-eps", 
		".eps.bz2:image/x-bzeps", 
		".eps.gz:image/x-gzeps", 
		".epsf:image/x-eps", 
		".epsf.bz2:image/x-bzeps", 
		".epsf.gz:image/x-gzeps", 
		".epsi:image/x-eps", 
		".epsi.bz2:image/x-bzeps", 
		".epsi.gz:image/x-gzeps", 
		".epub:application/epub+zip", 
		".erl:text/x-erlang", 
		".es:application/ecmascript", 
		".etheme:application/x-e-theme", 
		".etx:text/x-setext", 
		".exe:application/x-ms-dos-executable", 
		".exr:image/x-exr", 
		".ez:application/andrew-inset", 
		".f:text/x-fortran", 
		".f90:text/x-fortran", 
		".f95:text/x-fortran", 
		".fb2:application/x-fictionbook+xml", 
		".fig:image/x-xfig", 
		".fits:image/fits", 
		".fl:application/x-fluid", 
		".flac:audio/x-flac", 
		".flc:video/x-flic", 
		".fli:video/x-flic", 
		".flv:video/x-flv", 
		".flw:application/x-kivio", 
		".fo:text/x-xslfo", 
		".for:text/x-fortran", 
		".g3:image/fax-g3", 
		".gb:application/x-gameboy-rom", 
		".gba:application/x-gba-rom", 
		".gcrd:text/directory", 
		".ged:application/x-gedcom", 
		".gedcom:application/x-gedcom", 
		".gen:application/x-genesis-rom", 
		".gf:application/x-tex-gf", 
		".gg:application/x-sms-rom", 
		".gif:image/gif", 
		".glade:application/x-glade", 
		".gmo:application/x-gettext-translation", 
		".gnc:application/x-gnucash", 
		".gnd:application/gnunet-directory", 
		".gnucash:application/x-gnucash", 
		".gnumeric:application/x-gnumeric", 
		".gnuplot:application/x-gnuplot", 
		".gp:application/x-gnuplot", 
		".gpg:application/pgp-encrypted", 
		".gplt:application/x-gnuplot", 
		".gra:application/x-graphite", 
		".gsf:application/x-font-type1", 
		".gsm:audio/x-gsm", 
		".gtar:application/x-tar", 
		".gv:text/vnd.graphviz", 
		".gvp:text/x-google-video-pointer", 
		".gz:application/x-gzip", 
		".h:text/x-chdr", 
		".h++:text/x-c++hdr", 
		".hdf:application/x-hdf", 
		".hh:text/x-c++hdr", 
		".hp:text/x-c++hdr", 
		".hpgl:application/vnd.hp-hpgl", 
		".hpp:text/x-c++hdr", 
		".hs:text/x-haskell", 
		".htm:text/html", 
		".html:text/html", 
		".hwp:application/x-hwp", 
		".hwt:application/x-hwt", 
		".hxx:text/x-c++hdr", 
		".ica:application/x-ica", 
		".icb:image/x-tga", 
		".icns:image/x-icns", 
		".ico:image/vnd.microsoft.icon", 
		".ics:text/calendar", 
		".idl:text/x-idl", 
		".ief:image/ief", 
		".iff:image/x-iff", 
		".ilbm:image/x-ilbm", 
		".ime:text/x-imelody", 
		".imy:text/x-imelody", 
		".ins:text/x-tex", 
		".iptables:text/x-iptables", 
		".iso:application/x-cd-image", 
		".iso9660:application/x-cd-image", 
		".it:audio/x-it", 
		".j2k:image/jp2", 
		".jad:text/vnd.sun.j2me.app-descriptor", 
		".jar:application/x-java-archive", 
		".java:text/x-java", 
		".jng:image/x-jng", 
		".jnlp:application/x-java-jnlp-file", 
		".jp2:image/jp2", 
		".jpc:image/jp2", 
		".jpe:image/jpeg", 
		".jpeg:image/jpeg", 
		".jpf:image/jp2", 
		".jpg:image/jpeg", 
		".jpr:application/x-jbuilder-project", 
		".jpx:image/jp2", 
		".js:application/javascript", 
		".json:application/json", 
		".jsonp:application/jsonp", 
		".k25:image/x-kodak-k25", 
		".kar:audio/midi", 
		".karbon:application/x-karbon", 
		".kdc:image/x-kodak-kdc", 
		".kdelnk:application/x-desktop", 
		".kexi:application/x-kexiproject-sqlite3", 
		".kexic:application/x-kexi-connectiondata", 
		".kexis:application/x-kexiproject-shortcut", 
		".kfo:application/x-kformula", 
		".kil:application/x-killustrator", 
		".kino:application/smil", 
		".kml:application/vnd.google-earth.kml+xml", 
		".kmz:application/vnd.google-earth.kmz", 
		".kon:application/x-kontour", 
		".kpm:application/x-kpovmodeler", 
		".kpr:application/x-kpresenter", 
		".kpt:application/x-kpresenter", 
		".kra:application/x-krita", 
		".ksp:application/x-kspread", 
		".kud:application/x-kugar", 
		".kwd:application/x-kword", 
		".kwt:application/x-kword", 
		".la:application/x-shared-library-la", 
		".latex:text/x-tex", 
		".ldif:text/x-ldif", 
		".lha:application/x-lha", 
		".lhs:text/x-literate-haskell", 
		".lhz:application/x-lhz", 
		".log:text/x-log", 
		".ltx:text/x-tex", 
		".lua:text/x-lua", 
		".lwo:image/x-lwo", 
		".lwob:image/x-lwo", 
		".lws:image/x-lws", 
		".ly:text/x-lilypond", 
		".lyx:application/x-lyx", 
		".lz:application/x-lzip", 
		".lzh:application/x-lha", 
		".lzma:application/x-lzma", 
		".lzo:application/x-lzop", 
		".m:text/x-matlab", 
		".m15:audio/x-mod", 
		".m2t:video/mpeg", 
		".m3u:audio/x-mpegurl", 
		".m3u8:audio/x-mpegurl", 
		".m4:application/x-m4", 
		".m4a:audio/mp4", 
		".m4b:audio/x-m4b", 
		".m4v:video/mp4", 
		".mab:application/x-markaby", 
		".man:application/x-troff-man", 
		".mbox:application/mbox", 
		".md:application/x-genesis-rom", 
		".mdb:application/vnd.ms-access", 
		".mdi:image/vnd.ms-modi", 
		".me:text/x-troff-me", 
		".med:audio/x-mod", 
		".metalink:application/metalink+xml", 
		".mgp:application/x-magicpoint", 
		".mid:audio/midi", 
		".midi:audio/midi", 
		".mif:application/x-mif", 
		".minipsf:audio/x-minipsf", 
		".mka:audio/x-matroska", 
		".mkv:video/x-matroska", 
		".ml:text/x-ocaml", 
		".mli:text/x-ocaml", 
		".mm:text/x-troff-mm", 
		".mmf:application/x-smaf", 
		".mml:text/mathml", 
		".mng:video/x-mng", 
		".mo:application/x-gettext-translation", 
		".mo3:audio/x-mo3", 
		".moc:text/x-moc", 
		".mod:audio/x-mod", 
		".mof:text/x-mof", 
		".moov:video/quicktime", 
		".mov:video/quicktime", 
		".movie:video/x-sgi-movie", 
		".mp+:audio/x-musepack", 
		".mp2:video/mpeg", 
		".mp3:audio/mpeg", 
		".mp4:video/mp4", 
		".mpc:audio/x-musepack", 
		".mpe:video/mpeg", 
		".mpeg:video/mpeg", 
		".mpg:video/mpeg", 
		".mpga:audio/mpeg", 
		".mpp:audio/x-musepack", 
		".mrl:text/x-mrml", 
		".mrml:text/x-mrml", 
		".mrw:image/x-minolta-mrw", 
		".ms:text/x-troff-ms", 
		".msi:application/x-msi", 
		".msod:image/x-msod", 
		".msx:application/x-msx-rom", 
		".mtm:audio/x-mod", 
		".mup:text/x-mup", 
		".mxf:application/mxf", 
		".n64:application/x-n64-rom", 
		".nb:application/mathematica", 
		".nc:application/x-netcdf", 
		".nds:application/x-nintendo-ds-rom", 
		".nef:image/x-nikon-nef", 
		".nes:application/x-nes-rom", 
		".nfo:text/x-nfo", 
		".not:text/x-mup", 
		".nsc:application/x-netshow-channel", 
		".nsv:video/x-nsv", 
		".o:application/x-object", 
		".obj:application/x-tgif", 
		".ocl:text/x-ocl", 
		".oda:application/oda", 
		".odb:application/vnd.oasis.opendocument.database", 
		".odc:application/vnd.oasis.opendocument.chart", 
		".odf:application/vnd.oasis.opendocument.formula", 
		".odg:application/vnd.oasis.opendocument.graphics", 
		".odi:application/vnd.oasis.opendocument.image", 
		".odm:application/vnd.oasis.opendocument.text-master", 
		".odp:application/vnd.oasis.opendocument.presentation", 
		".ods:application/vnd.oasis.opendocument.spreadsheet", 
		".odt:application/vnd.oasis.opendocument.text", 
		".oga:audio/ogg", 
		".ogg:video/x-theora+ogg", 
		".ogm:video/x-ogm+ogg", 
		".ogv:video/ogg", 
		".ogx:application/ogg", 
		".old:application/x-trash", 
		".oleo:application/x-oleo", 
		".opml:text/x-opml+xml", 
		".ora:image/openraster", 
		".orf:image/x-olympus-orf", 
		".otc:application/vnd.oasis.opendocument.chart-template", 
		".otf:application/x-font-otf", 
		".otg:application/vnd.oasis.opendocument.graphics-template", 
		".oth:application/vnd.oasis.opendocument.text-web", 
		".otp:application/vnd.oasis.opendocument.presentation-template", 
		".ots:application/vnd.oasis.opendocument.spreadsheet-template", 
		".ott:application/vnd.oasis.opendocument.text-template", 
		".owl:application/rdf+xml", 
		".oxt:application/vnd.openofficeorg.extension", 
		".p:text/x-pascal", 
		".p10:application/pkcs10", 
		".p12:application/x-pkcs12", 
		".p7b:application/x-pkcs7-certificates", 
		".p7s:application/pkcs7-signature", 
		".pack:application/x-java-pack200", 
		".pak:application/x-pak", 
		".par2:application/x-par2", 
		".pas:text/x-pascal", 
		".patch:text/x-patch", 
		".pbm:image/x-portable-bitmap", 
		".pcd:image/x-photo-cd", 
		".pcf:application/x-cisco-vpn-settings", 
		".pcf.gz:application/x-font-pcf", 
		".pcf.z:application/x-font-pcf", 
		".pcl:application/vnd.hp-pcl", 
		".pcx:image/x-pcx", 
		".pdb:chemical/x-pdb", 
		".pdc:application/x-aportisdoc", 
		".pdf:application/pdf", 
		".pdf.bz2:application/x-bzpdf", 
		".pdf.gz:application/x-gzpdf", 
		".pef:image/x-pentax-pef", 
		".pem:application/x-x509-ca-cert", 
		".perl:application/x-perl", 
		".pfa:application/x-font-type1", 
		".pfb:application/x-font-type1", 
		".pfx:application/x-pkcs12", 
		".pgm:image/x-portable-graymap", 
		".pgn:application/x-chess-pgn", 
		".pgp:application/pgp-encrypted", 
		".php:application/x-php", 
		".php3:application/x-php", 
		".php4:application/x-php", 
		".pict:image/x-pict", 
		".pict1:image/x-pict", 
		".pict2:image/x-pict", 
		".pickle:application/python-pickle", 
		".pk:application/x-tex-pk", 
		".pkipath:application/pkix-pkipath", 
		".pkr:application/pgp-keys", 
		".pl:application/x-perl", 
		".pla:audio/x-iriver-pla", 
		".pln:application/x-planperfect", 
		".pls:audio/x-scpls", 
		".pm:application/x-perl", 
		".png:image/png", 
		".pnm:image/x-portable-anymap", 
		".pntg:image/x-macpaint", 
		".po:text/x-gettext-translation", 
		".por:application/x-spss-por", 
		".pot:text/x-gettext-translation-template", 
		".ppm:image/x-portable-pixmap", 
		".pps:application/vnd.ms-powerpoint", 
		".ppt:application/vnd.ms-powerpoint", 
		".pptm:application/vnd.openxmlformats-officedocument.presentationml.presentation", 
		".pptx:application/vnd.openxmlformats-officedocument.presentationml.presentation", 
		".ppz:application/vnd.ms-powerpoint", 
		".prc:application/x-palm-database", 
		".ps:application/postscript", 
		".ps.bz2:application/x-bzpostscript", 
		".ps.gz:application/x-gzpostscript", 
		".psd:image/vnd.adobe.photoshop", 
		".psf:audio/x-psf", 
		".psf.gz:application/x-gz-font-linux-psf", 
		".psflib:audio/x-psflib", 
		".psid:audio/prs.sid", 
		".psw:application/x-pocket-word", 
		".pw:application/x-pw", 
		".py:text/x-python", 
		".pyc:application/x-python-bytecode", 
		".pyo:application/x-python-bytecode", 
		".qif:image/x-quicktime", 
		".qt:video/quicktime", 
		".qtif:image/x-quicktime", 
		".qtl:application/x-quicktime-media-link", 
		".qtvr:video/quicktime", 
		".ra:audio/vnd.rn-realaudio", 
		".raf:image/x-fuji-raf", 
		".ram:application/ram", 
		".rar:application/x-rar", 
		".ras:image/x-cmu-raster", 
		".raw:image/x-panasonic-raw", 
		".rax:audio/vnd.rn-realaudio", 
		".rb:application/x-ruby", 
		".rdf:application/rdf+xml", 
		".rdfs:application/rdf+xml", 
		".reg:text/x-ms-regedit", 
		".rej:application/x-reject", 
		".rgb:image/x-rgb", 
		".rle:image/rle", 
		".rm:application/vnd.rn-realmedia", 
		".rmj:application/vnd.rn-realmedia", 
		".rmm:application/vnd.rn-realmedia", 
		".rms:application/vnd.rn-realmedia", 
		".rmvb:application/vnd.rn-realmedia", 
		".rmx:application/vnd.rn-realmedia", 
		".roff:text/troff", 
		".rp:image/vnd.rn-realpix", 
		".rpm:application/x-rpm", 
		".rss:application/rss+xml", 
		".rt:text/vnd.rn-realtext", 
		".rtf:application/rtf", 
		".rtx:text/richtext", 
		".rv:video/vnd.rn-realvideo", 
		".rvx:video/vnd.rn-realvideo", 
		".s3m:audio/x-s3m", 
		".sam:application/x-amipro", 
		".sami:application/x-sami", 
		".sav:application/x-spss-sav", 
		".scm:text/x-scheme", 
		".sda:application/vnd.stardivision.draw", 
		".sdc:application/vnd.stardivision.calc", 
		".sdd:application/vnd.stardivision.impress", 
		".sdp:application/sdp", 
		".sds:application/vnd.stardivision.chart", 
		".sdw:application/vnd.stardivision.writer", 
		".sgf:application/x-go-sgf", 
		".sgi:image/x-sgi", 
		".sgl:application/vnd.stardivision.writer", 
		".sgm:text/sgml", 
		".sgml:text/sgml", 
		".sh:application/x-shellscript", 
		".shar:application/x-shar", 
		".shn:application/x-shorten", 
		".siag:application/x-siag", 
		".sid:audio/prs.sid", 
		".sik:application/x-trash", 
		".sis:application/vnd.symbian.install", 
		".sisx:x-epoc/x-sisx-app", 
		".sit:application/x-stuffit", 
		".siv:application/sieve", 
		".sk:image/x-skencil", 
		".sk1:image/x-skencil", 
		".skr:application/pgp-keys", 
		".slk:text/spreadsheet", 
		".smaf:application/x-smaf", 
		".smc:application/x-snes-rom", 
		".smd:application/vnd.stardivision.mail", 
		".smf:application/vnd.stardivision.math", 
		".smi:application/x-sami", 
		".smil:application/smil", 
		".sml:application/smil", 
		".sms:application/x-sms-rom", 
		".snd:audio/basic", 
		".so:application/x-sharedlib", 
		".spc:application/x-pkcs7-certificates", 
		".spd:application/x-font-speedo", 
		".spec:text/x-rpm-spec", 
		".spl:application/x-shockwave-flash", 
		".spx:audio/x-speex", 
		".sql:text/x-sql", 
		".sr2:image/x-sony-sr2", 
		".src:application/x-wais-source", 
		".srf:image/x-sony-srf", 
		".srt:application/x-subrip", 
		".ssa:text/x-ssa", 
		".stc:application/vnd.sun.xml.calc.template", 
		".std:application/vnd.sun.xml.draw.template", 
		".sti:application/vnd.sun.xml.impress.template", 
		".stm:audio/x-stm", 
		".stw:application/vnd.sun.xml.writer.template", 
		".sty:text/x-tex", 
		".sub:text/x-subviewer", 
		".sun:image/x-sun-raster", 
		".sv4cpio:application/x-sv4cpio", 
		".sv4crc:application/x-sv4crc", 
		".svg:image/svg+xml", 
		".svgz:image/svg+xml-compressed", 
		".swf:application/x-shockwave-flash", 
		".sxc:application/vnd.sun.xml.calc", 
		".sxd:application/vnd.sun.xml.draw", 
		".sxg:application/vnd.sun.xml.writer.global", 
		".sxi:application/vnd.sun.xml.impress", 
		".sxm:application/vnd.sun.xml.math", 
		".sxw:application/vnd.sun.xml.writer", 
		".sylk:text/spreadsheet", 
		".t:text/troff", 
		".t2t:text/x-txt2tags", 
		".tar:application/x-tar", 
		".tar.bz:application/x-bzip-compressed-tar", 
		".tar.bz2:application/x-bzip-compressed-tar", 
		".tar.gz:application/x-compressed-tar", 
		".tar.lzma:application/x-lzma-compressed-tar", 
		".tar.lzo:application/x-tzo", 
		".tar.xz:application/x-xz-compressed-tar", 
		".tar.z:application/x-tarz", 
		".tbz:application/x-bzip-compressed-tar", 
		".tbz2:application/x-bzip-compressed-tar", 
		".tcl:text/x-tcl", 
		".tex:text/x-tex", 
		".texi:text/x-texinfo", 
		".texinfo:text/x-texinfo", 
		".tga:image/x-tga", 
		".tgz:application/x-compressed-tar", 
		".theme:application/x-theme", 
		".themepack:application/x-windows-themepack", 
		".tif:image/tiff", 
		".tiff:image/tiff", 
		".tk:text/x-tcl", 
		".tlz:application/x-lzma-compressed-tar", 
		".tnef:application/vnd.ms-tnef", 
		".tnf:application/vnd.ms-tnef", 
		".toc:application/x-cdrdao-toc", 
		".torrent:application/x-bittorrent", 
		".tpic:image/x-tga", 
		".tr:text/troff", 
		".ts:application/x-linguist", 
		".tsv:text/tab-separated-values", 
		".tta:audio/x-tta", 
		".ttc:application/x-font-ttf", 
		".ttf:application/x-font-ttf", 
		".ttx:application/x-font-ttx", 
		".txt:text/plain", 
		".txz:application/x-xz-compressed-tar", 
		".tzo:application/x-tzo", 
		".ufraw:application/x-ufraw", 
		".ui:application/x-designer", 
		".uil:text/x-uil", 
		".ult:audio/x-mod", 
		".uni:audio/x-mod", 
		".uri:text/x-uri", 
		".url:text/x-uri", 
		".ustar:application/x-ustar", 
		".vala:text/x-vala", 
		".vapi:text/x-vala", 
		".vcf:text/directory", 
		".vcs:text/calendar", 
		".vct:text/directory", 
		".vda:image/x-tga", 
		".vhd:text/x-vhdl", 
		".vhdl:text/x-vhdl", 
		".viv:video/vivo", 
		".vivo:video/vivo", 
		".vlc:audio/x-mpegurl", 
		".vob:video/mpeg", 
		".voc:audio/x-voc", 
		".vor:application/vnd.stardivision.writer", 
		".vst:image/x-tga", 
		".wav:audio/x-wav", 
		".wax:audio/x-ms-asx", 
		".wb1:application/x-quattropro", 
		".wb2:application/x-quattropro", 
		".wb3:application/x-quattropro", 
		".wbmp:image/vnd.wap.wbmp", 
		".wcm:application/vnd.ms-works", 
		".wdb:application/vnd.ms-works", 
		".webm:video/webm", 
		".wk1:application/vnd.lotus-1-2-3", 
		".wk3:application/vnd.lotus-1-2-3", 
		".wk4:application/vnd.lotus-1-2-3", 
		".wks:application/vnd.ms-works", 
		".wma:audio/x-ms-wma", 
		".wmf:image/x-wmf", 
		".wml:text/vnd.wap.wml", 
		".wmls:text/vnd.wap.wmlscript", 
		".wmv:video/x-ms-wmv", 
		".wmx:audio/x-ms-asx", 
		".wp:application/vnd.wordperfect", 
		".wp4:application/vnd.wordperfect", 
		".wp5:application/vnd.wordperfect", 
		".wp6:application/vnd.wordperfect", 
		".wpd:application/vnd.wordperfect", 
		".wpg:application/x-wpg", 
		".wpl:application/vnd.ms-wpl", 
		".wpp:application/vnd.wordperfect", 
		".wps:application/vnd.ms-works", 
		".wri:application/x-mswrite", 
		".wrl:model/vrml", 
		".wv:audio/x-wavpack", 
		".wvc:audio/x-wavpack-correction", 
		".wvp:audio/x-wavpack", 
		".wvx:audio/x-ms-asx", 
		".x3f:image/x-sigma-x3f", 
		".xac:application/x-gnucash", 
		".xbel:application/x-xbel", 
		".xbl:application/xml", 
		".xbm:image/x-xbitmap", 
		".xcf:image/x-xcf", 
		".xcf.bz2:image/x-compressed-xcf", 
		".xcf.gz:image/x-compressed-xcf", 
		".xhtml:application/xhtml+xml", 
		".xi:audio/x-xi", 
		".xla:application/vnd.ms-excel", 
		".xlc:application/vnd.ms-excel", 
		".xld:application/vnd.ms-excel", 
		".xlf:application/x-xliff", 
		".xliff:application/x-xliff", 
		".xll:application/vnd.ms-excel", 
		".xlm:application/vnd.ms-excel", 
		".xls:application/vnd.ms-excel", 
		".xlsm:application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", 
		".xlsx:application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", 
		".xlt:application/vnd.ms-excel", 
		".xlw:application/vnd.ms-excel", 
		".xm:audio/x-xm", 
		".xmf:audio/x-xmf", 
		".xmi:text/x-xmi", 
		".xml:application/xml", 
		".xpm:image/x-xpixmap", 
		".xps:application/vnd.ms-xpsdocument", 
		".xsl:application/xml", 
		".xslfo:text/x-xslfo", 
		".xslt:application/xml", 
		".xspf:application/xspf+xml", 
		".xul:application/vnd.mozilla.xul+xml", 
		".xwd:image/x-xwindowdump", 
		".xyz:chemical/x-pdb", 
		".xz:application/x-xz", 
		".w2p:application/w2p", 
		".z:application/x-compress", 
		".zabw:application/x-abiword", 
		".zip:application/zip", 
		".zoo:application/x-zoo"
};



@Data
public static class  OssVo{
	private String endpoint;
	private String accessKeyId;
	private String accessKeySecret;
	private String bucketName;
	private String key;
}



public OssVo  innit(){
	OssVo ossVo=new OssVo();
	ossVo.setEndpoint(redisUtils.getY("alioss_endpoint"));
	ossVo.setAccessKeyId(redisUtils.getY("alioss_accessKeyId"));
	ossVo.setAccessKeySecret(redisUtils.getY("alioss_accessKeySecret"));
	ossVo.setBucketName(redisUtils.getY("alioss_bucketName"));
	ossVo.setKey(redisUtils.getY("alioss_key"));

	if(StringUtils.isEmpty(ossVo.getAccessKeyId())){
		ossVo.setEndpoint("oss-cn-hangzhou.aliyuncs.com");
		ossVo.setAccessKeyId("LTAIbICnxJz6DYUH");
		ossVo.setAccessKeySecret("BLZlBZnMdXYHG2WYsE0VtA85BuucwJ");
		ossVo.setBucketName("uf7oss");
		ossVo.setKey("uf7_image_test/");
	}
	return ossVo;
}

/**
 * 初始化OSS客户端
 * @return
 */
public OSSClient initOSSClient() throws Exception{
	OssVo ossVo = innit();
	OSSClient ossClient = new OSSClient(ossVo.getEndpoint(), ossVo.getAccessKeyId(), ossVo.getAccessKeySecret());
	return ossClient;
}

/**
 * 上传文件
 * @param file 文件对象
 * @param dirPath 上传目录
 * @return 返回上传成功的外网访问地址
 * @throws Exception
 */
public String uploadFile(File file,String dirPath) throws Exception{
	OssVo ossVo = innit();
	ObjectMetadata objectMeta = new ObjectMetadata();
    objectMeta.setContentLength(file.length());
    String fileName = file.getName();
    dirPath = dirPath==null||"".equals(dirPath)?"":(dirPath.endsWith("/")?dirPath:dirPath+"/");
    String contentType = AliOSSUtil.getContentType(fileName);
    if(null==contentType){
    	System.err.println("文件名为["+fileName+"]的文件上传失败");
    	return null;
    }
    objectMeta.setContentType(contentType);
    //注册client
	OSSClient ossClient = new OSSClient(ossVo.getEndpoint(), ossVo.getAccessKeyId(), ossVo.getAccessKeySecret());
	PutObjectResult result = ossClient.putObject(ossVo.getBucketName(), ossVo.getKey()+dirPath+fileName, new FileInputStream(file), objectMeta);
	System.err.println("上传文件结果"+result);
	//String url = this.getFileUrl(ossClient,dirPath+fileName);
	String url = dirPath+fileName;
	System.err.println("上传文件路径:"+url);
	ossClient.shutdown();
	return url;
}

/**
 * 上传文件
 * @param inputStream 文件io流
 * @param dirPath 上传路径
 * @param fileName 文件名称
 * @return 返回上传成功的外网访问地址
 * @throws Exception
 */
public String uploadFile(InputStream inputStream,String dirPath,String fileName) throws Exception{

	OssVo ossVo = innit();
	
	ObjectMetadata objectMeta = new ObjectMetadata();
    dirPath = dirPath==null||"".equals(dirPath)?"":(dirPath.endsWith("/")?dirPath:dirPath+"/");
    String contentType = AliOSSUtil.getContentType(fileName);
    if(null==contentType){
    	System.err.println("文件名为["+fileName+"]的文件上传失败");
    	return null;
    }
    objectMeta.setContentType(contentType);
    //注册client
	OSSClient ossClient = new OSSClient(ossVo.getEndpoint(),ossVo.getAccessKeyId() , ossVo.getAccessKeySecret());
	PutObjectResult result = ossClient.putObject(ossVo.getBucketName(), ossVo.getKey()+dirPath+fileName, inputStream, objectMeta);
	System.err.println("上传文件结果"+result);
	//String url = this.getFileUrl(ossClient,dirPath+fileName);
	String url = dirPath+fileName;
	System.err.println("上传文件路径:"+url);
	ossClient.shutdown();
	return url;
}

/**
 * 获取文件外网访问路径
 * @param fileName
 * @return
 */
public String getFileUrl(String fileName) throws Exception{
	if(fileName==null || "".equals(fileName)){
		return fileName;
	}
	OssVo ossVo = innit();
	OSSClient ossClient = new OSSClient(ossVo.getEndpoint(), ossVo.getAccessKeyId(), ossVo.getAccessKeySecret());
	String url = this.getFileUrl(ossClient,fileName);
	ossClient.shutdown();
	return url;
}

/**
 * 文件下载到本地指定文件夹
 * @param path oss文件路径
 * @param localPath 本地文件夹
 * @throws Exception
 */
public void downloadFileToLocal(String path, String localPath)throws Exception{
	OssVo ossVo = innit();
	OSSClient ossClient = new OSSClient(ossVo.getEndpoint(), ossVo.getAccessKeyId(), ossVo.getAccessKeySecret());
	File file = new File(localPath);
	if (!file.getParentFile().exists()){
		file.getParentFile().mkdirs();
	}
	if("/".equals(path.substring(0,1))){
		path = path.substring(1);
	}
	try {
		FileOutputStream fos = new FileOutputStream(file);
		// 下载OSS文件流
		OSSObject object = ossClient.getObject(ossVo.getBucketName(), path);
		InputStream is = object.getObjectContent();
		byte[] b = new byte[1024];
		int length;
		while((length= is.read(b)) != -1){
			fos.write(b,0,length);
		}
		fos.flush();
		fos.close();
		is.close();
		// 关闭OSSClient。
		ossClient.shutdown();
	}catch (IOException e){
		e.printStackTrace();
	}
}


/**
 * 获取文件外网访问路径
 * @param fileName
 * @return
 */
public String getFileUrl(OSSClient ossClient, String fileName) throws Exception{
	if(ossClient==null || fileName==null || "".equals(fileName)){
		return fileName;
	}
	OssVo ossVo = innit();
	Date expiration = AliOSSUtil.getNoEffictDateByYear(100);
	String lastFile = (ossVo.getKey()+fileName).replaceAll("//", "/");
	URL url = ossClient.generatePresignedUrl(ossVo.getBucketName(), lastFile, expiration);
	return url.toString();
}

/**
 * 根据传入文件名获取文件ContentType
 * @param fileName
 * @return
 */
public static String getContentType(String fileName){
	fileName = fileName.toLowerCase();
	String fileContentType = null;
	for(String contentType : AliOSSUtil.contentTypes){
		String[] fileAttrs = contentType.split(":");
		String fileTypeName = fileAttrs[0];
		String fileType = fileAttrs[1];
		if(fileName.endsWith(fileTypeName)){
			fileContentType = fileType;
			break;
		}
	}
	System.err.println("文件名为["+fileName+"]的ContentType为["+fileContentType+"]");
	return fileContentType;
}	

/**
 * 获取自定义有效期url
 * @param fileName oss路径
 * @param expiration 有效期时间止
 * @return oss_url
 * @throws Exception
 */
public String getFileUrl(String fileName,Date expiration) throws Exception{
	if(fileName==null || "".equals(fileName)){
		return fileName;
	}
	if(expiration == null){
		expiration = AliOSSUtil.getNoEffictDateByYear(100);
	}
	OSSClient ossClient = initOSSClient();

	OssVo ossVo = innit();

	//Date expiration = new Date(new Date().getTime() + 3600 * 1000);
	String lastFile = (ossVo.getKey()+fileName).replaceAll("//", "/");
	URL url = ossClient.generatePresignedUrl(ossVo.getBucketName(), lastFile, expiration);
	return url.toString();
}


/**
 * 有效期 按天
 *
 * @param days
 * @return
 */
public static Date getNoEffictDateByDay(int days) {
	Calendar calendar = Calendar.getInstance();
	calendar.setTime(new Date());
	calendar.add(Calendar.DAY_OF_YEAR, days);
	return calendar.getTime();
}

/**
 * 有效期 按月
 *
 * @param months
 * @return
 */
public static Date getNoEffictDateByMonth(int months) {
	Calendar calendar = Calendar.getInstance();
	calendar.setTime(new Date());
	calendar.add(Calendar.MONTH, months);
	return calendar.getTime();
}

/**
 * 有效期 按年
 *
 * @param years
 * @return
 */
public static Date getNoEffictDateByYear(int years) {
	Calendar calendar = Calendar.getInstance();
	calendar.setTime(new Date());
	calendar.add(Calendar.YEAR, years);
	return calendar.getTime();
}

/**
 * 上传字符串
 * @param dirPath 上传路径
 * @param fileName 文件名称
 * @return 返回上传成功的外网访问地址
 * @throws Exception
 */
public String uploadString(String dirPath,String fileName,String content) throws Exception{
	OssVo ossVo = innit();

	//注册client
	OSSClient ossClient = new OSSClient(ossVo.getEndpoint(), ossVo.getAccessKeyId(), ossVo.getAccessKeySecret());
	PutObjectResult result = ossClient.putObject(ossVo.getBucketName(), ossVo.getKey() + dirPath + fileName, new ByteArrayInputStream(content.getBytes()));
	System.err.println("上传Json结果"+result);
	String url = dirPath+fileName;
	ossClient.shutdown();
	return url;
}

/**
 * 获取海尔 还款计划  五级分类 的内容
 * @param fileName
 * @return
 * @throws Exception
 */
public String getStringData(String fileName,String charsetName) throws Exception {
	if(fileName==null || "".equals(fileName)){
		return fileName;
	}
	OssVo ossVo = innit();

	OSSClient ossClient = new OSSClient(ossVo.getEndpoint(), ossVo.getAccessKeyId(), ossVo.getAccessKeySecret());

	// ossObject包含文件所在的存储空间名称、文件名称、文件元信息以及一个输入流。
	OSSObject ossObject = ossClient.getObject(ossVo.getBucketName(), ossVo.getKey()+fileName);

	// 读取文件内容。
	BufferedReader reader = new BufferedReader(new InputStreamReader(ossObject.getObjectContent(),charsetName));
	StringBuffer sb = new StringBuffer();
	while (true) {
		String line = reader.readLine();
		if (line == null) break;
		sb.append(line).append("\r\n");
	}
	// 数据读取完成后，获取的流必须关闭，否则会造成连接泄漏，导致请求无连接可用，程序无法正常工作。
	reader.close();
	ossClient.shutdown();
	return String.valueOf(sb);
}

/**
 * 单个文件上传
 * @param prefix 文件名前缀
 * @param dirPath 文件上传路径(长路径)
 * @param param 文件路径
 * @return
 */
public Map<String, Object> uploadfileUtil(String prefix, String dirPath, String param){
	String url;
	InputStream inputStream = null;
	Map<String, Object> result = new HashMap<>();
	result.put("code","200");
	try {
		HttpURLConnection connection = (HttpURLConnection) new URL(param).openConnection();
		connection.setReadTimeout(5000);
		connection.setConnectTimeout(5000);
		connection.setRequestMethod("GET");
		if (connection.getResponseCode() == HttpURLConnection.HTTP_OK) {
			inputStream = connection.getInputStream();
		}
		Random random = new Random();

		String suffixes="jpg|png|PNG|JPG|mp4";
		Pattern pat= Pattern.compile("[\\w]+[\\.]("+suffixes+")");//正则判断
		Matcher mc=pat.matcher(param);//条件匹配
		String substring = null;
		while(mc.find()){
			substring = mc.group();//截取文件名后缀名
		}
		if(substring == null){
			result.put("code","400");
			return result;
		}
		String fname = substring.substring(substring.lastIndexOf(".")+1);
		if("png".equals(fname) || "jpg".equals(fname) || "PNG".equals(fname) || "JPG".equals(fname)|| "mp4".equals(fname)){
			String filename = prefix + DateUtil.date2Str(new Date(), "yyyyMMddHHmmssSSSS") + "_" + random.nextInt(9999)+"."+fname;
			url = uploadFile(inputStream, dirPath, filename);//短路径
			//String fileUrl = aliOSSUtil.getFileUrl(url); //外网访问路径
			result.put("data",url);
			return result;
		}
	} catch (Exception e) {
		result.put("code","500");
		result.put("msg","内部调用异常");
	} finally {
		if(null != inputStream){
			try {
				inputStream.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
	return result;
}


public  String loadJson (String url) {
	StringBuilder json = new StringBuilder();

	try {
		URL urlObject = new URL(url);

		URLConnection uc = urlObject.openConnection();

		BufferedReader in = new BufferedReader(new InputStreamReader(uc.getInputStream(),"UTF-8"));

		String inputLine = null;

		while ( (inputLine = in.readLine()) != null) {
			json.append(inputLine);

		}

		in.close();

	} catch (MalformedURLException e) {
		e.printStackTrace();

	} catch (IOException e) {
		e.printStackTrace();

	}

	return json.toString();

}


/**
 * 上传文件并且返回可供访问的URL
 * @param file			文件
 * @param dirPath		OSS目录
 * @return				可访问URL
 * @throws Exception	文件上传失败异常,或文件异常
 */
public String uploadAndGetFileUrl(File file,String dirPath) throws Exception{
	String uploadFile = this.uploadFile(file,dirPath);
	if (ObjectUtils.isEmpty(uploadFile)){
		throw new BaseException("文件上传失败");
	}
	return this.getFileUrl(uploadFile);
}

/**
 * 通过完整URL将文件下载到本地
 * @param url   		云文件地址
 * @param localPath   	本地路径
 */
public void downloadUrlFileToLocal(String url,String localPath) throws IOException {
	if (ObjectUtils.isEmpty(url)){
		throw new BaseException("URL不能为空");
	}
	File file = new File(localPath);
	URLConnection urlConnection = new URL(url).openConnection();
	try (
			InputStream in = urlConnection.getInputStream();
			FileOutputStream fileOut = new FileOutputStream(file)
	) {
		byte[] buffer = new byte[1024];
		int length;
		while ((length = in.read(buffer,0,1024)) != -1) {
			fileOut.write(buffer,0,length);
		}
		fileOut.flush();
	}
}

}

/**

• Copyright © 2018-2021
• All rights reserved, Designed By www.yixiang.co
• 注意：
• 本软件为www.yixiang.co开发研制，未经购买不得使用
• 购买后可获得全部源代码（禁止转卖、分享、上传到码云、github等开源平台）
• 一经发现盗用、分享等行为，将追究法律责任，后果自负
  */
  package com.linkwechat.common.utils;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.Cursor;
import org.springframework.data.redis.core.RedisConnectionUtils;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ScanOptions;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**

• @author /
  */
  @Component
  @SuppressWarnings({“unchecked”,“all”})
  public class RedisUtils {

  private RedisTemplate<Object, Object> redisTemplate;
  /* @Value(“${jwt.online-key}”)
  private String onlineKey;*/

  public RedisUtils(RedisTemplate<Object, Object> redisTemplate) {
  this.redisTemplate = redisTemplate;
  }

  // =commonold

  /**

  • 指定缓存失效时间
  • @param key 键
  • @param time 时间(秒)
    */
    public boolean expire(String key, long time) {
    try {
    if (time > 0) {
    redisTemplate.expire(key, time, TimeUnit.SECONDS);
    }
    } catch (Exception e) {
    e.printStackTrace();
    return false;
    }
    return true;
    }

  /**

  • 根据 key 获取过期时间
  • @param key 键 不能为null
  • @return 时间(秒) 返回0代表为永久有效
    */
    public long getExpire(Object key) {
    return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }

  /**

  • 查找匹配key
  • @param pattern key
  • @return /
    */
    public List scan(String pattern) {
    ScanOptions options = ScanOptions.scanOptions().match(pattern).build();
    RedisConnectionFactory factory = redisTemplate.getConnectionFactory();
    RedisConnection rc = Objects.requireNonNull(factory).getConnection();
    Cursor<byte[]> cursor = rc.scan(options);
    List result = new ArrayList<>();
    while (cursor.hasNext()) {
    result.add(new String(cursor.next()));
    }
    try {
    RedisConnectionUtils.releaseConnection(rc, factory);
    } catch (Exception e) {
    e.printStackTrace();
    }
    return result;
    }

  /**

  • 分页查询 key
  • @param patternKey key
  • @param page 页码
  • @param size 每页数目
  • @return /
    */
    public List findKeysForPage(String patternKey, int page, int size) {
    ScanOptions options = ScanOptions.scanOptions().match(patternKey).build();
    RedisConnectionFactory factory = redisTemplate.getConnectionFactory();
    RedisConnection rc = Objects.requireNonNull(factory).getConnection();
    Cursor<byte[]> cursor = rc.scan(options);
    List result = new ArrayList<>(size);
    int tmpIndex = 0;
    int fromIndex = page * size;
    int toIndex = page * size + size;
    while (cursor.hasNext()) {
    if (tmpIndex >= fromIndex && tmpIndex < toIndex) {
    result.add(new String(cursor.next()));
    tmpIndex++;
    continue;
    }
    // 获取到满足条件的数据后,就可以退出了
    if(tmpIndex >=toIndex) {
    break;
    }
    tmpIndex++;
    cursor.next();
    }
    try {
    RedisConnectionUtils.releaseConnection(rc, factory);
    } catch (Exception e) {
    e.printStackTrace();
    }
    return result;
    }

  /**

  • 判断key是否存在
  • @param key 键
  • @return true 存在 false不存在
    /
    public boolean hasKey(String key) {
    try {
    return redisTemplate.hasKey(key);
    } catch (Exception e) {
    e.printStackTrace();
    return false;
    }
    }
    /*
  • 批量删除，根据key模糊匹配
  • @param pattern
    /
    public void delpn(final String… pattern) {
    for (String kp : pattern) {
    redisTemplate.delete(redisTemplate.keys(kp + ""));
    }
    }
    /**
  • 删除缓存
  • @param key 可以传一个值 或多个
    */
    public void del(String… key) {
    if (key != null && key.length > 0) {
    if (key.length == 1) {
    redisTemplate.delete(key[0]);
    } else {
    redisTemplate.delete(CollectionUtils.arrayToList(key));
    }
    }
    }

  // String=

  /**

  • 普通缓存获取
  • @param key 键
  • @return 值
    */
    public Object get(String key) {
    return key == null ? null : redisTemplate.opsForValue().get(key);
    }

  public String getY(String key){
  return key == null || !redisTemplate.hasKey(key) ? “” : redisTemplate.opsForValue().get(key).toString();
  }

  /**

  • 批量获取
  • @param keys
  • @return
    */
    public List multiGet(List keys) {
    Object obj = redisTemplate.opsForValue().multiGet(Collections.singleton(keys));
    return null;
    }

  /**

  • 普通缓存放入
  • @param key 键
  • @param value 值
  • @return true成功 false失败
    */
    public boolean set(String key, Object value) {
    try {
    redisTemplate.opsForValue().set(key, value);
    return true;
    } catch (Exception e) {
    e.printStackTrace();
    return false;
    }
    }

  /**

  • 普通缓存放入并设置时间
  • @param key 键
  • @param value 值
  • @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
  • @return true成功 false 失败
    */
    public boolean set(String key, Object value, long time) {
    try {
    if (time > 0) {
    redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
    } else {
    set(key, value);
    }
    return true;
    } catch (Exception e) {
    e.printStackTrace();
    return false;
    }
    }

  /**

  • 普通缓存放入并设置时间
  • @param key 键
  • @param value 值
  • @param time 时间
  • @param timeUnit 类型
  • @return true成功 false 失败
    */
    public boolean set(String key, Object value, long time, TimeUnit timeUnit) {
    try {
    if (time > 0) {
    redisTemplate.opsForValue().set(key, value, time, timeUnit);
    } else {
    set(key, value);
    }
    return true;
    } catch (Exception e) {
    e.printStackTrace();
    return false;
    }
    }

  // Map=

  /**

  • HashGet
  • @param key 键 不能为null
  • @param item 项 不能为null
  • @return 值
    */
    public Object hget(String key, String item) {
    return redisTemplate.opsForHash().get(key, item);
    }

  /**

  • 获取hashKey对应的所有键值
  • @param key 键
  • @return 对应的多个键值
    */
    public Map<Object, Object> hmget(String key) {
    return redisTemplate.opsForHash().entries(key);

  }

  /**

  • HashSet
  • @param key 键
  • @param map 对应多个键值
  • @return true 成功 false 失败
    */
    public boolean hmset(String key, Map<String, Object> map) {
    try {
    redisTemplate.opsForHash().putAll(key, map);
    return true;
    } catch (Exception e) {
    e.printStackTrace();
    return false;
    }
    }

  /**

  • HashSet 并设置时间
  • @param key 键
  • @param map 对应多个键值
  • @param time 时间(秒)
  • @return true成功 false失败
    */
    public boolean hmset(String key, Map<String, Object> map, long time) {
    try {
    redisTemplate.opsForHash().putAll(key, map);
    if (time > 0) {
    expire(key, time);
    }
    return true;
    } catch (Exception e) {
    e.printStackTrace();
    return false;
    }
    }

  /**

  • 向一张hash表中放入数据,如果不存在将创建
  • @param key 键
  • @param item 项
  • @param value 值
  • @return true 成功 false失败
    */
    public boolean hset(String key, String item, Object value) {
    try {
    redisTemplate.opsForHash().put(key, item, value);
    return true;
    } catch (Exception e) {
    e.printStackTrace();
    return false;
    }
    }

  /**

  • 向一张hash表中放入数据,如果不存在将创建
  • @param key 键
  • @param item 项
  • @param value 值
  • @param time 时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
  • @return true 成功 false失败
    */
    public boolean hset(String key, String item, Object value, long time) {
    try {
    redisTemplate.opsForHash().put(key, item, value);
    if (time > 0) {
    expire(key, time);
    }
    return true;
    } catch (Exception e) {
    e.printStackTrace();
    return false;
    }
    }

  /**

  • 删除hash表中的值
  • @param key 键 不能为null
  • @param item 项 可以使多个 不能为null
    */
    public void hdel(String key, Object… item) {
    redisTemplate.opsForHash().delete(key, item);
    }

  /**

  • 判断hash表中是否有该项的值
  • @param key 键 不能为null
  • @param item 项 不能为null
  • @return true 存在 false不存在
    */
    public boolean hHasKey(String key, String item) {
    return redisTemplate.opsForHash().hasKey(key, item);
    }

  /**

  • hash递增 如果不存在,就会创建一个 并把新增后的值返回
  • @param key 键
  • @param item 项
  • @param by 要增加几(大于0)
  • @return
    */
    public double hincr(String key, String item, double by) {
    return redisTemplate.opsForHash().increment(key, item, by);
    }

  /**

  • hash递减
  • @param key 键
  • @param item 项
  • @param by 要减少记(小于0)
  • @return
    */
    public double hdecr(String key, String item, double by) {
    return redisTemplate.opsForHash().increment(key, item, -by);
    }

  // set=

  /**

  • 根据key获取Set中的所有值
  • @param key 键
  • @return
    */
    public Set sGet(String key) {
    try {
    return redisTemplate.opsForSet().members(key);
    } catch (Exception e) {
    e.printStackTrace();
    return null;
    }
    }

  /**

  • 根据value从一个set中查询,是否存在
  • @param key 键
  • @param value 值
  • @return true 存在 false不存在
    */
    public boolean sHasKey(String key, Object value) {
    try {
    return redisTemplate.opsForSet().isMember(key, value);
    } catch (Exception e) {
    e.printStackTrace();
    return false;
    }
    }

  /**

  • 将数据放入set缓存
  • @param key 键
  • @param values 值 可以是多个
  • @return 成功个数
    */
    public long sSet(String key, Object… values) {
    try {
    return redisTemplate.opsForSet().add(key, values);
    } catch (Exception e) {
    e.printStackTrace();
    return 0;
    }
    }

  /**

  • 将set数据放入缓存
  • @param key 键
  • @param time 时间(秒)
  • @param values 值 可以是多个
  • @return 成功个数
    */
    public long sSetAndTime(String key, long time, Object… values) {
    try {
    Long count = redisTemplate.opsForSet().add(key, values);
    if (time > 0) {
    expire(key, time);
    }
    return count;
    } catch (Exception e) {
    e.printStackTrace();
    return 0;
    }
    }

  /**

  • 获取set缓存的长度
  • @param key 键
  • @return
    */
    public long sGetSetSize(String key) {
    try {
    return redisTemplate.opsForSet().size(key);
    } catch (Exception e) {
    e.printStackTrace();
    return 0;
    }
    }

  /**

  • 移除值为value的
  • @param key 键
  • @param values 值 可以是多个
  • @return 移除的个数
    */
    public long setRemove(String key, Object… values) {
    try {
    Long count = redisTemplate.opsForSet().remove(key, values);
    return count;
    } catch (Exception e) {
    e.printStackTrace();
    return 0;
    }
    }

  // =list===

  /**

  • 获取list缓存的内容
  • @param key 键
  • @param start 开始
  • @param end 结束 0 到 -1代表所有值
  • @return
    */
    public List lGet(String key, long start, long end) {
    try {
    return redisTemplate.opsForList().range(key, start, end);
    } catch (Exception e) {
    e.printStackTrace();
    return null;
    }
    }

  /**

  • 获取list缓存的长度
  • @param key 键
  • @return
    */
    public long lGetListSize(String key) {
    try {
    return redisTemplate.opsForList().size(key);
    } catch (Exception e) {
    e.printStackTrace();
    return 0;
    }
    }

  /**

  • 通过索引 获取list中的值
  • @param key 键
  • @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
  • @return
    */
    public Object lGetIndex(String key, long index) {
    try {
    return redisTemplate.opsForList().index(key, index);
    } catch (Exception e) {
    e.printStackTrace();
    return null;
    }
    }

  /**

  • 将list放入缓存
  • @param key 键
  • @param value 值
  • @return
    */
    public boolean lSet(String key, Object value) {
    try {
    redisTemplate.opsForList().rightPush(key, value);
    return true;
    } catch (Exception e) {
    e.printStackTrace();
    return false;
    }
    }

  /**

  • 将list放入缓存
  • @param key 键
  • @param value 值
  • @param time 时间(秒)
  • @return
    */
    public boolean lSet(String key, Object value, long time) {
    try {
    redisTemplate.opsForList().rightPush(key, value);
    if (time > 0) {
    expire(key, time);
    }
    return true;
    } catch (Exception e) {
    e.printStackTrace();
    return false;
    }
    }

  /**

  • 将list放入缓存
  • @param key 键
  • @param value 值
  • @return
    */
    public boolean lSet(String key, List value) {
    try {
    redisTemplate.opsForList().rightPushAll(key, value);
    return true;
    } catch (Exception e) {
    e.printStackTrace();
    return false;
    }
    }

  /**

  • 将list放入缓存
  • @param key 键
  • @param value 值
  • @param time 时间(秒)
  • @return
    */
    public boolean lSet(String key, List value, long time) {
    try {
    redisTemplate.opsForList().rightPushAll(key, value);
    if (time > 0) {
    expire(key, time);
    }
    return true;
    } catch (Exception e) {
    e.printStackTrace();
    return false;
    }
    }

  /**

  • 根据索引修改list中的某条数据
  • @param key 键
  • @param index 索引
  • @param value 值
  • @return /
    */
    public boolean lUpdateIndex(String key, long index, Object value) {
    try {
    redisTemplate.opsForList().set(key, index, value);
    return true;
    } catch (Exception e) {
    e.printStackTrace();
    return false;
    }
    }

  /**

  • 移除N个值为value
  • @param key 键
  • @param count 移除多少个
  • @param value 值
  • @return 移除的个数
    */
    public long lRemove(String key, long count, Object value) {
    try {
    return redisTemplate.opsForList().remove(key, count, value);
    } catch (Exception e) {
    e.printStackTrace();
    return 0;
    }
    }
    }

第三个工具类

package com.linkwechat.common.utils;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import net.sf.json.JSONObject;
import org.apache.commons.codec.binary.Base64;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.math.NumberUtils;

import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.*;

/**

• @Version 1.0

• @Description:

• @Date: 2021/7/12

• @Author: tanshizhong
  */
  public class CommonUtil {
  public static boolean isEmpty(Object obj) {
  if (null == obj || “”.equals(obj)) {
  return true;
  }
  return false;
  }

  /**

  • json字符串转化成List<Map<String,Object>>
  • eg. “[{“roleName”:“超级管理员角色”,“roleEnable”:1,“companyName”:“重庆市江北区汇金小额贷款有限公司”}]”
  • @param jsonStr
  • @return
    */
    public static List<Map<String, Object>> jsonToList(String jsonStr) {
    JSONArray json = JSONArray.parseArray(jsonStr);
    List<Map<String, Object>> mapListJson = (List) json;
    return mapListJson;
    }

  /**

  • 生成随机编码

  • @param length

  • @return
    */
    public static String randomCode(int length) {// 传入的字符串的长度
    StringBuilder builder = new StringBuilder(length);
    for (int i = 0; i < length; i++) {

     int r = (int) (Math.random() * 3);
     int rn1 = (int) (48 + Math.random() * 10);
     int rn2 = (int) (65 + Math.random() * 26);
     int rn3 = (int) (97 + Math.random() * 26);
    
     switch (r) {
         case 0:
             builder.append((char) rn1);
             break;
         case 1:
             builder.append((char) rn2);
             break;
         case 2:
             builder.append((char) rn3);
             break;
     }
    

    }
    return builder.toString().toUpperCase();
    }

  /**

  • 格式化金额数字
  • @param money
  • @return
    */
    public static String toMoney(Object money, String split) {
    String result = “”;
    String text = money.toString();
    String rail = “”;
    String fh = “”;
    if (text.indexOf(“-”) >= 0) {
    fh = text.substring(0, text.indexOf(“-”) + 1);
    text = text.substring(text.indexOf(“-”) + 1);
    }
    if (text.indexOf(“.”) >= 0) {
    rail = text.substring(text.indexOf(“.”));
    text = text.substring(0, text.indexOf(“.”));
    for (int i = text.length() - 1, j = 0; i >= 0; i–, j++) {
    if (j != 0 && j % 3 == 0) {
    result = text.charAt(i) + split + result;
    } else {
    result = text.charAt(i) + result;
    }
    }
    } else {
    for (int i = text.length() - 1, j = 0; i >= 0; i–, j++) {
    if (j != 0 && j % 3 == 0) {
    result = text.charAt(i) + split + result;
    } else {
    result = text.charAt(i) + result;
    }
    }
    }
    return fh + result + rail;
    }

  /**

  • 格式化日期
  • @param date
  • @param formate
  • @return
    */
    public static String toDate(Object date, String formate) {
    if (isEmpty(date)) {
    return “”;
    }
    String result = date.toString();
    try {
    if (isEmpty(formate)) {
    formate = “yyyy-MM-dd”;
    }
    DateFormat df = new SimpleDateFormat(formate);
    return df.format(df.parse(result));
    } catch (Exception e) {
    return result;
    }
    }

  public static Date stringToDate(String datestr, String formate) {
  if (isEmpty(datestr)) {
  return null;
  }
  try {
  if (isEmpty(formate)) {
  formate = “yyyy-MM-dd”;
  }
  DateFormat df = new SimpleDateFormat(formate);
  return df.parse(datestr);
  } catch (Exception e) {
  return null;
  }
  }

  /**

  • 判断指定字符串是否是JSON类型

  • @param str 待判断的字符串

  • @return 判断结果
    */
    public static boolean isJson(String str) {
    try {
    if (StringUtils.isNotBlank(str)) {
    JSON.parse(str);
    return true;
    }
    } catch (Exception e) {
    }

    return false;
    }

  /**

  • 判断指定字符串是否是JSON类型

  • @param str 待判断的字符串

  • @return 判断结果
    */
    public static boolean isFastJson(String str) {
    try {
    if (StringUtils.isNotBlank(str)) {
    JSON.parseObject(str);
    return true;
    }
    } catch (Exception e) {
    }

    return false;
    }
    /**

  • json字符串转换成map集合

  • @param jsonStr

  • @return
    */
    public static Map<String, String> jsonToMap(String jsonStr) {
    JSONObject jsonObject = JSONObject.fromObject(jsonStr);
    Map<String, String> map = new HashMap<>();
    for (Iterator iter = jsonObject.keys(); iter.hasNext(); ) {
    String key = (String) iter.next();
    map.put(key, jsonObject.get(key).toString());
    }
    return map;
    }

  /**

  • base64转inputStream
  • @param base64string
  • @return
    */
    public static InputStream baseToInputStream(String base64string) {
    ByteArrayInputStream stream = null;
    try {
    byte[] bytes1 = Base64.decodeBase64(base64string);
    stream = new ByteArrayInputStream(bytes1);
    } catch (Exception e) {
    e.printStackTrace();
    }
    return stream;
    }

  /**

  • 根据经纬度坐标算距离
  • @param lngOne
  • @param latOne
  • @param lngTwo
  • @param latTwo
  • @return
    */
    public static double distance(double lngOne, double latOne, double lngTwo,
    double latTwo) {
    double a, b, R;
    R = 6378137; // 地球半径
    latOne = latOne * Math.PI / 180.0;
    latTwo = latTwo * Math.PI / 180.0;
    a = latOne - latTwo;
    b = (lngOne - lngTwo) * Math.PI / 180.0;
    double d;
    double sa2, sb2;
    sa2 = Math.sin(a / 2.0);
    sb2 = Math.sin(b / 2.0);
    d = 2
    * R
    * Math.asin(Math.sqrt(sa2 * sa2 + Math.cos(latOne)
    * Math.cos(latTwo) * sb2 * sb2));
    return d;
    }

  public static String changeAmountOfMoney(double v) {
  String UNIT = “万千佰拾亿千佰拾万千佰拾元角分”;
  String DIGIT = “零壹贰叁肆伍陆柒捌玖”;
  double MAX_VALUE = 9999999999999.99D;
  if (v < 0 || v > MAX_VALUE) {
  return “参数非法!”;
  }
  long l = Math.round(v * 100);
  if (l == 0) {
  return “零元整”;
  }
  String strValue = l + “”;
  // i用来控制数
  int i = 0;
  // j用来控制单位
  int j = UNIT.length() - strValue.length();
  String rs = “”;
  boolean isZero = false;
  for (; i < strValue.length(); i++, j++) {
  char ch = strValue.charAt(i);
  if (ch == ‘0’) {
  isZero = true;
  if (UNIT.charAt(j) == ‘亿’ || UNIT.charAt(j) == ‘万’ || UNIT.charAt(j) == ‘元’) {
  rs = rs + UNIT.charAt(j);
  isZero = false;
  }
  } else {
  if (isZero) {
  rs = rs + “零”;
  isZero = false;
  }
  rs = rs + DIGIT.charAt(ch - ‘0’) + UNIT.charAt(j);
  }
  }
  if (!rs.endsWith(“分”)) {
  rs = rs + “整”;
  }
  rs = rs.replaceAll(“亿万”, “亿”);
  return rs;
  }

  public static String checkJsonStr(String json) {
  if (StringUtils.isNotBlank(json)) {
  boolean isJson = CommonUtil.isJson(json);
  if (!isJson) {
  int i = json.lastIndexOf(“,”);
  if (i > 0) {
  String sub = json.substring(0, i);
  return sub + “]”;
  }
  }
  }
  return json;

  }

  /**

  • 判断字符串是否是数字
  • @param str
  • @param res
  • @return
    */
    public static String isCreatable(String str,String res) {
    if (!NumberUtils.isCreatable(str)) {
    return res;
    }
    return str;
    }

  /**

  • 判断指定字符串是否是空，为空范围默认值
  • @author wangbangji 2021/9/2 21:19
  • @param str 待判断的字符串
  • @param def 默认字符串
  • @return java.lang.String
    **/
    public static String isBlank(String str,String def){
    return StringUtils.isBlank(str)?def:str;
    }

  public static void main(String[] args) {
  System.out.println(CommonUtil.distance(104.047587, 30.577250, 104.06047, 30.57458));
  }
  }
  最后轻松实现造轮子