首頁手記 Spring Boot項目實戰：從入門到簡單應用

Spring Boot項目實戰：從入門到簡單應用

標簽：

SpringBoot

概述

本文将详细介绍如何搭建和开发Spring Boot项目，从环境搭建到创建第一个项目，再到核心概念与配置的详解。接着，通过实战部分，我们将深入探讨RESTful API开发、数据库操作、邮件服务集成、缓存技术以及与外部API的交互，帮助读者全面掌握Spring Boot项目实战技能。Spring Boot项目实战涵盖了从基础到高级的各种应用场景，旨在帮助开发者快速构建高质量的应用。

Spring Boot简介与环境搭建

Spring Boot是什么

Spring Boot 是一个基于Spring框架的开源框架，旨在简化Spring应用的初始搭建以及开发过程。它通过提供一系列约定优于配置的特性，使开发人员能够快速搭建和配置独立的Spring应用。Spring Boot不仅简化了Spring的配置过程，还提供了嵌入式Web服务器支持、自动配置、对常见场景的生产就绪特性，使得开发者可以专注于业务逻辑的实现，而无需过多地关注底层配置和基础设施。

开发环境搭建

要开始使用Spring Boot进行开发，首先需要搭建开发环境。以下是搭建开发环境的步骤：

安装Java环境

下载Java：请访问Oracle官方网站或OpenJDK下载页面，根据需求选择适当的版本。
安装Java：下载完成后，按照安装向导完成Java的安装。安装过程中，确保添加环境变量。
验证安装：在命令行中输入java -version来验证Java是否安装成功。

安装IDE

选择合适的集成开发环境（IDE）来开发Spring Boot应用。推荐使用以下任意一种：

IntelliJ IDEA： IntelliJ IDEA是JetBrains公司出品的一款支持多种编程语言的集成开发环境，支持Spring Boot开箱即用。
Eclipse： Eclipse是另一个流行的开源IDE，适用于多种编程语言。安装Eclipse后，需安装Spring Boot插件或扩展，以支持Spring Boot项目的开发。

下载Spring Boot Starter项目

下载Spring Tool Suite（STS）：STS是一个基于Eclipse的IDE，专门为Spring应用开发而设计。在Spring官网下载STS。
安装STS：安装STS后，可以直接使用其内置的Spring Boot项目模板来创建项目。

安装Maven或Gradle

Spring Boot项目通常使用Maven或Gradle进行构建。这里以Maven为例：

下载Maven：从Apache Maven的官方网站下载Maven。
安装Maven：将下载的Maven压缩包解压，将其安装到指定目录。
配置环境变量：将Maven的bin目录添加到系统的PATH环境变量中。
验证安装：在命令行中输入mvn -version来验证Maven是否安装成功。

创建第一个Spring Boot项目

创建一个Spring Boot项目，首先可以通过STS或Maven来完成。这里以STS为例：

打开STS：启动STS后，选择“File”->“New”->“Spring Starter Project”。
填写项目信息：在弹出的对话框中，填写项目名称（例如springbootdemo），选择项目存放的目录，然后点击“Next”。
选择依赖：在依赖选择界面，选择“Web”和“Spring Web”，这些是基本的Web应用依赖，点击“Finish”完成项目的创建。

完成以上步骤后，STS会自动生成一个基本的Spring Boot项目结构，接下来可以进行项目的进一步开发。

以下是简单的Spring Boot应用示例：

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);
    }
}

以上代码中的@SpringBootApplication注解是Spring Boot的核心注解，它包含了@Configuration、@EnableAutoConfiguration和@ComponentScan三个注解，实现了自动配置、组件扫描和自定义配置的功能。

Spring Boot核心概念与配置

依赖管理和自动配置

依赖管理

在Spring Boot项目中，所有依赖都是通过Maven或Gradle的pom.xml或build.gradle文件管理的。这些文件位于项目根目录下，包含项目所需的所有库依赖。

例如，一个典型的Spring Boot项目的pom.xml可能如下所示：

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.4.0</version>
    </parent>
    <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>
</project>

在上面的pom.xml中，spring-boot-starter-web是一个预定义的starter，包含了构建Web应用所需的依赖。而spring-boot-starter-test则提供了测试环境所需的库。

自动配置

Spring Boot的自动配置功能旨在为常见的应用场景提供“开箱即用”的配置。这意味着，对于许多常见任务，开发人员无需手动配置，Spring Boot会智能地根据类路径中的依赖自动配置应用。例如，如果项目中引入了spring-boot-starter-data-jpa依赖，Spring Boot会自动配置JPA相关的设置。

自动配置的实现主要依赖于spring-boot-autoconfigure模块中的配置类，这些类会根据类路径中的依赖进行相应的配置。例如，AutoConfigurationImportSelector会根据存在的一些条件自动导入相应的配置类。

通过Spring Boot的自动配置功能，开发者可以专注于业务逻辑的实现，而无需过多关注底层配置。

应用配置文件详解

Spring Boot允许使用多种配置文件，最常用的是application.properties和application.yml。这些配置文件位于src/main/resources目录下，可以通过这些文件来覆盖默认配置，或者定义自定义的配置。

以下是application.properties文件的一个简单示例：

# 应用端口
server.port=8080

# 数据源配置
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=secret
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

# 日志配置
logging.level.root=INFO

在上述配置文件中，server.port定义了应用的默认端口，spring.datasource.*定义了数据库连接的相关设置，logging.level.root定义了根日志级别。

Spring Boot还支持使用外部配置文件，可以在命令行参数中指定配置文件的位置。例如：

java -jar myapp.jar --spring.config.location=classpath:/custom-config.properties

这样可以将自定义的配置文件覆盖默认配置，实现灵活的配置管理。

静态资源和模板引擎的使用

静态资源

Spring Boot默认支持静态资源的处理，如CSS、JavaScript和图片等。静态资源通常放置在src/main/resources/static目录下。例如，main/resources/static/index.html表示位于静态资源目录下的首页。

Spring Boot的资源映射规则如下：

/：映射到/static/index.html
/resources/**：映射到/resources目录下的资源
/static/**：映射到/static目录下的资源
/public/**：映射到/public目录下的资源

模板引擎

Spring Boot支持多种模板引擎，如Thymeleaf、FreeMarker等。这里以Thymeleaf为例进行介绍。

添加依赖：在pom.xml中添加Thymeleaf的依赖。

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>

创建模板文件：在src/main/resources/templates目录下创建模板文件，例如index.html。

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title th:text="${title}">标题</title>
</head>
<body>
    <h1 th:text="${greeting}">问候语</h1>
</body>
</html>

控制器：创建控制器类，用来渲染模板。

package com.example.demo;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class HomeController {

    @GetMapping("/")
    public String home(Model model) {
        model.addAttribute("title", "首页");
        model.addAttribute("greeting", "你好，世界！");
        return "index";
    }
}

在上述代码中，home方法渲染index.html模板，并传递了title和greeting两个属性。

通过以上步骤，可以轻松地将静态资源和模板引擎集成到Spring Boot应用中，实现动态页面渲染。

日志与监控

日志管理与配置

Spring Boot提供了丰富的日志管理与配置能力，支持多种日志框架，如Logback、Log4j等。默认情况下，Spring Boot使用Logback作为日志框架。可以通过配置application.properties或logback-spring.xml来定制日志行为。

例如，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>

通过配置application.properties中的logging.level.root属性，可以控制日志级别。此外，还可以通过Spring Boot Actuator获取应用的日志信息。

应用监控与健康检查

Spring Boot提供了强大的监控功能，可以通过集成Spring Boot Actuator来实现应用的监控与健康检查。Spring Boot Actuator提供了多种端点来获取应用的运行状态信息，如/health用来返回应用的健康信息，/metrics用来获取应用的度量信息等。

要启用Spring Boot Actuator，只需在pom.xml或build.gradle文件中添加相应的依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

启用Actuator后，可以在浏览器中访问http://localhost:8080/actuator来查看所有可用的端点。

实战一：RESTful API开发

创建RESTful服务

RESTful API是一种使用HTTP协议实现的Web服务架构，通常用于构建前后端分离的Web应用。Spring Boot提供了强大的支持，使得开发RESTful服务变得简单直接。

创建控制器：创建一个控制器类，用于定义RESTful接口。

package com.example.demo;

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

@RestController
public class HelloController {

    @RequestMapping("/hello")
    public String hello() {
        return "Hello, World!";
    }
}

在上述代码中，@RestController注解指定了这是一个REST控制器，而@RequestMapping注解定义了URL路径/hello，当访问该路径时，将调用hello方法返回“Hello, World!”。

运行应用：启动应用后，在浏览器或API测试工具（如Postman）中访问http://localhost:8080/hello，将看到返回的“Hello, World!”。

通过以上步骤，可以创建一个简单的RESTful服务，接下来可以继续添加更多的HTTP方法（如GET、POST、PUT、DELETE）来实现更丰富的功能。

使用Spring Data JPA进行数据库操作

Spring Data JPA是Spring框架中用于简化数据访问层操作的模块，提供了JPA（Java Persistence API）的简单集成。可以通过简单的配置和接口定义，实现对数据库的CRUD操作。

添加依赖：在pom.xml中添加Spring Data JPA和MySQL的依赖。

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>

配置数据库：在application.properties中配置数据库连接。

spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=secret
spring.jpa.hibernate.ddl-auto=update

定义实体类：创建一个实体类，用于映射数据库中的表。

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方法
}

创建仓库接口：定义一个接口，继承JpaRepository，用于实现对User实体的CRUD操作。

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> {
}

创建服务层：创建服务类，实现业务逻辑。

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;

import java.util.List;

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

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

    public User save(User user) {
        return userRepository.save(user);
    }
}

创建控制器：创建控制器类，用于处理HTTP请求。

package com.example.demo;

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
public class UserController {

    @Autowired
    private UserService userService;

    @GetMapping("/users")
    public List<User> getAllUsers() {
        return userService.findAll();
    }

    @PostMapping("/users")
    public User createUser(@RequestBody User user) {
        return userService.save(user);
    }
}

在上述代码中，UserController定义了两个RESTful接口，分别用于获取所有用户和创建新用户。通过调用UserService的findAll和save方法，实现了对数据库的操作。

参数绑定与响应格式设置

参数绑定

参数绑定是指将HTTP请求中的参数绑定到方法参数中，通常通过@RequestParam注解实现。例如：

@GetMapping("/users/{id}")
public User getUserById(@PathVariable Long id) {
    return userService.findById(id);
}

在上述代码中，@PathVariable注解用于将URL路径中的变量绑定到方法参数id上。

响应格式设置

Spring Boot可以自动地将返回的对象转换为JSON格式，并在响应头中设置Content-Type为application/json。如果需要自定义响应格式，可以使用HttpMessageConverter。

例如，通过自定义的RestControllerAdvice来统一设置响应格式：

package com.example.demo.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

import java.util.List;

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
        MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
        // 自定义Jackson配置
        converter.getObjectMapper().setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
        converters.add(converter);
    }
}

在上述代码中，通过配置MappingJackson2HttpMessageConverter中的ObjectMapper，可以设置日期格式等参数，实现响应格式的自定义。

通过以上步骤，可以轻松地实现参数绑定和响应格式设置的功能，进一步完善RESTful API的开发。

实战二：整合第三方服务

集成邮件服务

邮件服务在很多场景中都非常有用，比如发送注册确认邮件、密码重置请求等。Spring Boot可以通过spring-boot-starter-mail来整合邮件服务，使用JavaMail API发送邮件。

添加依赖：在pom.xml中添加邮件服务的依赖。

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-mail</artifactId>
</dependency>

配置邮件服务器：在application.properties文件中配置邮件服务器信息。

spring.mail.host=smtp.example.com
[email protected]
spring.mail.password=your-password
spring.mail.properties.mail.smtp.auth=true
spring.mail.properties.mail.smtp.starttls.enable=true

发送邮件：创建服务类，实现发送邮件的功能。

package com.example.demo.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.mail.SimpleMailMessage;
import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.stereotype.Service;

@Service
public class MailService {

    @Autowired
    private JavaMailSender mailSender;

    public void sendSimpleMail(String to, String subject, String text) {
        SimpleMailMessage message = new SimpleMailMessage();
        message.setTo(to);
        message.setSubject(subject);
        message.setText(text);
        mailSender.send(message);
    }
}

在上述代码中，sendSimpleMail方法用于发送简单的邮件。通过JavaMailSender发送SimpleMailMessage对象。

集成到控制器：在控制器中调用邮件服务发送邮件。

package com.example.demo;

import com.example.demo.service.MailService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class MailController {

    @Autowired
    private MailService mailService;

    @GetMapping("/send-mail")
    public String sendMail(@RequestParam String to, @RequestParam String subject, @RequestParam String text) {
        mailService.sendSimpleMail(to, subject, text);
        return "邮件已发送";
    }
}

在上述代码中，MailController定义了一个发送邮件的接口，通过@RequestParam注解获取请求参数，并调用MailService的sendSimpleMail方法发送邮件。

使用缓存技术

缓存技术可以显著提高应用的性能，减少数据库访问次数。Spring Boot可以通过spring-boot-starter-cache和spring-boot-starter-redis来集成缓存和Redis。

添加依赖：在pom.xml中添加缓存和Redis的依赖。

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

配置缓存：在application.properties文件中配置Redis缓存。

spring.cache.type=redis
spring.redis.host=localhost
spring.redis.port=6379

启用缓存：在服务层启用缓存功能。

package com.example.demo.service;

import com.example.demo.entity.User;
import com.example.demo.repository.UserRepository;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
@EnableCaching
public class UserService {

    private final UserRepository userRepository;

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

    @Cacheable(value = "users")
    public List<User> findAll() {
        return userRepository.findAll();
    }
}

在上述代码中，@EnableCaching注解用于启用缓存功能，@Cacheable注解用于缓存方法的返回值。value属性指定了缓存的名称users。

测试缓存功能：在控制器中调用缓存的服务方法。

package com.example.demo;

import com.example.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
public class UserController {

    @Autowired
    private UserService userService;

    @GetMapping("/users")
    public List<User> getUsers() {
        return userService.findAll();
    }
}

在上述代码中，UserController定义了一个获取用户列表的接口，当访问该接口时，将调用UserService的findAll方法，返回用户列表。该方法的结果将被缓存，从而避免多次访问数据库。

通过以上步骤，可以轻松地集成邮件服务和缓存技术，进一步完善应用的功能。

与外部API交互

与外部API交互是现代Web应用中常见的场景，例如获取天气信息、用户地理位置等。Spring Boot可以通过RestTemplate类来实现与外部API的交互。

添加依赖：在pom.xml中添加spring-boot-starter-web依赖，该依赖已经包含了RestTemplate。

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

创建服务类：创建服务类，实现对外部API的调用。

package com.example.demo.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

import java.util.Map;

@Service
public class WeatherService {

    private final RestTemplate restTemplate;

    public WeatherService(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }

    public Map<String, Object> getWeather(String city) {
        String url = "https://api.openweathermap.org/data/2.5/weather?q=" + city + "&appid=your-api-key";
        ResponseEntity<Map> response = restTemplate.getForEntity(url, Map.class);
        return response.getBody();
    }
}

在上述代码中，RestTemplate用于发送HTTP请求并获取响应。getWeather方法接受一个城市名称作为参数，构建请求URL，并调用restTemplate.getForEntity方法获取天气信息。

集成到控制器：在控制器中调用服务层的方法。

package com.example.demo;

import com.example.demo.service.WeatherService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.util.Map;

@RestController
public class WeatherController {

    @Autowired
    private WeatherService weatherService;

    @GetMapping("/weather")
    public Map<String, Object> getWeather(@RequestParam String city) {
        return weatherService.getWeather(city);
    }
}

在上述代码中，WeatherController定义了一个获取天气信息的接口，通过调用WeatherService的getWeather方法获取指定城市的天气信息。

通过以上步骤，可以轻松地实现与外部API的交互，从而丰富应用的功能。

部署与测试

应用打包与部署

应用打包与部署是将应用的源代码转换为可运行的二进制文件，并通过部署工具将其部署到服务器的过程。Spring Boot应用可以通过Maven或Gradle进行打包和部署。

打包应用：使用Maven或Gradle的命令进行打包。
```
mvn package
```
或者
```
gradle build
```
部署应用：将打包后的JAR文件部署到应用服务器，如Tomcat、Jetty等。
```
java -jar target/myapp.jar
```

单元测试与集成测试

单元测试和集成测试是确保应用质量的重要手段。Spring Boot为这两种测试提供了强大的支持。

单元测试示例：使用JUnit和Spring Boot Test进行单元测试。

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 static org.junit.jupiter.api.Assertions.assertEquals;

@SpringBootTest
public class UserControllerTest {

    @Autowired
    private UserController userController;

    @Test
    public void testGetUsers() {
        List<User> users = userController.getUsers();
        assertEquals(0, users.size(), "用户列表为空");
    }
}

在上述代码中，@SpringBootTest注解用于启动完整的Spring Boot应用上下文，并使用真实的环境进行测试。

集成测试示例：集成测试通常用于验证多个组件之间的交互。同样使用JUnit和Spring Boot Test进行集成测试。

package com.example.demo;

import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.web.client.TestRestTemplate;
import org.springframework.http.ResponseEntity;

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

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class UserControllerIT {

    @Autowired
    private TestRestTemplate restTemplate;

    @Test
    public void testGetUsers() {
        ResponseEntity<String> response = restTemplate.getForEntity("/users", String.class);
        assertEquals(200, response.getStatusCodeValue(), "用户列表请求成功");
    }
}

在上述代码中，@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)注解用于启动完整的Spring Boot应用上下文，并通过TestRestTemplate发送HTTP请求进行测试。

通过以上步骤，可以确保应用的质量和稳定性。

點擊查看更多內容

為 TA 點贊

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

評論

評論

共同學習，寫下你的評論

評論加載中...

展開查看更多評論

作者其他優質文章

正在加載中

qq_笑_17

手記
篇

粉絲

12

獲贊與收藏

52

關注作者，訂閱最新文章

閱讀免費教程

后端通用面試教程

41個小節 32074 358

網絡編程入門教程

20個小節 13196 249

Pandas 入門教程

25個小節 19564 369

推薦

評論

收藏

共同學習，寫下你的評論



感謝您的支持，我會繼續努力的～

掃碼打賞，你說多少就多少

贊賞金額會直接到老師賬戶

支付方式

打開微信掃一掃，即可進行掃碼打賞哦

今天注冊有機會得

100積分直接送

付費專欄免費學

大額優惠券免費領

立即參與放棄機會

點擊
抽獎

慕課手記新用戶專享福利

恭喜你，你的運氣太好了，居然抽中了 100個積分！

恭喜你，抽中了價值元的專欄！

太棒了，直接落到你賬戶里！

積分商城里的羅技鼠標、機械鍵盤、
Kindle 閱讀器、小米平衡車
Apple iPad （10.2英寸）、大額優惠券
在等著你去兌換了噢

作者：

免費贈送

兌換碼：1111222211 復制

優惠券可用于購買實戰課、體系課
無門檻使用

先去看看，有什么好東西馬上兌換我愛學習，選課去


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

熱搜

最近搜索清空