AI 助理
备案控制台
开发者社区 云原生 文章 正文

2025 年 Java 从入门到精通学习笔记全新版

2025-06-20 186
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
服务治理 MSE Sentinel/OpenSergo，Agent数量 不受限
注册配置 MSE Nacos/ZooKeeper，182元/月
MSE Nacos/ZooKeeper 企业版试用，1600元额度，限量50份
简介： 《Java学习笔记：从入门到精通（2025更新版）》是一本全面覆盖Java开发核心技能的指南，适合零基础到高级开发者。内容包括Java基础（如开发环境配置、核心语法增强）、面向对象编程（密封类、接口增强）、进阶技术（虚拟线程、结构化并发、向量API）、实用类库与框架（HTTP客户端、Spring Boot）、微服务与云原生（容器化、Kubernetes）、响应式编程（Reactor、WebFlux）、函数式编程（Stream API）、测试技术（JUnit 5、Mockito）、数据持久化（JPA、R2DBC）以及实战项目（Todo应用）。

Java学习笔记：从入门到精通（2025更新版）

一、Java基础（2025版）

1.1 开发环境配置

JDK推荐使用LTS版本17或最新版本21，通过SDKMAN!进行多版本管理：

# 安装SDKMAN!
curl -s "https://get.sdkman.io" | bash
source "$HOME/.sdkman/bin/sdkman-init.sh"

# 安装并使用Java 21
sdk install java 21.0.1-tem
sdk use java 21.0.1-tem

IDE推荐使用IntelliJ IDEA 2025.1或VS Code（需安装Extension Pack for Java）。

1.2 核心语法增强

1.2.1 文本块（Java 15+）

String html = """
    <html>
        <body>
            <h1>Hello, Java 21!</h1>
        </body>
    </html>
""";

1.2.2 模式匹配（Java 17+）

// 传统写法
if (obj instanceof String) {
   
    String s = (String) obj;
    System.out.println(s.length());
}

// 模式匹配写法
if (obj instanceof String s) {
   
    System.out.println(s.length());
}

1.2.3 记录类（Java 16+）

// 传统类
class Point {
   
    private final int x;
    private final int y;

    public Point(int x, int y) {
   
        this.x = x;
        this.y = y;
    }

    // Getters, equals, hashCode, toString
}

// 记录类
record Point(int x, int y) {
   }

1.2.4 增强的switch（Java 14+）

int day = 3;
String result = switch (day) {
   
    case 1, 2, 3, 4, 5 -> "Weekday";
    case 6, 7 -> "Weekend";
    default -> throw new IllegalArgumentException("Invalid day: " + day);
};

二、面向对象编程（2025版）

2.1 密封类（Java 17+）

// 限制继承范围
public sealed interface Shape 
    permits Circle, Rectangle, Square {
   
    double area();
}

final class Circle implements Shape {
    ... }
final class Rectangle implements Shape {
    ... }
non-sealed class Square implements Shape {
    ... }

2.2 接口增强

// Java 8+ 默认方法
public interface MyInterface {
   
    default void defaultMethod() {
   
        System.out.println("Default implementation");
    }

    // Java 9+ 私有方法
    private void privateMethod() {
   
        System.out.println("Private implementation");
    }
}

三、Java进阶（2025版）

3.1 虚拟线程（Java 21+）

// 传统线程池写法
ExecutorService executor = Executors.newFixedThreadPool(200);
for (int i = 0; i < 1000; i++) {
   
    executor.submit(() -> {
   
        Thread.sleep(Duration.ofSeconds(1));
        return "Done";
    });
}

// 虚拟线程写法
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
   
    IntStream.range(0, 10000).forEach(i -> {
   
        executor.submit(() -> {
   
            Thread.sleep(Duration.ofSeconds(1));
            return "Done";
        });
    });
}

3.2 结构化并发（Java 21+）

// 并行执行多个任务
try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
   
    Future<String> task1 = scope.fork(() -> fetchUser());
    Future<Integer> task2 = scope.fork(() -> fetchOrderCount());

    scope.join();           // 等待所有任务完成
    scope.throwIfFailed();  // 处理失败的任务

    String user = task1.resultNow();
    int count = task2.resultNow();
}

3.3 向量API（Java 21+）

// 传统数组计算
float[] a = new float[1024];
float[] b = new float[1024];
float[] c = new float[1024];

for (int i = 0; i < a.length; i++) {
   
    c[i] = a[i] * b[i] + 42.0f;
}

// 向量API加速计算
VectorSpecies<Float> species = FloatVector.SPECIES_PREFERRED;
for (int i = 0; i < a.length; i += species.length()) {
   
    var m = species.indexInRange(i, a.length);
    var va = FloatVector.fromArray(species, a, i, m);
    var vb = FloatVector.fromArray(species, b, i, m);
    var vc = va.mul(vb).add(42.0f);
    vc.intoArray(c, i, m);
}

四、实用类库与框架（2025版）

4.1 HTTP客户端（Java 11+）

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;

public class HttpClientExample {
   
    public static void main(String[] args) throws Exception {
   
        HttpClient client = HttpClient.newBuilder()
            .version(HttpClient.Version.HTTP_2)
            .connectTimeout(Duration.ofSeconds(10))
            .build();

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.example.com/data"))
            .header("Content-Type", "application/json")
            .GET()
            .build();

        client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
            .thenApply(HttpResponse::body)
            .thenAccept(System.out::println)
            .join();
    }
}

4.2 项目构建（Maven vs Gradle）

Gradle Kotlin DSL示例

// build.gradle.kts
plugins {
    application
    kotlin("jvm") version "1.9.20"
}

repositories {
    mavenCentral()
}

dependencies {
    implementation("org.springframework.boot:spring-boot-starter-web:3.2.4")
    testImplementation("org.junit.jupiter:junit-jupiter:5.10.2")
}

application {
    mainClass.set("com.example.MainKt")
}

五、微服务与云原生（2025版）

5.1 Spring Boot 3.2+

// REST API示例
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class UserServiceApplication {
   

    public static void main(String[] args) {
   
        SpringApplication.run(UserServiceApplication.class, args);
    }

    @GetMapping("/users/{id}")
    public User getUser(@PathVariable Long id) {
   
        return new User(id, "John Doe", "john@example.com");
    }

    record User(Long id, String name, String email) {
   }
}

5.2 容器化与Kubernetes

# Dockerfile示例
FROM eclipse-temurin:21-jre-alpine
WORKDIR /app
COPY target/myapp.jar .
CMD ["java", "-jar", "myapp.jar"]

# Kubernetes部署示例
apiVersion: apps/v1
kind: Deployment
metadata:
  name: user-service
spec:
  replicas: 3
  selector:
    matchLabels:
      app: user-service
  template:
    metadata:
      labels:
        app: user-service
    spec:
      containers:
      - name: user-service
        image: myregistry/user-service:1.0.0
        ports:
        - containerPort: 8080
        resources:
          requests:
            memory: "512Mi"
            cpu: "250m"
          limits:
            memory: "1024Mi"
            cpu: "500m"

六、响应式编程（2025版）

6.1 Reactor框架

import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.time.Duration;

public class ReactiveExample {
   
    public static void main(String[] args) {
   
        // 创建数据流
        Flux<String> names = Flux.just("Alice", "Bob", "Charlie")
            .delayElements(Duration.ofMillis(500));

        // 转换与过滤
        Flux<String> filteredNames = names
            .filter(name -> name.length() > 4)
            .map(String::toUpperCase);

        // 订阅并消费
        filteredNames.subscribe(
            name -> System.out.println("Received: " + name),
            error -> System.err.println("Error: " + error),
            () -> System.out.println("Completed")
        );

        // 合并多个Mono
        Mono<String> mono1 = Mono.just("Hello");
        Mono<String> mono2 = Mono.just("World");

        Mono.zip(mono1, mono2)
            .map(tuple -> tuple.getT1() + " " + tuple.getT2())
            .subscribe(System.out::println);
    }
}

6.2 Spring WebFlux

// 响应式REST API
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

@RestController
public class ProductController {
   

    private final ProductService productService;

    public ProductController(ProductService productService) {
   
        this.productService = productService;
    }

    @GetMapping("/products")
    public Flux<Product> getAllProducts() {
   
        return productService.findAll();
    }

    @GetMapping("/products/{id}")
    public Mono<Product> getProductById(@PathVariable String id) {
   
        return productService.findById(id);
    }
}

七、函数式编程（2025版）

7.1 Stream API增强

import java.util.List;
import java.util.stream.Stream;

public class StreamExample {
   
    public static void main(String[] args) {
   
        List<String> words = List.of("hello", "world", "java", "stream");

        // 传统流操作
        words.stream()
            .filter(w -> w.length() > 4)
            .map(String::toUpperCase)
            .forEach(System.out::println);

        // 新的takeWhile/dropWhile方法
        Stream.of(1, 2, 3, 4, 5, 2, 1)
            .takeWhile(n -> n < 5)  // [1, 2, 3, 4]
            .forEach(System.out::print);

        Stream.of(1, 2, 3, 4, 5, 2, 1)
            .dropWhile(n -> n < 5)  // [5, 2, 1]
            .forEach(System.out::print);
    }
}

7.2 函数式接口与Lambda

// 自定义函数式接口
@FunctionalInterface
interface TriFunction<T, U, V, R> {
   
    R apply(T t, U u, V v);
}

// 使用示例
TriFunction<Integer, Integer, Integer, Integer> sum = (a, b, c) -> a + b + c;
int result = sum.apply(1, 2, 3); // 6

八、测试技术（2025版）

8.1 JUnit 5与Mockito

import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.*;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;

@ExtendWith(MockitoExtension.class)
public class UserServiceTest {
   

    @Mock
    private UserRepository userRepository;

    @InjectMocks
    private UserService userService;

    @Test
    public void testGetUserById() {
   
        // 模拟存储库行为
        when(userRepository.findById(1L))
            .thenReturn(new User(1L, "John Doe", "john@example.com"));

        // 执行测试
        User result = userService.getUserById(1L);

        // 验证结果
        assertNotNull(result);
        assertEquals("John Doe", result.getName());
        verify(userRepository, times(1)).findById(1L);
    }
}

8.2 测试容器

import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.DynamicPropertyRegistry;
import org.springframework.test.context.DynamicPropertySource;
import org.testcontainers.containers.PostgreSQLContainer;
import org.testcontainers.junit.jupiter.Container;
import org.testcontainers.junit.jupiter.Testcontainers;

@Testcontainers
@SpringBootTest
public class DatabaseIntegrationTest {
   

    @Container
    static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:15-alpine")
        .withDatabaseName("testdb")
        .withUsername("test")
        .withPassword("test");

    @DynamicPropertySource
    static void configureProperties(DynamicPropertyRegistry registry) {
   
        registry.add("spring.datasource.url", postgres::getJdbcUrl);
        registry.add("spring.datasource.username", postgres::getUsername);
        registry.add("spring.datasource.password", postgres::getPassword);
    }

    @Test
    void contextLoads() {
   
        // 测试数据库连接
    }
}

九、数据持久化（2025版）

9.1 Spring Data JPA 3.2+

// 实体类
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;

@Entity
public class Product {
   
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private double price;
    // getters/setters
}

// 仓库接口
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import java.util.List;

public interface ProductRepository extends JpaRepository<Product, Long> {
   
    List<Product> findByNameContaining(String name);

    @Query("SELECT p FROM Product p WHERE p.price > :minPrice")
    List<Product> findByPriceGreaterThan(double minPrice);
}

9.2 响应式数据访问（R2DBC）

// R2DBC响应式仓库
import org.springframework.data.repository.reactive.ReactiveCrudRepository;
import reactor.core.publisher.Flux;

public interface UserRepository extends ReactiveCrudRepository<User, Long> {
   
    Flux<User> findByLastName(String lastName);
}

// 使用示例
@Service
public class UserService {
   
    private final UserRepository userRepository;

    public UserService(UserRepository userRepository) {
   
        this.userRepository = userRepository;
    }

    public Flux<User> getUsersByLastName(String lastName) {
   
        return userRepository.findByLastName(lastName);
    }
}

十、实战项目：Todo应用（2025版）

10.1 项目架构

todo-app/
├── todo-backend/            # Spring Boot后端
│   ├── src/
│   │   ├── main/
│   │   │   ├── java/com/example/todo/
│   │   │   │   ├── controller/      # REST控制器
│   │   │   │   ├── service/         # 业务逻辑
│   │   │   │   ├── repository/      # 数据访问
│   │   │   │   ├── entity/          # 实体类
│   │   │   │   └── TodoApplication.java
│   │   │   └── resources/
│   │   │       ├── application.yml  # 配置文件
│   │   │       └── static/          # 静态资源
│   │   └── test/
│   │       └── java/com/example/todo/ # 测试类
│   └── pom.xml
└── todo-frontend/           # React前端
    ├── src/
    │   ├── components/      # React组件
    │   ├── services/        # API服务
    │   ├── App.jsx
    │   └── index.jsx
    └── package.json

10.2 后端核心代码

// Todo实体
@Entity
public class Todo {
   
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String title;
    private boolean completed;
    // getters/setters
}

// Todo控制器
@RestController
@RequestMapping("/api/todos")
public class TodoController {
   
    private final TodoService todoService;

    @GetMapping
    public List<Todo> getAllTodos() {
   
        return todoService.getAllTodos();
    }

    @PostMapping
    public Todo createTodo(@RequestBody Todo todo) {
   
        return todoService.createTodo(todo);
    }

    @PutMapping("/{id}")
    public Todo updateTodo(@PathVariable Long id, @RequestBody Todo todoDetails) {
   
        return todoService.updateTodo(id, todoDetails);
    }

    @DeleteMapping("/{id}")
    public ResponseEntity<?> deleteTodo(@PathVariable Long id) {
   
        todoService.deleteTodo(id);
        return ResponseEntity.ok().build();
    }
}

10.3 前端核心代码（React + Vite）

// TodoList组件
import React, { useState, useEffect } from 'react';
import axios from 'axios';

const TodoList = () => {
  const [todos, setTodos] = useState([]);
  const [newTodo, setNewTodo] = useState('');

  useEffect(() => {
    fetchTodos();
  }, []);

  const fetchTodos = async () => {
    const response = await axios.get('/api/todos');
    setTodos(response.data);
  };

  const handleCreateTodo = async () => {
    if (!newTodo.trim()) return;
    await axios.post('/api/todos', { title: newTodo, completed: false });
    setNewTodo('');
    fetchTodos();
  };

  const handleToggleComplete = async (id, completed) => {
    await axios.put(`/api/todos/${id}`, { completed });
    fetchTodos();
  };

  return (
    <div className="container mx-auto p-4">
      <h1 className="text-2xl font-bold mb-4">Todo List</h1>

      <div className="flex mb-4">
        <input
          type="text"
          value={newTodo}
          onChange={(e) => setNewTodo(e.target.value)}
          className="flex-1 p-2 border rounded-l-md"
          placeholder="Add new todo"
        />
        <button
          onClick={handleCreateTodo}
          className="bg-blue-500 hover:bg-blue-600 text-white px-4 py-2 rounded-r-md"
        >
          Add
        </button>
      </div>

      <ul className="space-y-2">
        {todos.map((todo) => (
          <li
            key={todo.id}
            className={`flex items-center p-2 ${
              todo.completed ? 'bg-gray-100 line-through' : 'bg-white'
            } rounded-md`}
          >
            <input
              type="checkbox"
              checked={todo.completed}
              onChange={() => handleToggleComplete(todo.id, !todo.completed)}
              className="mr-2"
            />
            <span>{todo.title}</span>
          </li>
        ))}
      </ul>
    </div>
  );
};

export default TodoList;

以上代码示例涵盖了Java 21的最新特性、现代开发工具链以及微服务架构，帮助你快速掌握Java开发的核心技能。建议通过实际项目练习来加深理解，例如构建一个完整的Web应用或微服务系统。

--
Java 入门，Java 精通，Java 学习笔记，2025Java,Java 编程，Java 核心技术，Java 开发，Java 零基础，Java 面向对象，Java 框架，SpringBoot,JavaWeb,Java 并发编程，JavaEE,Java 实战

--
代码获取方式
https://pan.quark.cn/s/14fcf913bae6

--

文章标签：
Java
容器
微服务
Spring
API
关键词：
Java入门
Java学习笔记
啦啦啦191
目录
相关文章
啦啦啦191
|
10天前
|
安全 Java 数据库连接
2025 年最新 Java 学习路线图含实操指南助你高效入门 Java 编程掌握核心技能
2025年最新Java学习路线图，涵盖基础环境搭建、核心特性（如密封类、虚拟线程）、模块化开发、响应式编程、主流框架（Spring Boot 3、Spring Security 6）、数据库操作（JPA + Hibernate 6）及微服务实战，助你掌握企业级开发技能。
啦啦啦191
116 3
啦啦啦191
|
3月前
|
IDE Java 数据挖掘
Java 基础类从入门到精通实操指南
这份指南专注于**Java 17+**的新特性和基础类库的现代化用法，涵盖开发环境配置、数据类型增强（如文本块）、字符串与集合处理进阶、异常改进（如密封类）、IO操作及实战案例。通过具体代码示例，如CSV数据分析工具，帮助开发者掌握高效编程技巧。同时提供性能优化建议和常用第三方库推荐，适合从入门到精通的Java学习者。资源链接：[点此下载](https://pan.quark.cn/s/14fcf913bae6)。
啦啦啦191
169 35
啦啦啦191
|
3月前
|
监控 Java 测试技术
2025 年 Java 核心技术从入门到精通实战指南
《2025年Java核心技术实战指南》全面覆盖Java开发的最新趋势与最佳实践。内容包括Java新特性（如模式匹配、文本块、记录类）、微服务架构（Spring Boot 3.0+、Spring Cloud）、响应式编程（Reactor、WebFlux）、容器化与云原生（Docker、Kubernetes）、数据访问技术（JPA、R2DBC）、函数式编程、单元测试与集成测试（JUnit 5、Mockito）、性能优化与监控等。通过实战案例，帮助开发者掌握构建高性能、高可用系统的技能。代码资源可从[链接](https://pan.quark.cn/s/14fcf913bae6)获取。
啦啦啦191
191 7
啦啦啦191
|
3月前
|
消息中间件 Java 微服务
2025 版 Java 学习路线实战指南从入门到精通
《Java学习路线实战指南（2025版）》是一份全面的Java开发学习手册，涵盖基础环境搭建、核心语法与新特性、数据结构与算法、微服务架构、云原生技术栈、AI融合及项目实战。内容包括JDK安装配置、IntelliJ IDEA设置、Records类与模式匹配增强、LeetCode题解、Spring Cloud微服务开发、Kubernetes部署、OpenAI API调用等。结合在线商城系统案例，采用Vue 3、Spring Boot 3.5、MySQL、Elasticsearch等技术，提供从理论到实践的完整路径，助力开发者掌握2025年最新趋势与最佳实践。
啦啦啦191
298 4
啦啦啦191
|
20天前
|
前端开发 Java 数据库
Java 项目实战从入门到精通 ：Java Web 在线商城项目开发指南
本文介绍了一个基于Java Web的在线商城项目，涵盖技术方案与应用实例。项目采用Spring、Spring MVC和MyBatis框架，结合MySQL数据库，实现商品展示、购物车、用户注册登录等核心功能。通过Spring Boot快速搭建项目结构，使用JPA进行数据持久化，并通过Thymeleaf模板展示页面。项目结构清晰，适合Java Web初学者学习与拓展。
啦啦啦191
135 1
啦啦啦191
|
13天前
|
算法 Java 测试技术
零基础学 Java： 从语法入门到企业级项目实战的详细学习路线解析
本文为零基础学习者提供完整的Java学习路线，涵盖语法基础、面向对象编程、数据结构与算法、多线程、JVM原理、Spring框架、Spring Boot及项目实战，助你从入门到进阶，系统掌握Java编程技能，提升实战开发能力。
啦啦啦191
58 0
啦啦啦191
|
2月前
|
存储 缓存 NoSQL
java 集合入门基础理论的核心概念与实用长尾知识
本文介绍了Java集合框架的基础理论知识，包括单列集合（List、Set、Queue）和双列集合（Map）的特点及常用实现类（如ArrayList、HashSet、HashMap等）。详细讲解了集合的遍历方式（迭代器、增强for循环、Lambda表达式）和典型应用场景（如数据去重、键值存储等）。通过具体代码示例，帮助初学者理解集合框架的核心概念和实际应用，为Java编程中的数据存储与管理提供基础指导。
啦啦啦191
68 0
啦啦啦191
|
2月前
|
缓存 NoSQL Java
Java Web 从入门到精通之苍穹外卖项目实战技巧
本项目为JavaWeb综合实战案例——苍穹外卖系统，涵盖Spring Boot 3、Spring Cloud Alibaba、Vue 3等主流技术栈，涉及用户认证、订单处理、Redis缓存、分布式事务、系统监控及Docker部署等核心功能，助你掌握企业级项目开发全流程。
啦啦啦191
219 0
啦啦啦191
|
2月前
|
存储 安全 Java
Java 学习路线 35 掌握 List 集合从入门到精通的 List 集合核心知识
本文详细解析Java中List集合的原理、常用实现类（如ArrayList、LinkedList）、核心方法及遍历方式，并结合数据去重、排序等实际应用场景，帮助开发者掌握List在不同业务场景下的高效使用，提升Java编程能力。
啦啦啦191
267 0
啦啦啦191
|
2月前
|
前端开发 Java API
基于 Spring Boot 3 与 React 的 Java 学生信息管理系统从入门到精通实操指南
本项目基于Spring Boot 3与React 18构建学生信息管理系统，涵盖前后端开发、容器化部署及测试监控，提供完整实操指南与源码，助你掌握Java全栈开发技能。
啦啦啦191
104 0

云原生

热门文章

最新文章

  • 1
    Docker CE 镜像源站
  • 2
    Minikube - Kubernetes本地实验环境
  • 3
    重塑云上的 Java 语言
  • 4
    微服务架构的理论基础 - 康威定律
  • 5
    微服务（Microservice）那点事
  • 6
    Docker的Windows容器初体验
  • 7
    3分钟，了解阿里云热门开发者工具 Cloud Toolkit
  • 8
    Docker学习路线图 (持续更新中)
  • 9
    利用Zipkin对Spring Cloud应用进行服务追踪分析
  • 10
    谈谈 Docker Volume 之权限管理（一）
  • 1
    【App Service】在Azure环境中如何查看App Service实例当前的网络连接情况呢？
    21
  • 2
    基于函数计算FC构建 Browser Tool Sandbox 详解与实操
    19
  • 3
    【Azure 环境】Microsoft Graph API实现对Entra ID中应用生成密码的时间天数
    31
  • 4
    FunctionAI 图像生成：简化从灵感到 API 调用的每一步
    44
  • 5
    JavaScript 的三种引入方法详解
    43
  • 6
    ComPE for win 纯净的PE系统
    37
  • 7
    让天下没有难查的故障：2025 阿里云 AI 原生编程挑战赛正式启动
    110
  • 8
    Linux Docker & Docker Compose 一键安装
    54
  • 9
    使用git bash ，出现Can‘t get terminal settings: The handle is invalid. 的解决方法与思路
    44
  • 10
    可视化生成RocketMQ配置工具
    73

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0
    • 下一篇
    OSS存储类型概述