mongo查询 、kakfa实现Kerberos认证、 企微、邮件推送、okhttp配置https认证

mongo查询

Criteria criteria = new Criteria();
if (null != active) {
    criteria.and("active").is(active);
}
if (StringUtils.isNotEmpty(content)) {
    Pattern pattern = Pattern.compile(".*" + content + ".*", Pattern.CASE_INSENSITIVE);
    criteria.and("content").regex(pattern);
}
if (StringUtils.isNotEmpty(templateName)) {
    Pattern pattern = Pattern.compile(".*" + templateName + ".*", Pattern.CASE_INSENSITIVE);
    criteria.and("templateName").regex(pattern);
}
Query query = Query.query(criteria);
query.with(Sort.by(Sort.Order.desc("updateTime")));
query.skip((pageIndex - 1) * pageSize);
query.limit(pageSize);
result = (List<T>) mongoTemplate.find(query, MessageRecord.class, MESSAGERECORD);

kafkaUtils

package .common.utils;

import .controller.view.bo.KafkaConfig;
import org.apache.commons.lang3.StringUtils;
import org.apache.kafka.clients.admin.AdminClient;
import org.apache.kafka.clients.admin.AdminClientConfig;
import org.apache.kafka.clients.consumer.Consumer;
import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.Producer;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.common.config.SaslConfigs;
import org.apache.kafka.common.serialization.StringDeserializer;
import org.apache.kafka.common.serialization.StringSerializer;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.DependsOn;
import org.springframework.kafka.config.ConcurrentKafkaListenerContainerFactory;
import org.springframework.kafka.config.KafkaListenerContainerFactory;
import org.springframework.kafka.core.DefaultKafkaConsumerFactory;
import org.springframework.kafka.listener.ContainerProperties;
import org.springframework.stereotype.Component;

import java.util.HashMap;
import java.util.Map;
import java.util.Properties;

@Component
public class KafkaUtils {

    @Value("${spring.kafka.bootstrap-servers}")
    private String BOOT_STRAP_SERVER_ADDRESS;
    @Value("${spring.kafka.principal}")
    private String PRINCIPAL;
    @Value("${spring.kafka.keytab}")
    private String KEYTAB;

    @Value("${spring.mail.mailOpen}")
    private Boolean mailState;

    @Value("${spring.mail.wechatOpen}")
    private Boolean wechatState;

    @Value("${spring.mail.smsOpen}")
    private Boolean smsState;

    private final String CONSUMERGROUP = "dtb_messageTemplateTopicGroup";


    public Properties getConsumerProperties() {
        Properties kafkaProps = new Properties();
        kafkaProps.put(KafkaConstant.BOOTSTRAP_SERVERS, BOOT_STRAP_SERVER_ADDRESS);
        kafkaProps.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        kafkaProps.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        if (StringUtils.isNotBlank(PRINCIPAL)) {
            kafkaProps.put(AdminClientConfig.SECURITY_PROTOCOL_CONFIG, KafkaConstant.SASL_PLAINTEXT);
            kafkaProps.put(SaslConfigs.SASL_MECHANISM, SaslConfigs.GSSAPI_MECHANISM);
            kafkaProps.put(SaslConfigs.SASL_KERBEROS_SERVICE_NAME, KafkaConstant.SERVICE_NAME);
            kafkaProps.put(SaslConfigs.SASL_JAAS_CONFIG, String.format(KafkaConstant.GSSAPI_CONFIG, PRINCIPAL, KEYTAB));
        }
        return kafkaProps;
    }

    public Properties getProducerProperties() {
        Properties kafkaProps = new Properties();
        kafkaProps.put(KafkaConstant.BOOTSTRAP_SERVERS, BOOT_STRAP_SERVER_ADDRESS);
        kafkaProps.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        kafkaProps.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        if (StringUtils.isNotBlank(PRINCIPAL)) {
            kafkaProps.put(AdminClientConfig.SECURITY_PROTOCOL_CONFIG, KafkaConstant.SASL_PLAINTEXT);
            kafkaProps.put(SaslConfigs.SASL_MECHANISM, SaslConfigs.GSSAPI_MECHANISM);
            kafkaProps.put(SaslConfigs.SASL_KERBEROS_SERVICE_NAME, KafkaConstant.SERVICE_NAME);
            kafkaProps.put(SaslConfigs.SASL_JAAS_CONFIG, String.format(KafkaConstant.GSSAPI_CONFIG, PRINCIPAL, KEYTAB));
        }
        return kafkaProps;
    }

    public Consumer<String, String> getConsumer(Properties kafkaProps) {
        return new KafkaConsumer(kafkaProps);
    }

    public AdminClient getAdminClient(Properties kafkaProps) {
        return AdminClient.create(kafkaProps);
    }

    public Producer<String, String> getProducer(Properties kafkaProps) {
        return new KafkaProducer(kafkaProps);
    }

    @Bean
    KafkaListenerContainerFactory<?> batchFactory() {
        ConcurrentKafkaListenerContainerFactory<String, String> factory = new ConcurrentKafkaListenerContainerFactory<>();
        factory.setConsumerFactory(new DefaultKafkaConsumerFactory<>(consumerConfigs()));
        factory.getContainerProperties().setAckMode(ContainerProperties.AckMode.MANUAL);
//        factory.setBatchListener(true); // 开启批量监听
        return factory;
    }

    @Bean
    public Map<String, Object> consumerConfigs() {
        Map<String, Object> props = new HashMap<>();
        props.put(ConsumerConfig.GROUP_ID_CONFIG,CONSUMERGROUP+mailState+wechatState+smsState);
        props.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "earliest");
        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, BOOT_STRAP_SERVER_ADDRESS);
        props.put(ConsumerConfig.MAX_POLL_RECORDS_CONFIG, 100); //设置每次接收Message的数量
//        props.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG, "100");
        props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, false);
        props.put(ConsumerConfig.SESSION_TIMEOUT_MS_CONFIG, 120000);
        props.put(ConsumerConfig.REQUEST_TIMEOUT_MS_CONFIG, 180000);
        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        if (StringUtils.isNotBlank(PRINCIPAL)) {
            props.put(AdminClientConfig.SECURITY_PROTOCOL_CONFIG, KafkaConstant.SASL_PLAINTEXT);
            props.put(SaslConfigs.SASL_MECHANISM, SaslConfigs.GSSAPI_MECHANISM);
            props.put(SaslConfigs.SASL_KERBEROS_SERVICE_NAME, KafkaConstant.SERVICE_NAME);
            props.put(SaslConfigs.SASL_JAAS_CONFIG, String.format(KafkaConstant.GSSAPI_CONFIG, PRINCIPAL, KEYTAB));
        }
        return props;
    }

}

kafkaConstant

package .common.utils;

public class KafkaConstant {

    public final static String BOOTSTRAP_SERVERS = "bootstrap.servers";
    public final static String KEY_DESERIALIZER_CLASS_CONFIG = "key.deserializer";
    public final static String VALUE_DESERIALIZER_CLASS_CONFIG = "value.deserializer";

    public static final String SECURITY_PROTOCOL_CONFIG = "security.protocol";

    public static final String SASL_PLAINTEXT = "SASL_PLAINTEXT";

    public static final String SERVICE_NAME = "kafka";

    public static final String SASL_MECHANISM = "sasl.mechanism";


    public static final String SASL_KERBEROS_SERVICE_NAME = "sasl.kerberos.service.name";

    public static final String SASL_JAAS_CONFIG = "sasl.jaas.config";

    public static final String GSSAPI_CONFIG =
            "com.sun.security.auth.module.Krb5LoginModule required useKeyTab=true storeKey=true principal="%s"  keyTab="%s";";

    public static final String GSSAPI_MECHANISM = "GSSAPI";

    public static final String KAFKA = "KAFKA";
}

sendToKafka

private void sendToKafka(MessageRecord messageRecord) {
    Properties producerProperties = kafkaUtils.getProducerProperties();
    AdminClient adminClient = kafkaUtils.getAdminClient(producerProperties);
    ListTopicsResult listTopicsResult = adminClient.listTopics();
    boolean contains = false;
    try {
        contains = listTopicsResult.names().get().contains(TOPICNAME);
        if (!contains) {
            ArrayList<NewTopic> topics = new ArrayList<>();
            NewTopic newTopic = new NewTopic(TOPICNAME, 1, (short) 1);
            topics.add(newTopic);
            CreateTopicsResult result = adminClient.createTopics(topics);
        }
    } catch (Exception e) {
        log.error(e.getMessage());
    } finally {
        adminClient.close();
    }
    producerProperties.setProperty(ProducerConfig.ACKS_CONFIG, "-1");
    Producer<String, String> producer = kafkaUtils.getProducer(producerProperties);
    try {
        ProducerRecord<String, String> objectMessageRecordProducerRecord = new ProducerRecord<>(TOPICNAME, JSON.toJSONString(messageRecord));
        producer.send(objectMessageRecordProducerRecord);
    } catch (Exception e) {
        log.error(e.getMessage());
    } finally {
        producer.close();
    }
}

kafkaListner

@KafkaListener(topics = {TOPICNAME}, containerFactory = "batchFactory")
public void MessageConsumer(String record, Acknowledgment acknowledgment) {
    log.info("-----------{}-----", record);
    if (null == record) {
        return;
    }
    MessageRecord messageRecord = JSON.parseObject(record, MessageRecord.class);
    Integer type = messageRecord.getType();
    log.info("----------mailOpen-------{}", mailState);
    if (!mailState && 1 == type) {
        acknowledgment.acknowledge();
        return;
    }
    if (!smsState && 2 == type) {
        acknowledgment.acknowledge();
        return;
    }
    if (!wechatState && 3 == type) {
        acknowledgment.acknowledge();
        return;
    }
    if (null == type) {
        acknowledgment.acknowledge();
        return;
    }
    switch (type) {
        //1邮箱 2短信 3企业微信
        case 1:
            log.info("开始邮箱发送告警信息");
            log.info("告警记录是:{}",messageRecord);
            mailSender(messageRecord);
            break;
        case 2:
            break;
        case 3:
            wechatSender(messageRecord);
            break;
    }
    acknowledgment.acknowledge();
}

企业微信消息推送

package .service.impl;

import com.alibaba.fastjson.JSONObject;
import com.dtb.core.utils.SpringContextUtils;
import com.dtb.datafactory.common.utils.SnowFlakeUtils;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.codec.binary.Base64;
import org.apache.http.HttpEntity;
import org.apache.http.NameValuePair;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;


@Slf4j
@Service
public class WeChatMessageServiceImpl {
    protected int requestCount = 0;
    // 生成Basic 鉴权编码
    private String authString = "xxxxxx";
    private byte[] authEncBytes = Base64.encodeBase64(authString.getBytes());
    private final String CHARSET = "UTF-8";
    private final String CT_TYPE = "Content-Type";
    private final String CT_FROM = "application/x-www-form-urlencoded; charset=" + CHARSET;
    private final String CT_JSON = "application/json; charset=" + CHARSET;

    @Value("${spring.mail.wechatHost}")
    private String preUrl = "";

    private String reqFrom = "pppp";

    public void sendTxt(String phone,String context) throws Exception {
        long id = SpringContextUtils.getContext()
                .getBean(SnowFlakeUtils.class)
                .nextId();
        String guid=Long.toString(id);
        String time = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()).replace(" ", "%20");
        String url = String.format("%s/weWorkPortal_push_serviceTxtMsg?reqId=%s&reqFrom=%s&reqTime=%s", preUrl, guid, reqFrom, time);
        JSONObject jsonHeader = new JSONObject(true);
        String authStringEnc = new String(authEncBytes);
        jsonHeader.put("Authorization", "Basic " + authStringEnc);
        jsonHeader.put(CT_TYPE, CT_JSON);
        JSONObject jsonParam = new JSONObject(true);
        jsonParam.put("msgId", guid);
        jsonParam.put("systemId", "======");
        jsonParam.put("destName", "-------");
        jsonParam.put("msgType", "text");
        jsonParam.put("toUser", phone);
        jsonParam.put("content", context);
        String rtn = doPost(url, jsonParam, jsonHeader);
        log.debug("Response: {}", rtn);
        HashMap hashMap = JSONObject.parseObject(rtn, HashMap.class);
        if (null==hashMap || null==hashMap.get("code") || !"0".equals((hashMap.get("code")))){
            throw new RuntimeException("企业微信文本消息推送失败");
        }
    }

    public void sendCard(String phone,String context,String targetUrl,String title) throws Exception {
        long id = SpringContextUtils.getContext()
                .getBean(SnowFlakeUtils.class)
                .nextId();
        String guid=Long.toString(id);
        String time = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()).replace(" ", "%20");
        String url = String.format("%s/weWorkPortal_push_serviceTxtCardMsg?reqId=%s&reqFrom=%s&reqTime=%s", preUrl, guid, reqFrom, time);
        JSONObject jsonHeader = new JSONObject(true);
        String authStringEnc = new String(authEncBytes);
        jsonHeader.put("Authorization", "Basic " + authStringEnc);
        jsonHeader.put(CT_TYPE, CT_JSON);
        JSONObject jsonParam = new JSONObject(true);
        jsonParam.put("msgId", guid);
        jsonParam.put("systemId", "======");
        jsonParam.put("destName", "------");
        jsonParam.put("title", title);
        jsonParam.put("msgType", "textcard");
        jsonParam.put("toUser", phone);
        jsonParam.put("description", context);
        jsonParam.put("url", targetUrl);
        jsonParam.put("btnTxt", "更多");
        String rtn = doPost(url, jsonParam, jsonHeader);
        log.debug("Response: {}", rtn);
        HashMap hashMap = JSONObject.parseObject(rtn, HashMap.class);
        if (null==hashMap || null==hashMap.get("code") || !"0".equals((hashMap.get("code")))){
            throw new RuntimeException("企业微信卡片消息推送失败");
        }
    }

    public void sendPic(String phone,String context,String targetUrl,String picUrl,String title) throws Exception {
        long id = SpringContextUtils.getContext()
                .getBean(SnowFlakeUtils.class)
                .nextId();
        String guid=Long.toString(id);
        String time = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()).replace(" ", "%20");
        String url = String.format("%s/weWorkPortal_push_servicePicExtMsg?reqId=%s&reqFrom=%s&reqTime=%s", preUrl, guid, reqFrom, time);
        JSONObject jsonHeader = new JSONObject(true);
        String authStringEnc = new String(authEncBytes);
        jsonHeader.put("Authorization", "Basic " + authStringEnc);
        jsonHeader.put(CT_TYPE, CT_JSON);
        JSONObject jsonParam = new JSONObject(true);
        jsonParam.put("msgId", guid);
        jsonParam.put("systemId", "======");
        jsonParam.put("destName", "------");
        jsonParam.put("msgType", "news");
        jsonParam.put("toUser", phone);
        jsonParam.put("title", title);
        jsonParam.put("description", context);
        jsonParam.put("url",  targetUrl);
        jsonParam.put("picUrl", picUrl);
        String rtn = doPost(url, jsonParam, jsonHeader);
        log.debug("Response: {}", rtn);
        HashMap hashMap = JSONObject.parseObject(rtn, HashMap.class);
        if (null==hashMap || null==hashMap.get("code") || !"0".equals((hashMap.get("code")))){
            throw new RuntimeException("企业微信图文消息推送失败");
        }
    }

    protected String doPost(String url, JSONObject jsonParam, JSONObject jsonHeader) {
        String rtn = null;
        CloseableHttpClient httpClient = null;
        try {
            if (jsonHeader == null) {
                jsonHeader = new JSONObject(true);
            }
            jsonHeader.put("Accept", "application/json, text/plain, */*");
            jsonHeader.put("Accept-Encoding", "gzip, deflate, br");
            jsonHeader.put("Accept-Language", "zh-CN,zh;q=0.9,en;q=0.8,en-GB;q=0.7,en-US;q=0.6");
            jsonHeader.put("Connection", "keep-alive");
            log.debug("request: {}, url: {}, param: {}, header: {}", ++requestCount, url, jsonParam, jsonHeader);
            httpClient = HttpClientBuilder.create().build();
            RequestConfig requestConfig = RequestConfig.custom().setConnectionRequestTimeout(5000).setSocketTimeout(5000).setConnectTimeout(5000).build();
            // 创建Get请求
            HttpPost http = new HttpPost(url);
            String contentType = null;
            for (String key : jsonHeader.keySet()) {
                String value = jsonHeader.getString(key);
                http.addHeader(key, value);
                if (key.equals(CT_TYPE)) {
                    contentType = value;
                }
            }
            if (jsonParam != null) {
                if (contentType.equals(CT_FROM)) {
                    List<NameValuePair> params = new ArrayList<>();
                    for (String key : jsonParam.keySet()) {
                        String value = jsonParam.getString(key);
                        params.add(new BasicNameValuePair(key, value));
                    }
                    http.setEntity(new UrlEncodedFormEntity(params, CHARSET));
                } else if (contentType.equals(CT_JSON)) {
                    http.setEntity(new StringEntity(jsonParam.toJSONString(), CHARSET));
                }
            }
            CloseableHttpResponse response = null;
            // 由客户端执行(发送)Get请求
            response = httpClient.execute(http);
            // 从响应模型中获取响应实体
            HttpEntity responseEntity = response.getEntity();
            rtn = EntityUtils.toString(responseEntity);
        } catch (Exception e) {
            log.error(String.format("Post request throw exception: %s", e.getMessage()), e);
        } finally {
            if (httpClient != null) {
                try {
                    httpClient.close();
                } catch (Exception e) {
                    log.error(String.format("Close http client throw exception: %s", e.getMessage()), e);
                }
            }
        }
        return rtn;
    }
}

邮箱推送

private void mailSender(MessageRecord messageRecord) {
    SimpleMailMessage simpleMailMessage = new SimpleMailMessage();
    simpleMailMessage.setFrom(from);
    if (StringUtils.isBlank(messageRecord.getReceiver())) {
        return;
    }
    String[] receivers = messageRecord.getReceiver().split(",");
    simpleMailMessage.setTo(receivers);
    simpleMailMessage.setSubject(messageRecord.getTitle());
    simpleMailMessage.setText(messageRecord.getContent());
    messageRecord.setActive(true);
    messageRecord.setUpdateTime(LocalDateTime.now());
    try {
        javaMailSender.send(simpleMailMessage);
    } catch (Exception e) {
        messageRecord.setActive(false);
        log.error("------消息发送失败---------");
        log.error(e.getMessage());
    }
    Query query = new Query(Criteria.where("_id").is(messageRecord.getId()));
    Update update = new Update();
    update.set("active", messageRecord.getActive());
    update.set("updateTime", messageRecord.getUpdateTime());
    mongoTemplate.updateFirst(query, update, MESSAGERECORD);
}

okhttp

package .common.utils;

import .domain.entity.TrustCerts;
import okhttp3.ConnectionPool;
import okhttp3.OkHttpClient;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
import java.security.SecureRandom;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.concurrent.TimeUnit;

/**
 * Created by claire on 2019-09-10 - 15:02
 **/
@Configuration
public class OkHttpClientConfig {


    private  static  SSLSocketFactory createSSLSocketFactory() {
        SSLSocketFactory ssfFactory = null;

        try {
            SSLContext sc = SSLContext.getInstance("TLS");
            sc.init(null, new TrustManager[]{new TrustCerts()}, new SecureRandom());
            ssfFactory = sc.getSocketFactory();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }

        return ssfFactory;
    }

    @Bean
    public ConnectionPool pool() {
        return new ConnectionPool(200, 5, TimeUnit.MINUTES);
    }

    @Bean
    public OkHttpClient okHttpClient() {
        OkHttpClient.Builder builder = new OkHttpClient.Builder();

        TrustManager[] trustAllCertificates = new TrustManager[]{new X509TrustManager() {
            @Override
            public X509Certificate[] getAcceptedIssuers() {
                return new X509Certificate[0];
            }

            @Override
            public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
            }

            @Override
            public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
            }
        }};

        // 创建 SSLContext，并使用自定义的 TrustManager
        try {
            SSLContext sslContext = SSLContext.getInstance("TLS");
            sslContext.init(null, trustAllCertificates, new java.security.SecureRandom());

            // 从 SSLContext 中获取 SSLSocketFactory
            SSLSocketFactory sslSocketFactory = sslContext.getSocketFactory();

            builder.connectTimeout(30, TimeUnit.SECONDS)
                    .readTimeout(30, TimeUnit.SECONDS)
                    .writeTimeout(30, TimeUnit.SECONDS)
                    .retryOnConnectionFailure(false)
                    .connectionPool(pool())
                    .sslSocketFactory(sslSocketFactory,(X509TrustManager) trustAllCertificates[0])
                    .hostnameVerifier((hostname, session) -> true);
        }catch (Exception e){
            return null;
        }


        return builder.build();
    }
}

TrustCerts

package .domain.entity;

import javax.net.ssl.X509TrustManager;
import java.security.cert.X509Certificate;

public class TrustCerts implements X509TrustManager {
    @Override
    public void checkClientTrusted(X509Certificate[] chain, String authType) {}

    @Override
    public void checkServerTrusted(X509Certificate[] chain, String authType) {}

    @Override
    public X509Certificate[] getAcceptedIssuers() {return new X509Certificate[0];}

}

httpUtils

package .common.utils;

import lombok.extern.slf4j.Slf4j;
import okhttp3.*;
import org.springframework.http.HttpHeaders;
import org.springframework.util.StringUtils;

import java.util.List;
import java.util.Map;

@Slf4j
public class HttpUtils {

    private static String cookiesAuth;
    private static String execNewCall(Request request,OkHttpClient okHttpClient){
        Response response = null;
        try {

            response = okHttpClient.newCall(request).execute();
//            if(okHttpClient.cookieJar() != CookieJar.NO_COOKIES){
                List<Cookie> cookies = Cookie.parseAll(request.url(), response.headers());
                if(!cookies.isEmpty()){
                    cookiesAuth=cookies.get(0).toString();
                    okHttpClient.cookieJar().saveFromResponse(request.url(),cookies);
                }
//            }
            int status = response.code();
//            log.error(response.body().string());
//                log.error(cookiesAuth);
            if (status == 200 && response.isSuccessful()) {
                return response.body().string();
            }
        } catch (Exception e) {
            log.error("okhttp3 put error >> ex = {}", e);
        } finally {
            if (response != null) {
                response.close();
            }
        }
        return null;
    }

    public static String postFormParams(String url, Map<String, String> params, Map<String, String> headerParamsMap,OkHttpClient okHttpClient) {
        FormBody.Builder builder = new FormBody.Builder();
        //添加参数
        if (params != null && params.keySet().size() > 0) {
            for (String key : params.keySet()) {
                builder.add(key, params.get(key));
            }
        }
        Request.Builder builder1 = new Request.Builder();
        if(headerParamsMap != null && headerParamsMap.keySet().size()>0){
            Headers headers = Headers.of(headerParamsMap);
            builder1.headers(headers);
        }
        Request request = builder1
                .url(url)
                .post(builder.build())
                .build();
        return execNewCall(request,okHttpClient);
    }

    public static String postJsonParams(OkHttpClient okHttpClient,String url, String jsonParams,Map<String, String> headerParamsMap ) {
        RequestBody requestBody = RequestBody.create(MediaType.parse("application/json; charset=utf-8"), jsonParams);
        Request.Builder builder = new Request.Builder()
                .url(url)
                .post(requestBody);
        if(headerParamsMap != null && !headerParamsMap.isEmpty()) {
            if (!StringUtils.isEmpty(cookiesAuth)){
                headerParamsMap.put(HttpHeaders.COOKIE,cookiesAuth);
            }
            Headers headers = Headers.of(headerParamsMap);
            builder.headers(headers);
        }
        return execNewCall(builder.build(),okHttpClient);
    }

    public static String postJsonParams(OkHttpClient okHttpClient,String url, String jsonParams) {
        RequestBody requestBody = RequestBody.create(MediaType.parse("application/json; charset=utf-8"), jsonParams);
        Request request = new Request.Builder()
                .url(url)
                .post(requestBody)
                .build();
        return execNewCall(request,okHttpClient);
    }
}

service层

@Autowired
private OkHttpClientConfig okHttpClientConfig;

freeipa新增用户

package .common.constant;

public class IPARequestConstant {

    // URL
    public static final String LOGIN_SERVICE = "/ipa/session/login_password";
    public static final String LOOKUP_SERVICE = "/ipa/session/json";
    public static final String LOOKUP_REFERER = "/ipa/ui/";

    //request content
    public static final String USER_NAME = "user";
    public static final String USER_PASSWORD="password";

    public static String buildUserRequestInfo(String username){
        return "{"method":"user_show/1","params":[["" + username + ""],{"all":true,"version":"2.237"}]}";
    }

    public static String buildUserAddRequestInfo(String username){
        return "{"method":"user_add/1","params":[["" + username + ""],{"givenname":"+username+"","sn":"cdp","version":"2.237"}]}";
    }

}