జావాలో టెలిగ్రామ్ బాట్‌ను సృష్టించడం: భావన నుండి విస్తరణ వరకు

కాబట్టి బాట్‌లు అంటే ఏమిటి? మీరు దీని గురించి ఇక్కడ మరింత చదవవచ్చు . ప్రారంభించడానికి, మీరు టెలిగ్రామ్ బాట్‌లను అభివృద్ధి చేయడానికి ఉపయోగించే లైబ్రరీకి సంబంధించిన అధికారిక డాక్యుమెంటేషన్‌ను సమీక్షించాలి (ఇకపై "API"). ఇది ఇక్కడ చూడవచ్చు . అక్కడ ప్రతిదీ చాలా అందుబాటులో మరియు స్పష్టంగా ఉంది. మేము కేవలం కోడ్ వ్రాసి సంతోషించగలమని అనిపిస్తుంది! కానీ అది అంత సులభం కాదు. శోధించడంలో చాలా సమయం గడిపిన తర్వాత, నేను బోట్ డెవలప్‌మెంట్‌పై నాలెడ్జ్ యొక్క చిట్కాలను కనుగొన్నాను, ఉదాహరణకు, కీబోర్డ్‌ను ఎలా తయారు చేయాలి, హ్యాండిల్CallbackQuery, మొదలగునవి. కానీ, నేను జావా బాట్ డెవలప్‌మెంట్ కోసం పూర్తి, సమగ్రమైన గైడ్‌ని కనుగొనలేదు. అదే నన్ను ఈ వ్యాసం రాయడానికి ప్రేరేపించింది. మీరు మీ స్వంత సులభంగా అమలు చేయగల బోట్‌ను సృష్టించగల వెబ్‌సైట్‌లు చాలా ఉన్నాయి. కానీ వాస్తవం ఏమిటంటే, సృష్టించిన చాలా బాట్‌లు రిఫరెన్స్ సమాచారం మరియు ఇలాంటివి అందిస్తాయి. మా బాట్ పూర్తి స్థాయి వెబ్ అప్లికేషన్. మీరు డేటాబేస్ను బైండ్ చేయవచ్చు, వివిధ API అభ్యర్థనలను అమలు చేయవచ్చు, వెబ్‌సైట్‌లను అన్వయించవచ్చు, సంక్లిష్ట గణనలను నిర్వహించవచ్చు మరియు మరిన్ని చేయవచ్చు. అవకాశాలు మీ ఊహ ద్వారా మాత్రమే పరిమితం చేయబడ్డాయి. నేను దేని గురించి వ్రాయబోతున్నానో వివరించడానికి పైవి సహాయపడిందని నేను ఆశిస్తున్నాను. టెలిగ్రామ్‌లో బాట్‌ను నమోదు చేయడం చాలా సులభం. ఈ ప్రక్రియ పైన లింక్ చేసిన డాక్యుమెంటేషన్‌లో వివరంగా వివరించబడింది. మా అప్లికేషన్ కోసం, మీరు బాట్ పేరు మరియు బాట్‌ను నమోదు చేసేటప్పుడు మీరు స్వీకరించే టోకెన్‌ను మాత్రమే తెలుసుకోవాలి. ప్రాథమికంగా, బోట్ అనేది కన్సోల్ ఆధారిత వెబ్ అప్లికేషన్. ఫ్రంట్ ఎండ్ లేదు, స్వచ్ఛమైన కమాండ్ ప్రాసెసింగ్ మాత్రమే. మీరు మాస్టర్ కావాలనుకుంటేహైబర్నేట్ చేయండి లేదా JSONని ఎలా అన్వయించాలో నేర్చుకోండి , ఇది మీ కోసం ప్రాజెక్ట్. దీనికి డిపెండెన్సీని జోడించడం ద్వారా ప్రారంభిద్దాం pom.xml(మీరు మావెన్‌ని ఉపయోగిస్తున్నారని నేను అనుకుంటాను). మీరు దీన్ని ఇలా చేయవచ్చు:

<dependency>
            <groupId>org.telegram</groupId>
            <artifactId>telegrambots</artifactId>
            <version>3.5</version>
</dependency>

Botఆపై తరగతిని వారసత్వంగా పొందే తరగతిని సృష్టించండి TelegramLongPollingBotమరియు దాని పద్ధతులను భర్తీ చేయండి:

public class Bot extends TelegramLongPollingBot {

    /**
     * Method for receiving messages.
     * @param update Contains a message from the user.
     */
    @Override
    public void onUpdateReceived(Update update) {
    String message = update.getMessage().getText();
    sendMsg(update.getMessage().getChatId().toString(), message);
    }

    /**
     * Method for creating a message and sending it.
     * @param chatId chat id
     * @param s The String that you want to send as a message.
     */
    public synchronized void sendMsg(String chatId, String s) {
        SendMessage sendMessage = new SendMessage();
        sendMessage.enableMarkdown(true);
        sendMessage.setChatId(chatId);
        sendMessage.setText(s);
        try {
            sendMessage(sendMessage);
        } catch (TelegramApiException e) {
            log.log(Level.SEVERE, "Exception: ", e.toString());
        }
    }

    /**
     * This method returns the bot's name, which was specified during registration.
     * @return bot name
     */
    @Override
    public String getBotUsername() {
        return "BotName";
    }

    /**
     * This method returns the bot's token for communicating with the Telegram server
     * @return the bot's token
     */
    @Override
    public String getBotToken() {
        return "BotToken";
    }
}

మరియు ఇప్పుడు పద్ధతి యొక్క విషయాలు main:

public static void main(String[] args) {
        ApiContextInitializer.init();
        TelegramBotApi telegramBotApi = new TelegramBotApi();
        try {
            telegramBotApi.registerBot(Bot.getBot());
        } catch (TelegramApiRequestException e) {
            e.printStackTrace();
        }
}

getBotUsername()మరియు పద్ధతులను పూరించిన తర్వాత getBotToken(), బాట్‌ను ప్రారంభించండి. ప్రస్తుతానికి, ఇది " అద్దం " లాగా మనం పంపే ఏవైనా సందేశాలను మాకు దారి మళ్లిస్తుంది . ఇది ఇలా పనిచేస్తుంది: మీరు అప్లికేషన్‌ను ప్రారంభించినప్పుడు, ఇది టెలిగ్రామ్ సర్వర్‌కు, ప్రతి n సెకన్లకు ఒకసారి, క్రింది URLలో అభ్యర్థనలను పంపడం ప్రారంభిస్తుంది: https://api.telegram.org/BotToken/getMe , ఇక్కడ BotToken మీ బాట్ యొక్క టోకెన్. . ప్రతిస్పందనగా, ఇది అన్ని సందేశాలను కలిగి ఉన్న JSONని అందుకుంటుంది. ఈ సందేశాలలో ప్రతి ఒక్కటి లైబ్రరీ ద్వారా ప్రాసెస్ చేయబడుతుంది మరియు OnUpdateReceived(Update update)ఒక పద్ధతికి పంపబడుతుందిUpdateవస్తువు. మరియు మేము దానితో పని చేస్తాము. టెలిగ్రామ్ బాట్‌ల యొక్క అందం ఇక్కడ ఉంది: అవి ఏదైనా కంప్యూటర్‌లో రన్ అవుతాయి, దానిని పరీక్షించడానికి అప్లికేషన్‌ను ప్రారంభించడం అవసరం మరియు ప్రతి మార్పు తర్వాత మీరు దానిని హోస్ట్‌కు అమలు చేయవలసిన అవసరం లేదు. ఇది చాలా సౌకర్యవంతంగా ఉంటుంది. వాస్తవానికి, మీరు వెబ్‌హూక్స్ ఉపయోగించి పని చేయడానికి బోట్‌ను కాన్ఫిగర్ చేయవచ్చు. మీరు ఇంటర్నెట్‌లో దాని కోసం దిశలను కనుగొనవచ్చు. సరళత కోసం, మేము లాంగ్‌పోలింగ్‌ని ఉపయోగిస్తాము. సందేశాలు ఎలా ప్రాసెస్ చేయబడతాయి మరియు ప్రతిస్పందనగా మీరు పంపేవి భాష మరియు లైబ్రరీ సామర్థ్యాల ద్వారా మాత్రమే పరిమితం చేయబడతాయి. మిగతావన్నీ మీ ఇష్టం. మీరు మీ కోసం YouTube వీడియోలను శోధించే బాట్‌ను తయారు చేయవచ్చు. మీరు ఒక సంవత్సరం క్రితం నుండి టైమ్ క్యాప్సూల్ లాగా ప్రతిరోజూ పంపే వాటిని మీకు పంపే బోట్‌ను తయారు చేయవచ్చు. లేదా మీరు CRM సిస్టమ్‌లతో ఏకీకృతం చేయడం మరియు చిన్న వ్యాపారాల కోసం బాట్‌లను తయారు చేయడం నేర్చుకోవచ్చు—మీరు మీ ఊహ ద్వారా మాత్రమే పరిమితం చేయబడతారు. వెళ్ళేముందు. బాట్‌లను ఉపయోగించిన వారికి "" అక్షరంతో ప్రారంభమయ్యే ఆదేశాలను ఉపయోగించి వారితో పరస్పర చర్య చేయడం సౌకర్యంగా ఉంటుందని తెలుసు /, ఉదాహరణకు, /start. కానీ మరింత అనుకూలమైన మార్గం ఉంది: బటన్లు. రెండు రకాల బటన్‌లు ఉన్నాయి: ఇన్‌పుట్ ఫీల్డ్ ( ) కింద కనిపించేవి ReplyKeyboardMarkupమరియు అవి లింక్ చేయబడిన సందేశానికి నేరుగా దిగువన ఉన్న బటన్‌లు (InlineKeyboardMarkup) డాక్యుమెంటేషన్‌లోని వారి వివరణల నుండి మీరు వాటి గురించి ప్రాథమిక అవగాహనను పొందవచ్చు.

ప్రత్యుత్తరం కీబోర్డ్ మార్కప్

వాస్తవానికి, ఇది బటన్ శ్రేణుల శ్రేణి: List<KeyboardRow <KeyboardButton>>. కీబోర్డ్‌ను సృష్టించే నమూనా కోడ్ ఇక్కడ ఉంది:

public synchronized void setButtons(SendMessage sendMessage) {
        // Create a keyboard
        ReplyKeyboardMarkup replyKeyboardMarkup = new ReplyKeyboardMarkup();
        sendMessage.setReplyMarkup(replyKeyboardMarkup);
        replyKeyboardMarkup.setSelective(true);
        replyKeyboardMarkup.setResizeKeyboard(true);
        replyKeyboardMarkup.setOneTimeKeyboard(false);

        // Create a list of keyboard rows
        List<KeyboardRow> keyboard = new ArrayList<>();

        // First keyboard row
        KeyboardRow keyboardFirstRow = new KeyboardRow();
        // Add buttons to the first keyboard row
        keyboardFirstRow.add(new KeyboardButton("Hi"));

        // Second keyboard row
        KeyboardRow keyboardSecondRow = new KeyboardRow();
        // Add the buttons to the second keyboard row
        keyboardSecondRow.add(new KeyboardButton("Help");

        // Add all of the keyboard rows to the list
        keyboard.add(keyboardFirstRow);
        keyboard.add(keyboardSecondRow);
        // and assign this list to our keyboard
        replyKeyboardMarkup.setKeyboard(keyboard);
    }

sendMsg()మేము మెథడ్‌లో ఈ పద్ధతిని సందేశం పంపిన తర్వాత పిలుస్తాము . ఈ విధంగా మేము ఆ సందేశానికి కీబోర్డ్‌ను సెటప్ చేస్తాము. మేము ఈ సందేశాన్ని వినియోగదారుకు పంపినప్పుడు, అతను మా సందేశం యొక్క వచనాన్ని మరియు "హాయ్" మరియు "సహాయం" అని చెప్పే 2 బటన్‌లను ఒకదాని క్రింద మరొకటి చూస్తాడు. ఈ బటన్‌లలో ఒకదానిని క్లిక్ చేసినప్పుడు, బటన్ వచనాన్ని కలిగి ఉన్న సందేశం బోట్‌కు పంపబడుతుంది. కాబట్టి, క్లయింట్ "సహాయం" క్లిక్ చేస్తే, బోట్ "సహాయం" తో సందేశాన్ని అందుకుంటుంది . బోట్‌కు, క్లయింట్ స్వయంగా "సహాయం" అని వ్రాసి , వచనాన్ని బోట్‌కు పంపినట్లు అనిపిస్తుంది . ఆపై మీరు సందేశాలను ప్రాసెస్ చేయండి.

ఇన్‌లైన్ కీబోర్డ్ మార్కప్

ఇది కూడా శ్రేణుల శ్రేణి. ఇది మునుపటి మార్కప్ మాదిరిగానే ఉంటుంది, కానీ ఇక్కడ లాజిక్ కొద్దిగా భిన్నంగా పనిచేస్తుంది. ఈ రకమైన కీబోర్డ్ నిర్దిష్ట సందేశానికి జోడించబడింది మరియు దాని కోసం మాత్రమే ఉంటుంది. ఇన్‌లైన్ కీబోర్డ్‌ను సెటప్ చేయడానికి ఇక్కడ ఒక పద్ధతి ఉంది:

private void setInline() {
        List<List<InlineKeyboardButton>> buttons = new ArrayList<>();
        List<InlineKeyboardButton> buttons1 = new ArrayList<>();
        buttons1.add(new InlineKeyboardButton().setText("Button").setCallbackData(17));
        buttons.add(buttons1);

        InlineKeyboardMarkup markupKeyboard = new InlineKeyboardMarkup();
        markupKeyboard.setKeyboard(buttons);
    }

Listలోపల ఒక సృష్టించండి Listమరియు మొదటి వరుసకు ఇన్‌లైన్ బటన్‌ను జోడించండి. ఈ బటన్‌లో URL, ఛానెల్‌కి లింక్ లేదా ఒక CallbackQuery, నేను కొంచెం తర్వాత వ్రాస్తాను. ఇక్కడే మేము మా బటన్ యొక్క వచనాన్ని సెట్ చేస్తాము, ఇది వినియోగదారు చూస్తుంది, ఆపై మేము బోట్‌కు పంపబడే డేటాను సెట్ చేస్తాము. మా ఉదాహరణలో, వినియోగదారు "హాయ్"ని చూస్తారు మరియు బటన్‌ను నొక్కినప్పుడు 17 సంఖ్య బోట్‌కు పంపబడుతుంది. ఇది మాది CallbackQuery. గురించి కొన్ని మాటలు CallbackQuery. వస్తువు నుండి ఈ డేటాను పొందడానికి Update, మీరు అమలు చేయాలి update.getCallbackQuery(). ఈ పద్ధతి aని అందిస్తుంది CallbackQuery, దీని నుండి మీరు బాట్‌కు పంపబడిన డేటాను యాక్సెస్ చేయవచ్చు. పద్ధతి ద్వారా ఈ డేటాను పొందడానికి ప్రయత్నించవద్దు update.getMessage().getText()-మీరు ఒక పొందుతారు NullPointerException.

@Override
    public void onUpdateReceived(Update update) {
        if(update.hasMessage()) {
            ThreadClass thread = new ThreadClass(update.getMessage());
        } else  if(update.hasCallbackQuery()) {
            AnswerCallbackThread answerThread = new AnswerCallbackThread(update.getCallbackQuery());
        }
    }

ఏదైనా సందేశం ఉంటే, మేము దానిని ప్రాసెసింగ్ కోసం కొత్త థ్రెడ్‌కి పంపుతాము; ఒక ఉంటే CallbackQuery, మేము ప్రాసెసింగ్ కోసం తగిన థ్రెడ్‌కు పంపుతాము. మీరు ఒక ప్రతిస్పందనను పంపవచ్చు CallbackQuery. టెలిగ్రామ్‌లోని ప్రతి వస్తువుకు దాని స్వంత ఐడి ఉంటుంది. నిర్దిష్ట ప్రతిస్పందనను పంపడానికి CallbackQuery, మీరు దాని ఐడిని తెలుసుకోవాలి, అది సంబంధిత వస్తువు నుండి మనకు లభిస్తుంది. ప్రతిస్పందనను పంపడానికి, మేము ఈ పద్ధతిని పిలుస్తాము:

public synchronized void answerCallbackQuery(String callbackId, String message) {
        AnswerCallbackQuery answer = new AnswerCallbackQuery();
        answer.setCallbackQueryId(callbackId);
        answer.setText(message);
        answer.setShowAlert(true);
        try {
            answerCallbackQuery(answer);
        } catch (TelegramApiException e) {
            e.printStackTrace();
        }
    }

ముఖ్యమైనది:ప్రతిస్పందనలో వచనం తప్పనిసరిగా CallbackQuery200 అక్షరాల కంటే ఎక్కువ ఉండకూడదు! అటువంటి ప్రతిస్పందనను పంపిన తర్వాత, క్లయింట్ సందేశాన్ని కలిగి ఉన్న పాప్-అప్ విండోను చూస్తారు. ఈ విండో కనిపించిన కొన్ని సెకన్ల తర్వాత అదృశ్యం కావచ్చు లేదా వినియోగదారు సరే నొక్కినంత వరకు ఇది కొనసాగుతుంది. మోడ్‌లను మార్చడానికి, మేము answer.setShowAlert(true)పద్ధతిని పిలుస్తాము. trueమీరు పద్ధతికి వెళితే , సరే నొక్కినంత వరకు విండో కొనసాగుతుంది. మీరు తప్పును పాస్ చేస్తే, అది 5 సెకన్ల తర్వాత అదృశ్యమవుతుంది. ఇవన్నీ టెలిగ్రామ్ బాట్ లైబ్రరీ యొక్క ప్రాథమిక లక్షణాలు. మీకు కావాలంటే, మీరు మల్టీమీడియా, జియోలొకేషన్ మొదలైనవాటిని ఎలా పంపాలి వంటి విషయాలను తెలుసుకోవచ్చు. హోస్టింగ్ ప్లాట్‌ఫారమ్‌కు మా బాట్‌ని అమలు చేయడానికి ముందుకు వెళ్దాం. నా ప్రాజెక్ట్ కోసం, నేను హీరోకుని ఎంచుకున్నాను. ఇది దాని స్వంత CLIతో కాకుండా అనుకూలమైన హోస్టింగ్ ప్లాట్‌ఫారమ్ అని నేను భావిస్తున్నాను. ఇది ఉచితం, కానీ ఈ ప్లాన్‌లో ఎటువంటి అభ్యర్థనలు రాని 30 నిమిషాల తర్వాత మీ బోట్ నిద్రాణస్థితికి చేరుకుంటుంది. అభ్యర్థన వచ్చినప్పుడు అది మేల్కొంటుంది. ఇది చాలా త్వరగా జరుగుతుంది, మీరు గమనించలేరు (వాస్తవానికి, డేటాబేస్ కనెక్షన్ పునఃప్రారంభించబడకపోతే). ఉచిత ప్లాన్ 5MB డేటాబేస్, 100MB డిస్క్ స్పేస్, నెలకు 2TB డేటా మరియు 1 డైనోతో పరిమితం చేయబడింది. డైనో అనేది మీ రన్నింగ్ అప్లికేషన్. నేను మునుపెన్నడూ నా అప్లికేషన్‌లను డిప్లాయ్ చేయనందున, విస్తరణ వల్ల నాకు ఇబ్బందులు కలుగుతున్నాయని నేను వెంటనే చెబుతాను. విస్తరణ సమయంలో, Herokuకి Procfile అనే ఫైల్ అవసరం (పొడిగింపు లేకుండా). మేము దానిని ప్రాజెక్ట్ రూట్‌లో సృష్టిస్తాము. లోపల, మనం వ్రాస్తాము worker: sh target/bin/workerBot, ఇక్కడ వర్కర్‌బాట్ అనేది పేరులో పేర్కొనబడింది pom.xml. ఒక shమావెన్ అప్లికేషన్ అసెంబ్లర్ ప్లగిన్ (అప్పాసెంబ్లర్-మావెన్-ప్లగిన్) ద్వారా రూపొందించబడిన స్క్రిప్ట్ ప్రారంభించబడుతుంది. కంపైల్డ్ జార్ ఫైల్‌ను ఎలా ప్రారంభించాలో స్క్రిప్ట్ వివరిస్తుంది. ప్రారంభించాల్సిన తరగతి పేరు <mainClass>మరియు మధ్య పేర్కొనబడింది </mainClass>, అయితే స్క్రిప్ట్ పేరు మధ్యలో <name>ఇవ్వబడింది : </name>pom.xml

...
<build>
    <plugins>
        ...
       <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>appassembler-maven-plugin</artifactId>
            <version>1.1.1</version>
            <configuration>
                <assembleDirectory>target</assembleDirectory>
                <programs>
                    <program>
                        <mainClass>com.home.server.TelegramBot</mainClass>
                        <name>workerBot</name>
                    </program>
                </programs>
            </configuration>
            <executions>
                <execution>
                    <phase>package</phase>
                    <goals>
                        <goal>assemble</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

ఈ ప్రక్రియను ప్రారంభించే ముందు, మీరు Heroku లో నమోదు చేసుకోవాలి మరియు Git మరియు Heroku CLI రెండింటినీ ఇన్‌స్టాల్ చేయాలి . మీ అప్లికేషన్‌కు డేటాబేస్ అవసరమైతే, మీరు కొత్త అప్లికేషన్‌ను సృష్టించినప్పుడు అవసరమైన డేటాబేస్‌ను జోడించడం మర్చిపోవద్దు. ఇంకా, మీరు మీ డేటాబేస్ కోసం హోస్ట్, వినియోగదారు పేరు, పాస్‌వర్డ్ మరియు పోర్ట్‌ను గుర్తించి, ఆపై వాటిని మీ అప్లికేషన్‌లో సూచించాలి. తరువాత, అమలు చేయడానికి ముందు, మావెన్ ఉపయోగించి మీ ప్రాజెక్ట్‌ను రూపొందించండి .

mvn clean install

మొదట, మేము మా ప్రాజెక్ట్ డైరెక్టరీకి వెళ్లి రిపోజిటరీని కమాండ్‌తో ప్రారంభించాము git init. అప్పుడు మేము ఈ రిపోజిటరీకి మా ప్రాజెక్ట్‌ను జోడిస్తాము.

git add .

అప్పుడు మేము మార్పులకు కట్టుబడి ఉంటాము

git commit -m "First commit in the project"

తర్వాత, మీరు herokuకి సైన్ ఇన్ చేయాలి. కింది వాటిని కమాండ్ లైన్‌లో వ్రాయండి

heroku login

రిజిస్ట్రేషన్ సమయంలో మీరు సృష్టించిన ఆధారాలను నమోదు చేయండి. ఆ తర్వాత, హీరోకులో మీ రిపోజిటరీ URLని నిర్ణయించండి. మీరు దీన్ని సెట్టింగ్‌లలో చేయండి. అప్పుడు మేము వ్రాస్తాము

git remote add heroku [url]

మీ రిపోజిటరీ కోసం రిమోట్ హీరోకు రిపోజిటరీ జోడించబడింది. తరువాత మనం వ్రాస్తాము

git push heroku master

అప్పుడు మేము వేచి ఉంటాము… అప్లికేషన్ విజయవంతంగా అమలు చేయబడితే, కింది ఆదేశాన్ని అమలు చేయండి

heroku ps:scale worker=1

అంతే, మీ అప్లికేషన్ అమలులో ఉంది. అది కాకపోతే, లాగ్లను జాగ్రత్తగా చూడండి. చాలా మటుకు, మీ అప్లికేషన్‌లో లోపం కారణంగా అది విఫలమైంది. ఇంత సుదీర్ఘ కథనాన్ని చదివినందుకు ధన్యవాదాలు. ఎవరైనా దీన్ని ఉపయోగకరంగా కనుగొంటారని మరియు అభివృద్ధి సమయంలో నాకు ఇబ్బంది కలిగించిన ప్రాంతాల్లో ఇది మీకు చాలా సమయాన్ని ఆదా చేస్తుందని నేను ఆశిస్తున్నాను.