ISO网络模型七层架构及各层功能详解

# Python示例：检测网络接口的物理状态
import psutil
import socket
 
def check_network_interface():
    """检测网络接口状态"""
    interfaces = psutil.net_if_stats()
    
    for interface_name, stats in interfaces.items():
        if stats.isup:
            print(f"🟢 接口 {interface_name} 已连接")
            print(f"   速度: {stats.speed} Mbps")
            print(f"   MTU: {stats.mtu}")
        else:
            print(f"🔴 接口 {interface_name} 未连接")
 
check_network_interface()

// JavaScript示例：获取本机MAC地址
const os = require('os');
 
function getMacAddresses() {
    const interfaces = os.networkInterfaces();
    const macAddresses = {};
    
    for (const name in interfaces) {
        const iface = interfaces[name];
        for (const alias of iface) {
            if (alias.mac && alias.mac !== '00:00:00:00:00:00') {
                macAddresses[name] = alias.mac;
            }
        }
    }
    
    return macAddresses;
}
 
console.log('本机MAC地址:', getMacAddresses());

# Python示例：IP地址分析与子网计算
import ipaddress
 
def analyze_network(ip_with_mask):
    """分析IP网络和子网信息"""
    network = ipaddress.ip_network(ip_with_mask, strict=False)
    
    print(f"网络地址: {network.network_address}")
    print(f"广播地址: {network.broadcast_address}")
    print(f"子网掩码: {network.netmask}")
    print(f"可用主机数: {network.num_addresses - 2}")
    print(f"IP地址范围: {network.network_address + 1} - {network.broadcast_address - 1}")
    
    return {
        'network': str(network.network_address),
        'broadcast': str(network.broadcast_address),
        'hosts': network.num_addresses - 2
    }
 
# 示例：分析192.168.1.0/24网络
result = analyze_network("192.168.1.0/24")

// Java示例：TCP服务器端实现
import java.io.*;
import java.net.*;
 
public class TCPServer {
    public static void main(String[] args) {
        try (ServerSocket serverSocket = new ServerSocket(8080)) {
            System.out.println("服务器启动，监听端口 8080...");
            
            while (true) {
                // 等待客户端连接
                Socket clientSocket = serverSocket.accept();
                System.out.println("客户端连接: " + clientSocket.getInetAddress());
                
                // 处理客户端请求
                try (BufferedReader in = new BufferedReader(
                        new InputStreamReader(clientSocket.getInputStream()));
                     PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true)) {
                    
                    String inputLine;
                    while ((inputLine = in.readLine()) != null) {
                        System.out.println("收到消息: " + inputLine);
                        out.println("服务器响应: " + inputLine);
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

# Python示例：使用paramiko建立SSH会话
import paramiko
import time
 
def establish_ssh_session(hostname, username, password):
    """建立SSH会话并执行命令"""
    ssh = paramiko.SSHClient()
    ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
    
    try:
        # 建立SSH会话
        ssh.connect(hostname, username=username, password=password)
        print(f"成功建立到 {hostname} 的SSH会话")
        
        # 执行命令
        stdin, stdout, stderr = ssh.exec_command('ls -la')
        
        # 读取输出
        output = stdout.read().decode('utf-8')
        error = stderr.read().decode('utf-8')
        
        if output:
            print("命令输出:")
            print(output)
        
        if error:
            print("错误信息:")
            print(error)
            
    except Exception as e:
        print(f"SSH会话建立失败: {e}")
    finally:
        # 关闭会话
        ssh.close()
        print("SSH会话已关闭")
 
# 使用示例
establish_ssh_session('192.168.1.100', 'admin', 'password')

// JavaScript示例：Base64编码与解码（表示层功能）
class DataTransformer {
    // Base64编码
    static encodeBase64(data) {
        return Buffer.from(data).toString('base64');
    }
    
    // Base64解码
    static decodeBase64(encodedData) {
        return Buffer.from(encodedData, 'base64').toString('utf-8');
    }
    
    // URL编码
    static encodeURL(data) {
        return encodeURIComponent(data);
    }
    
    // URL解码
    static decodeURL(encodedData) {
        return decodeURIComponent(encodedData);
    }
}
 
// 使用示例
const originalData = "Hello, 世界! 这是一个测试消息。";
console.log("原始数据:", originalData);
 
const encoded = DataTransformer.encodeBase64(originalData);
console.log("Base64编码:", encoded);
 
const decoded = DataTransformer.decodeBase64(encoded);
console.log("Base64解码:", decoded);

# Python示例：AES加密解密（表示层安全功能）
from cryptography.fernet import Fernet
import base64
 
class SecureDataTransformer:
    def __init__(self):
        # 生成加密密钥
        self.key = Fernet.generate_key()
        self.cipher = Fernet(self.key)
    
    def encrypt_data(self, data):
        """加密数据"""
        if isinstance(data, str):
            data = data.encode('utf-8')
        encrypted = self.cipher.encrypt(data)
        return base64.b64encode(encrypted).decode('utf-8')
    
    def decrypt_data(self, encrypted_data):
        """解密数据"""
        encrypted_bytes = base64.b64decode(encrypted_data.encode('utf-8'))
        decrypted = self.cipher.decrypt(encrypted_bytes)
        return decrypted.decode('utf-8')
 
# 使用示例
transformer = SecureDataTransformer()
sensitive_data = "用户密码: mySecretPassword123"
 
encrypted = transformer.encrypt_data(sensitive_data)
print(f"加密后: {encrypted}")
 
decrypted = transformer.decrypt_data(encrypted)
print(f"解密后: {decrypted}")

# Python示例：使用Flask构建RESTful API
from flask import Flask, jsonify, request
import json
 
app = Flask(__name__)
 
# 模拟数据存储
users = {
    1: {"id": 1, "name": "张三", "email": "zhangsan@example.com"},
    2: {"id": 2, "name": "李四", "email": "lisi@example.com"}
}
 
@app.route('/api/users', methods=['GET'])
def get_users():
    """获取所有用户"""
    return jsonify({
        "status": "success",
        "data": list(users.values()),
        "count": len(users)
    })
 
@app.route('/api/users/<int:user_id>', methods=['GET'])
def get_user(user_id):
    """获取特定用户"""
    user = users.get(user_id)
    if user:
        return jsonify({
            "status": "success",
            "data": user
        })
    else:
        return jsonify({
            "status": "error",
            "message": "用户不存在"
        }), 404
 
@app.route('/api/users', methods=['POST'])
def create_user():
    """创建新用户"""
    data = request.get_json()
    
    if not data or 'name' not in data or 'email' not in data:
        return jsonify({
            "status": "error",
            "message": "缺少必要字段"
        }), 400
    
    new_id = max(users.keys()) + 1
    new_user = {
        "id": new_id,
        "name": data['name'],
        "email": data['email']
    }
    
    users[new_id] = new_user
    
    return jsonify({
        "status": "success",
        "data": new_user,
        "message": "用户创建成功"
    }), 201
 
if __name__ == '__main__':
    app.run(debug=True, port=5000)

# Linux命令：网络性能监控工具
 
# 1. 查看网络接口状态
ip -s link show
 
# 2. 实时监控网络流量
iftop -i eth0
 
# 3. 网络连接状态分析
netstat -tuln
 
# 4. 路由表查看
ip route show
 
# 5. DNS查询测试
dig www.example.com
 
# 6. 网络路径追踪
traceroute www.example.com
 
# 7. 网络带宽测试
iperf3 -s  # 服务器端
iperf3 -c server_ip  # 客户端