import org.telegram.telegrambots.exceptions.TelegramApiRequestException; //导入依赖的package包/类
@PostConstruct
public void init() throws TelegramApiRequestException {
    if (properties.getTelegram().getEnabled()) {
        LOGGER.info("Initializing Telegram service...");

        ApiContextInitializer.init();

        TelegramBotsApi botsApi = new TelegramBotsApi();

        bot = new FreqTradeTelegramBot(context);

        botsApi.registerBot(bot);
    } else {
        LOGGER.info("Telegram service is disabled");
    }
}
 

import org.telegram.telegrambots.exceptions.TelegramApiRequestException; //导入依赖的package包/类
/**
 * Creates an HTTPS server to receive webhook request
 * @param keyStore KeyStore for the server
 * @param keyStorePassword Key store password for the server
 * @param externalUrl External base url for the webhook
 * @param internalUrl Internal base url for the webhook
 */
public TelegramBotsApi(String keyStore, String keyStorePassword, String externalUrl, String internalUrl) throws TelegramApiRequestException {
    if (externalUrl == null || externalUrl.isEmpty()) {
        throw new TelegramApiRequestException("Parameter externalUrl can not be null or empty");
    }
    if (internalUrl == null || internalUrl.isEmpty()) {
        throw new TelegramApiRequestException("Parameter internalUrl can not be null or empty");
    }
    if (keyStore == null || keyStore.isEmpty()) {
        throw new TelegramApiRequestException("Parameter keyStore can not be null or empty");
    }
    if (keyStorePassword == null || keyStorePassword.isEmpty()) {
        throw new TelegramApiRequestException("Parameter keyStorePassword can not be null or empty");
    }

    this.useWebhook = true;
    this.extrenalUrl = fixExternalUrl(externalUrl);
    webhook = ApiContext.getInstance(Webhook.class);
    webhook.setInternalUrl(internalUrl);
    webhook.setKeyStore(keyStore, keyStorePassword);
    webhook.startServer();
}
 

import org.telegram.telegrambots.exceptions.TelegramApiRequestException; //导入依赖的package包/类
public void startServer() throws TelegramApiRequestException {
    ResourceConfig rc = new ResourceConfig();
    rc.register(restApi);
    rc.register(JacksonFeature.class);

    final HttpServer grizzlyServer;
    if (keystoreServerFile != null && keystoreServerPwd != null) {
        SSLContextConfigurator sslContext = new SSLContextConfigurator();

        // set up security context
        sslContext.setKeyStoreFile(keystoreServerFile); // contains server keypair
        sslContext.setKeyStorePass(keystoreServerPwd);

        grizzlyServer = GrizzlyHttpServerFactory.createHttpServer(getBaseURI(), rc, true,
                new SSLEngineConfigurator(sslContext).setClientMode(false).setNeedClientAuth(false));
    } else {
        grizzlyServer = GrizzlyHttpServerFactory.createHttpServer(getBaseURI(), rc);
    }

    try {
        grizzlyServer.start();
    } catch (IOException e) {
        throw new TelegramApiRequestException("Error starting webhook server", e);
    }
}
 

import org.telegram.telegrambots.exceptions.TelegramApiRequestException; //导入依赖的package包/类
@Override
public boolean init(String botId, Map<String, String> configs, String[] channels) {
    logger = LogManager.getLogger(TelegramBot.class.getSimpleName() + ":" + botId);

    this.configs = configs;

    try {
        telegramBotsApi.registerBot(this);
    } catch (TelegramApiRequestException e) {
        logger.error(e);
        return false;
    }

    this.botId = botId;

    return true;
}
 

import org.telegram.telegrambots.exceptions.TelegramApiRequestException; //导入依赖的package包/类
public void start(ITetradCallback callback) {
    logger.debug("Run");
    logger.info(MessageFormat.format("Connecting with botid {0}",
                                     botid
                                    ));
    this.startTimestamp = System.currentTimeMillis() / 1000L;
    this.callback = callback;

    try {
        bot.registerBot(this);
    } catch (TelegramApiRequestException e) {
        logger.error(MessageFormat.format("Error connecting with botid {0}. Message: {1}",
                                          botid,
                                          e.getMessage()
                                         ));
    }
}
 

import org.telegram.telegrambots.exceptions.TelegramApiRequestException; //导入依赖的package包/类
public static void main(String[] args) throws IOException {
	ApiContextInitializer.init();
	TelegramBotsApi bot = new TelegramBotsApi();

	try {
		bot.registerBot(new QualisBot(args[0]));
	} catch (TelegramApiRequestException e) {
		e.printStackTrace();
	}

}
 

import org.telegram.telegrambots.exceptions.TelegramApiRequestException; //导入依赖的package包/类
public static void main(String[] args) {
    // Inicializamos el API Context
    ApiContextInitializer.init();
    // Creamos el objeto Bot Api que manejará nuestro bot
    TelegramBotsApi botsApi = new TelegramBotsApi();
    try {
        // Aqui registramos nuestro bot
        botsApi.registerBot(new CoffeeAndyBot());
    } catch (TelegramApiRequestException ex) {
        Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
    }
}
 

import org.telegram.telegrambots.exceptions.TelegramApiRequestException; //导入依赖的package包/类
/**
 * registers the {@link TgBot} using {@link TelegramBotsApi#registerBot(LongPollingBot)}
 */
@PostConstruct
private void init() {
	try {
		telegramBotsApi.registerBot(tgBot);
	} catch (TelegramApiRequestException e) {
		log.error(String.format("Failed to initialize Telegram Bot: %s", e.getMessage()), e);
	}
}
 

import org.telegram.telegrambots.exceptions.TelegramApiRequestException; //导入依赖的package包/类
public static void main(String... args) {
    ApiContextInitializer.init();

    TelegramBotsApi api = new TelegramBotsApi();
    try {
        api.registerBot(new HelloBot());
    } catch (TelegramApiRequestException e) {
        BotLogger.error("Oops, something went wrong while registering bot", e);
    }
}
 

import org.telegram.telegrambots.exceptions.TelegramApiRequestException; //导入依赖的package包/类
@Override
public Message deserializeResponse(String answer) throws TelegramApiRequestException {
    try {
        ApiResponse<Message> result = OBJECT_MAPPER.readValue(answer,
                new TypeReference<ApiResponse<Message>>(){});
        if (result.getOk()) {
            return result.getResult();
        } else {
            throw new TelegramApiRequestException("Error forwarding message", result);
        }
    } catch (IOException e) {
        throw new TelegramApiRequestException("Unable to deserialize response", e);
    }
}
 

import org.telegram.telegrambots.exceptions.TelegramApiRequestException; //导入依赖的package包/类
@Override
public WebhookInfo deserializeResponse(String answer) throws TelegramApiRequestException {
    try {
        ApiResponse<WebhookInfo> result = OBJECT_MAPPER.readValue(answer,
                new TypeReference<ApiResponse<WebhookInfo>>() {
                });
        if (result.getOk()) {
            return result.getResult();
        } else {
            throw new TelegramApiRequestException("Error getting webhook info", result);
        }
    } catch (IOException e2) {
        throw new TelegramApiRequestException("Unable to deserialize response", e2);
    }
}
 

import org.telegram.telegrambots.exceptions.TelegramApiRequestException; //导入依赖的package包/类
@Override
public ArrayList<Update> deserializeResponse(String answer) throws
        TelegramApiRequestException {
    try {
        ApiResponse<ArrayList<Update>> result = OBJECT_MAPPER.readValue(answer,
                new TypeReference<ApiResponse<ArrayList<Update>>>(){});
        if (result.getOk()) {
            return result.getResult();
        } else {
            throw new TelegramApiRequestException("Error getting updates", result);
        }
    } catch (IOException e) {
        throw new TelegramApiRequestException("Unable to deserialize response", e);
    }
}
 

import org.telegram.telegrambots.exceptions.TelegramApiRequestException; //导入依赖的package包/类
@Override
public Boolean deserializeResponse(String answer) throws
        TelegramApiRequestException {
    try {
        ApiResponse<Boolean> result = OBJECT_MAPPER.readValue(answer,
                new TypeReference<ApiResponse<Boolean>>(){});
        if (result.getOk()) {
            return result.getResult();
        } else {
            throw new TelegramApiRequestException("Error deleting webhook", result);
        }
    } catch (IOException e) {
        throw new TelegramApiRequestException("Unable to deserialize response", e);
    }
}
 

import org.telegram.telegrambots.exceptions.TelegramApiRequestException; //导入依赖的package包/类
@Override
public Boolean deserializeResponse(String answer) throws TelegramApiRequestException {
    try {
        ApiResponse<Boolean> result = OBJECT_MAPPER.readValue(answer,
                new TypeReference<ApiResponse<Boolean>>() {
                });
        if (result.getOk()) {
            return result.getResult();
        } else {
            throw new TelegramApiRequestException("Error editing message caption", result);
        }
    } catch (IOException e) {
        throw new TelegramApiRequestException("Unable to deserialize response", e);
    }
}
 

import org.telegram.telegrambots.exceptions.TelegramApiRequestException; //导入依赖的package包/类
@Override
public Boolean deserializeResponse(String answer) throws TelegramApiRequestException {
    try {
        ApiResponse<Boolean> result = OBJECT_MAPPER.readValue(answer,
                new TypeReference<ApiResponse<Boolean>>(){});
        if (result.getOk()) {
            return result.getResult();
        } else {
            throw new TelegramApiRequestException("Error answering callback query", result);
        }
    } catch (IOException e) {
        throw new TelegramApiRequestException("Unable to deserialize response", e);
    }
}
 

import org.telegram.telegrambots.exceptions.TelegramApiRequestException; //导入依赖的package包/类
@Override
public Message deserializeResponse(String answer) throws TelegramApiRequestException {
    try {
        ApiResponse<Message> result = OBJECT_MAPPER.readValue(answer,
                new TypeReference<ApiResponse<Message>>(){});
        if (result.getOk()) {
            return result.getResult();
        } else {
            throw new TelegramApiRequestException("Error sending sticker", result);
        }
    } catch (IOException e) {
        throw new TelegramApiRequestException("Unable to deserialize response", e);
    }
}
 

import org.telegram.telegrambots.exceptions.TelegramApiRequestException; //导入依赖的package包/类
@Override
public Message deserializeResponse(String answer) throws TelegramApiRequestException {
    try {
        ApiResponse<Message> result = OBJECT_MAPPER.readValue(answer,
                new TypeReference<ApiResponse<Message>>(){});
        if (result.getOk()) {
            return result.getResult();
        } else {
            throw new TelegramApiRequestException("Error sending venue", result);
        }
    } catch (IOException e) {
        throw new TelegramApiRequestException("Unable to deserialize response", e);
    }
}
 

import org.telegram.telegrambots.exceptions.TelegramApiRequestException; //导入依赖的package包/类
@Override
public Message deserializeResponse(String answer) throws TelegramApiRequestException {
    try {
        ApiResponse<Message> result = OBJECT_MAPPER.readValue(answer,
                new TypeReference<ApiResponse<Message>>(){});
        if (result.getOk()) {
            return result.getResult();
        } else {
            throw new TelegramApiRequestException("Error sending audio", result);
        }
    } catch (IOException e) {
        throw new TelegramApiRequestException("Unable to deserialize response", e);
    }
}
 

import org.telegram.telegrambots.exceptions.TelegramApiRequestException; //导入依赖的package包/类
@Override
public Message deserializeResponse(String answer) throws TelegramApiRequestException {
    try {
        ApiResponse<Message> result = OBJECT_MAPPER.readValue(answer,
                new TypeReference<ApiResponse<Message>>(){});
        if (result.getOk()) {
            return result.getResult();
        } else {
            throw new TelegramApiRequestException("Error sending video", result);
        }
    } catch (IOException e) {
        throw new TelegramApiRequestException("Unable to deserialize response", e);
    }
}
 

import org.telegram.telegrambots.exceptions.TelegramApiRequestException; //导入依赖的package包/类
@Override
public Message deserializeResponse(String answer) throws TelegramApiRequestException {
    try {
        ApiResponse<Message> result = OBJECT_MAPPER.readValue(answer,
                new TypeReference<ApiResponse<Message>>(){});
        if (result.getOk()) {
            return result.getResult();
        } else {
            throw new TelegramApiRequestException("Error sending document", result);
        }
    } catch (IOException e) {
        throw new TelegramApiRequestException("Unable to deserialize response", e);
    }
}