亚洲在线久爱草,狠狠天天香蕉网,天天搞日日干久草,伊人亚洲日本欧美

為了賬號安全，請及時綁定郵箱和手機立即綁定

Spring Boot企業級開發入門教程

標簽：
SpringBoot
概述

Spring Boot企业级开发入门涵盖了从基础概念到环境搭建，再到项目创建与依赖管理的全过程。文章详细介绍了如何配置开发环境、创建第一个Spring Boot项目，并深入讲解了数据库连接、安全认证、Swagger集成等企业级特性。此外，还提供了实战项目实践和高级主题的探讨，帮助读者构建高质量的企业级应用。

Spring Boot企业级开发入门教程
Spring Boot基础概念与环境搭建

Spring Boot简介

Spring Boot 是由 Pivotal 团队提供的基于Spring框架的微框架。其主要目标是简化Spring应用的初始搭建以及配置过程。Spring Boot 设计初衷是为了解决 Spring 项目搭建、配置繁琐的问题，帮助开发者快速搭建独立的，生产级别的服务。Spring Boot 的核心功能包括自动配置、Starter 依赖管理、内置的运行时容器支持（如 Tomcat, Jetty, Undertow 等）、自动化的RESTful接口开发、数据访问（如 JPA, MyBatis, JdbcTemplate）等功能。

开发环境搭建

要开始使用 Spring Boot 进行开发，首先需要搭建好开发环境。最低需要以下工具：

  • Java JDK 8 或更高版本
  • Maven 或 Gradle 作为构建工具
  • 文本编辑器或 IDE

建议使用 Maven 或 Gradle 作为构建工具，以简化项目依赖管理。这里我们主要介绍 Maven 和 Gradle 的使用。

Maven 环境搭建

  1. 下载并安装 Maven。
  2. 配置 Maven 的环境变量。需要配置两个环境变量：
    • JAVA_HOME：指向你的 Java SDK 安装路径。
    • MAVEN_HOME：指向你的 Maven 安装路径。
  3. 将 Maven 的 bin 目录添加到系统的 PATH 变量中。

示例：检查 Maven 安装是否成功

可以通过在命令行中输入以下命令检查 Maven 是否安装成功：

mvn -v

如果输出 Maven 的版本信息，说明安装成功。

Gradle 环境搭建

  1. 下载并安装 Gradle。
  2. 配置 Gradle 的环境变量。需要配置两个环境变量：
    • JAVA_HOME：指向你的 Java SDK 安装路径。
      之后，将 Gradle 的 bin 目录添加到系统的 PATH 变量中。
  3. 示例：检查 Gradle 安装是否成功

可以通过在命令行中输入以下命令检查 Gradle 是否安装成功：

gradle -v

如果输出 Gradle 的版本信息，说明安装成功。

配置IDE（如IntelliJ IDEA、Eclipse）

推荐使用 IntelliJ IDEA 或 Eclipse 作为开发工具，因为它们都提供了对 Spring Boot 的良好支持。

IntelliJ IDEA 配置

  1. 下载并安装 IntelliJ IDEA。
  2. 打开 IntelliJ IDEA，选择 File -> New -> Project，在弹出的对话框中选择 Spring Initializr。
  3. 在 Project SDK 中选择你的 Java SDK 版本。
  4. 在 Project 选项卡中，选择项目名称和保存位置。
  5. 在 Module 选项卡中，选择 Java 模块类型。
  6. 接下来的对话框中，选择 Spring Boot，选择 Maven 作为构建工具。
  7. 在 Group 和 Artifact 中输入项目的基本信息。
  8. 在 Dependencies 中选择需要的依赖，例如 Spring Web，点击 Finish。

Eclipse 配置

  1. 下载并安装 Eclipse。
  2. 安装 Eclipse 插件，打开 Eclipse，进入 Help -> Eclipse Marketplace，搜索并安装 Spring Tools Suite。
  3. 打开 Eclipse，选择 File -> New -> Spring Starter Project。
  4. 输入项目的基本信息，选择需要的依赖，点击 Finish。

项目创建与依赖管理

使用 Spring Initializr 创建项目

Spring Initializr 是一个在线工具，帮助快速创建 Spring Boot 项目。

  1. 访问 Spring Initializr。
  2. 选择项目的基本信息，如 Project -> Maven Project，Language -> Java。
  3. 输入 Group 和 Artifact，选择 Java 版本。
  4. 选择需要的依赖，如 Spring Web。
  5. 点击 Generate，下载项目压缩包。
  6. 解压后，使用 IDE 打开项目。

Maven 依赖管理

在项目的 pom.xml 文件中声明需要的依赖。例如：

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

示例：创建一个简单的 Spring Boot 项目

  1. 使用 Spring Initializr 生成一个基本的 Spring Boot 项目。
  2. 在 src/main/java 目录下创建一个 Application 类，添加 @SpringBootApplication 注解：
package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}
  1. 在 src/main/resources 目录下的 application.properties 文件中添加一些配置：
spring.application.name=DemoApplication
  1. 运行应用，查看是否启动成功。
第一个Spring Boot应用

创建第一个Spring Boot项目

使用 Spring Initializr 创建一个简单的 Spring Boot 项目。按照之前的指南，生成一个基本的 Spring Boot 项目，并在 src/main/java 目录下创建一个 Application 类。

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

项目结构解析

Spring Boot 项目的标准目录结构如下：

  • src/main/java：存放 Java 类，通常包括 Application 类和业务逻辑。
  • src/main/resources：存放配置文件，如 application.properties 或 application.yml。
  • src/main/resources/static：存放静态资源文件，如 HTML、CSS、JavaScript 文件。
  • src/main/resources/templates：存放 Thymeleaf 模板文件。
  • src/main/resources/public：存放静态资源文件，如 HTML、CSS、JavaScript 文件。
  • src/test/java：存放测试类。
  • pom.xml：存放 Maven 配置信息。

使用注解与Spring Boot启动器

Spring Boot 使用注解来简化配置和开发流程。常用的注解包括：

  • @SpringBootApplication：组合注解，包含 @Configuration、@EnableAutoConfiguration 和 @ComponentScan。
  • @Configuration：表示该类中包含一个或多个 Bean 配置。
  • @EnableAutoConfiguration：启用 Spring Boot 的自动配置功能。
  • @ComponentScan：扫描指定包下的所有 Bean。

示例：定义一个简单的 REST API

  1. 在 src/main/java 目录下创建一个新的包 com.example.demo.controller。
  2. 创建一个 HelloController 类，使用 @RestController 和 @RequestMapping 注解：
package com.example.demo.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {
    @GetMapping("/hello")
    public String sayHello() {
        return "Hello, World!";
    }
}
  1. 重启项目，访问 http://localhost:8080/hello，查看是否返回 Hello, World!。

运行与打包项目

运行项目

使用 mvn spring-boot:run 命令运行项目，或通过 IDE 的运行功能启动项目。

打包项目

使用 mvn package 命令将项目打包成一个可执行的 JAR 文件。JAR 文件可以在任意位置运行：

mvn package

运行打包后的 JAR 文件：

java -jar target/demo-0.0.1-SNAPSHOT.jar
实战：CRUD操作

数据库连接与配置

使用 Spring Boot 连接数据库，需要以下步骤：

  1. 添加数据库驱动依赖。
  2. 配置数据库连接信息。
  3. 创建数据源和事务管理器。

示例：连接 MySQL 数据库

  1. 在 pom.xml 文件中添加 MySQL 驱动依赖：
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>
  1. 在 application.properties 文件中配置数据库连接信息：
spring.datasource.url=jdbc:mysql://localhost:3306/testdb
spring.datasource.username=root
spring.datasource.password=root

测试数据库连接

为了验证数据库连接是否成功，可以在 src/test/java 目录下创建一个简单的测试类，使用 Spring Boot 测试框架进行简单的数据库查询：

package com.example.demo;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.jdbc.core.JdbcTemplate;

import static org.junit.jupiter.api.Assertions.assertEquals;

@SpringBootTest
public class DatabaseConnectionTest {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Test
    public void testDatabaseConnection() {
        String result = jdbcTemplate.queryForObject("SELECT 'Hello, World!'", String.class);
        assertEquals("Hello, World!", result);
    }
}

使用Spring Data JPA进行数据操作

Spring Data JPA 是 Spring Data 的一部分，简化了与数据库的交互，支持 CRUD 操作。

示例：定义一个简单的实体类

  1. 创建一个 User 实体类：
package com.example.demo.entity;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private String email;

    // 构造函数、getter 和 setter 方法
}
  1. 创建一个 UserRepository 接口：
package com.example.demo.repository;

import com.example.demo.entity.User;
import org.springframework.data.jpa.repository.JpaRepository;

public interface UserRepository extends JpaRepository<User, Long> {
}

测试数据操作

为了验证 UserRepository 是否正确工作，可以在 src/test/java 目录下创建一个简单的测试类来插入和查询数据：

package com.example.demo;

import com.example.demo.entity.User;
import com.example.demo.repository.UserRepository;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.transaction.annotation.Transactional;

@SpringBootTest
public class UserRepositoryTest {

    @Autowired
    private UserRepository userRepository;

    @Test
    @Transactional
    public void testUserRepository() {
        User user = new User();
        user.setName("John Doe");
        user.setEmail("[email protected]");

        userRepository.save(user);

        User foundUser = userRepository.findById(user.getId()).orElse(null);
        assertEquals(user.getName(), foundUser.getName());
        assertEquals(user.getEmail(), foundUser.getEmail());
    }
}

创建CRUD接口

使用 Spring MVC 创建 CRUD 接口。

示例：定义一个 UserController 类

  1. 创建一个 UserController 类：
package com.example.demo.controller;

import com.example.demo.entity.User;
import com.example.demo.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/users")
public class UserController {
    @Autowired
    private UserRepository userRepository;

    @GetMapping
    public List<User> getAllUsers() {
        return userRepository.findAll();
    }

    @GetMapping("/{id}")
    public User getUserById(@PathVariable Long id) {
        return userRepository.findById(id).orElse(null);
    }

    @PostMapping
    public User createUser(@RequestBody User user) {
        return userRepository.save(user);
    }

    @PutMapping("/{id}")
    public User updateUser(@PathVariable Long id, @RequestBody User user) {
        return userRepository.save(user);
    }

    @DeleteMapping("/{id}")
    public void deleteUser(@PathVariable Long id) {
        userRepository.deleteById(id);
    }
}

测试API接口

使用 Postman 或其他 HTTP 客户端工具测试接口功能。

  1. 测试 GET /users：获取所有用户。
  2. 测试 GET /users/{id}：获取指定用户。
  3. 测试 POST /users：创建新用户。
  4. 测试 PUT /users/{id}：更新用户信息。
  5. 测试 DELETE /users/{id}：删除用户。
企业级特性实现

使用Spring Security进行安全认证

Spring Security 是一个强大的认证和授权框架。

示例：配置 Spring Security

  1. 添加 Spring Security 依赖：
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>
  1. 在 SecurityConfig 类中配置认证和授权：
package com.example.demo.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
                .antMatchers("/users").permitAll()
                .anyRequest().authenticated()
            .and()
                .httpBasic();
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

测试认证功能

为了验证 Spring Security 是否成功配置，可以在 src/test/java 目录下创建一个简单的测试类来模拟 HTTP 请求验证：

package com.example.demo;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors;
import org.springframework.security.test.web.servlet.response.SecurityMockMvcResultMatchers;
import org.springframework.test.web.servlet.MockMvc;

import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

@WebMvcTest
public class SecurityTest {

    @Autowired
    private MockMvc mockMvc;

    @Test
    public void testSecurity() throws Exception {
        mockMvc.perform(get("/users")
                .with(SecurityMockMvcRequestPostProcessors.httpBasic("user", "password")))
                .andExpect(status().isOk());
    }
}

集成Swagger进行API文档自动生成

Swagger 是一个强大的 API 文档生成工具。

示例：集成 Swagger

  1. 添加 Swagger 依赖：
<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-boot-starter</artifactId>
    <version>3.0.0</version>
</dependency>
  1. 配置 Swagger 设置：
package com.example.demo.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

@Configuration
@EnableSwagger2
public class SwaggerConfig {
    @Bean
    public Docket api() {
        return new Docket(DocumentationType.SWAGGER_2)
                .select()
                .apis(RequestHandlerSelectors.any())
                .paths(PathSelectors.any())
                .build();
    }
}

测试Swagger文档

为了验证 Swagger 是否成功集成并生成了 API 文档，可以通过浏览器访问 /swagger-ui.html 或使用 Swagger UI 测试工具来查看生成的 API 文档。

异常处理与日志记录

异常处理

自定义全局的异常处理机制，提高应用的健壮性。

示例：全局异常处理

  1. 创建一个 GlobalExceptionHandler 类：
package com.example.demo.exception;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

@RestControllerAdvice
public class GlobalExceptionHandler {
    @ExceptionHandler(value = Exception.class)
    public ResponseEntity<ExceptionResponse> handleException(Exception e) {
        ExceptionResponse response = new ExceptionResponse();
        response.setMessage(e.getMessage());
        return new ResponseEntity<>(response, HttpStatus.INTERNAL_SERVER_ERROR);
    }
}

class ExceptionResponse {
    private String message;

    // getter 和 setter 方法
}

日志记录

使用 SLF4J 和 Logback 进行日志记录。

示例：配置 Logback 日志

  1. 在 src/main/resources 目录下创建 logback-spring.xml 文件：
<configuration>
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss} %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>

    <root level="info">
        <appender-ref ref="STDOUT" />
    </root>
</configuration>
  1. 在 application.properties 文件中配置日志文件路径：
logging.config=classpath:logback-spring.xml
高级主题

配置Spring Boot的Profile

Spring Boot Profile 允许根据不同的环境（开发、测试、生产等）加载不同的配置。

示例：使用 Profile

  1. 在 application.properties 文件中定义 Profile 特定的配置：
# application.properties
spring.profiles.active=dev

# application-dev.properties
spring.datasource.url=jdbc:mysql://localhost:3306/devdb
  1. 在 pom.xml 文件中配置 Profile：
<profiles>
    <profile>
        <id>dev</id>
        <properties>
            <profile.active>dev</profile.active>
        </properties>
    </profile>
</profiles>

<build>
    <resources>
        <resource>
            <directory>src/main/resources</directory>
            <filtering>true</filtering>
        </resource>
    </resources>
</build>

测试Profile切换

为了验证 Profile 是否成功切换，可以在 src/test/java 目录下创建一个简单的测试类来读取配置文件中的不同 Profile 设置：

package com.example.demo;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class ProfileSwitchTest {

    @Value("${spring.datasource.url}")
    private String dataSourceUrl;

    @Test
    public void testProfileSwitch() {
        assertEquals("jdbc:mysql://localhost:3306/devdb", dataSourceUrl);
    }
}

实现分层架构

分层架构是一种常用的软件架构设计模式，将应用程序划分为多个层次，以实现模块化和可维护性。

  1. 根据功能将代码分解为不同的包。
  2. 使用服务层进行业务逻辑处理。
  3. 使用接口层处理网络请求。
  4. 使用持久层进行数据库交互。

示例：分层架构

  1. 创建 service 包，定义业务逻辑：
package com.example.demo.service;

import com.example.demo.entity.User;
import com.example.demo.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;

    public User createUser(User user) {
        return userRepository.save(user);
    }
}
  1. 在 controller 包中使用服务层：
package com.example.demo.controller;

import com.example.demo.entity.User;
import com.example.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/users")
public class UserController {
    @Autowired
    private UserService userService;

    @PostMapping
    public User createUser(@RequestBody User user) {
        return userService.createUser(user);
    }
}

测试分层架构

为了验证分层架构是否正确实现了业务逻辑，可以在 src/test/java 目录下创建一个简单的测试类来模拟服务层调用和数据库交互：

package com.example.demo;

import com.example.demo.entity.User;
import com.example.demo.service.UserService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class UserServiceTest {

    @Autowired
    private UserService userService;

    @Test
    public void testUserService() {
        User user = new User();
        user.setName("John Doe");
        user.setEmail("[email protected]");

        User savedUser = userService.createUser(user);
        assertEquals(user.getName(), savedUser.getName());
        assertEquals(user.getEmail(), savedUser.getEmail());
    }
}

使用Spring Boot Actuator监控应用

Spring Boot Actuator 提供了生产就绪的功能，如健康检查、审计、配置管理等。

示例：配置 Actuator

  1. 在 pom.xml 文件中添加 Actuator 依赖：
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
  1. 在 application.properties 文件中配置 Actuator 信息：
management.endpoints.web.exposure.include=*
management.endpoint.health.show-details=always
  1. 访问 /actuator 路径，查看 Actuator 提供的接口。
实战项目实践

构建一个简单的企业级应用

构建一个包含用户管理、商品管理、订单管理等功能的企业级应用。

示例：定义商品实体类

  1. 创建 Product 实体类：
package com.example.demo.entity;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Product {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private Double price;

    // 构造函数、getter 和 setter 方法
}
  1. 创建 ProductRepository 接口：
package com.example.demo.repository;

import com.example.demo.entity.Product;
import org.springframework.data.jpa.repository.JpaRepository;

public interface ProductRepository extends JpaRepository<Product, Long> {
}

示例：定义订单实体类

  1. 创建 Order 实体类：
package com.example.demo.entity;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import java.util.List;

@Entity
public class Order {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String customerName;
    private List<Product> products;

    // 构造函数、getter 和 setter 方法
}
  1. 创建 OrderRepository 接口：
package com.example.demo.repository;

import com.example.demo.entity.Order;
import org.springframework.data.jpa.repository.JpaRepository;

public interface OrderRepository extends JpaRepository<Order, Long> {
}

项目部署与运行

部署项目到生产环境，如 AWS、阿里云等。

  1. 将项目打包成 JAR 文件：
mvn package
  1. 部署到云服务器：
scp target/demo-0.0.1-SNAPSHOT.jar user@server:/path/to/deploy/
  1. 在云服务器上运行 JAR 文件：
java -jar demo-0.0.1-SNAPSHOT.jar

项目维护与更新

持续监控应用状态，根据需要进行更新。

  1. 使用监控工具如 Prometheus、Grafana 等监控应用状态。
  2. 使用 CI/CD 工具如 Jenkins、GitLab CI 等自动化部署。
  3. 定期检查应用代码，修复潜在的 Bug 和安全漏洞。

示例：使用 Jenkins 实现 CI/CD

  1. 安装 Jenkins。
  2. 配置 Jenkins 插件，如 Git、Maven。
  3. 创建 Jenkins 任务，配置源码管理（如 Git）、构建触发器（如 Poll SCM）、构建环境（如 Maven）。
  4. 在 Jenkins 任务中编写构建脚本，运行测试、打包、部署应用。

通过以上步骤，可以构建一个完整的企业级应用，并进行持续的监控与维护。

點擊查看更多內容
為 TA 點贊

若覺得本文不錯，就分享一下吧！

評論

作者其他優質文章

正在加載中
  • 推薦
  • 評論
  • 收藏
  • 共同學習，寫下你的評論
感謝您的支持，我會繼續努力的～
掃碼打賞，你說多少就多少
贊賞金額會直接到老師賬戶
支付方式
打開微信掃一掃，即可進行掃碼打賞哦
今天注冊有機會得

100積分直接送

付費專欄免費學

大額優惠券免費領

立即參與 放棄機會
微信客服

購課補貼
聯系客服咨詢優惠詳情

 幫助反饋 APP下載

慕課網APP
您的移動學習伙伴

 公眾號

掃描二維碼
關注慕課網微信公眾號

舉報

0/150
提交
取消