jsoup登录日志平台后调企业微信机器人自动发送错误日志告警

已于 2024-01-12 17:36:56 修改
阅读量696 收藏 9
点赞数 10
分类专栏： java 文章标签： 企业微信 机器人
于 2023-11-24 17:09:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wayne_youlu/article/details/134602736
版权

一、需求：错误日志Top10告警发送

二、需求分解

  1. jsoup实现登录，获取到cookie和token等用户鉴权信息
  2. 获取接口相应的key值
  3. 调用日志平台错误日志Top榜接口，查询到结果集
  4. 处理消息（调用企业微信机器人发送消息接口，电话预警功能）
  5. 加上定时任务，可以实现定时发送错误日志告警的功能

定时任务高度设置1小时（根据实际需要）执行一次，可以实现自动巡检错误日志的功能。以便及时发现生产问题

jsoup是java的爬虫框架，可以爬取网页数据，这里没有重点使用，只是做了个登录功能。后续可以专门它写一份爬虫的程序。。

  <dependency>
            <groupId>org.jsoup</groupId>
            <artifactId>jsoup</artifactId>
            <version>1.12.1</version>
        </dependency>
package com.smy.cbs.task;

import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.http.HttpRequest;
import cn.hutool.http.HttpResponse;
import cn.hutool.http.HttpUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.google.common.collect.Lists;
import com.smy.cbs.client.NtfServiceClient;
import com.smy.cbs.entity.DelayedElement;
import com.smy.cbs.util.RetryUtil;
import com.smy.framework.redis.RedisLock;
import com.smy.smyx.scheduler.dto.TaskRequest;
import com.smy.smyx.scheduler.dto.TaskResponse;
import com.smy.smyx.scheduler.service.TaskService;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.jsoup.Connection;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import javax.net.ssl.*;
import java.io.IOException;
import java.math.BigDecimal;
import java.security.SecureRandom;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.*;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.DelayQueue;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

/**
 * @author youlu
 * @ClassName logCenterTask
 * @Date 2023/11/22 17:14
 * @Version V1.0
 **/
@Slf4j
@Service("logCenterTask")
public class LogCenterTask implements TaskService {
    @Resource
    private RetryUtil retryUtil;
    @Resource
    private NtfServiceClient ntfServiceClient;

    @Value("${log.usename:aaaa}")
    public String USER_NAME;
    @Value("${log.password:bbbb}")
    public String PASSWORD;
    @Value("${log.content.warn.max:24000000}")
    public int maxCount;//达到阈值则告警
    @Value("${log.warn.count:100}")
    public int warnCount;//字体标黄,打电话告警阈值
    @Value("#{'${log.content.filter.content:输入要过滤的内容有英文逗号隔开}'.split(',')}")
    public List<String> filterContent = Lists.newArrayList();//过滤内容
    @Value("${log.content.length:240}")
    public int SUB_CONTENT_LENGTH = 300;//截取报错内容字符串长度
    @Value("${log.title.length:20}")
    public int SUB_TITLE_LENGTH = 40;//截取报错类型字符串长度
    @Value("${log.period.hour:24}")
    public int PERIOD_HOUR;//24小时内的错误日志
    @Value("#{'${log.search.system:cbs_core,rls_core,uts_core,adv_core}'.split(',')}")
    public List<String> SEARCH_SYSTEM;//查询的系统
    @Value("#{'${log.wx.url:https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=b54887d8-xxxx,https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=87140cb7-x123}'.split(',')}")
    public List<String> WX_ROBOT_URL;
    @Value("#{'${log.warn.phone:}'.split(',')}")
    public List<String> MOBILE_PHONE;//预警手机
    @Value("#{'${log.filter.phone.time:0,1,2,3,4,5,6,7,13,22,23}'.split(',')}")
    public List<Integer> filterPhoneTime;//电话预警时间过滤
    @Value("${log.phone.warn.lock.hour:6}")
    public int phoneWarnLockHour;//小时
    @Value("${log.url:https://log_center.xxxx.com/api/}")
    public  String LOG_CENTER_BASE_URL;

    public static String X_Csrf_Token = "59e82a89-d671-462e-87be-ee6cd30cd7f8";
    public static String COOKIE = "JSESSIONID=MWY1NjUxMDItYzU3Ny00Y2Y1LTk2OTYtZjUxZjQ5ZGIzZWRiLGwwMTU2MixyNmdNVkxsSHJWNW9kaDFoMTMxVGRNQ0oyc3c9";
    public static String id = "Zf_0-osBnsFDyEFyLnk0";

    public static final String TEMPLATE = "{\"msgtype\":\"markdown\",\"markdown\":{\"content\":\"%s\"}}";
    public static final String QUERY_TEMPLATE = "{\n" +
            "  \"app\": \"system\",\n" +
            "  \"source\": \"other\",\n" +
            "  \"query\": \"repo=\\\"smy_%s\\\" origin=\\\"*\\\" AND \\\"ERROR\\\"\\n| where level=\\\"ERROR\\\"\\n| eval err_type=arr_index(split(arr_index(split(_raw, \\\" - \\\"), 1), \\\"\\\\d+\\\"), 0)\\n| stats count() as num by err_type\\n| sort 10 by num\\n| join type=inner err_type [\\n  repo=\\\"smy_%s\\\" origin=\\\"*\\\" AND \\\"ERROR\\\"\\n  | where level=\\\"ERROR\\\"\\n  | eval err_type=arr_index(split(arr_index(split(_raw, \\\" - \\\"), 1), \\\"\\\\d+\\\"), 0)\\n  | fields + err_type, _raw\\n  | dedup err_type\\n]\\n| rename _raw as 原始日志, num as 统计, err_type as 错误类型\",\n" +
            "  \"mode\": \"smart\",\n" +
            "  \"preview\": false,\n" +
            "  \"collectSize\": -1,\n" +
            "  \"timeout\": 1000,\n" +
            "  \"sorts\": []\n" +
            "}";
    public static final BlockingQueue<DelayedElement> delayQueue = new DelayQueue<>();
    public static int telWarnIndex = 0;


    @PostConstruct
    public void init() {
        new Thread(() -> {
            while (true) {
                String  system = null;
                try {
                    DelayedElement element = delayQueue.take();
                    String data = element.getData();
                    if (StringUtils.isBlank(data)) {
                        continue;
                    }
                    Date date = new Date();
                    int hour = DateUtil.hour(date, true);
                    if (filterPhoneTime.stream().anyMatch(k -> k == hour)) {
                        continue;
                    }
                    JSONObject jsonObject = JSONObject.parseObject(data);
                    for (Map.Entry<String, Object> entry : jsonObject.entrySet()) {
                        String k = entry.getKey();
                        Object v = entry.getValue();
                        system = k;
                        boolean lock = RedisLock.tryLock("LOG_CENTER_PHONE_WARN_" + k, phoneWarnLockHour * 60 * 60, 0, TimeUnit.SECONDS);
                        if (!lock) {
                            log.info("{}系统在{}小时内重复触发电话告警，程序已拦截", k, phoneWarnLockHour);
                            continue;
                        }
                        JSONArray telWarnTitles = JSONObject.parseArray(v.toString());
                        String titleStr = telWarnTitles.stream().map(m -> m.toString()).collect(Collectors.joining("。"));
                        int size = telWarnTitles.size();
                        String content = String.format("%s共出现%s条超过阈值错误信息%s", k, size, titleStr);
                        MOBILE_PHONE.stream().forEach(m -> ntfServiceClient.callAlarmPhone(m, k, content));
                    }
                } catch (Exception e) {
                    log.error("{}超过电话预警获取延迟队列出现异常e：{}", system, e);
                }
            }
        }).start();
    }

    @SneakyThrows
    @Override
    public TaskResponse execute(TaskRequest request) {
        log.info("开始执行错误日志top10巡检");
        //1.模拟登录 jsoup
        jsoupLogin();

        for (String systemName : SEARCH_SYSTEM) {
            try {
                Thread.sleep(1000);
                //2.获取key
                String id = getKey(systemName);
                Thread.sleep(8000);
                //3.获取查询结果
                List<Map<String, Object>> logCenterList = retryUtil.doRetry(4, () -> getLogContents(systemName, id), systemName + "获取日志数据");
                if (CollectionUtils.isEmpty(logCenterList)) {
                    log.error("{}发送内容为空，不发送机器人微信消息", systemName);
                    continue;
                }
                //4.处理信息
                handleMessage(systemName, logCenterList);
            } catch (Exception e) {
                log.error("{}发送错误日志告警出现异常e:{}", systemName, e);
            }
        }
        telWarnIndex = 0;
        return new TaskResponse(TaskResponse.SUCCESS, "logCenter任务完成");
    }

    private List<Map<String, Object>> getLogContents(String systemName, String id) throws Exception {
        List<Map<String, Object>> contentList = getContentList(systemName, id);
        if (CollectionUtils.isEmpty(contentList)) {
            Thread.sleep(8000);
            throw new Exception(systemName + "未查询到数据，需要重试！");
        }
        return contentList;
    }

    public String getKey(String systemName) {
        Date endDate = new Date();
        Date startDate = DateUtil.offsetHour(endDate, -PERIOD_HOUR);
        //请求参数
        JSONObject paramJson = JSON.parseObject(String.format(QUERY_TEMPLATE, systemName, systemName));
        paramJson.put("startTime", startDate.getTime());
        paramJson.put("endTime", endDate.getTime());
        HttpResponse execute = HttpRequest.post(LOG_CENTER_BASE_URL + "jobs")
                //设置请求头(可任意加)
                .header("X-Csrf-Token", X_Csrf_Token)
                .header("Cookie", COOKIE)
                .header("Content-Type", "application/json")
                .header("Connection", "keep-alive")
                //请求参数
                .body(paramJson.toJSONString())
                .timeout(40000)
                .execute();
        String body1 = execute.body();
        String id = JSON.parseObject(body1).getString("id");
        return id;
    }

    public List<Map<String, Object>> getContentList(String systemName, String id) {
        String url = LOG_CENTER_BASE_URL + "jobs/" + id + "/results";
        HttpResponse execute = HttpRequest.get(url)
                //设置请求头(可任意加)
                .header("X-Csrf-Token", X_Csrf_Token)
                .header("Cookie", COOKIE)
                //.header("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.36")
                .timeout(40000)
                .execute();

        JSONArray rows = JSON.parseObject(execute.body()).getJSONArray("rows");
        System.err.println(rows.toString());
        List<Map<String, Object>> list = Lists.newArrayList();
        for (Object row : rows) {
            try {
                JSONArray jsonArray = JSON.parseArray(row.toString());
                String title = jsonArray.get(0).toString();
                Integer count = Integer.valueOf(jsonArray.get(1).toString());
                String content = jsonArray.get(2).toString();
                if (count >= maxCount) {
                    continue;
                }
                if (filterContent.stream().anyMatch(k -> content.contains(k))) {
                    continue;
                }
                int subContentLen = content.length() <= SUB_CONTENT_LENGTH ? content.length() : SUB_CONTENT_LENGTH;
                String subContent = content.substring(0, subContentLen);
                int subTitleLen = title.length() <= SUB_TITLE_LENGTH ? title.length() : SUB_TITLE_LENGTH;
                String subTitle = title.substring(0, subTitleLen);

                Map<String, Object> map = new HashMap<>();
                map.put("title", subTitle);
                map.put("count", count);
                map.put("content", StrUtil.removeSuffix(subContent, "{"));
                list.add(map);
            } catch (Exception e) {
                log.error("{}获取日志统计数据出现异常e:{}", systemName, e);
            }
        }
        if (CollectionUtils.isEmpty(list)) {
            log.info("{}未获取到数据，请求链接url：{},token:{},cookie:{}", systemName, url, X_Csrf_Token, COOKIE);
        }
        return list;
    }

    public void handleMessage(String systemName, List<Map<String, Object>> contentList) {
        int topNum = 1;
        int warnTitleNum = 1;
        List<String> wxContents = Lists.newArrayList();
        List<String> telWarnTitles = Lists.newArrayList();
        for (Map<String, Object> k : contentList) {
            String title = (String) k.get("title");
            Integer count = (Integer) k.get("count");
            Boolean warnFlag = Optional.ofNullable(count).map(m -> m > warnCount).orElse(false);
            String content = (String) k.get("content");
            String wxContent;
            if (warnFlag) {
                wxContent = String.format("> <font color=warning>top-%d：出现次数：%d</font>\n> <font color=warning>错误详情描述: %s</font>", topNum++, count, content.trim());
                String warnTitle = String.format("第%s条%s", warnTitleNum++, title);
                telWarnTitles.add(warnTitle);
            } else {
                wxContent = String.format("> top-%d：出现次数：%d\n> 错误详情描述: %s", topNum++, count, content.trim());
            }
            wxContents.add(wxContent);
        }
        sendWxMsg(systemName, wxContents);
        if (CollectionUtils.isNotEmpty(telWarnTitles) && PERIOD_HOUR <= 24) {
            JSONObject jsonObject = new JSONObject();
            jsonObject.put(systemName, telWarnTitles);
            try {//入延迟队列，为打电话做准备
                delayQueue.put(new DelayedElement(jsonObject.toJSONString(), 120000 * telWarnIndex));//n*2分钟
                telWarnIndex++;
            } catch (Exception e) {
                log.error("{}超过电话预警加入延迟队列出现异常e:{}", systemName, e);
            }
        }
    }

    private void sendWxMsg(String systemName, List<String> wxContents) {
        String periodDesc = getPeriodDesc();
        String StringContent = wxContents.stream().filter(Objects::nonNull).collect(Collectors.joining("\n\n"));
        String content = String.format("%s近%s内错误日志Top10\n%s", systemName, periodDesc, StringContent);
        String sendContent = String.format(TEMPLATE, content);//
        WX_ROBOT_URL.forEach(wx -> {
            String post2 = HttpUtil.post(wx, sendContent);
            String errcode = JSON.parseObject(post2).getString("errcode");
            if (!"0".equals(errcode)) {
                log.error("{}发送微信不成功，返回数据：{}", systemName, post2);
            }
        });
    }


    private String getPeriodDesc() {
        if (PERIOD_HOUR <= 24) {
            return PERIOD_HOUR + "小时";
        }
        BigDecimal dayBigDecimal = BigDecimal.valueOf(PERIOD_HOUR).divide(BigDecimal.valueOf(24), 2, BigDecimal.ROUND_HALF_UP);
        String s = StrUtil.removeSuffix(StrUtil.removeSuffix(String.valueOf(dayBigDecimal), "00"), "0");
        String[] split = s.split("\\.");
        if (split.length == 1) {
            return split[0] + "天";
        }
        return s + "天";
    }

    /**
     * Jsoup 模拟登录 访问个人中心
     * 在登录时先输入一个错误的账号密码，查看到登录所需要的参数
     * 先构造登录请求参数，成功后获取到cookies
     * 设置request cookies，再次请求
     *
     * @throws IOException
     */
    public void jsoupLogin() throws IOException {
        //Jsoup加这个，避免请求https报证书问题
        trustEveryone();
        // 构造登陆参数
        Map<String, String> data = new HashMap<>();
        data.put("username", USER_NAME);
        data.put("password", PASSWORD);
        Connection.Response response = Jsoup.connect(LOG_CENTER_BASE_URL + "account/ldap/login")
                .ignoreContentType(true) // 忽略类型验证
                .ignoreHttpErrors(true)
                .followRedirects(false) // 禁止重定向
                .postDataCharset("utf-8")
                .header("Upgrade-Insecure-Requests", "1")
                .header("Accept", "application/json")
                .header("Content-Type", "application/json")
                .header("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36")
                .requestBody(JSON.toJSONString(data))
                .method(Connection.Method.POST)
                .execute();
        response.charset("UTF-8");
        // login 中已经获取到登录成功之后的cookies
        // 构造访问个人中心的请求
        Map<String, String> cookies = response.cookies();
        cookies.forEach((k, v) -> COOKIE = k + "=" + v);
        String body = response.body();
        X_Csrf_Token = JSON.parseObject(body).getString("X-Csrf-Token");

        System.err.println("COOKIE:" + COOKIE);
        System.err.println("X_Csrf_Token:" + X_Csrf_Token);
    }

    public  void jsoupHandle(String id) throws IOException {
        String url = LOG_CENTER_BASE_URL + "jobs/" + id + "/results";
        Document document = Jsoup.connect(url)
                .header("X-Csrf-Token", X_Csrf_Token)
                .header("Cookie", COOKIE)
                .ignoreContentType(true) // 忽略类型验证
                .ignoreHttpErrors(true)
                .method(Connection.Method.GET)
                .get();
        System.err.println(url);
        String s = JSON.toJSONString(document);
        System.err.println(s);

    }


    public static void trustEveryone() {
        try {
            HttpsURLConnection.setDefaultHostnameVerifier(new HostnameVerifier() {
                public boolean verify(String hostname, SSLSession session) {
                    return true;
                }
            });

            SSLContext context = SSLContext.getInstance("TLS");
            context.init(null, new X509TrustManager[]{new X509TrustManager() {
                public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
                }

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

                public X509Certificate[] getAcceptedIssuers() {
                    return new X509Certificate[0];
                }
            }}, new SecureRandom());
            HttpsURLConnection.setDefaultSSLSocketFactory(context.getSocketFactory());
        } catch (Exception e) {
            // e.printStackTrace();
        }
    }

}
package com.smy.cbs.entity;

import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;

public class DelayedElement implements Delayed {
    private String data;
    private long delayTime;

    public DelayedElement(String data, long delayTime) {
        this.data = data;
        this.delayTime = System.currentTimeMillis() + delayTime;
    }

    @Override
    public long getDelay(TimeUnit unit) {
        long diff = delayTime - System.currentTimeMillis();
        return unit.convert(diff, TimeUnit.MILLISECONDS);
    }

    @Override
    public int compareTo(Delayed o) {
        long diff = this.getDelay(TimeUnit.MILLISECONDS) - o.getDelay(TimeUnit.MILLISECONDS);
        return Long.compare(diff, 0);
    }

    public String getData() {
        return data;
    }
}

三、实现效果

企业微信机器狗开发者文档：群机器人配置说明 - 接口文档 - 企业微信开发者中心

友谊之路
关注
专栏目录
发送Django error log 到企业微信，python+微信实现即时告警
cheng10cc的博客
06-01 1475
发送Django error log 到企业微信，python+微信实现即时告警Django的logging系统十分好用，使用file，mail_admins之类的handlers可以快捷地实现保存日志到文件，发送错误日志给管理员的功能。但是，如果能直接将应用的错误日志发送到手机上，实现即时告警，岂不是更好？发送Django error log 到企业微信python微信实现即时告警 注册企业微信1
java jsoup应用爬取数据存储数据库及日志开关
08-14
例如，可以设置每天创建新的日志文件，旧的日志自动归档。 在实际开发中，还要注意爬虫的道德和合法性问题，尊重网站的robots.txt规则，避免对目标服务器造成过大的负担，合理设置爬取频率。同时，考虑到反爬机制，...
根据阿里云日志服务SLS实现企业微信机器人预警
weixin_45785984的博客
01-12 552
【代码】根据阿里云日志服务SLS实现企业微信机器人预警。
springboot项目exception异常信息推送至企业微信
weixin_46764080的博客
10-09 802
springboot项目exception异常信息推送至企业微信
Java实现企业微信群的告警功能
weixin_52223673的博客
08-30 683
Java实现企业微信群的告警功能
【Java开发】Java实现调用微信机器人，发送企业微信通知
weixin_70280523的博客
03-04 1157
666
企业微信机器人实现自动推送天气预报
故事的小黄花的博客
09-28 3209
start~ 因为要用到天气信息，在网上找了很多免费的api，不是有调用限制要不就是返回的结果不满意，最终看了百度的比较合适，决定用爬虫抓下来。 在百度上搜索"长春天气"，将浏览器的地址复制，作为请求地址 因为我是吉林长春的所以就举例长春了可以换成自己想要的城市-.- 这里采用jsoup爬取数据 导入坐标↓ <!-- https://mvnrepository.com/artifact/org.jsoup/jsoup --> <dependency> <groupId
调用企业微信接口发送微信消息
热门推荐
Jepson的博客
01-10 1万+
准备工作： 1.需要注册个企业微信账号，地址：https://work.weixin.qq.com/wework_admin/loginpage_wx 2.在企业微信中，创建一个应用，如下图： 需要上传应用logo、填写应用名称、并选择成员，之后点击创建应用 3.应用创建成功后，进入应用，获取应用的AgentId和Secret，如下图： 4.企业微信发送应用消息接口文档地址：https://work.weixin.qq.com/api/doc/90000/90135/90236 实现代码： import
微信公众号完成自动回复机器人，在线问答，人工客服
weixin_45411740的博客
05-27 1052
此外，为了区分不同用户的提问状态，我这里使用了Redis进行保存用户提问数据的操作，并且设置1小时超时 ，在用户提问的时候，把用户的id存入Redis，由此可以分辨出每一位用户的问题，做出相对应的回答。需要注意的是，启用后我们之前在公众号上的菜单将会失效，需要我们用api的方式重新提交一次，所以说，有做过菜单的需要注意，下面是创建菜单的步骤。由于微信发送的信息室xml格式的，所以我们需要进行一定的处理，我这里使用的是jsonp包所带的方法进行处理的，使用jsonp需要在。需要在启用服务器后进行配置。
1yygwx.zip_JAVA夺宝岛_java夺宝源码_org.jsoup.Jsoup_夺宝_微信
09-14
【标题】"1yygwx.zip_JAVA夺宝岛_java夺宝源码_org.jsoup.Jsoup_夺宝_微信" 指的是一份基于Java语言开发的微信端一元夺宝应用的源代码。这个项目可能包含了一整套用于实现一元夺宝功能的后端服务、前端展示以及与...
基于SpringBoot框架和jsoup的LineBot机器人策略模式设计源码
09-30
该项目是基于SpringBoot框架与jsoup库构建的LineBot机器人源码，整体采用策略模式进行设计。项目包含282个文件，包括126个JAR包文件、69个编译后的.class文件、61个Java源文件、8个图片文件、4个PDF文档、3个属性...
【Android+OkHttp3+Jsoup】 模拟登录教务系统 抓取课表和成绩
10-12
这个项目就是基于Android Studio，使用OkHttp3和Jsoup库来实现模拟登录并抓取网页数据的示例。以下是对这个项目及其关键技术的详细解析： 1. **OkHttp3**：OkHttp是一个高效的HTTP客户端，它提供了异步和同步请求...
企业微信审批-回调，开发测试环境共用一个回调
appearappear的博客
10-09 201
使用nginx 的mirror复制流量。nginx A 配置一个域名。
手部姿态映射到远程操作机器人
weixin_40514381的博客
10-02 737
要将手部姿态数据映射到远程操作机器人，可以使用 Python 和一些库（如mediapipe和numpy）来i简单实现这个功能。以下是一个具体的实现步骤，主要包括手部姿态检测、数据处理和关节位置映射。
使用激光跟踪仪提升码垛机器人精度
chotest的博客
10-09 898
工业机器人校准及性能检测系统，借助RobotMaster软件强大的机器人校准和检测功能，配合激光跟踪仪顶尖的跟踪测量性能，强强组合，已经在工业机器人领域取得了客户充分认可和肯定，未来将用更快的响应和更好的服务支持，满足机器人行业的不同需求，与客户共同提高，确保机器人的性能时刻处于理想状态。根据需要进行校准项勾选进行校准计算，得到校准后的DH模型（图7左），将补偿值修正到机器人控制器，完成对机器人参数的补偿，可以看到校准后的最大位置精度提升到到0.5mm左右（7右）。图4 码垛机器人DH模型。
CoRL 2024 麻省理工学院提出T3触觉Transformer，打破触觉感知的壁垒，重塑未来机器人
weixin_44887311的博客
10-04 966
通过在FoTa数据集上进行预训练，T3具备了强大的泛化能力，我们可以通过少量领域的特定数据对其进行进一步的微调，并且其性能可随网络规模的增大而提高，如此便能够应对各种不同的感知需求。为了探究T3的优劣，我们训练和评估了3个策略：一个没有触觉输入的基础策略，一个由从头开始训练的神经网络编码的触觉输入策略，以及一个由T3编码的触觉输出策略。预训练的T3在许多任务上展现了显著的性能提升，特别是在复杂的长时间接触操作任务中，例如多引脚电子元件的插入任务，T3相较于传统方法提高了25%的任务成功率。
飞行机器人专栏（十六）-- 双臂机器人体感交互式控制
最新发布
Techblog of HaoWANG
10-10 766
利用新型仿人双臂空中机械手实现更自然、更拟人化的作业交互，实现混合智能遥操作控制，仍然是一个亟待解决的问题。针对我们设计的新型空中双手机械手，提出了一种基于视觉的直观控制策略，重点是增强人机交互（HRI）和基于视觉的遥操作。这种创新的HRI控制策略近似于人类操作员的运动意图和机械手定位之间的复杂非线性映射函数。此外，使用KF算法融合了来自多个Kinect DK单元的鲁棒全身3D骨架跟踪，为空中机械手的遥操作控制服务。采用这种控制系统，双臂空中机械手可以与人类合作，灵活高效地执行双手任务。
华为OD机试真题---机器人活动区域
风信子的博客
10-03 1891
华为OD机试中的“机器人活动区域”题目是一个典型的图论和搜索算法问题，要求在一个二维网格中找出满足特定条件的连续区域，并计算这些区域中最大的一个区域所包含的格子数。具体来说，这个问题要求机器人能够在网格中移动，其移动规则是相邻格子之间的数字编号差值的绝对值必须小于等于1。
jsoup登录带验证码的网站
05-30
要使用jsoup登录带验证码的网站，需要进行以下步骤： 1. 首先，使用jsoup获取登录页面的HTML源代码。 2. 解析HTML源代码，找到验证码图片的地址，并将其下载到本地。 3. 使用第三方库，如Tess4J，对验证码图片进行识别，获取验证码的文本信息。 4. 构建登录请求，将用户名、密码、验证码等信息作为参数提交给服务器。 5. 解析服务器返回的响应，判断登录是否成功。 以下是一个简单的示例代码，可以帮助你实现登录带验证码的网站： ``` import org.jsoup.Connection; import org.jsoup.Jsoup; import org.jsoup.nodes.Document; import java.io.File; public class LoginDemo { public static void main(String[] args) throws Exception { // 获取登录页面的HTML源代码 Connection.Response response = Jsoup.connect("https://example.com/login") .method(Connection.Method.GET) .execute(); Document doc = response.parse(); // 下载验证码图片到本地 String captchaUrl = doc.select("img#captchaImg").attr("src"); Connection.Response resultImageResponse = Jsoup.connect(captchaUrl) .cookies(response.cookies()) .ignoreContentType(true) .execute(); File captchaImageFile = new File("captcha.png"); FileUtils.copyInputStreamToFile(resultImageResponse.bodyStream(), captchaImageFile); // 识别验证码文本 String captchaText = Tess4JOCR.recognize(captchaImageFile); // 构建登录请求 Connection.Response loginResponse = Jsoup.connect("https://example.com/login") .data("username", "your_username") .data("password", "your_password") .data("captcha", captchaText) .cookies(response.cookies()) .method(Connection.Method.POST) .execute(); // 解析服务器返回的响应 Document loginDoc = loginResponse.parse(); if (loginDoc.title().contains("登录成功")) { System.out.println("登录成功！"); } else { System.out.println("登录失败！"); } } } ``` 请注意，这只是一个示例代码，实际情况可能会更复杂。您需要根据具体的网站和验证码识别库进行适当的修改。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值