ஜாவாவில் டெலிகிராம் பாட் உருவாக்குதல்: கருத்தரித்தல் முதல் வரிசைப்படுத்துதல் வரை

எனவே போட்கள் என்றால் என்ன? இதைப் பற்றி இங்கே மேலும் படிக்கலாம் . தொடங்குவதற்கு, டெலிகிராம் போட்களை உருவாக்கப் பயன்படுத்தப்படும் நூலகத்திற்கான அதிகாரப்பூர்வ ஆவணங்களை நீங்கள் மதிப்பாய்வு செய்ய வேண்டும் (இனிமேல் "API"). அதை இங்கே காணலாம் . அங்குள்ள அனைத்தும் மிகவும் அணுகக்கூடியவை மற்றும் தெளிவானவை. நாம் குறியீடு எழுதி மகிழ்ச்சியடையலாம் என்று தோன்றுகிறது! ஆனால் அது அவ்வளவு எளிதல்ல. நீண்ட நேரம் தேடலுக்குப் பிறகு, போட் மேம்பாடு பற்றிய அறிவின் நுணுக்கங்களைக் கண்டேன், எடுத்துக்காட்டாக, ஒரு விசைப்பலகையை எவ்வாறு உருவாக்குவது, ஒரு கையாளுதல்CallbackQuery, மற்றும் முன்னும் பின்னுமாக. ஆனால், ஜாவா போட் மேம்பாட்டிற்கான முழுமையான, முழுமையான வழிகாட்டியை என்னால் கண்டுபிடிக்க முடியவில்லை. அதுவே இந்தக் கட்டுரையை எழுதத் தூண்டியது. உங்கள் சொந்த எளிதாக பயன்படுத்தக்கூடிய போட்களை உருவாக்கக்கூடிய பல வலைத்தளங்கள் உள்ளன. ஆனால் உண்மை என்னவென்றால், உருவாக்கப்பட்ட பெரும்பாலான போட்கள் குறிப்புத் தகவல் மற்றும் பலவற்றை வழங்குகின்றன. எங்கள் போட் ஒரு முழு அளவிலான வலை பயன்பாடு ஆகும். நீங்கள் ஒரு தரவுத்தளத்தை பிணைக்கலாம், பல்வேறு API கோரிக்கைகளை இயக்கலாம், வலைத்தளங்களை அலசலாம், சிக்கலான கணக்கீடுகளைச் செய்யலாம் மற்றும் பலவற்றை செய்யலாம். சாத்தியக்கூறுகள் உங்கள் கற்பனையால் மட்டுமே வரையறுக்கப்பட்டுள்ளன. நான் எதைப் பற்றி எழுதப் போகிறேன் என்பதை தெளிவுபடுத்த மேலே உள்ளவை உதவியிருக்கும் என்று நம்புகிறேன். டெலிகிராமில் ஒரு போட் பதிவு செய்வது மிகவும் எளிதானது. இந்த செயல்முறை மேலே இணைக்கப்பட்ட ஆவணத்தில் விரிவாக விவரிக்கப்பட்டுள்ளது. எங்கள் விண்ணப்பத்திற்கு, நீங்கள் போட்டின் பெயரையும், போட்டை பதிவு செய்யும் போது நீங்கள் பெறும் டோக்கனையும் மட்டும் தெரிந்து கொள்ள வேண்டும். அடிப்படையில், ஒரு போட் என்பது ஒரு கன்சோல் அடிப்படையிலான வலைப் பயன்பாடு ஆகும். முன் முனை இல்லை, தூய கட்டளை செயலாக்கம். நீங்கள் தேர்ச்சி பெற விரும்பினால்உறக்கநிலையில் இருங்கள் அல்லது JSON ஐ எவ்வாறு அலசுவது என்பதை அறியுங்கள் , இது உங்களுக்கான திட்டமாகும். ஒரு சார்புநிலையைச் சேர்ப்பதன் மூலம் தொடங்குவோம் pom.xml(நீங்கள் Maven ஐப் பயன்படுத்துகிறீர்கள் என்று கருதுகிறேன்). நீங்கள் இதை இப்படி செய்யலாம்:

<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பொருள். அதனுடன் தான் நாங்கள் வேலை செய்கிறோம். டெலிகிராம் போட்களின் அழகு இங்கே உள்ளது: அவை எந்த கணினியிலும் இயங்க முடியும், அதைச் சோதிக்க பயன்பாட்டைத் தொடங்க வேண்டும், மேலும் ஒவ்வொரு மாற்றத்திற்குப் பிறகும் அதை ஹோஸ்டில் பயன்படுத்த வேண்டியதில்லை. இது மிகவும் வசதியானது. நிச்சயமாக, வெப்ஹூக்குகளைப் பயன்படுத்தி வேலை செய்ய ஒரு போட்டை உள்ளமைக்கலாம். அதற்கான வழிகளை இணையத்தில் காணலாம். எளிமைக்காக, LongPolling ஐப் பயன்படுத்துவோம். செய்திகள் எவ்வாறு செயலாக்கப்படுகின்றன மற்றும் நீங்கள் பதில் அனுப்புவது மொழி மற்றும் நூலகத்தின் திறன்களால் மட்டுமே வரையறுக்கப்படுகிறது. மற்ற அனைத்தும் உங்களுடையது. உங்களுக்காக 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, இதிலிருந்து நீங்கள் bot க்கு அனுப்பப்பட்ட தரவை அணுகலாம். முறை மூலம் இந்தத் தரவைப் பெற முயற்சிக்காதீர்கள் 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, இதில் workerBot என்பது குறிப்பிடப்பட்ட பெயர் pom.xml. ஒரு ஷஸ்கிரிப்ட், மேவன் அப்ளிகேஷன் அசெம்பிளர் ப்ளகின் (appassembler-maven-plugin) மூலம் உருவாக்கப்படும் . தொகுக்கப்பட்ட ஜார் கோப்பை எவ்வாறு தொடங்குவது என்பதை ஸ்கிரிப்ட் விவரிக்கிறது. தொடங்குவதற்கான வகுப்பின் பெயர் <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 இரண்டையும் நிறுவ வேண்டும் . உங்கள் பயன்பாட்டிற்கு தரவுத்தளம் தேவைப்பட்டால், புதிய பயன்பாட்டை உருவாக்கும் போது தேவையான தரவுத்தளத்தைச் சேர்க்க மறக்காதீர்கள். மேலும், உங்கள் தரவுத்தளத்திற்கான ஹோஸ்ட், பயனர்பெயர், கடவுச்சொல் மற்றும் போர்ட் ஆகியவற்றை நீங்கள் தீர்மானிக்க வேண்டும், பின்னர் அவற்றை உங்கள் பயன்பாட்டில் குறிப்பிடவும். அடுத்து, பயன்படுத்துவதற்கு முன், Maven ஐப் பயன்படுத்தி உங்கள் திட்டத்தை உருவாக்கவும் .

mvn clean install

முதலில், நாங்கள் எங்கள் திட்ட கோப்பகத்திற்குச் சென்று, கட்டளையுடன் களஞ்சியத்தை துவக்குகிறோம் git init. பின்னர் இந்த களஞ்சியத்தில் எங்கள் திட்டத்தை சேர்க்கிறோம்.

git add .

பின்னர் நாங்கள் மாற்றங்களைச் செய்கிறோம்

git commit -m "First commit in the project"

அடுத்து, நீங்கள் ஹீரோகுவில் உள்நுழைய வேண்டும். கட்டளை வரியில் பின்வருவனவற்றை எழுதவும்

heroku login

பதிவின் போது நீங்கள் உருவாக்கிய நற்சான்றிதழ்களை உள்ளிடவும். அதன் பிறகு, உங்கள் களஞ்சியத்தின் URL ஐ ஹீரோகுவில் தீர்மானிக்கவும். அமைப்புகளில் இதைச் செய்யுங்கள். பிறகு எழுதுகிறோம்

git remote add heroku [url]

உங்கள் களஞ்சியத்திற்கு ரிமோட் ஹீரோகு களஞ்சியம் சேர்க்கப்பட்டுள்ளது. அடுத்து எழுதுகிறோம்

git push heroku master

பின்னர் நாங்கள் காத்திருக்கிறோம்… பயன்பாடு வெற்றிகரமாக வரிசைப்படுத்தப்பட்டால், பின்வரும் கட்டளையை இயக்கவும்

heroku ps:scale worker=1

அவ்வளவுதான், உங்கள் பயன்பாடு இயங்குகிறது. அது இல்லையென்றால், பதிவுகளை கவனமாகப் பாருங்கள். பெரும்பாலும், உங்கள் பயன்பாட்டில் ஏற்பட்ட பிழையால் அது தோல்வியடையும். இவ்வளவு நீண்ட கட்டுரையைப் படித்ததற்கு நன்றி. யாராவது இதைப் பயனுள்ளதாகக் காண்பார்கள் என்றும், வளர்ச்சியின் போது எனக்குச் சிக்கலைக் கொடுத்த பகுதிகளில் இது உங்களுக்கு நிறைய நேரத்தை மிச்சப்படுத்தும் என்றும் நம்புகிறேன்.