$lang['tuto'] = "பயிற்சிகள்"; ?>$lang['tuto'] = "பயிற்சிகள்"; ?>$lang['tuto'] = "பயிற்சிகள்"; ?> ரெஸ்ட்ஃபுல்

ரெஸ்ட்ஃபுல் புரோகிராமிங்கைப் புரிந்துகொள்வது: ஒரு ஆழமான வழிகாட்டி

Arthur Petit
வியாழன், 20 ஜூன், 2024 ’அன்று’ முற்பகல் 4:54:49
JavaScript

RESTful நிரலாக்கத்தின் அத்தியாவசியங்கள்

RESTful நிரலாக்கம், அல்லது பிரதிநிதித்துவ மாநில பரிமாற்றம், இணைய சேவைகளின் உலகில் ஒரு முக்கிய கட்டடக்கலை பாணியாகும். இது கிளையன்ட் மற்றும் சர்வர் இடையே மென்மையான தகவல்தொடர்புகளை செயல்படுத்துகிறது, இது நவீன வலை மேம்பாட்டின் ஒரு மூலக்கல்லாகும். RESTful API களின் எளிமை மற்றும் நிலையற்ற தன்மையே அவற்றை மிகவும் சக்திவாய்ந்ததாகவும் பரவலாக ஏற்றுக்கொள்ளப்பட்டதாகவும் ஆக்குகிறது.

இந்த அறிமுகம், RESTful நிரலாக்கமானது என்ன, அதன் கொள்கைகள் மற்றும் நிஜ உலகப் பயன்பாடுகளில் எவ்வாறு செயல்படுத்தப்படுகிறது என்பதைப் பற்றிய தெளிவான புரிதலை வழங்கும். அடிப்படைகளை ஆராய்வதன் மூலம், டெவலப்பர்களின் திட்டங்களில் RESTful APIகளை திறம்பட பயன்படுத்துவதற்கான அறிவை அவர்களுக்கு வழங்குவதை நோக்கமாகக் கொண்டுள்ளோம்.

கட்டளை விளக்கம்
app.use(bodyParser.json()) இந்த மிடில்வேர் உங்கள் ஹேண்ட்லர்களுக்கு முன் மிடில்வேரில் உள்வரும் கோரிக்கை உடல்களை பாகுபடுத்துகிறது, இது req.body சொத்தின் கீழ் கிடைக்கும்.
app.get('/items', (req, res) =>app.get('/items', (req, res) => {}) அனைத்து பொருட்களையும் பெற "/items" இறுதிப்புள்ளிக்கான GET கோரிக்கைகளுக்கான வழி கையாளுதலை வரையறுக்கிறது.
app.post('/items', (req, res) =>app.post('/items', (req, res) => {}) புதிய உருப்படியை உருவாக்க "/items" இறுதிப்புள்ளிக்கான POST கோரிக்கைகளுக்கான வழி கையாளுதலை வரையறுக்கிறது.
app.put('/items/:id', (req, res) =>app.put('/items/:id', (req, res) => {}) ஏற்கனவே உள்ள உருப்படியை ஐடி மூலம் புதுப்பிக்க "/items/:id" இறுதிப்புள்ளிக்கான PUT கோரிக்கைகளுக்கான ரூட் ஹேண்ட்லரை வரையறுக்கிறது.
app.delete('/items/:id', (req, res) =>app.delete('/items/:id', (req, res) => {}) ஐடி மூலம் உருப்படியை நீக்க "/items/:id" இறுதிப்புள்ளிக்கான கோரிக்கைகளை நீக்குவதற்கான வழி கையாளுதலை வரையறுக்கிறது.
if (itemIndex === -1) அணிவரிசையில் உருப்படி இன்டெக்ஸ் கிடைக்கவில்லையா எனச் சரிபார்த்து, சரி எனில் பிழைச் செய்தியை வழங்கும்.
@app.route('/items', methods=['GET']) அனைத்து பொருட்களையும் பெறுவதற்கான GET கோரிக்கைகளுக்கான ரூட் ஹேண்ட்லரை வரையறுக்க பிளாஸ்கில் உள்ள டெக்கரேட்டர்.
@app.route('/items', methods=['POST']) புதிய உருப்படியை உருவாக்குவதற்கான POST கோரிக்கைகளுக்கான ரூட் ஹேண்ட்லரை வரையறுக்க பிளாஸ்கில் உள்ள டெக்கரேட்டர்.
app.run(debug=True) பிழைத்திருத்த பயன்முறையுடன் பிளாஸ்க் பயன்பாட்டைத் தொடங்குகிறது, இது சேவையகத்தை மறுதொடக்கம் செய்யாமல் நிகழ்நேர குறியீட்டு மாற்றங்களை அனுமதிக்கிறது.
request.json['name'] Flask இல் உள்வரும் கோரிக்கையின் JSON பேலோடில் இருந்து 'பெயர்' புலத்தை அணுகுகிறது.

Node.js மற்றும் Flask இல் RESTful APIகளை செயல்படுத்துதல்

மேலே கொடுக்கப்பட்டுள்ள ஸ்கிரிப்டுகள், எக்ஸ்பிரஸ் ஃப்ரேம்வொர்க்குடன் Node.js ஐப் பயன்படுத்தியும், பிளாஸ்க் ஃப்ரேம்வொர்க்குடன் பைத்தானையும் பயன்படுத்தி எப்படி ஒரு RESTful API ஐ உருவாக்குவது என்பதை விளக்குகிறது. Node.js எடுத்துக்காட்டில், தேவையான தொகுதிகளை இறக்குமதி செய்வதன் மூலம் ஸ்கிரிப்ட் தொடங்குகிறது மற்றும் . தி உள்வரும் JSON கோரிக்கை அமைப்புகளை அலசுவதற்கு மிடில்வேர் பயன்படுத்தப்படுகிறது. ஸ்கிரிப்ட் பல்வேறு HTTP முறைகளைக் கையாள வழிகளை அமைக்கிறது. உதாரணமாக, தி app.get('/items', (req, res) => {}) அனைத்து பொருட்களையும் பெறுவதற்கான GET கோரிக்கைகளை வழி கையாளுகிறது புதிய உருப்படிகளைச் சேர்க்க POST கோரிக்கைகளைக் கையாளுகிறது. ஒவ்வொரு வழியும் CRUD செயல்பாடுகளைச் செய்ய மாதிரி தரவு வரிசையுடன் தொடர்பு கொள்கிறது, அடிப்படை RESTful API செயல்பாடுகளை எவ்வாறு செயல்படுத்துவது என்பதை விளக்குகிறது.

பிளாஸ்க் எடுத்துக்காட்டில், ஸ்கிரிப்ட் பாதைகளை வரையறுக்க பைதான் டெக்கரேட்டர்களைப் பயன்படுத்துகிறது. தி டெக்கரேட்டர் GET கோரிக்கைகளை கையாள ஒரு வழியை வரையறுக்கிறது, மாதிரி தரவு வரிசையில் இருந்து அனைத்து பொருட்களையும் பெறுகிறது. இதேபோல், தி அலங்கரிப்பவர் ஒரு பொருளை அதன் ஐடி மூலம் பெறுகிறார். ஃபிளாஸ்க் ஸ்கிரிப்ட், Node.js உதாரணத்தைப் போலவே உருப்படிகளைச் சேர்ப்பது, புதுப்பித்தல் மற்றும் நீக்குவதற்கான வழிகளையும் உள்ளடக்கியது. உதாரணமாக, தி புதிய உருப்படிகளை உருவாக்குவதற்கான POST கோரிக்கைகளை வழி கையாளுகிறது @app.route('/items/<int:item_id>', methods=['PUT']) மற்றும் உருப்படிகளை புதுப்பித்தல் மற்றும் நீக்குதல் ஆகியவற்றை முறையே கையாளவும். வெவ்வேறு நிரலாக்க சூழல்களில் RESTful APIகளை எவ்வாறு உருவாக்குவது என்பதை ஸ்கிரிப்ட்கள் காண்பிக்கின்றன, HTTP முறைகளைப் புரிந்துகொள்வதன் முக்கியத்துவத்தையும் API மேம்பாட்டில் அவற்றின் பொருத்தமான பயன்பாட்டையும் வலியுறுத்துகிறது.

Node.js மற்றும் Express உடன் RESTful API ஐ உருவாக்குதல்

எக்ஸ்பிரஸ் கட்டமைப்புடன் JavaScript மற்றும் Node.js ஐப் பயன்படுத்துதல்

// Import required modules
const express = require('express');
const app = express();
const bodyParser = require('body-parser');

// Middleware setup
app.use(bodyParser.json());

// Sample data
let items = [
    { id: 1, name: 'Item 1' },
    { id: 2, name: 'Item 2' }
];

// GET request to fetch all items
app.get('/items', (req, res) => {
    res.json(items);
});

// GET request to fetch a single item by ID
app.get('/items/:id', (req, res) => {
    const item = items.find(i => i.id === parseInt(req.params.id));
    if (!item) return res.status(404).send('Item not found');
    res.json(item);
});

// POST request to add a new item
app.post('/items', (req, res) => {
    const newItem = {
        id: items.length + 1,
        name: req.body.name
    };
    items.push(newItem);
    res.status(201).json(newItem);
});

// PUT request to update an item
app.put('/items/:id', (req, res) => {
    const item = items.find(i => i.id === parseInt(req.params.id));
    if (!item) return res.status(404).send('Item not found');
    item.name = req.body.name;
    res.json(item);
});

// DELETE request to remove an item
app.delete('/items/:id', (req, res) => {
    const itemIndex = items.findIndex(i => i.id === parseInt(req.params.id));
    if (itemIndex === -1) return res.status(404).send('Item not found');
    const deletedItem = items.splice(itemIndex, 1);
    res.json(deletedItem);
});

// Start the server
const port = process.env.PORT || 3000;
app.listen(port, () => console.log(`Server running on port ${port}`));

பைதான் மற்றும் பிளாஸ்க் மூலம் ஒரு RESTful API ஐ உருவாக்குதல்

பைதான் மற்றும் பிளாஸ்க் கட்டமைப்பைப் பயன்படுத்துதல்

from flask import Flask, request, jsonify

app = Flask(__name__)

# Sample data
items = [
    {'id': 1, 'name': 'Item 1'},
    {'id': 2, 'name': 'Item 2'}
]

# GET request to fetch all items
@app.route('/items', methods=['GET'])
def get_items():
    return jsonify(items)

# GET request to fetch a single item by ID
@app.route('/items/<int:item_id>', methods=['GET'])
def get_item(item_id):
    item = next((i for i in items if i['id'] == item_id), None)
    if item is None:
        return jsonify({'message': 'Item not found'}), 404
    return jsonify(item)

# POST request to add a new item
@app.route('/items', methods=['POST'])
def add_item():
    new_item = {
        'id': len(items) + 1,
        'name': request.json['name']
    }
    items.append(new_item)
    return jsonify(new_item), 201

# PUT request to update an item
@app.route('/items/<int:item_id>', methods=['PUT'])
def update_item(item_id):
    item = next((i for i in items if i['id'] == item_id), None)
    if item is None:
        return jsonify({'message': 'Item not found'}), 404
    item['name'] = request.json['name']
    return jsonify(item)

# DELETE request to remove an item
@app.route('/items/<int:item_id>', methods=['DELETE'])
def delete_item(item_id):
    global items
    items = [i for i in items if i['id'] != item_id]
    return jsonify({'message': 'Item deleted'})

# Start the server
if __name__ == '__main__':
    app.run(debug=True)

RESTful நிரலாக்கத்தின் கோட்பாடுகள் மற்றும் நன்மைகளைப் புரிந்துகொள்வது

RESTful நிரலாக்கமானது இணைய சேவைகளை திறமையாகவும் பயன்படுத்த எளிதாகவும் செய்யும் கொள்கைகளின் அடிப்படையில் அமைந்துள்ளது. முக்கிய கொள்கைகளில் ஒன்று நிலையற்ற தன்மை, அதாவது கிளையண்டிலிருந்து சேவையகத்திற்கான ஒவ்வொரு கோரிக்கையும் கோரிக்கையைப் புரிந்துகொள்வதற்கும் செயலாக்குவதற்கும் தேவையான அனைத்து தகவல்களையும் கொண்டிருக்க வேண்டும். கிளையன்ட் அமர்வைப் பற்றி சேவையகம் எந்த நிலையையும் சேமித்து வைக்காது, இது கணினியை அளவிடக்கூடியதாகவும் தோல்விகளுக்கு மீள்தன்மையுடையதாகவும் ஆக்குகிறது. மற்றொரு முக்கியமான கொள்கை சீரான இடைமுகம் ஆகும், இது கட்டிடக்கலையை எளிதாக்குகிறது மற்றும் துண்டிக்கிறது, ஒவ்வொரு பகுதியும் சுயாதீனமாக உருவாகிறது. GET, POST, PUT மற்றும் DELETE போன்ற நிலையான HTTP முறைகளின் தொகுப்பின் மூலம் இது பொதுவாக அடையப்படுகிறது.

RESTful நிரலாக்கத்தின் மற்றொரு குறிப்பிடத்தக்க அம்சம் வள அடிப்படையிலான URLகளைப் பயன்படுத்துவதாகும். செயல்கள் அல்லது வினைச்சொற்களுக்குப் பதிலாக, RESTful URLகள் பெயர்ச்சொற்களை அடிப்படையாகக் கொண்டவை, அவை கையாளப்படும் வளங்களைக் குறிக்கும். எடுத்துக்காட்டாக, ஒரு பயனரைப் பற்றிய தகவலைப் பெற, நீங்கள் /users/{user_id} போன்ற URL ஐப் பயன்படுத்தலாம். இந்த அணுகுமுறை API ஐ உள்ளுணர்வு மற்றும் புரிந்துகொள்ள எளிதாக்குகிறது. REST ஆனது ஹைப்பர்மீடியாவை பயன்பாட்டு நிலையின் (HATEOAS) இன்ஜினாகப் பயன்படுத்துவதை ஊக்குவிக்கிறது, அங்கு சேவையகம் மற்ற ஆதாரங்கள் மற்றும் எடுக்கக்கூடிய செயல்களுக்கான இணைப்புகளை வழங்குகிறது, இது பயன்பாட்டின் மூலம் கிளையண்டை மாறும் வகையில் வழிநடத்துகிறது. இது API ஐ சுய விளக்கமாகவும் கண்டறியக்கூடியதாகவும் ஆக்குகிறது.

  1. REST என்றால் என்ன?
  2. REST என்பது பிரதிநிதித்துவ மாநில பரிமாற்றத்தைக் குறிக்கிறது, இது நெட்வொர்க் செய்யப்பட்ட பயன்பாடுகளை வடிவமைப்பதற்கான கட்டடக்கலை பாணியாகும்.
  3. REST இன் முக்கிய கொள்கைகள் என்ன?
  4. முக்கிய கொள்கைகளில் நிலையற்ற தன்மை, ஒரு சீரான இடைமுகம், வள அடிப்படையிலான URLகள் மற்றும் HATEOAS ஆகியவை அடங்கும்.
  5. REST இல் நிலையற்ற தன்மை என்றால் என்ன?
  6. நிலையற்ற தன்மை என்பது கிளையண்டிலிருந்து சர்வர் வரையிலான ஒவ்வொரு கோரிக்கையும் கோரிக்கையைப் புரிந்துகொள்வதற்கும் செயலாக்குவதற்கும் தேவையான அனைத்து தகவல்களையும் கொண்டிருக்க வேண்டும்.
  7. RESTful APIகளில் என்ன HTTP முறைகள் பொதுவாகப் பயன்படுத்தப்படுகின்றன?
  8. பொதுவான HTTP முறைகள் , , , மற்றும் DELETE.
  9. HATEOAS என்றால் என்ன?
  10. HATEOAS என்பது ஹைப்பர்மீடியாவை பயன்பாட்டு நிலையின் இயந்திரமாக குறிக்கிறது, அங்கு சேவையகம் பிற ஆதாரங்கள் மற்றும் செயல்களுக்கான இணைப்புகளை வழங்குகிறது.
  11. RESTful URLகள் மற்றவற்றிலிருந்து எவ்வாறு வேறுபடுகின்றன?
  12. RESTful URLகள் வளங்களைக் குறிக்கும் பெயர்ச்சொற்களை அடிப்படையாகக் கொண்டவை, அவற்றை உள்ளுணர்வு மற்றும் எளிதாகப் புரிந்துகொள்கின்றன.
  13. REST இல் சீரான இடைமுகம் ஏன் முக்கியமானது?
  14. ஒரு சீரான இடைமுகம் கட்டிடக்கலையை எளிதாக்குகிறது மற்றும் துண்டிக்கிறது, ஒவ்வொரு பகுதியும் சுயாதீனமாக உருவாக அனுமதிக்கிறது.
  15. REST இல் வள பிரதிநிதித்துவம் என்றால் என்ன?
  16. ஆதார பிரதிநிதித்துவம் என்பது JSON அல்லது XML போன்ற வடிவங்களில் தரவை வழங்குவதை உள்ளடக்கியது, இது வளத்தின் நிலையை குறிக்கிறது.
  17. RESTful APIகளைப் பயன்படுத்துவதன் நன்மைகள் என்ன?
  18. நன்மைகள் அளவிடுதல், எளிமை, மாற்றியமைத்தல் மற்றும் மேம்பட்ட செயல்திறன் ஆகியவை அடங்கும்.

RESTful நிரலாக்கமானது திறமையான மற்றும் அளவிடக்கூடிய இணைய சேவைகளை உருவாக்குவதற்கான ஒரு இன்றியமையாத முறையாகும். நிலையற்ற தன்மை மற்றும் சீரான இடைமுகங்கள் போன்ற கொள்கைகளை மேம்படுத்துவதன் மூலம், டெவலப்பர்கள் எளிதாக பராமரிக்க மற்றும் விரிவாக்கக்கூடிய APIகளை உருவாக்க முடியும். Express உடன் Node.js மற்றும் Flask உடன் Python ஆகியவற்றைப் பயன்படுத்தும் எடுத்துக்காட்டுகள் நடைமுறைச் செயலாக்கங்களை நிரூபிக்கின்றன, இது அவர்களின் சொந்த RESTful API களை உருவாக்க விரும்பும் எவருக்கும் உறுதியான அடித்தளத்தை வழங்குகிறது. இந்த முக்கிய கருத்துக்கள் மற்றும் நுட்பங்களைப் புரிந்துகொள்வது நவீன வலை வளர்ச்சிக்கு முக்கியமானது.