static存在的主要意义【Java基础题】

28岁青春痘老男孩

于 2024-03-05 07:22:10 发布

阅读量835

点赞数 21

文章标签： java

本文链接：https://blog.csdn.net/stan_ko/article/details/136451827

版权

1.认识static

首先，static是一个关键字。可用于变量、方法、代码块和嵌套类。

作用：

(1).创建独立于具体对象的变量或者方法

不需要创建对象，就能直接使用属于类的静态属性和静态方法。(当你使用类的静态属性或静态方法时，属于首次主动使用该类，JVM就会把该类加载到运行时内存中，不需要去创建对象)

静态变量和静态方法，都属于类，不属于某个实例。（且所有该类的实例共享同一个静态变量，任何实例对静态变量的修改都会被其他实例看到。无论类实例化多少次，类只拥有静态变量的一份副本。--->涉及到数据的安全性问题）

（静态方法可以访问类中的静态变量和其他静态方法。静态方法不能直接访问类的实例变量和方法，因为它们在没有类的实例的情况下被调用。）

(2).形成静态代码块以优化程序性能

static块可以置于类中的任何地方，类中可以有多个static块。在类初次被加载的时候，会按照static块的顺序来执行每个static块，并且只会执行一次。为什么说static块可以用来优化程序性能，是因为它的特性:只会在类加载的时候执行一次。因此，很多时候会将一些只需要进行一次的初始化操作都放在static代码块中进行，比如加载驱动器或其他配置。

2.项目中使用的场景

（1）.静态变量

public class RedisManagerImpl implements RedisManager {

    @Autowired
    private DaoSupport daoSupport;

    @Autowired
    private List<IRedisBuilder> redisBuilder;

    private static Logger logger = LoggerFactory.getLogger(StringRedisTemplateBuilder.class);

    /**
     * 构建锁
     */
    private static final Lock LOCK = new ReentrantLock();

    //其他代码忽略
    @Override
    public StringRedisTemplate getConnection(Redis redis) {

        RedisConnectionConfig config = getRedisConnectionConfig(redis);

        StringRedisTemplate redisTemplate = null;

        JedisSetting.loadPoolConfig(config);

        while (true) {
            try {
                LOCK.tryLock(10, TimeUnit.MILLISECONDS);
                if (redisTemplate == null) {

                    IRedisBuilder redisBuilder = this.getRedisBuilder(config.getType());
                    LettuceConnectionFactory lettuceConnectionFactory = (LettuceConnectionFactory) redisBuilder.buildConnectionFactory( config);
                    // 初始化连接pool
                    lettuceConnectionFactory.afterPropertiesSet();
                    redisTemplate = new StringRedisTemplate();
                    redisTemplate.setConnectionFactory(lettuceConnectionFactory);
                    redisTemplate.afterPropertiesSet();
                    return redisTemplate;
                }
            } catch (Exception e) {
                // 容错
                logger.error(e.getMessage(), e);
                break;
            } finally {
                LOCK.unlock();
            }
            try {
                // 活锁
                TimeUnit.MILLISECONDS.sleep(200 + new Random().nextInt(1000));
            } catch (InterruptedException e) {
                logger.error(e.getMessage(), e);
            }
        }
        return redisTemplate;
    }

}

这是一个对Redis实例管理（针对的是）的实现类，对RedisManager接口定义的一系列Redis实例管理操作的方法进行了实现。这里定义了两个static类，一个是 Logger logger（记录类的行为，而不是记录单个实例的行为），另一个是 Lock LOCK（这里用到了ReentrantLock锁【该知识点需扩展】）。

Logger logger: 日志记录器通常被声明为static，因为它们是与类相关联而非与类的某个实例相关联的。日志记录器的目的是记录一个类的行为，而不是记录特定实例的状态。因此，无论创建多少个RedisManagerImpl的实例，它们都会共享同一个logger实例，这有助于减少内存消耗并避免为每个类实例创建额外的日志记录器实例。这也意味着logger可以在类的静态方法中使用，而不需要访问类的实例。

Lock LOCK: LOCK被声明为static以确保在RedisManagerImpl类的所有实例之间共享同一个锁。这是重要的，因为如果每个实例有自己的锁，那么同步控制将会失效，因为不同实例之间的锁不会相互影响。在这个场景中，使用静态锁可以确保无论是哪个实例调用getConnection方法，都能正确地通过LOCK实现线程安全，以避免在创建StringRedisTemplate实例时可能出现的并发问题。这种方式确保了在任何给定时间点，只有一个线程可以进入那些需要排他访问资源的代码块。

（2）.静态方法

A.常见在工具类中出现：

//AES加密和解密工具类

public class SecureUtils {
    public static String aesEncrypt(String sSrc, String key) {
        SymmetricCrypto aes = new SymmetricCrypto(SymmetricAlgorithm.AES, key.getBytes());
        String res = aes.encryptBase64(sSrc);
        return res;
    }

    public static String aesDecrypt(String sSrc, String key) {
        SymmetricCrypto aes = new SymmetricCrypto(SymmetricAlgorithm.AES, key.getBytes());
        String res = aes.decryptStr(sSrc);
        return res;
    }
}

B. 枚举类的匹配方法：不依赖于枚举类型的任何特定实例，而是需要访问枚举类中定义的所有可能的实例。静态方法通过类本身调用，而不是通过类的某个特定对象实例调用。如果matchByValue方法不是static的，那么它就必须通过枚举的一个实例来调用，这在逻辑上是不合理的，因为你正在试图通过一个特定的枚举值来查找另一个枚举值。这不仅违反了直觉，而且在实际使用中也不便捷。你需要先创建或引用一个枚举实例，然后才能调用方法来查找可能是另一个完全不同的枚举实例。这样的设计降低了代码的可读性和易用性。

@Getter
@AllArgsConstructor
public enum DataImportTypeEnum {
    OFFLINE_SHOP_TARGET(1, "OFFLINE_SHOP_TARGET", "线下店铺目标"),
    BUSINESS_LINE_TARGET(2, "BUSINESS_LINE_TARGET", "业务线目标"),
    LIFECYCLE(3, "LIFECYCLE", "生命周期"),
    OFFLINE_TO_ONLINE(4, "OFFLINE_TO_ONLINE", "线下转线上"),
    ONLINE_SHOP_TARGET(5, "ONLINE_SHOP_TARGET", "线上店铺目标"),
    VIP_TIKTOK(6, "VIP_TIKTOK", "唯品会抖音销售"),

    DELAY_PRODUCT(7, "DELAY_PRODUCT", "延续款"),

    //    PRICE_TAG_IMPORT(8, "PRICE_TAG_IMPORT", "商品价格标签");
    PRODUCT_COST_IMPORT(8, "PRODUCT_COST_IMPORT", "成本导入"),
    VIP_IMG_IMPORT(9, "VIP_IMG_IMPORT", "唯品会图片导入");


    /**
     * 值
     */
    private Integer value;

    /**
     * 编码
     */
    private String code;
    /**
     * 名
     */
    private String name;

    public static final DataImportTypeEnum matchByValue(Integer value) {
        if (value == null) {
            return null;
        }
        for (DataImportTypeEnum clazzEnum : DataImportTypeEnum.values()) {
            if (value.equals(clazzEnum.value)) {
                return clazzEnum;
            }
        }
        return null;
    }

}

（3）.静态代码块

public class ComplainFlow {

    /**
     * 取消流程
     */
    private static List<OrderFlowNode> CANCEL_FLOW;

    /**
     * 正常流程
     */
    private static List<OrderFlowNode> NORMAL_FLOW;

    static{
        initFlow();
    }

    /**
     * 初始化
     */
    private static void initFlow() {

        //取消流程
        CANCEL_FLOW = new MyList()
                .addComplain(ComplainStatusEnum.NEW)
                .addComplain(ComplainStatusEnum.CANCEL)
                .getList();

        /**
         * 正常流程
         */
        NORMAL_FLOW = new MyList()
                .addComplain(ComplainStatusEnum.NEW)
                .addComplain(ComplainStatusEnum.WAIT_APPEAL)
                .addComplain(ComplainStatusEnum.COMMUNICATION)
                .addComplain(ComplainStatusEnum.WAIT_ARBITRATION)
                .addComplain(ComplainStatusEnum.COMPLETE)
                .getList();
    }

    /**
     * 获取取消流程
     * @return
     */
    public static List<OrderFlowNode> getCancelFlow(){

        return CANCEL_FLOW;
    }


    /**
     * 获取正常流程
     * @return
     */
    public static List<OrderFlowNode> getNormalFlow(){

        return NORMAL_FLOW;
    }


}

ComplainFlow类是一个用于定义和管理投诉流程的类。它利用静态初始化块来设置两种类型的流程——取消流程（CANCEL_FLOW）和正常流程（NORMAL_FLOW）。这些流程是通过静态方法initFlow初始化的（因为这些流程基本上固定的，也就不需要各种不同的实例，但是它又分为正常与不正常两种情况，一个枚举类是列举不完的），该方法构造了两个List<OrderFlowNode>类型的列表，每个列表代表一个流程中的节点序列。

利用到的地方：根据交易投诉的状态获取对应正常或非正常的流程图（用于控制前端的流程节点的展示）。

/**
     * 查询交易投诉的流程图
     * @param id 投诉id
     * @return 交易投诉流程图
     */
    @Override
    public List<OrderFlowNode> getComplainFlow(Long id) {

        OrderComplain model = this.getModel(id);
        // 交易投诉状态
        String status = model.getStatus();
        // 获取已撤销流程
        if (ComplainStatusEnum.CANCEL.name().equals(status)) {
            return ComplainFlow.getCancelFlow();
        }

        //获取交易投诉正常流程
        List<OrderFlowNode> flowList = ComplainFlow.getNormalFlow();

        //遍历流程，设置当前状态之前的流程为展示，之后的流程为灰色
        boolean isEnd = false;
        for (OrderFlowNode flow : flowList) {

            Integer showStatus = isEnd ? 0 : 1;
            flow.setShowStatus(showStatus);

            if (flow.getOrderStatus().equals(status)) {
                //当前状态往后的流程都是没走的，所以是灰色
                isEnd = true;
            }
        }

        return flowList;
    }

28岁青春痘老男孩

关注

21
点赞
踩
21

收藏

觉得还不错? 一键收藏
0
评论
static存在的主要意义【Java基础题】

这是一个对Redis实例管理（针对的是）的实现类，对RedisManager接口定义的一系列Redis实例管理操作的方法进行了实现。这是重要的，因为如果每个实例有自己的锁，那么同步控制将会失效，因为不同实例之间的锁不会相互影响。B. 枚举类的匹配方法：不依赖于枚举类型的任何特定实例，而是需要访问枚举类中定义的所有可能的实例。初始化的（因为这些流程基本上固定的，也就不需要各种不同的实例，但是它又分为正常与不正常两种情况，一个枚举类是列举不完的），该方法构造了两个。类是一个用于定义和管理投诉流程的类。
复制链接

扫一扫