无需PHP和MySQL实现图片上传至服务器的方法咨询

Hey there! I’ve been in a similar spot before, so I totally get what you’re looking for. You don’t need PHP or MySQL to handle image uploads—there are plenty of straightforward alternatives that work seamlessly with your Camera2 API setup. Let’s dive into practical options:

1. Use Static Object Storage APIs (No Backend Code Needed) #

Many cloud providers offer object storage services (like S3-compatible storage) that let you upload files directly via their REST API, no server-side code required. Here’s how it works:

• Step 1: Generate a pre-signed URL (on your client or via a lightweight auth service) that grants temporary permission to upload a file to the storage bucket.
• Step 2: Use an HTTP client like OkHttp or even Volley to send a PUT request with your image binary data to that pre-signed URL.

Example code snippet with OkHttp:

// Assume you have your Camera2-captured image as a File or byte array
File imageFile = new File("/path/to/camera2-image.jpg");
String preSignedUrl = "your-generated-pre-signed-url";

RequestBody requestBody = RequestBody.create(imageFile, MediaType.parse("image/jpeg"));
Request request = new Request.Builder()
        .url(preSignedUrl)
        .put(requestBody)
        .build();

OkHttpClient client = new OkHttpClient();
client.newCall(request).enqueue(new Callback() {
    @Override
    public void onFailure(Call call, IOException e) {
        // Handle upload failure
    }

    @Override
    public void onResponse(Call call, Response response) throws IOException {
        if (response.isSuccessful()) {
            // Upload succeeded!
        }
    }
});

2. Build a Minimal Node.js Backend (No MySQL) #

If you prefer having your own server but want to avoid PHP, a simple Node.js + Express setup can handle file uploads without a database. We’ll use multer to handle multipart/form-data requests:

First, set up the Node.js server:

const express = require('express');
const multer = require('multer');
const app = express();

// Configure storage for uploaded images
const storage = multer.diskStorage({
    destination: (req, file, cb) => {
        cb(null, './uploads/'); // Make sure this directory exists
    },
    filename: (req, file, cb) => {
        cb(null, Date.now() + '-' + file.originalname);
    }
});

const upload = multer({ storage: storage });

// Create an upload endpoint
app.post('/upload', upload.single('image'), (req, res) => {
    res.status(200).json({ message: 'Image uploaded successfully', filePath: req.file.path });
});

app.listen(3000, () => {
    console.log('Server running on port 3000');
});

Then, from your Android app (using Volley, for example), send a multipart request to this endpoint:

String url = "http://your-server-ip:3000/upload";
File imageFile = new File("/path/to/camera2-image.jpg");

MultipartRequest multipartRequest = new MultipartRequest(url,
        response -> {
            // Handle success
        },
        error -> {
            // Handle error
        }) {
    @Override
    protected Map<String, DataPart> getByteData() {
        Map<String, DataPart> params = new HashMap<>();
        params.put("image", new DataPart(imageFile.getName(), getFileBytes(imageFile), "image/jpeg"));
        return params;
    }
};

Volley.newRequestQueue(context).add(multipartRequest);

(Note: You’ll need a custom MultipartRequest class for Volley, but there are plenty of open-source implementations available.)

3. FTP/SFTP Direct Upload #

If your server supports FTP or SFTP, you can upload images directly from your Android app using libraries like Apache Commons Net:

FTPClient ftpClient = new FTPClient();
try {
    ftpClient.connect("your-server-ip", 21);
    ftpClient.login("ftp-username", "ftp-password");
    ftpClient.setFileType(FTP.BINARY_FILE_TYPE);

    File imageFile = new File("/path/to/camera2-image.jpg");
    InputStream inputStream = new FileInputStream(imageFile);
    ftpClient.storeFile("uploaded-image.jpg", inputStream);

    inputStream.close();
    ftpClient.logout();
} catch (IOException e) {
    e.printStackTrace();
} finally {
    if (ftpClient.isConnected()) {
        try {
            ftpClient.disconnect();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

This skips any application-level backend entirely—you just need your server configured with FTP/SFTP access.

4. WebDAV Protocol #

Many web servers (like Apache or Nginx) support WebDAV, which lets you treat server directories like remote file systems. You can use OkHttp or dedicated WebDAV libraries to upload files directly:

// Example with OkHttp for WebDAV PUT request
String webdavUrl = "http://your-server-ip/webdav-directory/uploaded-image.jpg";
File imageFile = new File("/path/to/camera2-image.jpg");

RequestBody requestBody = RequestBody.create(imageFile, MediaType.parse("image/jpeg"));
Request request = new Request.Builder()
        .url(webdavUrl)
        .put(requestBody)
        .addHeader("Authorization", "Basic " + Base64.encodeToString("username:password".getBytes(), Base64.NO_WRAP))
        .build();

OkHttpClient client = new OkHttpClient();
client.newCall(request).enqueue(new Callback() {
    // Handle response/failure
});

Quick Note on Volley #

You mentioned thinking Volley requires PHP—don’t worry, Volley is just an HTTP client! You can use it with any of the above methods: send PUT requests to object storage URLs, post multipart data to a Node.js endpoint, etc. The backend technology doesn’t matter as long as you’re making valid HTTP requests.

内容的提问来源于stack exchange，提问作者Vivian Tio