SpringBoot深度整合高德地图，构建高性能位置服务

悟空码字2026-01-27 19:12

大家好，我是小悟。

一、高德地图简介

1.1 高德地图概述

高德地图是中国领先的数字地图内容、导航和位置服务解决方案提供商，由阿里巴巴集团控股。它提供了全面的地图服务，包括：

  • 基础地图服务：街道、建筑物、地形等地图数据
  • 定位服务：GPS、基站、Wi-Fi多重定位
  • 地理编码：地址与坐标之间的相互转换
  • 路径规划：驾车、步行、骑行、公交路线规划
  • 地图展示：2D/3D地图展示、自定义地图样式
  • 地点搜索：POI（兴趣点）搜索、周边搜索
  • 轨迹服务：车辆轨迹管理和分析

1.2 高德地图服务优势

  • 高精度定位：米级到厘米级精确定位
  • 丰富API：提供Web端、Android、iOS、服务端全方位SDK
  • 实时路况：覆盖全国主要城市的实时交通信息
  • 数据更新快：地图数据每周更新

1.3 高德地图应用场景

  • 位置服务（LBS）应用
  • 物流配送和路径优化
  • 出行服务和导航应用
  • 地理信息系统（GIS）
  • 商业分析和选址决策

二、SpringBoot集成高德地图SDK详细步骤

2.1 环境准备

2.1.1 注册高德开发者账号
  1. 访问高德开放平台
  2. 注册账号并完成实名认证
  3. 创建应用，获取API Key
2.1.2 创建SpringBoot项目
复制代码 
# 使用Spring Initializr创建项目
mvn archetype:generate -DgroupId=com.example -DartifactId=amap-demo -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

# 或使用Spring Boot CLI
spring init --dependencies=web,configuration-processor amap-demo

2.2 项目依赖配置

pom.xml配置
复制代码 
<?xml version="1.0" encoding="UTF-8"?>
<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>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.0</version>
        <relativePath/>
    </parent>

    <groupId>com.example</groupId>
    <artifactId>amap-demo</artifactId>
    <version>1.0.0</version>

    <properties>
        <java.version>11</java.version>
    </properties>

    <dependencies>
        <!-- Spring Boot Web -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        
        <!-- Spring Boot Configuration Processor -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>
        
        <!-- Lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        
        <!-- HTTP Client -->
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.5.13</version>
        </dependency>
        
        <!-- JSON Processing -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
        </dependency>
        
        <!-- Test Dependencies -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

2.3 配置文件

application.yml
复制代码 
server:
  port: 8080
  servlet:
    context-path: /api

spring:
  application:
    name: amap-service

# 高德地图配置
amap:
  # 在高德开放平台申请的key
  api-key: your-amap-api-key-here
  # API基础URL
  base-url: https://restapi.amap.com/v3
  # 地理编码服务路径
  geocode-path: /geocode/geo
  # 逆地理编码服务路径
  regeocode-path: /geocode/regeo
  # 路径规划服务路径
  direction-path: /direction/driving
  # IP定位服务路径
  ip-locate-path: /ip
  # 天气查询服务路径
  weather-path: /weather/weatherInfo
  # 签名密钥（可选）
  sig-key: 
  # 返回数据格式
  output: JSON

2.4 核心代码实现

2.4.1 配置类
复制代码 
package com.example.amap.config;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;

@Data
@Configuration
@ConfigurationProperties(prefix = "amap")
public class AmapProperties {
    private String apiKey;
    private String baseUrl;
    private String geocodePath;
    private String regeocodePath;
    private String directionPath;
    private String ipLocatePath;
    private String weatherPath;
    private String sigKey;
    private String output = "JSON";
    
    public String getGeocodeUrl() {
        return baseUrl + geocodePath;
    }
    
    public String getRegeocodeUrl() {
        return baseUrl + regeocodePath;
    }
    
    public String getDirectionUrl() {
        return baseUrl + directionPath;
    }
    
    public String getIpLocateUrl() {
        return baseUrl + ipLocatePath;
    }
    
    public String getWeatherUrl() {
        return baseUrl + weatherPath;
    }
}
2.4.2 HTTP客户端配置
复制代码 
package com.example.amap.config;

import org.apache.http.client.config.RequestConfig;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.client.ClientHttpRequestFactory;
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
import org.springframework.web.client.RestTemplate;

@Configuration
public class HttpClientConfig {
    
    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate(httpRequestFactory());
    }
    
    @Bean
    public ClientHttpRequestFactory httpRequestFactory() {
        return new HttpComponentsClientHttpRequestFactory(httpClient());
    }
    
    @Bean
    public CloseableHttpClient httpClient() {
        PoolingHttpClientConnectionManager connectionManager = 
            new PoolingHttpClientConnectionManager();
        connectionManager.setMaxTotal(200);
        connectionManager.setDefaultMaxPerRoute(50);
        
        RequestConfig requestConfig = RequestConfig.custom()
            .setSocketTimeout(10000)
            .setConnectTimeout(5000)
            .setConnectionRequestTimeout(5000)
            .build();
        
        return HttpClientBuilder.create()
            .setConnectionManager(connectionManager)
            .setDefaultRequestConfig(requestConfig)
            .build();
    }
}
2.4.3 服务层实现
复制代码 
package com.example.amap.service;

import com.example.amap.config.AmapProperties;
import com.example.amap.model.*;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;
import org.springframework.web.util.UriComponentsBuilder;

import java.net.URI;
import java.util.HashMap;
import java.util.Map;

@Slf4j
@Service
@RequiredArgsConstructor
public class AmapService {
    
    private final RestTemplate restTemplate;
    private final AmapProperties amapProperties;
    private final ObjectMapper objectMapper;
    
    /**
     * 地理编码：地址转坐标
     */
    public GeoResult geocode(String address, String city) {
        Map<String, String> params = new HashMap<>();
        params.put("key", amapProperties.getApiKey());
        params.put("address", address);
        if (city != null && !city.isEmpty()) {
            params.put("city", city);
        }
        
        String url = buildUrl(amapProperties.getGeocodeUrl(), params);
        log.info("请求地理编码API: {}", url);
        
        ResponseEntity<String> response = restTemplate.getForEntity(url, String.class);
        return parseGeoResult(response.getBody());
    }
    
    /**
     * 逆地理编码：坐标转地址
     */
    public RegeoResult regeocode(String location) {
        Map<String, String> params = new HashMap<>();
        params.put("key", amapProperties.getApiKey());
        params.put("location", location);
        params.put("extensions", "all"); // 返回详细信息
        
        String url = buildUrl(amapProperties.getRegeocodeUrl(), params);
        log.info("请求逆地理编码API: {}", url);
        
        ResponseEntity<String> response = restTemplate.getForEntity(url, String.class);
        return parseRegeoResult(response.getBody());
    }
    
    /**
     * 路径规划
     */
    public DirectionResult direction(String origin, String destination, String strategy) {
        Map<String, String> params = new HashMap<>();
        params.put("key", amapProperties.getApiKey());
        params.put("origin", origin);
        params.put("destination", destination);
        params.put("strategy", strategy != null ? strategy : "0"); // 0:速度优先
        
        String url = buildUrl(amapProperties.getDirectionUrl(), params);
        log.info("请求路径规划API: {}", url);
        
        ResponseEntity<String> response = restTemplate.getForEntity(url, String.class);
        return parseDirectionResult(response.getBody());
    }
    
    /**
     * IP定位
     */
    public IpLocateResult ipLocate(String ip) {
        Map<String, String> params = new HashMap<>();
        params.put("key", amapProperties.getApiKey());
        params.put("ip", ip != null ? ip : "");
        
        String url = buildUrl(amapProperties.getIpLocateUrl(), params);
        log.info("请求IP定位API: {}", url);
        
        ResponseEntity<String> response = restTemplate.getForEntity(url, String.class);
        return parseIpLocateResult(response.getBody());
    }
    
    /**
     * 天气查询
     */
    public WeatherResult weather(String city, String extensions) {
        Map<String, String> params = new HashMap<>();
        params.put("key", amapProperties.getApiKey());
        params.put("city", city);
        params.put("extensions", extensions != null ? extensions : "base"); // base:实时天气
        
        String url = buildUrl(amapProperties.getWeatherUrl(), params);
        log.info("请求天气查询API: {}", url);
        
        ResponseEntity<String> response = restTemplate.getForEntity(url, String.class);
        return parseWeatherResult(response.getBody());
    }
    
    /**
     * 构建请求URL
     */
    private String buildUrl(String baseUrl, Map<String, String> params) {
        UriComponentsBuilder builder = UriComponentsBuilder.fromHttpUrl(baseUrl);
        params.forEach(builder::queryParam);
        return builder.build().toUriString();
    }
    
    /**
     * 解析地理编码结果
     */
    private GeoResult parseGeoResult(String json) {
        try {
            JsonNode root = objectMapper.readTree(json);
            GeoResult result = new GeoResult();
            result.setStatus(root.get("status").asText());
            result.setInfo(root.get("info").asText());
            
            if ("1".equals(result.getStatus())) {
                JsonNode geocodes = root.get("geocodes");
                if (geocodes != null && geocodes.isArray() && geocodes.size() > 0) {
                    JsonNode first = geocodes.get(0);
                    GeoCode geoCode = new GeoCode();
                    geoCode.setFormattedAddress(first.get("formatted_address").asText());
                    geoCode.setCountry(first.get("country").asText());
                    geoCode.setProvince(first.get("province").asText());
                    geoCode.setCity(first.get("city").asText());
                    geoCode.setDistrict(first.get("district").asText());
                    String location = first.get("location").asText();
                    if (location.contains(",")) {
                        String[] coords = location.split(",");
                        geoCode.setLongitude(Double.parseDouble(coords[0]));
                        geoCode.setLatitude(Double.parseDouble(coords[1]));
                    }
                    result.setGeocode(geoCode);
                }
            }
            return result;
        } catch (Exception e) {
            log.error("解析地理编码结果失败", e);
            return null;
        }
    }
    
    /**
     * 解析逆地理编码结果
     */
    private RegeoResult parseRegeoResult(String json) {
        try {
            JsonNode root = objectMapper.readTree(json);
            RegeoResult result = new RegeoResult();
            result.setStatus(root.get("status").asText());
            result.setInfo(root.get("info").asText());
            
            if ("1".equals(result.getStatus())) {
                JsonNode regeocode = root.get("regeocode");
                if (regeocode != null) {
                    RegeoCode regeoCode = new RegeoCode();
                    regeoCode.setFormattedAddress(regeocode.get("formatted_address").asText());
                    result.setRegeocode(regeoCode);
                }
            }
            return result;
        } catch (Exception e) {
            log.error("解析逆地理编码结果失败", e);
            return null;
        }
    }
    
    // 其他解析方法类似，限于篇幅省略...
}
2.4.4 数据模型
复制代码 
package com.example.amap.model;

import lombok.Data;
import java.util.List;

@Data
public class GeoResult {
    private String status;
    private String info;
    private GeoCode geocode;
}

@Data
class GeoCode {
    private String formattedAddress;
    private String country;
    private String province;
    private String city;
    private String district;
    private Double longitude;
    private Double latitude;
}

@Data
public class RegeoResult {
    private String status;
    private String info;
    private RegeoCode regeocode;
}

@Data
class RegeoCode {
    private String formattedAddress;
    private AddressComponent addressComponent;
}

@Data
class AddressComponent {
    private String province;
    private String city;
    private String district;
    private String township;
}

@Data
public class DirectionResult {
    private String status;
    private String info;
    private Route route;
}

@Data
class Route {
    private List<Path> paths;
}

@Data
class Path {
    private Double distance;
    private Double duration;
    private String strategy;
    private String tolls;
    private String restriction;
    private String trafficLights;
}

@Data
public class IpLocateResult {
    private String status;
    private String info;
    private String province;
    private String city;
    private String adcode;
    private String rectangle;
}

@Data
public class WeatherResult {
    private String status;
    private String info;
    private String count;
    private List<LiveWeather> lives;
    private List<ForecastWeather> forecasts;
}

@Data
class LiveWeather {
    private String province;
    private String city;
    private String adcode;
    private String weather;
    private String temperature;
    private String winddirection;
    private String windpower;
    private String humidity;
    private String reporttime;
}

@Data
class ForecastWeather {
    private String city;
    private String adcode;
    private String province;
    private String reporttime;
    private List<Cast> casts;
}

@Data
class Cast {
    private String date;
    private String week;
    private String dayweather;
    private String nightweather;
    private String daytemp;
    private String nighttemp;
    private String daywind;
    private String nightwind;
    private String daypower;
    private String nightpower;
}
2.4.5 控制器层
复制代码 
package com.example.amap.controller;

import com.example.amap.model.*;
import com.example.amap.service.AmapService;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/amap")
@RequiredArgsConstructor
public class AmapController {
    
    private final AmapService amapService;
    
    /**
     * 地址转坐标
     */
    @GetMapping("/geocode")
    public ApiResponse<GeoResult> geocode(
            @RequestParam String address,
            @RequestParam(required = false) String city) {
        GeoResult result = amapService.geocode(address, city);
        return ApiResponse.success(result);
    }
    
    /**
     * 坐标转地址
     */
    @GetMapping("/regeocode")
    public ApiResponse<RegeoResult> regeocode(@RequestParam String location) {
        RegeoResult result = amapService.regeocode(location);
        return ApiResponse.success(result);
    }
    
    /**
     * 路径规划
     */
    @GetMapping("/direction")
    public ApiResponse<DirectionResult> direction(
            @RequestParam String origin,
            @RequestParam String destination,
            @RequestParam(required = false) String strategy) {
        DirectionResult result = amapService.direction(origin, destination, strategy);
        return ApiResponse.success(result);
    }
    
    /**
     * IP定位
     */
    @GetMapping("/ip-locate")
    public ApiResponse<IpLocateResult> ipLocate(@RequestParam(required = false) String ip) {
        IpLocateResult result = amapService.ipLocate(ip);
        return ApiResponse.success(result);
    }
    
    /**
     * 天气查询
     */
    @GetMapping("/weather")
    public ApiResponse<WeatherResult> weather(
            @RequestParam String city,
            @RequestParam(required = false) String extensions) {
        WeatherResult result = amapService.weather(city, extensions);
        return ApiResponse.success(result);
    }
}

/**
 * 统一API响应格式
 */
@Data
class ApiResponse<T> {
    private int code;
    private String message;
    private T data;
    private long timestamp;
    
    public static <T> ApiResponse<T> success(T data) {
        ApiResponse<T> response = new ApiResponse<>();
        response.setCode(200);
        response.setMessage("success");
        response.setData(data);
        response.setTimestamp(System.currentTimeMillis());
        return response;
    }
    
    public static <T> ApiResponse<T> error(int code, String message) {
        ApiResponse<T> response = new ApiResponse<>();
        response.setCode(code);
        response.setMessage(message);
        response.setTimestamp(System.currentTimeMillis());
        return response;
    }
}
2.4.6 全局异常处理
复制代码 
package com.example.amap.exception;

import com.example.amap.controller.ApiResponse;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

@Slf4j
@RestControllerAdvice
public class GlobalExceptionHandler {
    
    @ExceptionHandler(Exception.class)
    public ApiResponse<Object> handleException(Exception e) {
        log.error("系统异常", e);
        return ApiResponse.error(500, e.getMessage());
    }
    
    @ExceptionHandler(AmapException.class)
    public ApiResponse<Object> handleAmapException(AmapException e) {
        log.error("高德地图服务异常", e);
        return ApiResponse.error(e.getCode(), e.getMessage());
    }
}

class AmapException extends RuntimeException {
    private int code;
    
    public AmapException(int code, String message) {
        super(message);
        this.code = code;
    }
    
    public int getCode() {
        return code;
    }
}
2.4.7 启动类
复制代码 
package com.example.amap;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.context.properties.EnableConfigurationProperties;

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

2.5 测试示例

复制代码 
package com.example.amap.test;

import com.example.amap.AmapApplication;
import com.example.amap.service.AmapService;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@Slf4j
@SpringBootTest(classes = AmapApplication.class)
public class AmapServiceTest {
    
    @Autowired
    private AmapService amapService;
    
    @Test
    void testGeocode() {
        var result = amapService.geocode("北京市朝阳区阜通东大街6号", "北京");
        log.info("地理编码结果: {}", result);
    }
    
    @Test
    void testRegeocode() {
        var result = amapService.regeocode("116.481488,39.990464");
        log.info("逆地理编码结果: {}", result);
    }
    
    @Test
    void testDirection() {
        var result = amapService.direction("116.481488,39.990464", "116.434307,39.90909", "0");
        log.info("路径规划结果: {}", result);
    }
}

三、详细总结

3.1 集成要点总结

技术架构优势
  1. 微服务友好：通过RestTemplate封装，易于集成到微服务架构
  2. 配置灵活：使用Spring Boot配置属性，支持多环境配置
  3. 性能优化：HTTP连接池配置，提高并发性能
  4. 异常处理：统一的异常处理机制，提高系统稳定性
  5. 日志完善：完整的日志记录，便于问题排查
安全性考虑
  1. API Key保护：配置文件中存储，避免硬编码
  2. 请求签名：支持SIG参数，提高接口安全性
  3. 输入验证：对用户输入进行校验，防止非法参数
  4. 限流机制：可结合Redis实现API调用限流

3.2 最佳实践建议

性能优化
复制代码 
// 1. 使用缓存减少重复请求
@Cacheable(value = "geocodeCache", key = "#address + '-' + #city")
public GeoResult geocode(String address, String city) {
    // 实现逻辑
}

// 2. 异步调用提高响应速度
@Async
public CompletableFuture<GeoResult> geocodeAsync(String address, String city) {
    return CompletableFuture.completedFuture(geocode(address, city));
}

// 3. 批量处理接口
public List<GeoResult> batchGeocode(List<AddressRequest> requests) {
    return requests.stream()
        .map(req -> geocode(req.getAddress(), req.getCity()))
        .collect(Collectors.toList());
}
监控与告警
复制代码 
// 添加监控指标
@Component
public class AmapMetrics {
    
    private final MeterRegistry meterRegistry;
    private final Counter successCounter;
    private final Counter failureCounter;
    private final Timer apiTimer;
    
    public AmapMetrics(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
        this.successCounter = Counter.builder("amap.api.calls")
            .tag("status", "success")
            .register(meterRegistry);
        this.failureCounter = Counter.builder("amap.api.calls")
            .tag("status", "failure")
            .register(meterRegistry);
        this.apiTimer = Timer.builder("amap.api.duration")
            .register(meterRegistry);
    }
    
    public void recordSuccess(long duration) {
        successCounter.increment();
        apiTimer.record(duration, TimeUnit.MILLISECONDS);
    }
}

3.3 扩展功能

  1. 地理围栏服务：实现电子围栏监控
  2. 轨迹分析：车辆轨迹管理和分析
  3. 热力图生成：基于位置数据的可视化
  4. 地址标准化：地址数据清洗和标准化
  5. 智能推荐：基于位置的商家推荐

3.4 注意事项

  1. API调用限制：注意高德地图API的调用频率限制
  2. 错误码处理：完整处理高德地图返回的错误码
  3. 服务降级：在API服务不可用时实现降级策略
  4. 数据一致性：考虑数据更新和缓存的同步问题
  5. 合规性：确保应用符合国家的地理信息安全规定

3.5 部署

  1. 多环境配置：开发、测试、生产环境使用不同的API Key
  2. 密钥轮换：定期更新API Key，提高安全性
  3. 监控告警：设置API调用异常告警
  4. 文档完善：编写详细的API使用文档
  5. 压力测试：上线前进行充分的压力测试

通过以上完整的集成方案，SpringBoot应用可以高效、稳定地集成高德地图SDK，为业务提供丰富的位置服务功能。

谢谢你看我的文章，既然看到这里了，如果觉得不错，随手点个赞、转发、在看三连吧，感谢感谢。那我们，下次再见。

您的一键三连，是我更新的最大动力，谢谢

山水有相逢，来日皆可期，谢谢阅读，我们再会

我手中的金箍棒，上能通天，下能探海

相关推荐
千金裘换酒2 小时前
栈和队列定义及常用语法 LeetCode
java·开发语言
0x532 小时前
JAVA|智能无人机平台(二)
java·开发语言·无人机
JH30732 小时前
SpringBoot自定义启动banner：给项目加个专属“开机画面”
java·spring boot·后端
假女吖☌3 小时前
限流算法-redis实现与java实现
java·redis·算法
lixin5565563 小时前
基于迁移学习的图像风格增强器
java·人工智能·pytorch·python·深度学习·语言模型
面汤放盐3 小时前
企业权限--系统性方案探究
java·开发语言
what丶k3 小时前
深度解析Redis LRU与LFU算法：区别、实现与选型
java·redis·后端·缓存
悟能不能悟3 小时前
java Date转换为string
java·开发语言
菜宾3 小时前
java-redis面试题
java·开发语言·redis
热门推荐
01GitHub 镜像站点02OpenCode 入门教程：介绍 · 安装 · 配置第三方 API (如 Claude)03Claude Code Skills 实用使用手册04struts2 XML外部实体注入漏洞复现（CVE-2025-68493）05UV安装并设置国内源06Open Code教程（四）| 高级配置与集成07Linux下V2Ray安装配置指南08AI 规范驱动开发“三剑客”深度对比：Spec-Kit、Kiro 与 OpenSpec 实战指南09在VSCode配置Java开发环境的保姆级教程（适配各类AI编程IDE）10Antigravity AI编程工具添加和使用Skill完整教程