ZooKeeper学习总结【概念，安装配置，命令操作，JAVA API操作，集群搭建，案例所写代码】

已于 2022-09-16 15:51:18 修改
阅读量2.1k 收藏 4
点赞数 1
分类专栏： JAVA 文章标签： java zookeeper 注册中心
于 2022-04-05 00:50:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53041251/article/details/123963602
版权

目录

1、ZooKeeper概念

2、安装与配置

3、Zookerper命令操作

3.1 Zookeeper 数据模型

3.2 Zookeeper服务端常用命令

3.3 Zookeeper客户端常用命令

4、ZooKeeper JavaAPI操作

4.1 Curator 介绍

4.2 Curator API 常用操作

4.2.1 建立连接

4.2.2 添加节点

4.2.3 查询节点

4.2.4 修改节点

4.2.5 删除节点

4.2.6 Watch事件监听

4.3 分布式锁

4.3.1 Zookeeper分布式锁原理

4.4 模拟12306 售票案例

5、ZooKeeper集群搭建

6、代码仓库地址

1、ZooKeeper概念

Zookeeper 是 Apache Hadoop 项目下的一个子项目，是一个树形目录服务。

Zookeeper 翻译过来就是 动物园管理员，他是用来管 Hadoop（大象）、Hive(蜜蜂)、Pig(小 猪)的管理员。简称zk。

Zookeeper 是一个分布式的、开源的分布式应用程序的协调服务。简单点说就是它是来管理分布式应用程序的，它自己不做事情，它是来管人的。

Zookeeper 提供的主要功能包括：

1、配置管理：ZooKeeper提供了一个配置中心，用于管理配置。

2、分布式锁：提供了一个分布式锁中心，谁要访问就去中心取锁。

3、集群管理：注册中心

2、安装与配置

Linux版ZooKeeper安装_一切总会归于平淡的博客-CSDN博客

3、Zookerper命令操作

3.1 Zookeeper 数据模型

  1. ZooKeeper 是一个树形目录服务,其数据模型和Unix的文件系统目录树很类似，拥有一个层次化结构。

  2. 这里面的每一个节点都被称为： ZNode，每个节点上都会保存自己的数据和节点信息。

  3. 节点可以拥有子节点，同时也允许少量（1MB）数据存储在该节点之下。

  4. 节点可以分为四大类：

  • PERSISTENT 持久化节点

  • EPHEMERAL 临时节点 ：-e

  • PERSISTENT_SEQUENTIAL 持久化顺序节点 ：-s

  • EPHEMERAL_SEQUENTIAL 临时顺序节点 ：-es

3.2 Zookeeper服务端常用命令

启动 ZooKeeper 服务

 ./zkServer.sh  start

查看 ZooKeeper 服务状态

./zkServer.sh status

停止 ZooKeeper 服务

./zkServer.sh stop

重启 ZooKeeper 服务

./zkServer.sh restart

3.3 Zookeeper客户端常用命令

连接ZooKeeper服务端

#./zkCli.sh –server ip:port
./zkCli.sh -server localhost:2181

 断开连接

quit

显示指定目录下节点

ls 目录

 创建节点

create /节点path value

 获取节点值

get /节点path

 设置节点值

set /节点path value

 删除单个节点

delete /节点path

 删除带有子节点的节点

deleteall /节点path

查看命令帮助

help

创建临时节点

create -e /节点path value

 创建顺序节点

create -s /节点path value

创建临时顺序节点

create -es /节点path value

ls2 /

 查询节点详细信息

ls –s /节点path

 

4、ZooKeeper JavaAPI操作

4.1 Curator 介绍

Curator 是 Apache ZooKeeper 的Java客户端库。

其实Curator 是一个 外来者，其实ZooKeeper 提供了很多Java客户端。

常见的ZooKeeper Java API ：

  1. 原生Java API

  2. ZkClient

  3. Curator

Curator 项目的目标是简化 ZooKeeper 客户端的使用。 Curator 最初是 Netfix 研发的,后来捐献了 Apache 基金会,目前是 Apache 的顶级项目。 官网：Apache Curator –

4.2 Curator API 常用操作

4.2.1 建立连接

/**
     * @description:建立连接
     * @author: jie
     * @time: 2022/4/3 23:02
     */
    @Test
    void testConnect() {
        /**
         *  第一个参数 : 连接字符串
         *  第二个参数 : 会话超时时间
         *  第三个参数 : 连接超时时间
         *  第四个参数 : 重试策略
         *
         */
        //重试策略 参数： 每次休眠的时间，最大的重试次数
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(3000, 10);
        //1、第一种连接方式
//        CuratorFramework client = CuratorFrameworkFactory.newClient("192.168.58.150:2181",
//                60 * 1000, 15 * 1000, retryPolicy);
//        //2、开启连接
//        client.start();
        //第二种方式 CuratorFrameworkFactory.builder();
        CuratorFramework client = CuratorFrameworkFactory.builder()
                .connectString("192.168.58.150:2181")
                .sessionTimeoutMs(60 * 1000)
                .connectionTimeoutMs(15 * 1000)
                .retryPolicy(retryPolicy).namespace("jie").build();
        //2、开启连接
        client.start();
    }

4.2.2 添加节点

1、创建节点

 /**
     * @description:创建节点 ：节点类型 持久  临时 顺序 数据
     * @author: jie
     * @time: 2022/4/4 11:35
     */
    @Test
    void testCreate() {
        try {
            //1.基本创建 注：如果创建节点，没有指定数据。则默认将当前客户端的IP作为数据存储
            client.create().forPath("/app1");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

2、创建节点 带数据

 @Test
    void testCreate2() {
        try {
            //1.创建节点 带有数据 注：如果创建节点，没有指定数据。则默认将当前客户端的IP作为数据存储
            client.create().forPath("/app2","求个关注".getBytes(StandardCharsets.UTF_8));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

 3、设置节点类型

@Test
    void testCreate3() {
        try {
            //设置节点的类型 默认类型：持久化 CreateMode.EPHEMERAL 临时节点，方法结束消失，因为只存在于一次会话
            client.create().withMode(CreateMode.EPHEMERAL).forPath("/app3 ","求个关注".getBytes(StandardCharsets.UTF_8));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

4、创建多级节点

 @Test
    void testCreate4() {
        try {
            //创建多级节点 creatingParentsIfNeeded():如果父节点不存在，就先创建父节点
            client.create().creatingParentsIfNeeded().forPath("/app4/p1 ","求个关注".getBytes(StandardCharsets.UTF_8));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

4.2.3 查询节点

1、查询数据

/**
     * @description:查询节点
     * @author: jie
     * @time: 2022/4/4 12:04
     */
    @Test
    void testGet() {
        try {
            //查询数据
            byte[] bytes = client.getData().forPath("/app2");
            System.out.println(new String(bytes));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

2、查询子节点

 @Test
    void testGet2() {
        try {
            //查询子节点
            List<String> list = client.getChildren().forPath("/app4");
            System.out.println(list);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

3、查询节点状态信息

 @Test
    void testGet3() {
        try {
            Stat status = new Stat();
            System.out.println(status);
            //查询节点的状态信息
            client.getData().storingStatIn(status).forPath("/app1");
            System.out.println(status);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

4.2.4 修改节点

1、修改数据

 /**
     * @description:修改数据
     * @author: jie
     * @time: 2022/4/4 12:20
     */
    @Test
    void testset() {
        try {
            client.setData().forPath("/app1","求个点赞".getBytes(StandardCharsets.UTF_8));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

2、根据版本修改

 @Test
    void testsetForVersion() {
        try {
            Stat status = new Stat();
            //查询节点的状态信息
            client.getData().storingStatIn(status).forPath("/app1");
            //version 是通过查询出来的，目的就是为了让其他客户端或者线程不干扰。
            int version = status.getVersion();
            System.out.println(version);
            //根据版本修改
            client.setData().withVersion(version).forPath("/app1","求个关注".getBytes(StandardCharsets.UTF_8));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

4.2.5 删除节点

1、删除单个节点

 /**
     * @description:删除节点
     * @author: jie
     * @time: 2022/4/4 12:30
     */
    @Test
    void testDelete() {
        //删除单个节点
        try {
            client.delete().forPath("/app1");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

2、删除带有子节点的节点

  @Test
    void testDelete2() {
        try {
            //删除带有子节点的节点
            client.delete().deletingChildrenIfNeeded().forPath("/app4");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

3、保证其删除成功

 @Test
    void testDelete3() {
        //保证其删除成功
        try {
            client.delete().guaranteed().forPath("/app2");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

4、回调

 @Test
    void testDelete4() {
        //回调
        try {
            client.delete().guaranteed().inBackground(new BackgroundCallback() {
                @Override
                public void processResult(CuratorFramework curatorFramework, CuratorEvent curatorEvent) throws Exception {
                    System.out.println("被删除了");
                    System.out.println(curatorEvent);
                }
            }).forPath("/app1");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

4.2.6 Watch事件监听

  1. ZooKeeper 允许用户在指定节点上注册一些Watcher，并且在一些特定事件触发的时候，ZooKeeper 服务端会将事件通知到感兴趣的客户端上去，该机制是 ZooKeeper 实现分布式协调服务的重要特性。

  2. ZooKeeper 中引入了Watcher机制来实现了发布/订阅功能能，能够让多个订阅者同时监听某一个对象，当一个对象自身状态变化时，会通知所有订阅者。

  3. ZooKeeper 原生支持通过注册Watcher来进行事件监听，但是其使用并不是特别方便需要开发人员自己反复注册Watcher，比较繁琐,我们不用。

  4. Curator引入了 Cache 来实现对 ZooKeeper 服务端事件的监听。

  5. ZooKeeper提供了三种Watcher：

5.1 NodeCache : 只是监听某一个特定的节点。 ​ 5.2 PathChildrenCache : 监控一个ZNode的子节点。 ​ 5.3 TreeCache : 可以监控整个树上的所有节点，类似于PathChildrenCache和NodeCache的组合。

代码演示：

1、NodeCathe：给指定一个节点注册监听器

  /**
     * @description:演示 NodeCathe:给指定一个节点注册监听器
     * @author: jie
     * @time: 2022/4/4 12:53
     */
    @Test
    void testNodeCathe() throws Exception {
        //1、创建NodeCath对象
        NodeCache nodeCache = new NodeCache(client,"/app1");
        //2、注册监听
        nodeCache.getListenable().addListener(new NodeCacheListener() {
            @Override
            public void nodeChanged() throws Exception {
                System.out.println("节点变化了~");
                //获取修改节点后的数据
                byte[] data = nodeCache.getCurrentData().getData();
                System.out.println("最新的数据："+new String(data));
            }
        });
        //3、开启监听 如果设置为True,则开启监听，加载缓冲数据
        nodeCache.start(true);
        while (true){

        }
    }

2、 PathChildrenCache:监听某个节点的所有子节点

 /**
     * @description:演示 PathChildrenCache:监听某个节点的所有子节点
     * @author: jie
     * @time: 2022/4/4 12:53
     */
    @Test
    void testPathChildrenCache() throws Exception {
        //创建监听对象 连接 地址 是否缓存
        PathChildrenCache pathChildrenCache = new PathChildrenCache(client,"/app2",true);
        //绑定监听器
         pathChildrenCache.getListenable().addListener(new PathChildrenCacheListener() {
             @Override
             public void childEvent(CuratorFramework curatorFramework, PathChildrenCacheEvent pathChildrenCacheEvent) throws Exception {
                 System.out.println("子节点变化了");
                 System.out.println(pathChildrenCacheEvent);
                 //监听子节点的 数据变更，并且拿到变更后的数据
                 //1、获取类型
                 PathChildrenCacheEvent.Type type = pathChildrenCacheEvent.getType();
                 //2、判断类型是否是update
                 if(type.equals((PathChildrenCacheEvent.Type.CHILD_UPDATED))){
                     System.out.println("数据变了！！！");
                     byte[] data = pathChildrenCacheEvent.getData().getData();
                     System.out.println(new String(data));
                 }
             }
         });
        //开启
        pathChildrenCache.start();
        while (true){
        }
    }

3、ThreeCathe():监听某个节点和所有子节点们

/**
     * @description:ThreeCathe():监听某个节点和所有子节点们
     * @author: jie
     * @time: 2022/4/4 13:33
     */
    @Test
    void testThreeCathe() throws Exception {
        //创建监听器
        TreeCache treeCache = new TreeCache(client,"/app2");

        //注册监听
        treeCache.getListenable().addListener(new TreeCacheListener() {
            @Override
            public void childEvent(CuratorFramework curatorFramework, TreeCacheEvent treeCacheEvent) throws Exception {
                System.out.println("节点变化了");
                System.out.println(treeCacheEvent);
            }
        });
        //开启
        treeCache.start();
        while (true){
        }
    }

4.3 分布式锁

在我们进行单机应用开发，涉及并发同步的时候，我们往往采用synchronized或者Lock的方式来解决多线程间的代码同步问题，这时多线程的运行都是在同一个JVM之下，没有任何问题。

但当我们的应用是分布式集群工作的情况下，属于多JVM下的工作环境，跨JVM之间已经无法通过多线程的锁解决同步问题。

那么就需要一种更加高级的锁机制，来处理种跨机器的进程之间的数据同步问题——这就是分布式锁。

 

4.3.1 Zookeeper分布式锁原理

核心思想：当客户端要获取锁，则创建节点，使用完锁，则删除该节点。

这里有三个客户端，它们都和ZooKeeper Server连接起来的，ZooKeeper Server里面现在又三个节点，现在client1如果想获取锁，那他就可以在/lock节点下创建一个节点，就代表获取锁了，用完了之后，释放资源，再把这个节点删除掉。

1、客户端获取锁时，在lock节点下创建临时顺序节点。

2、然后获取lock下面的所有子节点，客户端获取到所有的子节点之后，如果发现自己创 建的子节点序号最小，那么就认为该客户端获取到了锁。使用完锁后，将该节点删除。

3、如果发现自己创建的节点并非lock所有子节点中最小的，说明自己还没有获取到锁，此时客户端需要找到比自己小的那个节点，同时对其注册事件监听器，监听删除事件。

4、如果发现比自己小的那个节点被删除，则客户端的Watcher会收到相应通知，此时再次判断自己创建的节点是否是lock子节点中序号最小的，如果是则获取到了锁，如果不是则重复以上步骤继续获取到比自己小的一个节点并注册监听。

4.4 模拟12306 售票案例

在Curator中有五种实现分布式锁方案：

  1. InterProcessSemaphoreMutex：分布式排它锁（非可重入锁）

  2. InterProcessMutex：分布式可重入排它锁

  3. InterProcessReadWriteLock：分布式读写锁

  4. InterProcessMultiLock：将多个锁作为单个实体管理的容器

  5. InterProcessSemaphoreV2：共享信号量

接下来是代码演示，我这里为了方便，就不搞好几台机器了，就简单的模拟一下。

12306 实体类

package com.jie.curatorzk;

import org.apache.curator.RetryPolicy;
import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.framework.recipes.locks.InterProcessMutex;
import org.apache.curator.retry.ExponentialBackoffRetry;

import java.util.concurrent.TimeUnit;

public class Ticket12306 implements Runnable {

    private int tickets = 10;//数据库的票数

    private InterProcessMutex lock;

    public Ticket12306() {
        //重试策略 参数： 每次休眠的时间，最大的重试次数
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(3000, 10);
        CuratorFramework client = CuratorFrameworkFactory.builder()
                .connectString("192.168.58.150:2181")
                .sessionTimeoutMs(60 * 1000)
                .connectionTimeoutMs(15 * 1000)
                .retryPolicy(retryPolicy).build();
        //2、开启连接
        client.start();
        lock = new InterProcessMutex(client,"/lock");
    }

    @Override
    public void run() {
        while (true) {
            try {
                //获取锁 参数 时间 时间单位
                lock.acquire(3, TimeUnit.SECONDS);
                if (tickets > 0) {
                    System.out.println(Thread.currentThread() + ":" + tickets);
                    Thread.sleep(1000);
                    tickets--;
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                //释放锁
                try {
                    lock.release();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }

        }
    }
}

测试类

package com.jie.curatorzk;

import org.apache.curator.RetryPolicy;
import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.framework.recipes.cache.*;
import org.apache.curator.retry.ExponentialBackoffRetry;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class LoockTest {
    public static void main(String[] args) {
        Ticket12306 ticket12306 = new Ticket12306();
        //创建客户端
        Thread t1 = new Thread(ticket12306,"携程");
        Thread t2 = new Thread(ticket12306,"飞猪");

        t1.start();
        t2.start();
    }
}

代码实现还是比较简单的，主要是要知道原理。

5、ZooKeeper集群搭建

 

这里有这么多台机器，那么多台机器，那么到底谁说得算呢？那么ZooKeeper搭建集群第一步，就是要从这么多台机器中选举出一台领导者。

Leader选举：

  1. Serverid：服务器ID， 比如有三台服务器，编号分别是1,2,3；编号越大在选择算法中的权重越大。

  2. Zxid：数据ID；服务器中存放的最大数据ID.值越大说明数据 越新，在选举算法中数据越新权重越大。

在Leader选举的过程中，如果某台ZooKeeper获得了超过半数的选票， 则此ZooKeeper就可以成为Leader了。

搭建教程：

ZooKeeper集群搭建_一切总会归于平淡的博客-CSDN博客

ZooKeeper集群角色介绍

在ZooKeeper集群服中务中有三个角色： Leader 领导者 ：

1.处理事务请求 2 .集群内部各服务器的调度者

Follower 跟随者 ：

1.处理客户端非事务请求，转发事务请求给Leader服务器 ​ 2 .参与Leader选举投票

Observer 观察者：

处理客户端非事务请求，转发事务请求给Leader服务器

6、代码仓库地址

ZooKeeper学习: ZooKeeper学习代码

叫我阿杰好了
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
springboot整合dubbo+zookeeper案例
12-08
Apache ZooKeeper是一个分布式的，开放源码的分布式应用程序协调服务，它是集群的管理者，监视着集群中各个节点的状态根据节点提交的反馈进行下一步合理操作。最终将简单易用的接口和性能高效、功能稳定的系统提供...
dubbo+zookeeper 视频演示案例
08-07
Zookeeper 通过维护一个层次化的命名空间来存储数据，并允许客户端通过简单的 API 对这些数据进行读写操作。 #### 三、Dubbo与Zookeeper的集成 在分布式系统中，服务的自动注册与发现是非常关键的功能之一。Dubbo ...
dubbo+zookeeper案例
12-13
首先，我们需要在本地搭建Zookeeper环境，下载安装并启动Zookeeper服务器。接着，配置Dubbo项目的Zookeeper地址，以便服务能够正确地注册和查找。 在"Dubbo案例"中，"dubbo-parent"可能代表了一个Maven多模块项目，...
solrcloud 高可用集群搭建
03-19
SolrCloud高可用集群搭建是实现大规模、分布式搜索引擎的关键步骤，它通过集成Zookeeper来管理和协调各个Solr节点，确保数据的一致性和可用性。在搭建过程中，我们需要遵循一定的步骤和配置，以下是一些关键的知识点...
java面试总结
04-04
### Java面试总结——技术栈与项目经验解析 #### 一、自我介绍中的技术要点解析 在自我介绍中，提到了多种技术栈与项目背景，这些是面试官关注的重点。接下来，我们将逐一分析这些技术点。 ##### 1. 技术栈 - **...
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
qq_43700885的博客
07-29 571
1.导入hutool的maven依赖。2.复制一下代码执行。
深入理解Java注解
weixin_55745942的博客
08-01 505
Java注解是用来描述程序元素（如类、方法、变量等）的一种机制。它们可以提供关于程序的补充信息，帮助编译器、框架或其他工具更好地理解和处理代码。注解通常以符号开头，后跟注解名称和可能的参数。要创建自定义注解，需要使用@interface关键字定义一个接口，并在接口中声明注解的属性。这个注解名为，可以被用来标记方法。它有一个名为value的属性，具有默认值"default"。
社区养老服务小程序的设计
Karen198的博客
07-31 478
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 339
1.导入hutool的maven依赖。2.直接复制一下代码运行。
26.jdk源码阅读之ConcurrentLinkedQueue
前端、移动端、后端源码级底层原理分享
07-29 955
ConcurrentLinkedQueue 是 Java 中提供的一个基于无界非阻塞算法的线程安全队列。它是一个适用于高并发环境的队列实现，基于链表结构。
string类的模拟实现(C++)
最新发布
2302_80190394的博客
08-02 633
C++ string的功能函数实现
SpringMVC02
2301_78875117的博客
08-02 637
参数异常/** 自定义异常：参数异常*/private String msg="参数异常";super("参数异常！");super(msg);super("参数异常！");super(msg);return msg;业务异常private String msg="业务异常";super("业务异常！");super(msg);super("业务异常！");super(msg);return msg;
Java并发（十一）一文搞懂Java并发各种容器
m0_58466443的博客
07-29 838
同步容器将所有对容器状态的访问都串行化，以保证线程安全性，这种策略会严重降低并发性。Java 1.5 后提供了多种并发容器，使用并发容器来替代同步容器，可以极大地提高伸缩性并降低风险。并发容器对应的普通容器描述HashMapJava 1.8 之前采用分段锁机制细化锁粒度，降低阻塞，从而提高并发性；Java 1.8 之后基于 CAS 实现。SortedMap基于跳表实现的ArrayListSet基于实现。SortedSet基于实现。Queue线程安全的无界队列。底层采用单链表。支持 FIFO。
javaweb_03：在ide中配置tomcat
qq_52200849的博客
08-01 112
④创建artifact。②点击加号创建，选择。
java中static关键字的作用
weixin_41020960的博客
08-01 502
这意味着这个变量被类的所有实例共享，而不是每个实例拥有自己的副本。类变量可以通过类名直接访问，而不需要创建类的实例。关键字是 Java 中一个非常重要的特性，它允许开发者在不创建对象的情况下访问类的方法和变量，这在很多场景下非常有用。这类方法可以在没有创建类的实例的情况下被调用，它们只能访问类的静态变量和静态方法。关键字也可以用于静态初始化块，这是一段在类加载时执行的代码块，用于初始化静态变量。: 静态变量是不变的，一旦在静态初始化块或静态方法中被初始化，它们的值就不能被修改。关键字可以声明静态内部类。
spring原理（自学第六天）
GD2604279407的博客
08-02 384
今天将会学到Aware 接口及 InitializingBean 接口我们可以先了解他们的作用：1. Aware 接口用于注入一些与容器相关信息, 例如a. BeanNameAware 注入 bean 的名字b. BeanFactoryAware 注入 BeanFactory 容器c. ApplicationContextAware 注入 ApplicationContext 容器2. InitializingBean 接口提供了一种【内置】的初始化手段。
day12 Java基础——自增自减运算符，初识Math类
Qhumaing的博客
07-30 298
int b = a++;//执行完这行代码后，先给b复制，再自增1
高级java每日一道面试题-2024年7月31日-并发篇-你对ThreadLocal了解多少?
qq_43071699的博客
07-31 905
是Java中提供的一个类，用于实现线程局部变量。它允许每个线程访问自己的独立变量副本，而不会影响到其他线程中的变量。为每个使用该变量的线程提供了独立的变量实例，因此，即使是多个线程同时访问同一个变量，它们也是访问自己线程内部的那个副本，从而实现了线程间的数据隔离,干扰和同步开销。
Spring框架中的@AliasFor注解
一起coding，一起嗨。
08-01 235
Spring框架中的@AliasFor注解
学习Zookeeper搭建、原理及Java客户端操作
本文将重点介绍Zookeeper的搭建和原理学习，以及Java客户端的操作。 Zookeeper的搭建相对简单，首先需要解压Zookeeper的安装包，然后配置环境变量，启动Zookeeper服务。在解压完成后，需要配置环境变量以便系统能够...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

叫我阿杰好了

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值