寒山李白

oss文件操作（文件列举、文件大小）

天行健，君子以自强不息；地势坤，君子以厚德载物。

每个人都有惰性，但不断学习是好好生活的根本，共勉！

文章均为学习整理笔记，分享记录为主，如有错误请指正，共同学习进步。

文章目录

一、介绍
二、依赖
三、实现
- 1. 连接参数
- 2. 列举文件
- - 2.1 列举bucket的所有文件夹（单层）
  - 2.2 列举指定bucket中的所有文件夹和文件（单层）
  - 2.3 列举指定bucket中的所有文件（多层）
  - 2.4 列举指定文件夹的所有文件（多层）
  - 2.5 列举指定文件夹中的所有文件夹和文件（单层）
  - 2.6 列举指定bucket中的所有文件夹（单层）
- 3. 文件大小计算
- 4. 工具类整合
- - 拓展业务逻辑计算
- 5. 测试

一、介绍

oss对象存储可以存储各类型数据，更加灵活，云端管理，安全高效，详细介绍可参考百度

官网地址：文件列举

官网对文件夹的说明：

OSS没有文件夹的概念，所有元素都是以文件来存储。创建文件夹本质上来说是创建了一个大小为0并以正斜线（/）结尾的文件。这个文件可以被上传和下载，控制台会对以正斜线（/）结尾的文件以文件夹的方式展示。关于创建文件夹的完整示例代码，请参见GitHub示例。
通过delimiter和prefix两个参数可以模拟文件夹功能：
– 如果设置prefix为某个文件夹名称，则会列举以此prefix开头的文件，即该文件夹下所有的文件和子文件夹（目录）均显示为objects。
– 如果在设置了prefix的情况下，将delimiter设置为正斜线（/），则只列举该文件夹下的文件和子文件夹（目录），该文件夹下的子文件夹（目录）显示为CommonPrefixes，子文件夹下的文件和文件夹不显示。
注意：默认列举数量为100个，如果文件夹中超过100，则只会列举前100个，想要列举更多，可以通过设置maxKeys参数的值，最大为1000

二、依赖

所使用的所有依赖如下

    
        





        
        
            com.aliyun.oss
            aliyun-sdk-oss
            3.15.1
        
        
            org.projectlombok
            lombok
            1.18.24
        
        
            com.alibaba
            fastjson
            2.0.32

三、实现

1. 连接参数

连接oss需要三个参数endpoint、accessKeyId、accessKeySecret

endpoint 服务器所在区域 如华东-上海 https://oss-cn-shanghai.aliyuncs.com
另外两个参数为服务的秘钥验证参数，需要在实例中查看获取
accessKeyId 如 UuSdeE9e89kEe4QG9rdfeDKeEDed98n
accessKeySecret 如 fMDdfDEGsdDfdY7F4CtvwDRFe4fe9DeERde834X

2. 列举文件

列举文件主要就两个方向，一个是文件夹，一个是文件，但文件夹也是文件，是带/的文件，大小为0
列举文件细分又分为：
列举桶即bucket的所有文件夹（单层，不向内继续列举）
列举桶即bucket的所有文件夹和文件（单层，不向内继续列举）
列举桶即bucket的所有文件（多层，子文件夹下如果还有文件夹则继续向内遍历列举）
列举指定文件夹下所有文件
列举指定文件夹下的所有文件夹及文件（文件夹下的子文件夹和文件不再进行列举）
列举指定文件夹下的所有文件夹（只列举文件夹，文件、子文件夹及其中的文件夹和文件都不列举）
描述起来不是很好描述，但只要自己找个oss文件夹跑一遍就一目了然了

注意：默认列举数量为100个，如果文件夹中超过100，则只会列举前100个，想要列举更多，可以通过设置maxKeys参数的值，最大为1000
//设置最大列举数量 listObjectsRequest.setMaxKeys(1000);

2.1 列举bucket的所有文件夹（单层）

    /**
     * 列举指定桶的所有文件夹
     * @param bucketName 桶名称
     * @return 返回文件夹列表
     */
    public static List listBucketPackages(String bucketName){

        List packageList = new ArrayList();
        OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);
        // 构造ListObjectsRequest请求。
        ListObjectsRequest listObjectsRequest = new ListObjectsRequest(bucketName);
        // 设置正斜线（/）为文件夹的分隔符。
        listObjectsRequest.setDelimiter("/");
        // 列出桶目录下的所有文件和文件夹。此处为空即可
        listObjectsRequest.setPrefix("");
        //设置最大列举数量
        listObjectsRequest.setMaxKeys(1000);
        // 列举文件。
        ObjectListing listing = ossClient.listObjects(listObjectsRequest);
        // 遍历所有commonPrefix。
        System.out.println("CommonPrefixes:");
        for (String commonPrefix : listing.getCommonPrefixes()) {
            System.out.println(commonPrefix);
            packageList.add(commonPrefix);
        }
        if (ossClient != null) {
            ossClient.shutdown();
        }
        return packageList;
    }

2.2 列举指定bucket中的所有文件夹和文件（单层）

    /**
     * 列举指定桶的所有文件和文件夹
     * @param bucketName 桶名称
     * @return 返回文件和文件夹列表
     */
    public static List listBucketFileAndPackage(String bucketName){
        List packageList = new ArrayList();
        OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);
        // 构造ListObjectsRequest请求。
        ListObjectsRequest listObjectsRequest = new ListObjectsRequest(bucketName);
        // 设置正斜线（/）为文件夹的分隔符。
        listObjectsRequest.setDelimiter("/");
        // 列出桶目录下的所有文件和文件夹。此处为空即可
        listObjectsRequest.setPrefix("");
        //设置最大列举数量
        listObjectsRequest.setMaxKeys(1000);
        // 列举文件。
        ObjectListing listing = ossClient.listObjects(listObjectsRequest);
        // 遍历所有文件。
        System.out.println("Objects:");
        for (OSSObjectSummary objectSummary : listing.getObjectSummaries()) {
            System.out.println(objectSummary.getKey());
            packageList.add(objectSummary.getKey());
        }
        // 遍历所有commonPrefix。
        System.out.println("CommonPrefixes:");
        for (String commonPrefix : listing.getCommonPrefixes()) {
            System.out.println(commonPrefix);
            packageList.add(commonPrefix);
        }
        if (ossClient != null) {
            ossClient.shutdown();
        }
        return packageList;
    }

2.3 列举指定bucket中的所有文件（多层）

    /**
     * 列举存储空间下的所有文件
     * @param bucketName 存储空间的桶名称
     * @return
     */
    public static List listAllFilesForBucket(String bucketName){
        List fileList = new ArrayList();
        // 创建OSSClient实例。
        OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);
        // 构造ListObjectsRequest请求。
        ListObjectsRequest listObjectsRequest = new ListObjectsRequest(bucketName);
        // 列举文件。
        ObjectListing listing = ossClient.listObjects(listObjectsRequest);
        // 遍历所有文件。
        System.out.println("Objects:");
        List objList = new ArrayList();
        for (OSSObjectSummary objectSummary : listing.getObjectSummaries()) {
            System.out.println(objectSummary.getKey());
            objList.add(objectSummary.getKey());
        }
        // 遍历所有commonPrefix。
        System.out.println("CommonPrefixes:");
//        List comprefList = new ArrayList();
        for (String commonPrefix : listing.getCommonPrefixes()) {
            System.out.println(commonPrefix);
//            comprefList.add(commonPrefix);
        }
        if (ossClient != null) {
            ossClient.shutdown();
        }
        fileList.add(objList);
//        fileList.add(comprefList);
        return fileList;
    }

2.4 列举指定文件夹的所有文件（多层）

    /**
     * 列举指定目录下的所有文件（包含了子目录下的所有文件及子目录）
     * @param bucketName 桶名称
     * @param prefixName 指定目录的名称 如 fun/
     * @return 返回指定目录下的所有文件
     */
    public static List listAllFileByPrefix(String bucketName, String prefixName){
        List fileList = new ArrayList();
        // 创建OSSClient实例。
        OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);
        // 构造ListObjectsRequest请求。
        ListObjectsRequest listObjectsRequest = new ListObjectsRequest(bucketName);
        // 设置prefix参数来获取fun目录下的所有文件。
//            listObjectsRequest.setPrefix("fun/");
        listObjectsRequest.setPrefix(prefixName);
        // 递归列举fun目录下的所有文件。
        ObjectListing listing = ossClient.listObjects(listObjectsRequest);
        // 遍历所有文件。
        System.out.println("Objects:");
        for (OSSObjectSummary objectSummary : listing.getObjectSummaries()) {
            System.out.println(objectSummary.getKey());
            fileList.add(objectSummary.getKey());
        }
        // 遍历所有commonPrefix。
        System.out.println("\nCommonPrefixes:");
        for (String commonPrefix : listing.getCommonPrefixes()) {
//            System.out.println(commonPrefix);
//            fileList.add(commonPrefix);
        }
        if (ossClient != null) {
            ossClient.shutdown();
        }
        return fileList;
    }

2.5 列举指定文件夹中的所有文件夹和文件（单层）

    /**
     * 列举文件夹下的文件夹及文件
     * 列举目录下的文件和子目录(只有一层，子目录下的子文件和子子目录不管)
     * @param bucketName 桶名称
     * @param prefixName 文件夹名称
     * @return 返回文件夹下所有文件和目录列表
     */
    public static List listAllFilesAndPackagesByPrefix(String bucketName, String prefixName){
        List fileList = new ArrayList();
        // 创建OSSClient实例。
        OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);
        // 构造ListObjectsRequest请求。
        ListObjectsRequest listObjectsRequest = new ListObjectsRequest(bucketName);
        // 设置正斜线（/）为文件夹的分隔符。
        listObjectsRequest.setDelimiter("/");
        // 列出fun目录下的所有文件和文件夹。
//            listObjectsRequest.setPrefix("fun/");
        listObjectsRequest.setPrefix(prefixName);
        ObjectListing listing = ossClient.listObjects(listObjectsRequest);
        // 遍历所有文件。
        System.out.println("Objects:");
        // objectSummaries的列表中给出的是fun目录下的文件。
        for (OSSObjectSummary objectSummary : listing.getObjectSummaries()) {
            System.out.println(objectSummary.getKey());
            fileList.add(objectSummary.getKey());
        }
        // 遍历所有commonPrefix。
        System.out.println("\nCommonPrefixes:");
        // commonPrefixs列表中显示的是fun目录下的所有子文件夹。由于fun/movie/001.avi和fun/movie/007.avi属于fun文件夹下的movie目录，因此这两个文件未在列表中。
        for (String commonPrefix : listing.getCommonPrefixes()) {
            System.out.println(commonPrefix);
            fileList.add(commonPrefix);
        }
        if (ossClient != null) {
            ossClient.shutdown();
        }
        return fileList;
    }

2.6 列举指定bucket中的所有文件夹（单层）

    /**
     * 只列举文件夹下的所有文件夹
     * 列举目录下所有子目录(只有一层，子目录下的子文件和子子目录不管)
     * @param bucketName 桶名称
     * @param prefixName 文件夹名称
     * @return 返回文件夹下所有文件和目录列表
     */
    public static List listAllPackagesByPrefix(String bucketName, String prefixName){
        List fileList = new ArrayList();
        // 创建OSSClient实例。
        OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);
        // 构造ListObjectsRequest请求。
        ListObjectsRequest listObjectsRequest = new ListObjectsRequest(bucketName);
        // 设置正斜线（/）为文件夹的分隔符。
        listObjectsRequest.setDelimiter("/");
        // 列出fun目录下的所有文件和文件夹。
//            listObjectsRequest.setPrefix("fun/");
        listObjectsRequest.setPrefix(prefixName);
        ObjectListing listing = ossClient.listObjects(listObjectsRequest);
        // 遍历所有commonPrefix。
//        System.out.println("\nCommonPrefixes:");
        // commonPrefixs列表中显示的是fun目录下的所有子文件夹。由于fun/movie/001.avi和fun/movie/007.avi属于fun文件夹下的movie目录，因此这两个文件未在列表中。
        for (String commonPrefix : listing.getCommonPrefixes()) {
//            System.out.println(commonPrefix);
            fileList.add(commonPrefix);
        }
        if (ossClient != null) {
            ossClient.shutdown();
        }
        return fileList;
    }

3. 文件大小计算

根据指定的桶名称和指定的文件夹来计算文件夹中所有文件的大小（即计算指定文件夹的大小）

    /**
     * 计算文件夹下所有文件大小
     * 通过GetBucket (ListObjects)方法获取指定目录下的文件大小
     * @param bucketName 桶名称
     * @param keyPrefix 所要计算的文件夹，后缀不加斜杠
     * @return 返回文件夹下文件大小
     */
    public static long fileSizeUtil(String bucketName, String keyPrefix){
        OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);
        long fileSize = 0;
        try {
            ObjectListing objectListing = null;
            do {
                // 默认情况下，每次列举100个文件或目录。
                ListObjectsRequest request = new ListObjectsRequest(bucketName).withDelimiter("/").withPrefix(keyPrefix);
                if (objectListing != null) {
                    request.setMarker(objectListing.getNextMarker());
                }
                objectListing = ossClient.listObjects(request);
//                objectListing = osscon.listObjects(request);
                List<String> folders = objectListing.getCommonPrefixes();
                for (String folder : folders) {
//                    System.out.println(folder + " fffffffffffffff: " + (calculateFolderLength(ossClient, bucketName, folder) / 1024) + "KB");
//                    System.out.println(folder + " : " + (calculateFolderLength(osscon, bucketName, folder) / 1024) + "KB");
                    fileSize = (calculateFolderLength(ossClient, bucketName, folder) / 1024);
                }
                List<OSSObjectSummary> sums = objectListing.getObjectSummaries();
                for (OSSObjectSummary s : sums) {
//                    System.out.println(s.getKey() + " 111111111111111: " + (s.getSize() / 1024) + "KB");
                }
            } while (objectListing.isTruncated());
        } catch (OSSException oe) {
//            System.out.println("Caught an OSSException, which means your request made it to OSS, "
//                    + "but was rejected with an error response for some reason.");
//            System.out.println("Error Message:" + oe.getErrorMessage());
//            System.out.println("Error Code:" + oe.getErrorCode());
//            System.out.println("Request ID:" + oe.getRequestId());
//            System.out.println("Host ID:" + oe.getHostId());
        } catch (ClientException ce) {
//            System.out.println("Caught an ClientException, which means the client encountered "
//                    + "a serious internal problem while trying to communicate with OSS, "
//                    + "such as not being able to access the network.");
//            System.out.println("Error Message:" + ce.getMessage());
        } finally {
            if (ossClient != null) {
//            if (osscon != null) {
                ossClient.shutdown();
//                osscon.shutdown();
            }
        }
        return fileSize;
    }
    /**
     * 计算文件大小
     * 获取某个存储空间下指定目录（文件夹）下的文件大小。
     * @param ossClient
     * @param bucketName
     * @param folder
     * @return
     */
    private static long calculateFolderLength(OSS ossClient, String bucketName, String folder) {
        long size = 0L;
        ObjectListing objectListing = null;
        do {
            // MaxKey默认值为100，最大值为1000。
            ListObjectsRequest request = new ListObjectsRequest(bucketName).withPrefix(folder).withMaxKeys(1000);
            if (objectListing != null) {
                request.setMarker(objectListing.getNextMarker());
            }
            objectListing = ossClient.listObjects(request);
            List<OSSObjectSummary> sums = objectListing.getObjectSummaries();
            for (OSSObjectSummary s : sums) {
                size += s.getSize();
            }
        } while (objectListing.isTruncated());
        return size;
    }

4. 工具类整合

注意：默认列举数量为100个，如果文件夹中超过100，则只会列举前100个，想要列举更多，可以通过设置maxKeys参数的值，最大为1000
//设置最大列举数量 listObjectsRequest.setMaxKeys(1000);
OssFileUtils.java

package com.oss.Utils;

import com.aliyun.oss.*;
import com.aliyun.oss.model.ListObjectsRequest;
import com.aliyun.oss.model.OSSObjectSummary;
import com.aliyun.oss.model.ObjectListing;
import org.springframework.stereotype.Component;
import java.util.ArrayList;
import java.util.List;

/**
 * @ClassDescription: 文件及文件夹的操作
 * 官网地址：
 * https://help.aliyun.com/zh/oss/developer-reference/list-objects-3?spm=a2c4g.11186623.0.0.4789a744TF3rDO
 * 官网对文件夹的说明：
 * - OSS没有文件夹的概念，所有元素都是以文件来存储。创建文件夹本质上来说是创建了一个大小为0并以正斜线（/）结尾的文件。这个文件可以被上传和下载，控制台会对以正斜线（/）结尾的文件以文件夹的方式展示。关于创建文件夹的完整示例代码，请参见GitHub示例。
 * - 通过delimiter和prefix两个参数可以模拟文件夹功能：
 *      如果设置prefix为某个文件夹名称，则会列举以此prefix开头的文件，即该文件夹下所有的文件和子文件夹（目录）均显示为objects。
 *      如果在设置了prefix的情况下，将delimiter设置为正斜线（/），则只列举该文件夹下的文件和子文件夹（目录），该文件夹下的子文件夹（目录）显示为CommonPrefixes，子文件夹下的文件和文件夹不显示。
 * - 注意： 默认列举数量为100个，如果文件夹中超过100，则只会列举前100个，想要列举更多，可以通过设置maxKeys参数的值，最大为1000
 * @JdkVersion: 1.8
 * @Author: 李白
 * @Created: 2023/12/18 8:46
 */
@Component
public class OssFileUtils {
    private static final String endpoint = "https://oss-cn-shanghai.aliyuncs.com";
    private static final String accessKeyId = "LdiEKDe9eE8EDDJREe899Ee4Qdjfe93LEsDE3390Ded";
    private static final String accessKeySecret = "Elkedfe393rkDFdfe4F4Ctvwt4IeE4l4d4kjlJL4Ld";

    /**
     * 列举指定桶的所有文件夹
     * @param bucketName 桶名称
     * @return 返回文件夹列表
     */
    public static List listBucketPackages(String bucketName){

        List packageList = new ArrayList();
        OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);
        // 构造ListObjectsRequest请求。
        ListObjectsRequest listObjectsRequest = new ListObjectsRequest(bucketName);
        // 设置正斜线（/）为文件夹的分隔符。
        listObjectsRequest.setDelimiter("/");
        // 列出桶目录下的所有文件和文件夹。此处为空即可
        listObjectsRequest.setPrefix("");
        //设置最大列举数量
        listObjectsRequest.setMaxKeys(1000);
        // 列举文件。
        ObjectListing listing = ossClient.listObjects(listObjectsRequest);
        // 遍历所有commonPrefix。
        System.out.println("CommonPrefixes:");
        for (String commonPrefix : listing.getCommonPrefixes()) {
            System.out.println(commonPrefix);
            packageList.add(commonPrefix);
        }
        if (ossClient != null) {
            ossClient.shutdown();
        }
        return packageList;
    }


    /**
     * 列举指定桶的所有文件和文件夹
     * @param bucketName 桶名称
     * @return 返回文件和文件夹列表
     */
    public static List listBucketFileAndPackage(String bucketName){
        List packageList = new ArrayList();
        OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);
        // 构造ListObjectsRequest请求。
        ListObjectsRequest listObjectsRequest = new ListObjectsRequest(bucketName);
        // 设置正斜线（/）为文件夹的分隔符。
        listObjectsRequest.setDelimiter("/");
        // 列出桶目录下的所有文件和文件夹。此处为空即可
        listObjectsRequest.setPrefix("");
        //设置最大列举数量
        listObjectsRequest.setMaxKeys(1000);
        // 列举文件。
        ObjectListing listing = ossClient.listObjects(listObjectsRequest);
        // 遍历所有文件。
        System.out.println("Objects:");
        for (OSSObjectSummary objectSummary : listing.getObjectSummaries()) {
            System.out.println(objectSummary.getKey());
            packageList.add(objectSummary.getKey());
        }
        // 遍历所有commonPrefix。
        System.out.println("CommonPrefixes:");
        for (String commonPrefix : listing.getCommonPrefixes()) {
            System.out.println(commonPrefix);
            packageList.add(commonPrefix);
        }
        if (ossClient != null) {
            ossClient.shutdown();
        }
        return packageList;
    }



    /**
     * 列举存储空间下的所有文件
     * @param bucketName 存储空间的桶名称
     * @return
     */
    public static List listAllFilesForBucket(String bucketName){
        List fileList = new ArrayList();
        // 创建OSSClient实例。
        OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);
        // 构造ListObjectsRequest请求。
        ListObjectsRequest listObjectsRequest = new ListObjectsRequest(bucketName);
        // 列举文件。
        ObjectListing listing = ossClient.listObjects(listObjectsRequest);
        // 遍历所有文件。
        System.out.println("Objects:");
        List objList = new ArrayList();
        for (OSSObjectSummary objectSummary : listing.getObjectSummaries()) {
            System.out.println(objectSummary.getKey());
            objList.add(objectSummary.getKey());
        }
        // 遍历所有commonPrefix。
        System.out.println("CommonPrefixes:");
//        List comprefList = new ArrayList();
        for (String commonPrefix : listing.getCommonPrefixes()) {
            System.out.println(commonPrefix);
//            comprefList.add(commonPrefix);
        }
        if (ossClient != null) {
            ossClient.shutdown();
        }
        fileList.add(objList);
//        fileList.add(comprefList);
        return fileList;
    }



    /**
     * 列举指定目录下的所有文件（包含了子目录下的所有文件及子目录）
     * @param bucketName 桶名称
     * @param prefixName 指定目录的名称 如 fun/
     * @return 返回指定目录下的所有文件
     */
    public static List listAllFileByPrefix(String bucketName, String prefixName){
        List fileList = new ArrayList();
        // 创建OSSClient实例。
        OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);
        // 构造ListObjectsRequest请求。
        ListObjectsRequest listObjectsRequest = new ListObjectsRequest(bucketName);
        // 设置prefix参数来获取fun目录下的所有文件。
//            listObjectsRequest.setPrefix("fun/");
        listObjectsRequest.setPrefix(prefixName);
        // 递归列举fun目录下的所有文件。
        ObjectListing listing = ossClient.listObjects(listObjectsRequest);
        // 遍历所有文件。
        System.out.println("Objects:");
        for (OSSObjectSummary objectSummary : listing.getObjectSummaries()) {
            System.out.println(objectSummary.getKey());
            fileList.add(objectSummary.getKey());
        }
        // 遍历所有commonPrefix。
        System.out.println("\nCommonPrefixes:");
        for (String commonPrefix : listing.getCommonPrefixes()) {
//            System.out.println(commonPrefix);
//            fileList.add(commonPrefix);
        }
        if (ossClient != null) {
            ossClient.shutdown();
        }
        return fileList;
    }





    /**
     * 列举文件夹下的文件夹及文件
     * 列举目录下的文件和子目录(只有一层，子目录下的子文件和子子目录不管)
     * @param bucketName 桶名称
     * @param prefixName 文件夹名称
     * @return 返回文件夹下所有文件和目录列表
     */
    public static List listAllFilesAndPackagesByPrefix(String bucketName, String prefixName){
        List fileList = new ArrayList();
        // 创建OSSClient实例。
        OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);
        // 构造ListObjectsRequest请求。
        ListObjectsRequest listObjectsRequest = new ListObjectsRequest(bucketName);
        // 设置正斜线（/）为文件夹的分隔符。
        listObjectsRequest.setDelimiter("/");
        // 列出fun目录下的所有文件和文件夹。
//            listObjectsRequest.setPrefix("fun/");
        listObjectsRequest.setPrefix(prefixName);
        ObjectListing listing = ossClient.listObjects(listObjectsRequest);
        // 遍历所有文件。
        System.out.println("Objects:");
        // objectSummaries的列表中给出的是fun目录下的文件。
        for (OSSObjectSummary objectSummary : listing.getObjectSummaries()) {
            System.out.println(objectSummary.getKey());
            fileList.add(objectSummary.getKey());
        }
        // 遍历所有commonPrefix。
        System.out.println("\nCommonPrefixes:");
        // commonPrefixs列表中显示的是fun目录下的所有子文件夹。由于fun/movie/001.avi和fun/movie/007.avi属于fun文件夹下的movie目录，因此这两个文件未在列表中。
        for (String commonPrefix : listing.getCommonPrefixes()) {
            System.out.println(commonPrefix);
            fileList.add(commonPrefix);
        }
        if (ossClient != null) {
            ossClient.shutdown();
        }
        return fileList;
    }

    /**
     * 只列举文件夹下的所有文件夹
     * 列举目录下所有子目录(只有一层，子目录下的子文件和子子目录不管)
     * @param bucketName 桶名称
     * @param prefixName 文件夹名称
     * @return 返回文件夹下所有文件和目录列表
     */
    public static List listAllPackagesByPrefix(String bucketName, String prefixName){
        List fileList = new ArrayList();
        // 创建OSSClient实例。
        OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);
        // 构造ListObjectsRequest请求。
        ListObjectsRequest listObjectsRequest = new ListObjectsRequest(bucketName);
        // 设置正斜线（/）为文件夹的分隔符。
        listObjectsRequest.setDelimiter("/");
        // 列出fun目录下的所有文件和文件夹。
//            listObjectsRequest.setPrefix("fun/");
        listObjectsRequest.setPrefix(prefixName);
        ObjectListing listing = ossClient.listObjects(listObjectsRequest);
        // 遍历所有commonPrefix。
//        System.out.println("\nCommonPrefixes:");
        // commonPrefixs列表中显示的是fun目录下的所有子文件夹。由于fun/movie/001.avi和fun/movie/007.avi属于fun文件夹下的movie目录，因此这两个文件未在列表中。
        for (String commonPrefix : listing.getCommonPrefixes()) {
//            System.out.println(commonPrefix);
            fileList.add(commonPrefix);
        }
        if (ossClient != null) {
            ossClient.shutdown();
        }
        return fileList;
    }


    /**
     * 计算文件夹下所有文件大小
     * 通过GetBucket (ListObjects)方法获取指定目录下的文件大小
     * @param bucketName 桶名称
     * @param keyPrefix 所要计算的文件夹，后缀不加斜杠
     * @return 返回文件夹下文件大小
     */
    public static long fileSizeUtil(String bucketName, String keyPrefix){
        OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);
        long fileSize = 0;
        try {
            ObjectListing objectListing = null;
            do {
                // 默认情况下，每次列举100个文件或目录。
                ListObjectsRequest request = new ListObjectsRequest(bucketName).withDelimiter("/").withPrefix(keyPrefix);
                if (objectListing != null) {
                    request.setMarker(objectListing.getNextMarker());
                }
                objectListing = ossClient.listObjects(request);
//                objectListing = osscon.listObjects(request);
                List<String> folders = objectListing.getCommonPrefixes();
                for (String folder : folders) {
//                    System.out.println(folder + " fffffffffffffff: " + (calculateFolderLength(ossClient, bucketName, folder) / 1024) + "KB");
//                    System.out.println(folder + " : " + (calculateFolderLength(osscon, bucketName, folder) / 1024) + "KB");
                    fileSize = (calculateFolderLength(ossClient, bucketName, folder) / 1024);
                }
                List<OSSObjectSummary> sums = objectListing.getObjectSummaries();
                for (OSSObjectSummary s : sums) {
//                    System.out.println(s.getKey() + " 111111111111111: " + (s.getSize() / 1024) + "KB");
                }
            } while (objectListing.isTruncated());
        } catch (OSSException oe) {
//            System.out.println("Caught an OSSException, which means your request made it to OSS, "
//                    + "but was rejected with an error response for some reason.");
//            System.out.println("Error Message:" + oe.getErrorMessage());
//            System.out.println("Error Code:" + oe.getErrorCode());
//            System.out.println("Request ID:" + oe.getRequestId());
//            System.out.println("Host ID:" + oe.getHostId());
        } catch (ClientException ce) {
//            System.out.println("Caught an ClientException, which means the client encountered "
//                    + "a serious internal problem while trying to communicate with OSS, "
//                    + "such as not being able to access the network.");
//            System.out.println("Error Message:" + ce.getMessage());
        } finally {
            if (ossClient != null) {
//            if (osscon != null) {
                ossClient.shutdown();
//                osscon.shutdown();
            }
        }
        return fileSize;
    }
    /**
     * 计算文件大小
     * 获取某个存储空间下指定目录（文件夹）下的文件大小。
     * @param ossClient
     * @param bucketName
     * @param folder
     * @return
     */
    private static long calculateFolderLength(OSS ossClient, String bucketName, String folder) {
        long size = 0L;
        ObjectListing objectListing = null;
        do {
            // MaxKey默认值为100，最大值为1000。
            ListObjectsRequest request = new ListObjectsRequest(bucketName).withPrefix(folder).withMaxKeys(1000);
            if (objectListing != null) {
                request.setMarker(objectListing.getNextMarker());
            }
            objectListing = ossClient.listObjects(request);
            List<OSSObjectSummary> sums = objectListing.getObjectSummaries();
            for (OSSObjectSummary s : sums) {
                size += s.getSize();
            }
        } while (objectListing.isTruncated());
        return size;
    }

    /**
     * 计算文件大小
     * 获取某个存储空间下指定目录（文件夹）下的文件大小。
     * @param bucketName
     * @param folder
     * @return
     */
    private static long calculateFolderSize(String bucketName, String folder) {
        OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);
        long size = 0L;
        ObjectListing objectListing = null;
        do {
            // MaxKey默认值为100，最大值为1000。
            ListObjectsRequest request = new ListObjectsRequest(bucketName).withPrefix(folder).withMaxKeys(1000);
            if (objectListing != null) {
                request.setMarker(objectListing.getNextMarker());
            }
            objectListing = ossClient.listObjects(request);
            List<OSSObjectSummary> sums = objectListing.getObjectSummaries();
            for (OSSObjectSummary s : sums) {
                size += s.getSize();
            }
        } while (objectListing.isTruncated());
        return size;
    }


}

拓展业务逻辑计算

计算指定桶内所有设备的指定文件夹中的文件，统计总和并输出，编写工具
YearSizeCalUtilForOssFile.java

package com.oss.Utils;

import com.alibaba.fastjson.JSONObject;
import org.springframework.stereotype.Component;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * @ClassDescription:
 * @JdkVersion: 1.8
 * @Author: 李白
 * @Created: 2023/12/18 14:15
 */
@Component
public class YearSizeCalUtilForOssFile {
    private static final String bucketName = "hs-li-bai";

    /**
     * 计算所有设备对应DATA数据的22年和23年的文件总和，即所有设备22年的文件大小，和23年的大小
     * @return
     */
    public static JSONObject fileSizeForYear(){
        List list = OssFileUtils.listBucketPackages(bucketName);
        List deviceIdList = new ArrayList();
        for (int i = 0; i < list.size(); i++) {
            String filePackage = list.get(i).toString();
            if (filePackage.contains("Num")){
//            if (filePackage.contains("UA")){
                filePackage = filePackage.replace("/","");
                deviceIdList.add(filePackage);
            }
        }
        //排序
        deviceIdList = Arrays.asList(deviceIdList.stream().sorted().toArray());
        System.out.println(deviceIdList);
        
        long fileSizeFor22 = 0;
        long fileSizeFor23 = 0;
        long allDeviceAllSize=0;
        List sizeList22 = new ArrayList();
        List sizeList23 = new ArrayList();
        JSONObject  fileSizeInfo = new JSONObject();
        for (int i = 0; i < deviceIdList.size(); i++) {
            JSONObject oneDeviceSize = new JSONObject();
            String deviceId = deviceIdList.get(i).toString();
            String prefixName = deviceId+"/DATA/";
            List yearList = OssFileUtils.listAllPackagesByPrefix(bucketName, prefixName);
//            System.out.println(yearList);
            long filesize22 = 0;
            if (yearList.contains(prefixName+"22/")){
                filesize22 = OssFileUtils.fileSizeUtil(bucketName, prefixName + "22");
                sizeList22.add(filesize22);
                oneDeviceSize.put("22",filesize22);
            }else{
                oneDeviceSize.put("22",0);
            }
            fileSizeFor22= fileSizeFor22+filesize22;
            long filesize23 = 0;
            if (yearList.contains(prefixName+"23/")){
                filesize23 = OssFileUtils.fileSizeUtil(bucketName, prefixName + "23");
                sizeList23.add(filesize23);
                oneDeviceSize.put("23",filesize23);
            }else{
                oneDeviceSize.put("23",0);
            }
            fileSizeFor23= fileSizeFor23+filesize23;
            long oneDeviceAllSize = OssFileUtils.fileSizeUtil(bucketName, prefixName);
            allDeviceAllSize = allDeviceAllSize+oneDeviceAllSize;
            fileSizeInfo.put(deviceId, oneDeviceSize);
        }
        System.out.println("================================================>>>>");
        System.out.println(fileSizeInfo);
        System.out.println("全部文件大小: "+allDeviceAllSize + "KB");
        System.out.println("22年文件大小: "+ fileSizeFor22 + "KB");
        System.out.println("23年文件大小: "+ fileSizeFor23 + "KB");

        return fileSizeInfo;


    }


}

5. 测试

测试的main方法代码
RequestController.java

package com.oss.controller;

import com.oss.Utils.YearSizeCalUtilForOssFile;
import java.util.concurrent.TimeUnit;

/**
 * @ClassDescription:
 * @JdkVersion: 1.8
 * @Author: 李白
 * @Created: 2023/12/15 9:54
 */
public class RequestController {
    public static void main(String[] args) {
        long calTimeStarting = System.currentTimeMillis();
        
        YearSizeCalUtilForOssFile.fileSizeForYear();

        long calTimeEnding = System.currentTimeMillis();

        long calTime = calTimeEnding - calTimeStarting;

        long minutes = TimeUnit.MILLISECONDS.toMinutes(calTime);

        System.out.println("消耗时间（分）："+minutes);

    }


}

执行后输出打印如下

感谢阅读，祝君暴富！

你可能感兴趣的:(#,OSS,数据库,java)

【爸爸带娃日更174】吃维生素的计算机思考蓝色眼镜007
中午，家里人为了有没有给冬冬喂过维生素，而反复确认。问冬冬，她就算吃了，也就是很被动的张口，而且每天都吃，她也不清楚。再问当事人，因为也是每天都喂，也不太确定。好像吃了，好像又没吃。有时，A顺手已喂冬冬吃了，B却并不知道。确认混乱。其实，无非就是没有「中心化数据库」嘛。以后，在墙上贴张表格，不管谁喂完后，就马上在上面打个勾。或者，每天的量都用纸包起来，纸外面写上日期，吃完就扔，这是「分布的思维」。
Kotlin 代替Java接口回调，就这么简单深海呐 Android #Kotlin java kotlin 开发语言
假如你使用旧的接口回调：通常三步：1定义接口和方法；2使用接口中方法；3继承接口并实现方法；例：classXXXAdapter{publicvarmClickCollBack:clickCollBack?=null//1定义interfaceclickCollBack{//1定义funclick(int:Int)//1定义}itemView.setOnClickListener{mClickCol
Android 用线程池实现一个简单的任务队列(Kotlin) 深海呐 Android #Android进阶 #Kotlin android kotlin 线程池延时任务队列线程池延时任务
关于线程池,Kotlin和java的使用方式一样在Android中,很多人喜欢用Handler的postDelayed()去实现延时任务.要使用postDelayed(),去实现延时任务队列,就不可避免要使用递归.但是这样做,代码的简洁性,和书写的简易,就远不如使用线程池.使用线程池的简单程度:privatevalmThreadPool=Executors.newSingleThreadSched
（小白入门）Windows环境下搭建React Native Android开发环境码农老黑前端 React Native 移动开发 Android studio
ReactNative(简称RN)是Facebook于2015年4月开源的跨平台移动应用开发框架，是Facebook早先开源的UI框架React在原生移动应用平台的衍生产物，目前支持iOS和Android两大平台。RN的环境搭建在RN的中文社区有所介绍，但是对于小白来说还是有些太过简略了。RN中文社区详见参考，本文不涉及的问题也许在其中能够有所解答。ReactNative思想底层引擎是JavaSc
Java刷题day34 小突击花呀刷题 java 网络服务器
1.IPv4版本的因特网总共有多少有效A类地址网络（）A.255B.128C.256D.126答案：D解析：A类IP地址范围从1.0.0.0到126.0.0.0。可用的A类网络有126个。B类IP地址范围从128.0.0.0到191.255.255.255。可用的B类网络有16382个。C类IP地址范围从192.0.0.0到223.255.255.255。C类网络可达209万余个。D类地址用于多点
Android界面特效全汇总小飞鹤 Android开发详解 android
（一）Activity页面切换的效果Android2.0之后有了overridePendingTransition（），其中里面两个参数，一个是前一个activity的退出两一个activity的进入，Java代码1.@OverridepublicvoidonCreate(BundlesavedInstanceState){2.super.onCreate(savedInstanceState);
Spring Cloud+Spring Boot+Mybatis+Java版电子招标采购系统源码及功能清单 Xiaohong0716 mybatis java spring cloud
一、立项管理1、招标立项申请功能点：招标类项目立项申请入口，用户可以保存为草稿，提交。2、非招标立项申请功能点：非招标立项申请入口、用户可以保存为草稿、提交。3、采购立项列表功能点：对草稿进行编辑，驳回的立项编辑，在途流程查看。二、项目管理1、采购计划管理功能点：采购计划新增、编辑、删除2、采购过程管理功能点：查询、维护基准价、组建评审小组、项目答疑澄清、文件费保证金审核、供应商报价维护、查看评审
笔记：JAVA面向对象三大特征——封装继承多态听原来是雨落 Java java 开发语言后端
高内聚，低耦合：高内聚：类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。一、封装：含义：1.指把对象的属性和行为看成一个密不可分的整体，将这两者“封装”在一个密不可分的独立单位（即对象）中； 2.指“信息隐藏”，把不需要外界知道的信息隐藏起来，有些对象的属性及行为为允许外界用户知道或使用，但不允许更改，而另一些属性或行为，则不允许外界知道，
【JavaSE】封装、继承与多态泡芙冰淇淋ya JavaSE java 开发语言
1、封装1.1简介在Javase中，封装（Encapsulation）是面向对象编程（OOP）的一个重要概念。封装的主要目的是隐藏对象的内部状态和信息，只提供必要的公共方法来访问和操作这些状态和信息。通过封装可以控制对对象内部数据的访问级别，并保护数据不被随意修改，从而提高代码的安全性和可维护性。1.2特点信息隐藏：对象的内部状态（即属性或数据成员）被隐藏起来，外部世界只能通过对象提供的方法来访问
02 Java-Lambda-Java 8 自带的函数接口王小杰at2019
Java8自带的函数接口我们使用lambda在处理自己定义的业务时，需要自定义函数式接口，其实java8已经内置了常用的接口，这样我们在用的时候不要需要自己定义接口，根据需要选择符合自己业务逻辑的接口接口|输入参数|返回值类型|说明---|---|---|---|---Predicate|T|boolean|断言Consumer|T|/|消费一个数据|Function|T|R|输入一个T输出一个R
JavaSE:4、流程控制 _Power_Y JavaSE java 算法开发语言
1、代码块与作用域变量的使用范围，仅限于其定义时所处的代码块，也就是他的作用域。目前所说的变量均为局部变量publicclassMain{publicstaticvoidmain(String[]argv){inta=10;{intb=10;System.out.println(a);System.out.println(b);}System.out.println(a);//System.out
Java并发编程-AQS详解及案例实战（上篇）猿与禅 Java技术栈源码分析 java AQS 并发编程原理
文章目录AQS概述AQS的核心概念AQS的工作原理AQS的灵活性使用场景使用指南使用示例AQS的本质:为啥叫做异步队列同步器AQS的核心机制“异步队列”的含义“同步器”的含义总结加锁失败的时候如何借助AQS异步入队阻塞等待AQS的锁队列加锁失败时的处理流程异步入队的机制总结ReentractLock如何设置公平锁策略以及原理设置公平锁策略公平锁的运作原理尝试获取锁释放锁性能与公平性的权衡tryLo
计算机毕业设计Node.js+Vue基于Java的医院预约挂号系统(程序+源码+LW+部署) Nodejs洋洋程序 java vue.js 课程设计
该项目含有源码、文档、程序、数据库、配套开发软件、软件安装教程。欢迎交流项目运行环境配置：Node.js+Vscode+Mysql5.7+HBuilderX+Navicat11+Vue+Express。项目技术：Express框架+Node.js+Vue等等组成，B/S模式+Vscode管理+前后端分离等等。环境需要1.运行环境：最好是Nodejs最新版，我们在这个版本上开发的。其他版本理论上也可
Java高并发编程详解系列-深入理解Thread构造 nihui123 高并发 Java高并发 Java 高并发
上篇分享中主要是对线程的基本概念和基本操作做了一个分享，同时提出了两种常用的创建多线程的方法，当然在后期的分享中也会提及到更多的创建线程的方式，到后期的分享的时候再说。这次主要是深入的理解一下Thread的构造函数，通过构造函数对于Thread有一个更加深入的了解。这里首先提供一个JDK1.6的ThreadAPI截图线程命名规范从源码分析可以看到在Thread类中默认提供了线程的命名方式，这个
Java高并发编程详解系列-Balking设计模式 nihui123 高并发设计模式 java 编程语言
导语在实际操作中当某个线程因为发现其他线程正在进行相同的工作而放弃即将开始的任务，这种情况就被称为是Balking模式，Balking英文的意思是犹豫。在多个线程监控某个共享变量，A线程监控到共享变量发生变化后立即触发某个动作，但是这个这个时候发现了B线程也对该变量开始了行动，这个时候A变量就放弃了准备工作。下面就来详细的讲解一下关于Balking模式什么是Balking模式在餐厅吃饭的时
Java高并发编程详解系列-Future设计模式 nihui123 高并发 Java高并发 Future 高并发
导语假设，在一个使用场景中有一个任务需要执行比较长的时间，通常需要等待任务执行结束之后或者是中途出错之后才能返回结果。在这个期间调用者只能等待，对于这个结果Future设计模式提供了一种凭据式的解决方案。在日常生活中，这种方案也是存在的。例如去洗衣店洗衣服，当你把衣服放到洗衣店，等他洗完需要一段时间，这个时候洗衣店就会给你一凭证，你可以通过这个凭证到时候去取洗好的衣服。这个例子就是生活中的Fu
ajax讲解夜不眠，码三千 okhttp
1.AJAX概述1.1什么是ajaxAJAX（AsynchronousJavascriptAndXML）翻译成中文就是“异步Javascript和XML”。即使用Javascript语言与服务器进行异步交互，传输的数据为XML（当然，传输的数据不只是XML）。AJAX还有一个最大的特点就是，当服务器响应时，不用刷新整个浏览器页面，而是可以局部刷新。这一特点给用户的感受是在不知不觉中完成请求和响应过
Java岗外包干了五年，废了。。。跟着我学Java 面试 Java 程序员 java jvm 面试程序人生架构
先说一下自己的个人情况，大专生，17年通过校招进入湖南某软件公司，干了接近5年的CRUD，今年年初，感觉自己不能够在这样下去了，长时间呆在一个舒适的环境会让一个人堕落!而我已经在一个企业干了五年的CRUD，已经让我变得不思进取，谈了3年的女朋友也因为我的心态和工资和我分手了。于是，我决定要改变现状刚开始准备时，自己都蒙了，五年的CRUD让我的技术没有一丝的进步，提升的只有我的年龄...没办法，我找
Keras深度学习框架入门及实战指南司莹嫣Maude
Keras深度学习框架入门及实战指南keraskeras-team/keras:是一个基于Python的深度学习库，它没有使用数据库。适合用于深度学习任务的开发和实现，特别是对于需要使用Python深度学习库的场景。特点是深度学习库、Python、无数据库。项目地址:https://gitcode.com/gh_mirrors/ke/keras一、项目介绍Keras简介Keras是一款高级神经网络
python基于django/flask的NBA球员大数据分析与可视化python+java+node.js QQ_511008285 python django flask java spring boot 数据分析
前端开发框架:vue.js数据库mysql版本不限后端语言框架支持：1java(SSM/springboot)-idea/eclipse2.Nodejs+Vue.js-vscode3.python(flask/django)--pycharm/vscode4.php(thinkphp/laravel)-hbuilderx数据库工具：Navicat/SQLyog等都可以本文针对NBA球员的大数据进行
Java基于spring boot的国产电影数据分析与可视化python+java+node.js QQ_511008285 java spring boot 数据分析 python django vue.js flask
前端开发框架:vue.js数据库mysql版本不限后端语言框架支持：1java(SSM/springboot)-idea/eclipse2.Nodejs+Vue.js-vscode3.python(flask/django)--pycharm/vscode4.php(thinkphp/laravel)-hbuilderx数据库工具：Navicat/SQLyog等都可以该系统使用进行大数据处理和
Mac上有哪些虚拟机软件？性能兼容性都怎么样该如何下载安装 Hot1422 macos windows
Mac上常用的虚拟机软件大概有三个，一个是VMwareFusionVM虚拟机，一个是ParallelsDesktopPD虚拟机，还有一个是CrossOver其中PD与VM都是纯正的虚拟机软件，通过安装windows操作系统来运行windows软件，而CrossOver是无需安装操作系统的，但兼容性比较差，下面详细介绍一下：ParallelsDesktop（PD虚拟机）PD虚拟机对于RAM架构的Ma
MTK Camera2 预览图成像质量差（马赛克） AQUARICES Android java android
MTK推送来的原生Camera2应用拍照之后生成的预览图（Thumbnail）居然是马赛克！！但如果点击预览图之后再退出，就又是正常的。Camera2对于更新预览图的操作位于：vendor/mediatek/proprietary/packages/apps/Camera2/host/src/com/mediatek/camera/ui/ThumbnailViewManager.java这个函数对
Java中的多态性（Polymorphism）天蓝蓝23528 java 开发语言
Java中的多态性（Polymorphism）是面向对象编程（OOP）中的一个核心概念，它允许同一个接口或方法在不同对象上具有不同的实现方式。多态性极大地提高了代码的灵活性和可扩展性，使得程序能够以一种统一的方式处理不同类型的对象。以下是对Java中多态性的详细解释，包括其定义、实现方式、优点以及具体示例。一、多态性的定义多态性是指允许不同类的对象对同一消息作出响应，即同一操作作用于不同的对象，可
openGauss 扩展FDW与其他openGauss特性 openGaussMan 数据库 openGauss
扩展FDW与其他openGauss特性openGauss基于PostgreSQL，而PostgreSQL没有内置存储引擎适配器，如MySQL的handlerton。为了使MOT存储引擎能够集成到openGauss中，我们利用并扩展了现有的FDW机制。随着FDW引入PostgreSQL9.1，现在可以将这些外表和数据源呈现为统一、本地可访问的关系来访问外部管理的数据库。和PostgreSQL不同的是
如何实现Java中的多态性 Good_tea_h java python 开发语言
Java中的多态性是一个核心概念，它允许对象在其所属的类层次结构中有多种表现形式。多态性的实现主要依赖于继承、方法重写以及接口实现等机制。以下将详细阐述Java中多态性的实现方式，并探讨其原理、作用及优势。一、多态性的定义多态性（Polymorphism）在Java中指的是允许不同类的对象对同一消息作出不同的响应。简单来说，就是同一个方法调用，作用于不同的对象，可以有不同的执行结果。多态性增强了程
Java的多态性 zaneily JAVA java 开发语言
Java的多态性多态性是面向对象编程的一个重要特征，是指在父类中定义的属性和方法被子类继承之后，可以具有不同的数据类型或表现出不同的行为，这使得同一个属性或方法在父类及其各个子类中具有不同的涵义。可以理解为一个事务的多种形态。Java实现多态有三个条件：继承，重写和向上转型。继承：在多态中必须存在有继承关系的子类和父类。重写：子类对父类中某些方法进行重新定义，在调用这些方法时就会调用重写的子类方法
java 什么是多态性_Java多态性理解职路施语 java 什么是多态性
什么是多态面向对象的三大特性：封装、继承、多态。从一定角度来看，封装和继承几乎都是为多态而准备的。这是我们最后一个概念，也是最重要的知识点。多态的定义：指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。(发送消息就是函数调用)实现多态的技术称为：动态绑定(dynamicbinding)，是指在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应
2019-08-01 Sophia_Lu
JavaScript调试使用debugger进行打断点JavaScript严格模式(usestrict)它不是一条语句，但是是一个字面量表达式，在JavaScript旧版本中会被忽略。"usestrict"的目的是指定代码在严格条件下执行。严格模式下你不能使用未声明的变量。
java 动态多态性_Java语言中动态多态性的实现及应用阿野与阿厉 java 动态多态性
科技信息1.引言多态性(polymorphism)一词来源于拉丁语poly(表示多的意思)和mor-phos(意为形态)，其字面的含义是多种形态。在面向对象系统中，多态性是其核心内容之一，反映了人们在求解问题时，对相似性问题的一种求解方法。Java语言实现了两种多态性：静态多态性和动态多态性。本文重点论述其采用重写机制实现动态多态性的原理，并结合实例讲解动态多态性的应用。2.关于多态的概念2.1继
java线程Thread和Runnable区别和联系 zx_code java jvm thread 多线程 Runnable
我们都晓得java实现线程2种方式，一个是继承Thread，另一个是实现Runnable。模拟窗口买票，第一例子继承thread，代码如下 package thread; public class ThreadTest { public static void main(String[] args) { Thread1 t1 = new Thread1(
【转】JSON与XML的区别比较丁_新 json xml
1.定义介绍 (1).XML定义扩展标记语言 (Extensible Markup Language, XML) ，用于标记电子文件使其具有结构性的标记语言，可以用来标记数据、定义数据类型，是一种允许用户对自己的标记语言进行定义的源语言。 XML使用DTD(document type definition)文档类型定义来组织数据;格式统一，跨平台和语言，早已成为业界公认的标准。 XML是标
c++ 实现五种基础的排序算法 CrazyMizzz C++c 算法
#include<iostream> using namespace std; //辅助函数，交换两数之值 template<class T> void mySwap(T &x, T &y){ T temp = x; x = y; y = temp; } const int size = 10; //一、用直接插入排
我的软件麦田的设计者我的软件音乐类娱乐放松
这是我写的一款app软件，耗时三个月，是一个根据央视节目开门大吉改变的，提供音调，猜歌曲名。1、手机拥有者在android手机市场下载本APP，同意权限，安装到手机上。2、游客初次进入时会有引导页面提醒用户注册。（同时软件自动播放背景音乐）。3、用户登录到主页后，会有五个模块。a、点击不胫而走，用户得到开门大吉首页部分新闻，点击进入有新闻详情。b、
linux awk命令详解被触发 linux awk
awk是行处理器: 相比较屏幕处理的优点，在处理庞大文件时不会出现内存溢出或是处理缓慢的问题，通常用来格式化文本信息 awk处理过程: 依次对每一行进行处理，然后输出 awk命令形式: awk [-F|-f|-v] ‘BEGIN{} //{command1; command2} END{}’ file [-F|-f|-v]大参数，-F指定分隔符，-f调用脚本，-v定义变量 var=val
各种语言比较 _wy_ 编程语言
Java Ruby PHP 擅长领域
oracle 中数据类型为clob的编辑知了ing oracle clob
public void updateKpiStatus(String kpiStatus,String taskId){ Connection dbc=null; Statement stmt=null; PreparedStatement ps=null; try { dbc = new DBConn().getNewConnection(); //stmt = db
分布式服务框架 Zookeeper -- 管理分布式环境中的数据矮蛋蛋 zookeeper
原文地址： http://www.ibm.com/developerworks/cn/opensource/os-cn-zookeeper/ 安装和配置详解本文介绍的 Zookeeper 是以 3.2.2 这个稳定版本为基础，最新的版本可以通过官网 http://hadoop.apache.org/zookeeper/来获取，Zookeeper 的安装非常简单，下面将从单机模式和集群模式两
tomcat数据源 alafqq tomcat
数据库 JNDI(Java Naming and Directory Interface，Java命名和目录接口)是一组在Java应用中访问命名和目录服务的API。没有使用JNDI时我用要这样连接数据库： 03. Class.forName("com.mysql.jdbc.Driver"); 04. conn
遍历的方法百合不是茶遍历
遍历在java的泛
linux查看硬件信息的命令 bijian1013 linux
linux查看硬件信息的命令一.查看CPU： cat /proc/cpuinfo 二.查看内存： free 三.查看硬盘： df linux下查看硬件信息 1、lspci 列出所有PCI 设备； lspci - list all PCI devices:列出机器中的PCI设备（声卡、显卡、Modem、网卡、USB、主板集成设备也能
java常见的ClassNotFoundException bijian1013 java
1.java.lang.ClassNotFoundException: org.apache.commons.logging.LogFactory 添加包common-logging.jar2.java.lang.ClassNotFoundException: javax.transaction.Synchronization
【Gson五】日期对象的序列化和反序列化 bit1129 反序列化
对日期类型的数据进行序列化和反序列化时，需要考虑如下问题： 1. 序列化时，Date对象序列化的字符串日期格式如何 2. 反序列化时，把日期字符串序列化为Date对象，也需要考虑日期格式问题 3. Date A -> str -> Date B,A和B对象是否equals 默认序列化和反序列化 import com
【Spark八十六】Spark Streaming之DStream vs. InputDStream bit1129 Stream
1. DStream的类说明文档： /** * A Discretized Stream (DStream), the basic abstraction in Spark Streaming, is a continuous * sequence of RDDs (of the same type) representing a continuous st
通过nginx获取header信息 ronin47 nginx header
1. 提取整个的Cookies内容到一个变量，然后可以在需要时引用，比如记录到日志里面， if ( $http_cookie ~* "(.*)$") { set $all_cookie $1; } 变量$all_cookie就获得了cookie的值，可以用于运算了
java-65.输入数字n，按顺序输出从1最大的n位10进制数。比如输入3，则输出1、2、3一直到最大的3位数即999 bylijinnan java
参考了网上的http://blog.csdn.net/peasking_dd/article/details/6342984 写了个java版的： public class Print_1_To_NDigit { /** * Q65.输入数字n，按顺序输出从1最大的n位10进制数。比如输入3，则输出1、2、3一直到最大的3位数即999 * 1.使用字符串
Netty源码学习-ReplayingDecoder bylijinnan java netty
ReplayingDecoder是FrameDecoder的子类，不熟悉FrameDecoder的，可以先看看 http://bylijinnan.iteye.com/blog/1982618 API说，ReplayingDecoder简化了操作，比如： FrameDecoder在decode时，需要判断数据是否接收完全： public class IntegerH
js特殊字符过滤 cngolon js特殊字符 js特殊字符过滤
1.js中用正则表达式过滤特殊字符, 校验所有输入域是否含有特殊符号function stripscript(s) { var pattern = new RegExp("[`~!@#$^&*()=|{}':;',\\[\\].<>/?~！@#￥……&*（）——|{}【】‘；：”“'。，、？]"
hibernate使用sql查询 ctrain Hibernate
import java.util.Iterator; import java.util.List; import java.util.Map; import org.hibernate.Hibernate; import org.hibernate.SQLQuery; import org.hibernate.Session; import org.hibernate.Transa
linux shell脚本中切换用户执行命令方法 daizj linux shell 命令切换用户
经常在写shell脚本时，会碰到要以另外一个用户来执行相关命令，其方法简单记下： 1、执行单个命令：su - user -c "command" 如：下面命令是以test用户在/data目录下创建test123目录 [root@slave19 /data]# su - test -c "mkdir /data/test123"
好的代码里只要一个 return 语句 dcj3sjt126com return
别再这样写了：public boolean foo() { if (true) { return true; } else { return false;
Android动画效果学习 dcj3sjt126com android
1、透明动画效果方法一：代码实现 public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { View rootView = inflater.inflate(R.layout.fragment_main, container, fals
linux复习笔记之bash shell (4)管道命令 eksliang linux管道命令汇总 linux管道命令 linux常用管道命令
转载请出自出处： http://eksliang.iteye.com/blog/2105461 bash命令执行的完毕以后，通常这个命令都会有返回结果，怎么对这个返回的结果做一些操作呢？那就得用管道命令‘|’。上面那段话，简单说了下管道命令的作用，那什么事管道命令呢？答：非常的经典的一句话，记住了，何为管
Android系统中自定义按键的短按、双击、长按事件 gqdy365 android
在项目中碰到这样的问题：由于系统中的按键在底层做了重新定义或者新增了按键，此时需要在APP层对按键事件（keyevent）做分解处理，模拟Android系统做法，把keyevent分解成： 1、单击事件：就是普通key的单击； 2、双击事件：500ms内同一按键单击两次； 3、长按事件：同一按键长按超过1000ms（系统中长按事件为500ms）； 4、组合按键：两个以上按键同时按住；
asp.net获取站点根目录下子目录的名称 hvt .net C#asp.net hovertree Web Forms
使用Visual Studio建立一个.aspx文件(Web Forms)，例如hovertree.aspx,在页面上加入一个ListBox代码如下： <asp:ListBox runat="server" ID="lbKeleyiFolder" /> 那么在页面上显示根目录子文件夹的代码如下： string[] m_sub
Eclipse程序员要掌握的常用快捷键 justjavac java eclipse 快捷键 ide
判断一个人的编程水平，就看他用键盘多，还是鼠标多。用键盘一是为了输入代码（当然了，也包括注释），再有就是熟练使用快捷键。曾有人在豆瓣评《卓有成效的程序员》：“人有多大懒，才有多大闲”。之前我整理了一个程序员图书列表，目的也就是通过读书，让程序员变懒。写道程序员作为特殊的群体，有的人可以这么懒，懒到事情都交给机器去做，而有的人又可
c++编程随记 lx.asymmetric C++笔记
为了字体更好看，改变了格式…… &&运算符： #include<iostream> using namespace std; int main(){ int a=-1,b=4,k; k=(++a<0)&&!(b--
linux标准IO缓冲机制研究音频数据 linux
一、什么是缓存I/O(Buffered I/O)缓存I/O又被称作标准I/O,大多数文件系统默认I/O操作都是缓存I/O。在Linux的缓存I/O机制中，操作系统会将I/O的数据缓存在文件系统的页缓存(page cache)中，也就是说，数据会先被拷贝到操作系统内核的缓冲区中，然后才会从操作系统内核的缓冲区拷贝到应用程序的地址空间。1.缓存I/O有以下优点:A.缓存I/O使用了操作系统内核缓冲区，
随想生活暗黑小菠萝生活
其实账户之前就申请了，但是决定要自己更新一些东西看也是最近。从毕业到现在已经一年了。没有进步是假的，但是有多大的进步可能只有我自己知道。毕业的时候班里12个女生，真正最后做到软件开发的只要两个包括我，PS：我不是说测试不好。当时因为考研完全放弃找工作，考研失败，我想这只是我的借口。那个时候才想到为什么大学的时候不能好好的学习技术，增强自己的实战能力，以至于后来找工作比较费劲。我
我认为POJO是一个错误的概念 windshome java POJO 编程 J2EE 设计
这篇内容其实没有经过太多的深思熟虑，只是个人一时的感觉。从个人风格上来讲，我倾向简单质朴的设计开发理念；从方法论上，我更加倾向自顶向下的设计；从做事情的目标上来看，我追求质量优先，更愿意使用较为保守和稳妥的理念和方法。 &