curl https://api.laozhang.ai/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{
    "model": "gpt-4o",
    "messages": [
      {"role": "system", "content": "你是一位专业的图像创作助手，能生成高质量图像。"},
      {"role": "user", "content": "请创建一个现代科技风格的登录界面设计，使用蓝色和白色为主色调，需要包含用户名和密码输入框，以及登录按钮。"}
    ]
  }'

import requests
import json
import os
import base64
from io import BytesIO
from PIL import Image

# API配置
api_key = "YOUR_API_KEY"  # 替换为你的API密钥
api_url = "https://api.laozhang.ai/v1/chat/completions"

# 请求头
headers = {
    "Content-Type": "application/json",
    "Authorization": f"Bearer {api_key}"
}

# 请求参数
data = {
    "model": "gpt-4o",
    "messages": [
        {"role": "system", "content": "你是一位专业的图像创作助手，能生成高质量图像。"},
        {"role": "user", "content": "请创建一个现代科技风格的登录界面设计，使用蓝色和白色为主色调，需要包含用户名和密码输入框，以及登录按钮。"}
    ]
}

# 发送请求
response = requests.post(api_url, headers=headers, json=data)
result = response.json()

# 处理响应
if response.status_code == 200:
    # 提取生成的图像（Base64编码）
    for message in result.get("choices", [{}])[0].get("message", {}).get("content", []):
        if isinstance(message, dict) and message.get("type") == "image":
            image_data = message.get("image_url", {}).get("url", "")
            if image_data.startswith("data:image"):
                # 提取Base64部分
                base64_data = image_data.split(",")[1]
                # 解码并保存图像
                image_bytes = base64.b64decode(base64_data)
                image = Image.open(BytesIO(image_bytes))
                image.save("generated_image.png")
                print("图像已保存为: generated_image.png")
else:
    print(f"请求失败: {response.status_code}")
    print(result)

// 使用fetch API调用GPT-4o图像生成
async function generateImage(prompt) {
  const apiKey = "YOUR_API_KEY"; // 替换为你的API密钥
  const apiUrl = "https://api.laozhang.ai/v1/chat/completions";
  
  const requestData = {
    model: "gpt-4o",
    messages: [
      {role: "system", content: "你是一位专业的图像创作助手，能生成高质量图像。"},
      {role: "user", content: prompt}
    ]
  };
  
  try {
    const response = await fetch(apiUrl, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "Authorization": `Bearer ${apiKey}`
      },
      body: JSON.stringify(requestData)
    });
    
    const result = await response.json();
    
    if (response.ok) {
      // 提取生成的图像URL
      const content = result.choices[0]?.message?.content;
      const imageData = content.find(item => item.type === "image")?.image_url?.url;
      
      if (imageData) {
        // 处理Base64图像数据
        return imageData;
      } else {
        throw new Error("响应中未找到图像数据");
      }
    } else {
      throw new Error(`请求失败: ${response.status}`);
    }
  } catch (error) {
    console.error("图像生成失败:", error);
    throw error;
  }
}

// 使用示例
document.getElementById("generateBtn").addEventListener("click", async () => {
  const prompt = document.getElementById("promptInput").value;
  try {
    const imageData = await generateImage(prompt);
    document.getElementById("resultImage").src = imageData;
  } catch (error) {
    alert(`图像生成失败: ${error.message}`);
  }
});

// 前端组件示例 (React)
import React, { useState } from 'react';
import axios from 'axios';

function ImageGenerator() {
  const [prompt, setPrompt] = useState('');
  const [image, setImage] = useState(null);
  const [loading, setLoading] = useState(false);
  const [error, setError] = useState(null);

  const generateImage = async () => {
    setLoading(true);
    setError(null);
    
    try {
      // 请求发送到后端API，避免在前端暴露API密钥
      const response = await axios.post('/api/generate-image', { prompt });
      setImage(response.data.imageUrl);
    } catch (err) {
      setError(err.response?.data?.message || '图像生成失败');
      console.error('生成失败:', err);
    } finally {
      setLoading(false);
    }
  };

  return (
    

      
AI图像生成器
      

         setPrompt(e.target.value)}
          placeholder="描述你想要生成的图像..."
          rows={4}
        />
        <button !prompt.trim()}="" disabled="{loading" onclick="{generateImage}" ||="">
          {loading ? '生成中...' : '生成图像'}
        </button>
      
      
      {error && 
{error}
}
      
      {image && (
        

          
生成结果
          
           window.open(image, '_blank')}>
            查看原图
          
        
      )}
    
  );
}

export default ImageGenerator;

// backend/routes/imageGeneration.js
const express = require('express');
const axios = require('axios');
const router = express.Router();

// 环境变量中获取API密钥
const API_KEY = process.env.LAOZHANG_API_KEY;
const API_URL = 'https://api.laozhang.ai/v1/chat/completions';

router.post('/generate-image', async (req, res) => {
  try {
    const { prompt } = req.body;
    
    if (!prompt || prompt.trim().length === 0) {
      return res.status(400).json({ message: '提示词不能为空' });
    }
    
    // 调用laozhang.ai API
    const response = await axios.post(API_URL, 
      {
        model: 'gpt-4o',
        messages: [
          { role: 'system', content: '你是一位专业的图像创作助手，能生成高质量图像。' },
          { role: 'user', content: prompt }
        ]
      },
      {
        headers: {
          'Content-Type': 'application/json',
          'Authorization': `Bearer ${API_KEY}`
        }
      }
    );
    
    // 提取图像URL
    const content = response.data.choices[0]?.message?.content;
    const imageData = content.find(item => item.type === 'image')?.image_url?.url;
    
    if (!imageData) {
      return res.status(404).json({ message: '未能生成图像' });
    }
    
    // 返回图像URL给前端
    res.json({ imageUrl: imageData });
    
  } catch (error) {
    console.error('图像生成API调用失败:', error);
    res.status(500).json({ 
      message: '图像生成失败',
      error: error.response?.data || error.message
    });
  }
});

module.exports = router;

// ImageGenerator.js (React Native)
import React, { useState, useCallback } from 'react';
import { View, Text, TextInput, Image, Button, StyleSheet, ActivityIndicator } from 'react-native';
import { useFocusEffect } from '@react-navigation/native';
import AsyncStorage from '@react-native-async-storage/async-storage';

const API_ENDPOINT = 'https://your-backend-api.com/generate-image';

const ImageGenerator = () => {
  const [prompt, setPrompt] = useState('');
  const [image, setImage] = useState(null);
  const [loading, setLoading] = useState(false);
  const [error, setError] = useState(null);
  
  // 加载已缓存的最后一次结果
  useFocusEffect(
    useCallback(() => {
      const loadLastResult = async () => {
        try {
          const cachedImage = await AsyncStorage.getItem('lastGeneratedImage');
          const cachedPrompt = await AsyncStorage.getItem('lastPrompt');
          if (cachedImage) {
            setImage(cachedImage);
            setPrompt(cachedPrompt || '');
          }
        } catch (e) {
          console.error('Failed to load cached image:', e);
        }
      };
      
      loadLastResult();
    }, [])
  );
  
  const generateImage = async () => {
    if (!prompt.trim()) {
      setError('请输入图像描述');
      return;
    }
    
    setLoading(true);
    setError(null);
    
    try {
      const response = await fetch(API_ENDPOINT, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
        },
        body: JSON.stringify({ prompt }),
      });
      
      const data = await response.json();
      
      if (!response.ok) {
        throw new Error(data.message || '生成失败');
      }
      
      setImage(data.imageUrl);
      
      // 缓存结果
      await AsyncStorage.setItem('lastGeneratedImage', data.imageUrl);
      await AsyncStorage.setItem('lastPrompt', prompt);
      
    } catch (err) {
      setError(err.message || '图像生成失败，请重试');
      console.error(err);
    } finally {
      setLoading(false);
    }
  };
  
  return (
    
      AI图像生成
      
      
      
      
      
      {error && {error}}
      
      {loading && (
        
          
          正在创作精美图像，请稍候...
        
      )}
      
      {image && !loading && (
        
          生成结果
          
        
      )}
    
  );
};

const styles = StyleSheet.create({
  container: {
    flex: 1,
    padding: 16,
    backgroundColor: '#fff',
  },
  title: {
    fontSize: 22,
    fontWeight: 'bold',
    marginBottom: 16,
  },
  input: {
    borderWidth: 1,
    borderColor: '#ccc',
    borderRadius: 8,
    padding: 12,
    marginBottom: 16,
    minHeight: 100,
  },
  error: {
    color: 'red',
    marginTop: 8,
  },
  loadingContainer: {
    marginTop: 20,
    alignItems: 'center',
  },
  loadingText: {
    marginTop: 8,
    color: '#666',
  },
  resultContainer: {
    marginTop: 20,
    alignItems: 'center',
  },
  resultTitle: {
    fontSize: 18,
    fontWeight: 'bold',
    marginBottom: 8,
  },
  resultImage: {
    width: '100%',
    height: 300,
    borderRadius: 8,
  },
});

export default ImageGenerator;

// 安全中间件示例 (Node.js Express)
const rateLimit = require('express-rate-limit');
const helmet = require('helmet');
const cors = require('cors');

// 安全HTTP头设置
app.use(helmet());

// 配置CORS策略
const corsOptions = {
  origin: ['https://yourdomain.com'],
  methods: ['POST'],
  allowedHeaders: ['Content-Type', 'Authorization'],
  maxAge: 86400 // 24小时
};
app.use(cors(corsOptions));

// 速率限制中间件
const apiLimiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15分钟
  max: 25, // 每个IP 15分钟内最多25个请求
  standardHeaders: true,
  message: {
    status: 429,
    message: '请求过于频繁，请稍后再试'
  }
});

// 应用速率限制到图像生成路由
app.use('/api/generate-image', apiLimiter);

// 内容过滤中间件
const contentFilter = (req, res, next) => {
  const { prompt } = req.body;
  
  // 简单的敏感词过滤示例
  const bannedWords = ['违禁词1', '违禁词2', '违禁词3'];
  
  if (bannedWords.some(word => prompt.toLowerCase().includes(word))) {
    return res.status(403).json({
      status: 'error',
      message: '提示词包含不适当内容，请修改后重试'
    });
  }
  
  next();
};

// 应用内容过滤
app.use('/api/generate-image', contentFilter);