阿里人脸融合接入

阿里人脸融合接入

application.yml

1
2
3
4
5
aliyun:
  face:
    end-point: ${face_end_point}
    access-key-id: ${face_access_key_id}
    access-key-secret: ${face_access_key_secret}

FaceConfig

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import lombok.Data;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;

/**
 * @author 曳戈泰尔
 * @version 1.0
 * @description 曳戈泰尔
 * @date 2023/3/14 11:50 AM
 */
@Configuration
@Data
public class FaceConfig {

    @Value("${aliyun.face.access-key-id}")
    private String accessKeyId;

    @Value("${aliyun.face.access-key-secret}")
    private String accessKeySecret;

    @Value("${aliyun.face.end-point}")
    private String endPoint;

}

AddFaceImageTemplate

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
import com.aliyun.facebody20191230.models.AddFaceImageTemplateResponse;
import com.aliyun.tea.TeaException;
import com.aliyun.tea.TeaModel;
import com.yqxc.aiface.common.exception.AiException;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;

import java.io.InputStream;

/**
 * @author 曳戈泰尔
 * @version 1.0
 * @description 添加人脸融合模板
 * @date 2023/3/14 2:17 PM
 */
@Component
@Slf4j
public class AddFaceImageTemplate {

    /** Face配置类 */
    private FaceConfig faceConfig;

    /** 客户端 */
    private com.aliyun.facebody20191230.Client client;

    @Autowired
    public AddFaceImageTemplate(FaceConfig faceConfig) {
        this.faceConfig = faceConfig;

        try {
            client =
                    createClient(
                            this.faceConfig.getAccessKeyId(),
                            this.faceConfig.getAccessKeySecret(),
                            this.faceConfig.getEndPoint());
        } catch (Exception ex) {
            log.error("初始化人脸融合Client失败，原因：{}", ex.getMessage());
        }
    }

    /**
     * 使用AK&SK初始化账号Client
     *
     * @param accessKeyId
     * @param accessKeySecret
     * @return Client
     * @throws Exception
     */
    public com.aliyun.facebody20191230.Client createClient(
            String accessKeyId, String accessKeySecret, String endPoint) throws Exception {

        com.aliyun.teaopenapi.models.Config config =
                new com.aliyun.teaopenapi.models.Config()
                        // 必填，您的 AccessKey ID
                        .setAccessKeyId(accessKeyId)
                        // 必填，您的 AccessKey Secret
                        .setAccessKeySecret(accessKeySecret);
        // 访问的域名
        config.endpoint = endPoint;

        return new com.aliyun.facebody20191230.Client(config);
    }

    /**
     * 返回模板ID
     *
     * @param imageUrl
     * @return
     * @throws Exception
     */
    @Transactional(rollbackFor = Exception.class)
    public String addTemplate(String imageUrl, MultipartFile file) {

        try {
            // 场景一，使用本地文件
            InputStream inputStream = file.getInputStream();

            // 场景二，使用任意可访问的url
            // URL url = new URL(imageUrl);
            // InputStream inputStream = url.openConnection().getInputStream();

            // 设置请求参数
            com.aliyun.facebody20191230.models.AddFaceImageTemplateAdvanceRequest
                    addFaceImageTemplateAdvanceRequest =
                            new com.aliyun.facebody20191230.models
                                            .AddFaceImageTemplateAdvanceRequest()
                                    .setImageURLObject(inputStream);
            com.aliyun.teautil.models.RuntimeOptions runtime =
                    new com.aliyun.teautil.models.RuntimeOptions();

            // 执行请求
            AddFaceImageTemplateResponse addFaceImageTemplateResponse =
                    client.addFaceImageTemplateAdvance(addFaceImageTemplateAdvanceRequest, runtime);
            // 获取整体结果
            log.info(
                    "添加人脸融合模板整体结果：{}",
                    com.aliyun.teautil.Common.toJSONString(
                            TeaModel.buildMap(addFaceImageTemplateResponse)));
            // 获取单个字段——模板ID
            log.info(
                    "添加人脸融合模板ID：{}",
                    addFaceImageTemplateResponse.getBody().getData().getTemplateId());

            // 返回人脸融合模板ID
            return addFaceImageTemplateResponse.getBody().getData().getTemplateId();

        } catch (TeaException teaException) {
            // 获取整体报错信息
            log.error("添加人脸融合模板整体报错信息：{}", com.aliyun.teautil.Common.toJSONString(teaException));

            // 根据不同的报错信息返回不同的结果
            if (com.aliyun.teautil.Common.toJSONString(teaException).contains("输入图像含有敏感或违规信息")) {
                throw new AiException("图片中含有敏感或违规信息");
            } else if (com.aliyun.teautil.Common.toJSONString(teaException)
                    .contains("输入图像未检测到人脸")) {
                throw new AiException("图片中未检测到完整人脸");
            } else {
                throw new AiException("添加模板失败，请重试");
            }

        } catch (Exception ex) {
            log.error("人脸融合 添加模板失败，原因：{}", ex.getMessage());

            throw new AiException("添加模板失败，请重试");
        }
    }
}

QueryFaceImageTemplate

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
import com.alibaba.fastjson.JSONObject;
import com.yqxc.aiface.common.exception.AiException;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * @author 曳戈泰尔
 * @version 1.0
 * @description 查询人脸模板
 * @date 2023/3/14 2:23 PM
 */
@Component
@Slf4j
public class QueryFaceImageTemplate {

    /** Face配置类 */
    private FaceConfig faceConfig;

    /** 客户端 */
    private com.aliyun.teaopenapi.Client client;

    /** 请求其他参数 */
    com.aliyun.teaopenapi.models.Params params = createApiInfo();

    @Autowired
    public QueryFaceImageTemplate(FaceConfig faceConfig) {
        this.faceConfig = faceConfig;

        try {
            client =
                    createClient(
                            this.faceConfig.getAccessKeyId(),
                            this.faceConfig.getAccessKeySecret(),
                            this.faceConfig.getEndPoint());
        } catch (Exception ex) {
            log.error("初始化人脸融合Client失败，原因：{}", ex.getMessage());
        }
    }

    /**
     * 使用AK&SK初始化账号Client
     *
     * @param accessKeyId
     * @param accessKeySecret
     * @return Client
     * @throws Exception
     */
    public com.aliyun.teaopenapi.Client createClient(
            String accessKeyId, String accessKeySecret, String endPoint) throws Exception {

        com.aliyun.teaopenapi.models.Config config =
                new com.aliyun.teaopenapi.models.Config()
                        // 必填，您的 AccessKey ID
                        .setAccessKeyId(accessKeyId)
                        // 必填，您的 AccessKey Secret
                        .setAccessKeySecret(accessKeySecret);

        // 访问的域名
        config.endpoint = endPoint;

        return new com.aliyun.teaopenapi.Client(config);
    }

    /**
     * API 相关
     *
     * @return OpenApi.Params
     */
    public static com.aliyun.teaopenapi.models.Params createApiInfo() {
        return new com.aliyun.teaopenapi.models.Params()
                // 接口名称
                .setAction("QueryFaceImageTemplate")
                // 接口版本
                .setVersion("2019-12-30")
                // 接口协议
                .setProtocol("HTTPS")
                // 接口 HTTP 方法
                .setMethod("GET")
                .setAuthType("AK")
                .setStyle("RPC")
                // 接口 PATH
                .setPathname("/")
                // 接口请求体内容格式
                .setReqBodyType("json")
                // 接口响应体内容格式
                .setBodyType("json");
    }

    public JSONObject queryTemplate(String templateId) {

        try {
            // query params
            java.util.Map<String, Object> queries = new java.util.HashMap<>();
            queries.put("TemplateId", templateId);

            // runtime options
            com.aliyun.teautil.models.RuntimeOptions runtime =
                    new com.aliyun.teautil.models.RuntimeOptions();
            com.aliyun.teaopenapi.models.OpenApiRequest request =
                    new com.aliyun.teaopenapi.models.OpenApiRequest()
                            .setQuery(com.aliyun.openapiutil.Client.query(queries));

            // 复制代码运行请自行打印 API 的返回值
            // 返回值为 Map 类型，可从 Map 中获得三类数据：响应体 body、响应头 headers、HTTP 返回的状态码 statusCode
            java.util.Map<String, ?> resp = client.callApi(params, request, runtime);
            // 打印返回结果
            log.info("人脸融合查询模板返回结果：{}", com.aliyun.teautil.Common.toJSONString(resp));

            // 查询成功
            if (JSONObject.parseObject(com.aliyun.teautil.Common.toJSONString(resp))
                    .get("statusCode")
                    .equals(200)) {
                return JSONObject.parseObject(com.aliyun.teautil.Common.toJSONString(resp))
                        .getJSONObject("body");
            } else {
                throw new AiException("人脸融合查询模板不存在");
            }

        } catch (Exception ex) {
            log.error("人脸融合查询模板失败，原因：{}", ex.getMessage());

            throw new AiException("人脸融合查询模板失败");
        }
    }
}

DeleteFaceImageTemplate

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
import com.alibaba.fastjson.JSONObject;
import com.yqxc.aiface.common.exception.AiException;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * @author 曳戈泰尔
 * @version 1.0
 * @description 删除人脸融合模板
 * @date 2023/3/14 2:28 PM
 */
@Component
@Slf4j
public class DeleteFaceImageTemplate {

    /** Face配置类 */
    private FaceConfig faceConfig;

    /** 客户端 */
    private com.aliyun.teaopenapi.Client client;

    /** 请求其他参数 */
    com.aliyun.teaopenapi.models.Params params = createApiInfo();

    @Autowired
    public DeleteFaceImageTemplate(FaceConfig faceConfig) {
        this.faceConfig = faceConfig;

        try {
            client =
                    createClient(
                            this.faceConfig.getAccessKeyId(),
                            this.faceConfig.getAccessKeySecret(),
                            this.faceConfig.getEndPoint());
        } catch (Exception ex) {
            log.error("初始化人脸融合Client失败，原因：{}", ex.getMessage());
        }
    }

    /**
     * 使用AK&SK初始化账号Client
     *
     * @param accessKeyId
     * @param accessKeySecret
     * @return Client
     * @throws Exception
     */
    public com.aliyun.teaopenapi.Client createClient(
            String accessKeyId, String accessKeySecret, String endPoint) throws Exception {

        com.aliyun.teaopenapi.models.Config config =
                new com.aliyun.teaopenapi.models.Config()
                        // 必填，您的 AccessKey ID
                        .setAccessKeyId(accessKeyId)
                        // 必填，您的 AccessKey Secret
                        .setAccessKeySecret(accessKeySecret);

        // 访问的域名
        config.endpoint = endPoint;

        return new com.aliyun.teaopenapi.Client(config);
    }

    /**
     * API 相关
     *
     * @return OpenApi.Params
     */
    public static com.aliyun.teaopenapi.models.Params createApiInfo() {
        return new com.aliyun.teaopenapi.models.Params()
                // 接口名称
                .setAction("DeleteFaceImageTemplate")
                // 接口版本
                .setVersion("2019-12-30")
                // 接口协议
                .setProtocol("HTTPS")
                // 接口 HTTP 方法
                .setMethod("POST")
                .setAuthType("AK")
                .setStyle("RPC")
                // 接口 PATH
                .setPathname("/")
                // 接口请求体内容格式
                .setReqBodyType("formData")
                // 接口响应体内容格式
                .setBodyType("json");
    }

    public boolean deleteTemplate(String templateId) {

        try {
            // body params
            java.util.Map<String, Object> body = new java.util.HashMap<>();
            body.put("UserId", null);
            body.put("TemplateId", templateId);

            // runtime options
            com.aliyun.teautil.models.RuntimeOptions runtime =
                    new com.aliyun.teautil.models.RuntimeOptions();
            com.aliyun.teaopenapi.models.OpenApiRequest request =
                    new com.aliyun.teaopenapi.models.OpenApiRequest().setBody(body);

            // 复制代码运行请自行打印 API 的返回值
            // 返回值为 Map 类型，可从 Map 中获得三类数据：响应体 body、响应头 headers、HTTP 返回的状态码 statusCode
            java.util.Map<String, ?> resp = client.callApi(params, request, runtime);
            // 打印返回结果
            log.info("人脸融合删除模板返回结果：{}", com.aliyun.teautil.Common.toJSONString(resp));

            // 删除成功
            return JSONObject.parseObject(com.aliyun.teautil.Common.toJSONString(resp))
                    .get("statusCode")
                    .equals(200);

        } catch (Exception ex) {
            log.error("人脸融合删除模板失败，原因：{}", ex.getMessage());

            throw new AiException("人脸融合删除模板失败");
        }
    }
}

MergeImageFace

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
import com.alibaba.fastjson.JSONObject;
import com.yqxc.aiface.common.exception.AiException;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * @author 曳戈泰尔
 * @version 1.0
 * @description 图像人脸融合
 * @date 2023/3/14 11:39 AM
 */
@Component
@Slf4j
public class MergeImageFace {

    /** Face配置类 */
    private FaceConfig faceConfig;

    /** 客户端 */
    private com.aliyun.teaopenapi.Client client;

    /** 请求其他参数 */
    com.aliyun.teaopenapi.models.Params params = createApiInfo();

    @Autowired
    public MergeImageFace(FaceConfig faceConfig) {
        this.faceConfig = faceConfig;

        try {
            client =
                    createClient(
                            this.faceConfig.getAccessKeyId(),
                            this.faceConfig.getAccessKeySecret(),
                            this.faceConfig.getEndPoint());
        } catch (Exception ex) {
            log.error("初始化人脸融合Client失败，原因：{}", ex.getMessage());
        }
    }

    /**
     * 使用AK&SK初始化账号Client
     *
     * @param accessKeyId
     * @param accessKeySecret
     * @return Client
     * @throws Exception
     */
    public com.aliyun.teaopenapi.Client createClient(
            String accessKeyId, String accessKeySecret, String endPoint) throws Exception {

        com.aliyun.teaopenapi.models.Config config =
                new com.aliyun.teaopenapi.models.Config()
                        // 必填，您的 AccessKey ID
                        .setAccessKeyId(accessKeyId)
                        // 必填，您的 AccessKey Secret
                        .setAccessKeySecret(accessKeySecret);

        // 访问的域名
        config.endpoint = endPoint;

        return new com.aliyun.teaopenapi.Client(config);
    }

    /**
     * API 相关
     *
     * @return OpenApi.Params
     */
    public static com.aliyun.teaopenapi.models.Params createApiInfo() {
        return new com.aliyun.teaopenapi.models.Params()
                // 接口名称
                .setAction("MergeImageFace")
                // 接口版本
                .setVersion("2019-12-30")
                // 接口协议
                .setProtocol("HTTPS")
                // 接口 HTTP 方法
                .setMethod("POST")
                .setAuthType("AK")
                .setStyle("RPC")
                // 接口 PATH
                .setPathname("/")
                // 接口请求体内容格式
                .setReqBodyType("formData")
                // 接口响应体内容格式
                .setBodyType("json");
    }

    /**
     * 执行人脸融合请求
     *
     * @param templateId
     * @param imageUrl
     * @return
     */
    public String mergeFace(String templateId, String imageUrl) {

        try {
            // body params
            java.util.Map<String, Object> body = new java.util.HashMap<>();
            body.put("UserId", null);
            body.put("TemplateId", templateId);
            body.put("ImageURL", imageUrl);

            // runtime options
            com.aliyun.teautil.models.RuntimeOptions runtime =
                    new com.aliyun.teautil.models.RuntimeOptions();
            com.aliyun.teaopenapi.models.OpenApiRequest request =
                    new com.aliyun.teaopenapi.models.OpenApiRequest().setBody(body);

            // 复制代码运行请自行打印 API 的返回值
            // 返回值为 Map 类型，可从 Map 中获得三类数据：响应体 body、响应头 headers、HTTP 返回的状态码 statusCode
            java.util.Map<String, ?> resp = client.callApi(params, request, runtime);
            // 打印返回结果
            log.info("人脸融合返回结果：{}", com.aliyun.teautil.Common.toJSONString(resp));

            // 判断人脸融合是否成功
            if (!JSONObject.parseObject(com.aliyun.teautil.Common.toJSONString(resp))
                    .get("statusCode")
                    .equals(200)) {
                throw new AiException("人脸融合失败，请重试");
            }

            // 获取人脸融合结果临时url
            return JSONObject.parseObject(com.aliyun.teautil.Common.toJSONString(resp))
                    .getJSONObject("body")
                    .getString("ImageURL");

        } catch (Exception ex) {
            log.error("人脸融合失败，原因：{}", ex.getMessage());

            throw new AiException("人脸融合失败，请检查后重试");
        }
    }
}

MergeImageFaceByInputStream

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
import com.aliyun.facebody20191230.models.MergeImageFaceResponse;
import com.aliyun.tea.TeaException;
import com.aliyun.tea.TeaModel;
import com.yqxc.aiface.biz.orderWorks.model.dto.MergeResultDto;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.io.InputStream;
import java.net.URL;

/**
 * @author 曳戈泰尔
 * @version 1.0
 * @description 图像人脸融合
 * @date 2023/3/14 11:39 AM
 */
@Component
@Slf4j
public class MergeImageFaceByInputStream {

    /** Face配置类 */
    private FaceConfig faceConfig;

    /** 客户端 */
    private com.aliyun.facebody20191230.Client client;

    @Autowired
    public MergeImageFaceByInputStream(FaceConfig faceConfig) {
        this.faceConfig = faceConfig;

        try {
            client =
                    createClient(
                            this.faceConfig.getAccessKeyId(),
                            this.faceConfig.getAccessKeySecret(),
                            this.faceConfig.getEndPoint());
        } catch (Exception ex) {
            log.error("初始化人脸融合Client失败，原因：{}", ex.getMessage());
        }
    }

    /**
     * 使用AK&SK初始化账号Client
     *
     * @param accessKeyId
     * @param accessKeySecret
     * @return Client
     * @throws Exception
     */
    public com.aliyun.facebody20191230.Client createClient(
            String accessKeyId, String accessKeySecret, String endPoint) throws Exception {

        com.aliyun.teaopenapi.models.Config config =
                new com.aliyun.teaopenapi.models.Config()
                        // 必填，您的 AccessKey ID
                        .setAccessKeyId(accessKeyId)
                        // 必填，您的 AccessKey Secret
                        .setAccessKeySecret(accessKeySecret);

        // 访问的域名
        config.endpoint = endPoint;

        return new com.aliyun.facebody20191230.Client(config);
    }

    /**
     * 执行人脸融合请求
     *
     * @param templateId
     * @param imageUrl
     * @return 合成图临时访问url
     */
    public MergeResultDto mergeFace(String templateId, String imageUrl) {

        try {
            // 场景一，使用本地文件
            // InputStream inputStream = new FileInputStream(new File("/tmp/mergeImageFace.png"));

            // 场景二，使用任意可访问的url
            URL url = new URL(imageUrl);
            InputStream inputStream = url.openConnection().getInputStream();

            // 设置请求参数
            com.aliyun.facebody20191230.models.MergeImageFaceAdvanceRequest
                    mergeImageFaceAdvanceRequest =
                            new com.aliyun.facebody20191230.models.MergeImageFaceAdvanceRequest()
                                    .setImageURLObject(inputStream)
                                    .setTemplateId(templateId);
            com.aliyun.teautil.models.RuntimeOptions runtime =
                    new com.aliyun.teautil.models.RuntimeOptions();

            // 执行请求
            MergeImageFaceResponse mergeImageFaceResponse =
                    client.mergeImageFaceAdvance(mergeImageFaceAdvanceRequest, runtime);
            // 获取整体结果
            log.info(
                    "人脸融合整体结果：{}",
                    com.aliyun.teautil.Common.toJSONString(
                            TeaModel.buildMap(mergeImageFaceResponse)));
            // 获取合成图临时url
            log.info("人脸融合结果临时url：{}", mergeImageFaceResponse.getBody().getData().getImageURL());

            if (StringUtils.isBlank(mergeImageFaceResponse.getBody().getData().getImageURL())) {
                return MergeResultDto.builder().status(false).err("图片无正脸或含有敏感违规信息").build();
            } else {
                return MergeResultDto.builder()
                        .status(true)
                        .tempUrl(mergeImageFaceResponse.getBody().getData().getImageURL())
                        .build();
            }

        } catch (TeaException teaException) {
            // 获取整体报错信息
            log.error("人脸融合整体报错信息：{}", com.aliyun.teautil.Common.toJSONString(teaException));

            // 不同结果返回不同内容
            if (com.aliyun.teautil.Common.toJSONString(teaException).contains("输入图像未检测到人脸")) {
                return MergeResultDto.builder().status(false).err("在您的图片中未检测到完整正脸").build();
            } else if (com.aliyun.teautil.Common.toJSONString(teaException)
                    .contains("输入图像含有敏感或违规信息")) {
                return MergeResultDto.builder().status(false).err("您上传的图片含有敏感违规信息").build();
            } else {
                return MergeResultDto.builder().status(false).err("图片无正脸或含有敏感违规信息").build();
            }

        } catch (Exception ex) {
            log.error("人脸融合失败，原因：{}", ex.getMessage());

            return MergeResultDto.builder().status(false).err("图片无正脸或含有敏感违规信息").build();
        }
    }

    //    /**
    //     * 执行人脸融合请求
    //     *
    //     * @param templateId
    //     * @param imageUrl
    //     * @return 合成图临时访问url
    //     */
    //    public String mergeFace(String templateId, String imageUrl) {
    //
    //        try {
    //            // 场景一，使用本地文件
    //            // InputStream inputStream = new FileInputStream(new
    // File("/tmp/mergeImageFace.png"));
    //
    //            // 场景二，使用任意可访问的url
    //            URL url = new URL(imageUrl);
    //            InputStream inputStream = url.openConnection().getInputStream();
    //
    //            // 设置请求参数
    //            com.aliyun.facebody20191230.models.MergeImageFaceAdvanceRequest
    //                    mergeImageFaceAdvanceRequest =
    //                            new
    // com.aliyun.facebody20191230.models.MergeImageFaceAdvanceRequest()
    //                                    .setImageURLObject(inputStream)
    //                                    .setTemplateId(templateId);
    //            com.aliyun.teautil.models.RuntimeOptions runtime =
    //                    new com.aliyun.teautil.models.RuntimeOptions();
    //
    //            // 执行请求
    //            try {
    //                MergeImageFaceResponse mergeImageFaceResponse =
    //                        client.mergeImageFaceAdvance(mergeImageFaceAdvanceRequest, runtime);
    //                // 获取整体结果
    //                log.info(
    //                        "人脸融合整体结果：{}",
    //                        com.aliyun.teautil.Common.toJSONString(
    //                                TeaModel.buildMap(mergeImageFaceResponse)));
    //                // 获取合成图临时url
    //                log.info(
    //                        "人脸融合结果临时url：{}",
    // mergeImageFaceResponse.getBody().getData().getImageURL());
    //
    //                return mergeImageFaceResponse.getBody().getData().getImageURL();
    //            } catch (TeaException teaException) {
    //                // 获取整体报错信息
    //                log.error("人脸融合整体报错信息：{}",
    // com.aliyun.teautil.Common.toJSONString(teaException));
    //
    //                throw new AiException("人脸融合失败");
    //            }
    //
    //        } catch (Exception ex) {
    //            log.error("人脸融合失败，原因：{}", ex.getMessage());
    //
    //            throw new AiException("人脸融合失败");
    //        }
    //    }
}

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

徘徊在原子与字节的边缘<br><br>将更好的自己呈现给世界<br><br><br><br>修心至要，事上磨练<br><br>一蓑衣，一壶酒，一曲长歌，一剑天涯<br><br>见自己，见天地，见众生<br><br>