SpringBoot适配fastdfs

已于 2022-06-16 14:42:02 修改
阅读量1k 收藏
点赞数
分类专栏： SpringBoot 文章标签： java spring boot
于 2022-03-31 13:32:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39855223/article/details/123869736
版权

SpringBoot适配fastdfs

添加关于fastdfs的pom依赖

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.79/version>
</dependency>

配置文件中需要配置相关参数

#-------FastDFS配置，后端上传文件时需要读取的------
fdfsread_confFileName=application.properties # 这个后面会专门提到
connect_timeout=100
network_timeout=300
charset=ISO8859-1
tracker_server=10.16.2.57:22122
fdfsread_server=10.16.2.57
http.tracker_http_port=80
tracker_port=22122

提供测试类

@RestController
@RequestMapping("/file")
@Component
public class FileUploadCtrl{
    @Override
    @PostMapping("/upload")
    public ResponseEntity<String> uploadContractFile(@RequestParam("file") MultipartFile file, HttpServletRequest request) {
        try {
            Map<String, String> searchParams = getSearchParamsFromRequest(request);
            if (!searchParams.containsKey("type") || StringUtils.isBlank((String) searchParams.get("type"))) {
                return HeaderUtil.createOkEntity("type参数不得为空", "0", null);
            }
            String type = searchParams.get("type");
            byte[] byteFile = file.getBytes();
            String attachment = fileManager.uploadFile("\\." + type, byteFile);
            return HeaderUtil.createOkEntity(null, "1", "/" + attachment);
        } catch (Exception e) {
            e.printStackTrace();
            return HeaderUtil.createOkEntity(e.getMessage(), "2", null);
        }
    }
    
    /**
     * @param @param  request
     * @param @return 设定文件
     * @return Map<String, String>    返回类型
     * @throws
     * @Title: getSearchParamsFromRequest
     * @Description: 从request中拿到参数MAP
     */
    private Map<String, String> getSearchParamsFromRequest(HttpServletRequest request) {
        Map<String, String> searchParams = new HashMap<>();
        Enumeration<String> enumeration = request.getParameterNames();

        while (enumeration.hasMoreElements()) {
            String args = enumeration.nextElement();
            searchParams.put(args, request.getParameter(args));
        }
        return searchParams;
    }
}

封装上传公共类

@Component
public class FileManager {
    @Value("${fdfsread_confFileName}")
    private String confFileName;

    //下面讲到这个是什么作用
    @Autowired 
    private FastdfsProperties fastdfsProperties;
    
    public static Logger logger = LoggerFactory.getLogger(FileManager.class);

    public FileManager() {
    }

    public String uploadFile(String fileName, byte[] fileContent) {
        String saveName = UUID.randomUUID().toString() + "_" + fileName;
        try {
            NameValuePair[] metaData = new NameValuePair[]{};
            FastdfsClient client = FastdfsClient.getInstance(fileName,fastdfsProperties);
            saveName = client.upload(metaData, fileContent, fileName);
        } catch (Exception e) {
            saveName = null;
            logger.error("fastdfs上传出错", e);
            throw new BusinessException("fastdfs上传出错：" + e.getMessage());
        }
        return saveName;
    }
    
    public byte[] downLoadFile(String fileName) {
        byte[] contents = null;
        try {
            contents = FastdfsClient.getInstance(confFileName,fastdfsProperties).download(fileName);
            if (contents == null) {
                logger.error("没有找到文件内容！");
                throw new BusinessException("没有找到文件内容！");
            }
        } catch (Exception e) {
            logger.error("fastdfs下载失败！");
            throw new BusinessException("fastdfs下载失败：" + e.getMessage());
        }
        return contents;
    }

    public boolean deleteFile(String fileName) {
        boolean flag = false;
        FastdfsClient client = FastdfsClient.getInstance(confFileName,fastdfsProperties);

        try {
            flag = client.delete(fileName);
        } catch (Exception e) {
            logger.error("fastdfs删除失败！");
            throw new BusinessException("fastdfs删除失败：" + e.getMessage());
        }
        return flag;
    }
    
    
}

FastdfsClient

public class FastdfsClient {
    public static Logger logger = LoggerFactory.getLogger(FastdfsClient.class);
    private static volatile FastdfsClient fdfsClient;
    private TrackerClient tracker;

    private FastdfsClient() {
		private FastdfsClient(String confFileName) {
        try {
                String confRealUrl = Thread.currentThread().getContextClassLoader().getResource(confFileName).getPath().toString();
                ClientGlobal.init(confRealUrl);
                this.tracker = new TrackerClient();
            } catch (FileNotFoundException var4) {
                logger.error("未找到fdfs对应的配置文件!", var4);
            } catch (Exception var5) {
                logger.error("初始化FastdfsClient报错!", var5);
            }
    	}
    }
     private FastdfsClient(String confFileName,FastdfsProperties properties) {
        try {
            initClientGlobal(confFileName,properties);
            this.tracker = new TrackerClient();
        } catch (FileNotFoundException var4) {
            logger.error("未找到fdfs对应的配置文件!", var4);
        } catch (Exception var5) {
            logger.error("初始化FastdfsClient报错!", var5);
        }
    }

    public static FastdfsClient getInstance(String confFileName) {
        if (fdfsClient == null || fdfsClient.tracker == null) {
            Class var0 = FastdfsClient.class;
            synchronized(FastdfsClient.class) {
                if (fdfsClient == null || fdfsClient.tracker == null) {
                    fdfsClient = new FastdfsClient(confFileName);
                }
            }
        }

        return fdfsClient;
    }


    public static FastdfsClient getInstance(String confFileName,FastdfsProperties properties) {
        if (fdfsClient == null || fdfsClient.tracker == null) {
            Class var0 = FastdfsClient.class;
            synchronized(FastdfsClient.class) {
                if (fdfsClient == null || fdfsClient.tracker == null) {
                    fdfsClient = new FastdfsClient(confFileName,properties);
                }
            }
        }

        return fdfsClient;
    }


 /**
     * 初始化ClientGlobal
     * @param confFileName
     * @param properties
     * @throws MyException
     */
    private void initClientGlobal(String confFileName,FastdfsProperties properties)  throws FileNotFoundException, IOException, MyException  {
        ClientGlobal.setG_connect_timeout(properties.getConnectTimeout()*1000);
        ClientGlobal.setG_network_timeout(properties.getNetworkTimeout()*1000);
        ClientGlobal.setG_charset(properties.getCharset());
        String[] szTrackerServers = getTrackerServerValues(properties.getTrackerServer());
        if(szTrackerServers == null){
            throw new MyException("item \"tracker_server\" in " + confFileName + " not found");
        }else{

            InetSocketAddress[] tracker_servers = new InetSocketAddress[szTrackerServers.length];
            for(int i = 0; i < szTrackerServers.length; ++i) {
                String[] parts = szTrackerServers[i].split("\\:", 2);
                if (parts.length != 2) {
                    throw new MyException("the value of item \"tracker_server\" is invalid, the correct format is host:port");
                }

                tracker_servers[i] = new InetSocketAddress(parts[0].trim(), Integer.parseInt(parts[1].trim()));
            }
            ClientGlobal.setG_tracker_group(new TrackerGroup(tracker_servers));
            ClientGlobal.setG_tracker_http_port(properties.getTrackerHttpPort());
            ClientGlobal.setG_anti_steal_token(properties.getAntiStealToken());
            if (ClientGlobal.getG_anti_steal_token()) {
                ClientGlobal.setG_secret_key(properties.getSecretKey());            }
        }

    }

    /**
     * @param obj
     * @return
     */
    private static String[] getTrackerServerValues(Object obj) {
        if (obj == null) {
            return null;
        } else {
            String[] values;
            if (obj instanceof String) {
                values = new String[]{(String)obj};
                return values;
            } else {
                Object[] objs = ((ArrayList)obj).toArray();
                values = new String[objs.length];
                System.arraycopy(objs, 0, values, 0, objs.length);
                return values;
            }
        }
    }
    public String upload(NameValuePair[] metaData, byte[] fileContent, String fileName) throws Exception {
        String prefix = fileName.substring(fileName.lastIndexOf(".") + 1);
        return this.upload(fileContent, (NameValuePair[])metaData, prefix);
    }

    public String upload(byte[] fileContent, String fileName) throws Exception {
        String prefix = fileName.substring(fileName.lastIndexOf(".") + 1);
        return this.upload(fileContent, (NameValuePair[])null, prefix);
    }

    public String upload(String localFilePath) throws Exception {
        return this.upload((String)localFilePath, (NameValuePair[])null);
    }

    public String upload(byte[] fileContent) throws Exception {
        return this.upload(fileContent, (NameValuePair[])null);
    }

    public String upload(String localFilePath, NameValuePair[] metaData) throws Exception {
        if (null == localFilePath) {
            throw new Exception("FDFSClient invalid arguement");
        } else {
            TrackerServer trackerServer = null;
            StorageClient1 storageClient = null;
            String master_file_id = null;

            try {
                trackerServer = this.tracker.getConnection();
                StorageServer storageServer = null;
                storageClient = new StorageClient1(trackerServer, (StorageServer)storageServer);
                master_file_id = storageClient.upload_file1(localFilePath, (String)null, metaData);
            } finally {
                if (trackerServer != null) {
                    trackerServer.close();
                }

            }

            return master_file_id;
        }
    }

    public String upload(byte[] fileContent, NameValuePair[] metaData) throws Exception {
        if (null == fileContent) {
            throw new Exception("FDFSClient invalid arguement");
        } else {
            TrackerServer trackerServer = null;
            StorageClient1 storageClient = null;
            String master_file_id = null;

            try {
                trackerServer = this.tracker.getConnection();
                StorageServer storageServer = null;
                storageClient = new StorageClient1(trackerServer, (StorageServer)storageServer);
                master_file_id = storageClient.upload_file1(fileContent, "jpg", metaData);
            } finally {
                if (trackerServer != null) {
                    trackerServer.close();
                }

            }

            return master_file_id;
        }
    }

    public String upload(byte[] fileContent, NameValuePair[] metaData, String prefix) throws Exception {
        if (null != fileContent && null != prefix) {
            TrackerServer trackerServer = null;
            StorageClient1 storageClient = null;
            String master_file_id = null;

            try {
                trackerServer = this.tracker.getConnection();
                StorageServer storageServer = null;
                storageClient = new StorageClient1(trackerServer, (StorageServer)storageServer);
                master_file_id = storageClient.upload_file1(fileContent, prefix, metaData);
            } finally {
                if (trackerServer != null) {
                    trackerServer.close();
                }

            }

            return master_file_id;
        } else {
            throw new Exception("FDFSClient invalid arguement");
        }
    }

    public NameValuePair[] getMetaData(String fileId) throws Exception {
        if (null == fileId) {
            throw new Exception("FDFSClient invalid arguement");
        } else {
            TrackerServer trackerServer = null;
            StorageClient1 storageClient = null;
            NameValuePair[] nvPair = null;

            try {
                trackerServer = this.tracker.getConnection();
                StorageServer storageServer = null;
                storageClient = new StorageClient1(trackerServer, (StorageServer)storageServer);
                nvPair = storageClient.get_metadata1(fileId);
            } finally {
                if (trackerServer != null) {
                    trackerServer.close();
                }

            }

            return nvPair;
        }
    }

    public boolean delete(String filePath) throws Exception {
        if (null == filePath) {
            throw new Exception("FDFSClient invalid arguement");
        } else {
            TrackerServer trackerServer = null;
            StorageClient1 storageClient = null;
            boolean success = false;

            try {
                trackerServer = this.tracker.getConnection();
                StorageServer storageServer = null;
                storageClient = new StorageClient1(trackerServer, (StorageServer)storageServer);
                if (storageClient.delete_file1(filePath) == 0) {
                    success = true;
                }
            } finally {
                if (trackerServer != null) {
                    trackerServer.close();
                }

            }

            return success;
        }
    }

    public InputStream download(String fileId, String localFilePath) throws Exception {
        if (null != fileId && null != localFilePath) {
            return new ByteArrayInputStream(this.download(fileId));
        } else {
            throw new Exception("FDFSClient invalid arguement");
        }
    }

    public byte[] download(String fileId) throws Exception {
        if (null == fileId) {
            throw new Exception("FDFSClient invalid arguement");
        } else {
            TrackerServer trackerServer = null;
            StorageClient1 storageClient = null;
            Object var4 = null;

            byte[] fileContent;
            try {
                trackerServer = this.tracker.getConnection();
                StorageServer storageServer = null;
                storageClient = new StorageClient1(trackerServer, (StorageServer)storageServer);
                fileContent = storageClient.download_file1(fileId);
            } finally {
                if (trackerServer != null) {
                    trackerServer.close();
                }

            }

            return fileContent;
        }
    }
    
}

搞定之后，可以进行测试：

String confRealUrl = Thread.currentThread().getContextClassLoader().getResource(confFileName).getPath().toString();

这个的作用是：获取配置文件的路径进行加载，然后获取对应配置文件中的关于FastDfs的配置信息，实例化ClientGlobal对象。

/D:/CRM/workSpace/fuseWorkSpace/occ-kb-web/target/classes/application.properties

但是我们将服务打成jar包后，便报错，对应路径为

/data/fmcg-occ/tomcat-kb/webapps/ROOT/WEB-INF/lib/occ-common-web-2022.1.0-SNAPSHOT.jar! /application-common-test52.properties

那么需要我们了解一下ClientGlobal，看源码核心内容，

即：获取配置文件的路径进行加载，然后获取对应配置文件中的关于FastDfs的配置信息，实例化ClientGlobal对象

//此时获取不到对应的文件
IniFileReader iniReader = new IniFileReader(conf_filename);
g_connect_timeout = iniReader.getIntValue("connect_timeout", 5);

public class ClientGlobal {
    public static int g_connect_timeout;
    public static int g_network_timeout;
    public static String g_charset;
    public static int g_tracker_http_port;
    public static boolean g_anti_steal_token;
    public static String g_secret_key;
    public static TrackerGroup g_tracker_group;
    public static final int DEFAULT_CONNECT_TIMEOUT = 5;
    public static final int DEFAULT_NETWORK_TIMEOUT = 30;

    private ClientGlobal() {
    }

    public static void init(String conf_filename) throws FileNotFoundException, IOException, MyException {
        IniFileReader iniReader = new IniFileReader(conf_filename);
        g_connect_timeout = iniReader.getIntValue("connect_timeout", 5);
        if (g_connect_timeout < 0) {
            g_connect_timeout = 5;
        }

        g_connect_timeout *= 1000;
        g_network_timeout = iniReader.getIntValue("network_timeout", 30);
        if (g_network_timeout < 0) {
            g_network_timeout = 30;
        }

        g_network_timeout *= 1000;
        g_charset = iniReader.getStrValue("charset");
        if (g_charset == null || g_charset.length() == 0) {
            g_charset = "ISO8859-1";
        }

        String[] szTrackerServers = iniReader.getValues("tracker_server");
        if (szTrackerServers == null) {
            throw new MyException("item \"tracker_server\" in " + conf_filename + " not found");
        } else {
            InetSocketAddress[] tracker_servers = new InetSocketAddress[szTrackerServers.length];

            for(int i = 0; i < szTrackerServers.length; ++i) {
                String[] parts = szTrackerServers[i].split("\\:", 2);
                if (parts.length != 2) {
                    throw new MyException("the value of item \"tracker_server\" is invalid, the correct format is host:port");
                }

                tracker_servers[i] = new InetSocketAddress(parts[0].trim(), Integer.parseInt(parts[1].trim()));
            }

            g_tracker_group = new TrackerGroup(tracker_servers);
            g_tracker_http_port = iniReader.getIntValue("http.tracker_http_port", 80);
            g_anti_steal_token = iniReader.getBoolValue("http.anti_steal_token", false);
            if (g_anti_steal_token) {
                g_secret_key = iniReader.getStrValue("http.secret_key");
            }

        }
    }
  }

通过分析源码，其实就是获取配置文件信息，那我们该怎么做

可以在启动服务时获取配置文件内容，后面建ClientGlobal时进行重写，但是我们发现ClientGlobal重写不了，那么我们可以将整个类进行重写。

public class ClientGlobal {
    public static int g_connect_timeout;
    public static int g_network_timeout;
    public static String g_charset;
    public static int g_tracker_http_port;
    public static boolean g_anti_steal_token;
    public static String g_secret_key;
    public static TrackerGroup g_tracker_group;
    public static final int DEFAULT_CONNECT_TIMEOUT = 5;
    public static final int DEFAULT_NETWORK_TIMEOUT = 30;

    private ClientGlobal() {
    }

    public static void init(String conf_filename) throws FileNotFoundException, IOException, MyException {
        IniFileReader iniReader = new IniFileReader(conf_filename);
        g_connect_timeout = iniReader.getIntValue("connect_timeout", 5);
        if (g_connect_timeout < 0) {
            g_connect_timeout = 5;
        }

        g_connect_timeout *= 1000;
        g_network_timeout = iniReader.getIntValue("network_timeout", 30);
        if (g_network_timeout < 0) {
            g_network_timeout = 30;
        }

        g_network_timeout *= 1000;
        g_charset = iniReader.getStrValue("charset");
        if (g_charset == null || g_charset.length() == 0) {
            g_charset = "ISO8859-1";
        }

        String[] szTrackerServers = iniReader.getValues("tracker_server");
        if (szTrackerServers == null) {
            throw new MyException("item \"tracker_server\" in " + conf_filename + " not found");
        } else {
            InetSocketAddress[] tracker_servers = new InetSocketAddress[szTrackerServers.length];

            for(int i = 0; i < szTrackerServers.length; ++i) {
                String[] parts = szTrackerServers[i].split("\\:", 2);
                if (parts.length != 2) {
                    throw new MyException("the value of item \"tracker_server\" is invalid, the correct format is host:port");
                }

                tracker_servers[i] = new InetSocketAddress(parts[0].trim(), Integer.parseInt(parts[1].trim()));
            }

            g_tracker_group = new TrackerGroup(tracker_servers);
            g_tracker_http_port = iniReader.getIntValue("http.tracker_http_port", 80);
            g_anti_steal_token = iniReader.getBoolValue("http.anti_steal_token", false);
            if (g_anti_steal_token) {
                g_secret_key = iniReader.getStrValue("http.secret_key");
            }

        }
    }
    //添加的这一个新方法
    public static void init(String conf_filename,FastdfsProperties properties) throws  IOException, MyException {
        g_connect_timeout = properties.getConnectTimeout();
        if (g_connect_timeout < 0) {
            g_connect_timeout = 5;
        }

        g_connect_timeout *= 1000;
        g_network_timeout = properties.getNetworkTimeout();
        if (g_network_timeout < 0) {
            g_network_timeout = 30;
        }

        g_network_timeout *= 1000;
        g_charset = properties.getCharset();
        if (g_charset == null || g_charset.length() == 0) {
            g_charset = "ISO8859-1";
        }
        String[] szTrackerServers = getTrackerServerValues(properties.getTrackerServer());
        if(szTrackerServers == null){
            throw new MyException("item \"tracker_server\" in " + conf_filename + " not found");
        }else{

            InetSocketAddress[] tracker_servers = new InetSocketAddress[szTrackerServers.length];

            for(int i = 0; i < szTrackerServers.length; ++i) {
                String[] parts = szTrackerServers[i].split("\\:", 2);
                if (parts.length != 2) {
                    throw new MyException("the value of item \"tracker_server\" is invalid, the correct format is host:port");
                }

                tracker_servers[i] = new InetSocketAddress(parts[0].trim(), Integer.parseInt(parts[1].trim()));
            }

            g_tracker_group = new TrackerGroup(tracker_servers);
            g_tracker_http_port = properties.getTrackerHttpPort();
            g_anti_steal_token = properties.getAntiStealToken();
            if (g_anti_steal_token) {
                g_secret_key = properties.getSecretKey();
            }
        }

    }

    private static String[] getTrackerServerValues(Object obj) {
        if (obj == null) {
            return null;
        } else {
            String[] values;
            if (obj instanceof String) {
                values = new String[]{(String)obj};
                return values;
            } else {
                Object[] objs = ((ArrayList)obj).toArray();
                values = new String[objs.length];
                System.arraycopy(objs, 0, values, 0, objs.length);
                return values;
            }
        }
    }

    public static Socket getSocket(String ip_addr, int port) throws IOException {
        Socket sock = new Socket();
        sock.setSoTimeout(g_network_timeout);
        sock.connect(new InetSocketAddress(ip_addr, port), g_connect_timeout);
        return sock;
    }

    public static Socket getSocket(InetSocketAddress addr) throws IOException {
        Socket sock = new Socket();
        sock.setSoTimeout(g_network_timeout);
        sock.connect(addr, g_connect_timeout);
        return sock;
    }

    public static int getG_connect_timeout() {
        return g_connect_timeout;
    }

    public static void setG_connect_timeout(int connect_timeout) {
        g_connect_timeout = connect_timeout;
    }

    public static int getG_network_timeout() {
        return g_network_timeout;
    }

    public static void setG_network_timeout(int network_timeout) {
        g_network_timeout = network_timeout;
    }

    public static String getG_charset() {
        return g_charset;
    }

    public static void setG_charset(String charset) {
        g_charset = charset;
    }

    public static int getG_tracker_http_port() {
        return g_tracker_http_port;
    }

    public static void setG_tracker_http_port(int tracker_http_port) {
        g_tracker_http_port = tracker_http_port;
    }

    public static boolean getG_anti_steal_token() {
        return g_anti_steal_token;
    }

    public static boolean isG_anti_steal_token() {
        return g_anti_steal_token;
    }

    public static void setG_anti_steal_token(boolean anti_steal_token) {
        g_anti_steal_token = anti_steal_token;
    }

    public static String getG_secret_key() {
        return g_secret_key;
    }

    public static void setG_secret_key(String secret_key) {
        g_secret_key = secret_key;
    }

    public static TrackerGroup getG_tracker_group() {
        return g_tracker_group;
    }

    public static void setG_tracker_group(TrackerGroup tracker_group) {
        g_tracker_group = tracker_group;
    }
}

FastdfsProperties 获取关于fastdfs的配置文件：

@Configuration
@Getter
public class FastdfsProperties {

    @Value("${fdfsread_confFileName}")
    private String confFileName;

    @Value("${storeType}")
    private String storeType;

    @Value("${connect_timeout:5}")
    private int connectTimeout;

    @Value("${network_timeout:30}")
    private int networkTimeout;

    @Value("${charset:ISO8859-1}")
    private String charset;

    @Value("${tracker_server}")
    private Object trackerServer;

    @Value("${fdfsread_server}")
    private String fdfsreadServer;

    @Value("${http.tracker_http_port:80}")
    private int trackerHttpPort;

    @Value("${tracker_port:22122}")
    private String trackerPort;


    @Value("${anti_steal_token:false}")
    private Boolean antiStealToken;

    @Value("${http.secret_key:null}")
    private String secretKey;

}

测试效果：
在这里插入图片描述

阿文-AW
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springboot整合fastdfs完整版代码
07-20
springboot整合fastdfs完整版代码，下载解压后需要在yml配置文件中填上你的数据库信息和安装fastdfs的服务器信息
springBoot2.0以上集成FastDFSv5.05
qq_37922509的博客
07-31 303
springBoot完美集成FastDFS 我们在日常开发中存储文件是很常见。市面上提供给我们的资源也很多。最简单的办法就是去买比如BAT的。但是随着项目的增大，数据的增多。集群、多数据源等只是解决了请求的接受分发。但是文件数据并没有的到很好的处理。 一介绍 什么是FastDFS FastDFS是用c语言编写的一款开源的分布式文件系统。FastDFS为互联网量身定制，充分考虑了冗余备份、负载均衡...
SpringBoot重点详解--集成FastDFS（二）
pengjunlee的博客
09-18 551
一、Maven依赖 <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.1.8.RELE...
druid yml 完整配置
lizhengyu891231的博客
02-25 6381
转载自：https://www.cnblogs.com/zhangzhonghui/p/11567623.html 叙述 开发中遇到需要配置yml 方式的druid 参数时，一直找不到完整的参数，现在整理到此参数清单。方便以后查询。 清单 spring: datasource: # druid连接池 type: com.alibaba.druid.pool.DruidDataSource #数据库驱动 driver: com.mysql.jdbc.Drive..
spring-boot启动和fdfs-client的版本冲突
the_sky_is_blue的博客
05-19 720
DEBUG org.springframework.boot.diagnostics.LoggingFailureAnalysisReporter - Application failed to start due to an exception org.springframework.boot.context.properties.source.InvalidConfigurationPropertyNameException: Configuration property name 'fdfs.thum
关于fastDFS测试javaDemo报错的问题解决
Zzzzby的博客
09-28 901
Exception in thread “main” org.csource.common.MyException: the value of item “tracker_server” is invalid, the correct format is host:port at org.csource.fastdfs.ClientGlobal.init(ClientGlobal.java:103) at com.offcn.text.TestStorageClient.main(TestStora...
fastdfs工具类
xing.lin的博客
04-19 547
/** * Bestpay.com.cn Inc. * Copyright (c) 2011-2016 All Rights Reserved. */ package com.bestpay.messagecenter.product.common.constant; import java.util.List; /** * fastdfs 常量类 * @author lxn *
SpringBoot 集成 FastDFS（附安装教程）
曹俊的博客
04-25 2438
FastDFS是用 c 语言编写的一款开源的分布式文件系统，它对文件进行管理，功能包括：文件存储、文件同步、文件访问（文件上传、文件下载）等，解决了大容量存储和负载均衡的问题。特别适合以文件为载体的在线服务，如相册网站、视频网站等等。 FastDFS为互联网量身定制，充分考虑了冗余备份、负载均衡、线性扩容等机制，并注重高可用、高性能等指标，使用FastDFS很容易搭建一套高性能的文件服务器集群提供文件上传、下载等服务。
fastdfs java测试,关于fastDFS测试javaDemo报错的问题解决
weixin_42388485的博客
03-19 280
关于fastDFS测试javaDemo报错的问题解决关于fastDFS测试javaDemo报错的问题解决Exception in thread “main” org.csource.common.MyException: the value of item “tracker_server” is invalid, the correct format is host:portat org.csou...
springboot集合fastdfs的demo
12-21
springboot集合fastdfs的demo springboot集合fastdfs的demo
FastDFS源码封装（SpringBoot集成FastDFS）
12-25
FastDFS源码，sSpringBoot集成FastDFS源码，解决了跨域问题，集成了Swagger，方便测试使用。
SpringBoot集成FastDFS文件服务器实例
10-26
SpringBoot集成FastDFS文件服务器实例，里面使用SpringBoot2.0.6集成了FastDFS相关的代码，包括上传跟删除，已完成测试，完全可用。
springboot集成fastDfs过程代码实例
08-25
主要介绍了springboot集成fastDfs过程代码实例,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
java方法重写（重点讲），方法重载
weixin_46281068的博客
04-27 956
一、方法重载定义：一个类中，出现多个方法的名称相同，但是它们的形参列表是不同的，那么这些方法就称为方法重载了。注意：一个类中，只要一些方法的名称相同、形参列表不同，那么它们就是方法重载了，其它的都不管（如:修饰符，返回值类型是否一样都无所谓）。形参列表不同指的是:形参的个数、类型、顺序不同，不关心形参的名称。应用场景：开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的。
Day25-Java基础之常用类1
m0_46053885的博客
04-27 895
同时我们发现Math类中的方法都是静态的，因此在使用的时候我们可以直接通过类名去调用。对于计算机而言，其实是没有数据类型的概念的，都是0101010101，数据类型是编程语言自己规定的，所以在实际存储的时候，先把具体的数字变成二进制，每32个bit为一组，存储在数组中。比较内存地址值一般情况下是没有意义的，我们希望比较的是对象的属性，如果两个对象的属性相同，我们认为就是同一个对象；如果我们的数据是一个浮点类型的数据，有的时候计算机并不会将这个数据完全转换成一个二进制数据，而是将这个将其转换成一个无限的。
Lambda表达式特点
weixin_57763462的博客
04-24 819
**API 设计**：Lambda 表达式鼓励使用函数式接口的设计模式，这改变了 Java 库的设计，例如 `java.util.function` 包下的一系列函数式接口。- **函数式编程**：Lambda 表达式引入了函数式编程的理念，使得 Java 更接近于函数式编程语言，如 Scala 和 Clojure。- **并发编程**：Lambda 表达式与 Java 8 新增的 Stream API 结合使用，可以简化并发编程，特别是与集合的操作相关。
Java解决最长公共前缀
最新发布
无人罪的博客
04-28 231
编写一个函数来查找字符串数组中的最长公共前缀。如果不存在公共前缀，返回空字符串""。
MSE实现全链路灰度实践
云计算、数据库、大数据、深度学习、NLP、Python
04-24 449
待更新。
springboot和fastdfs
09-01
- *1* *2* *3* [springboot整合Fastdfs](https://blog.csdn.net/lingerlan510/article/details/121943781)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值