<Connector port="8080" protocol="HTTP/1.1"
           connectionTimeout="20000"
           redirectPort="8443"
           compression="on"
           compressionMinSize="2048"
           noCompressionUserAgents="gozilla, traviata"
           compressableMimeType="text/html,text/xml,text/javascript,text/css,text/plain" />

@PostMapping("/import")
public R<?> importExcel(@RequestParam("file") MultipartFile file) {
    List<MyDataModel> dataList = EasyExcel.read(file.getInputStream())
        .head(MyDataModel.class)
        .sheet()
        .doReadSync();
    // 业务处理逻辑
    return R.ok("导入成功");
}

@GetMapping("/export")
public void exportExcel(HttpServletResponse response) throws IOException {
    List<MyDataModel> dataList = ...; // 业务数据获取逻辑
    String fileName = "exported_data.xlsx";
    response.setContentType("application/vnd.ms-excel");
    response.setCharacterEncoding("utf-8");
    response.setHeader("Content-disposition", "attachment;filename=" + URLEncoder.encode(fileName, "UTF-8").replaceAll("\\+", "%20"));
    EasyExcel.write(response.getOutputStream(), MyDataModel.class)
        .sheet("Sheet1")
        .doWrite(dataList);
}

<template>
  <el-upload
    action="http://your-backend-service/import"
    :on-success="handleImportSuccess"
    :on-error="handleImportError">
    <el-button slot="trigger" size="small" type="primary">选择文件</el-button>
    <el-button size="small" type="success" @click="submitUpload">上传到服务器</el-button>
  </el-upload>
</template>

<script>
export default {
  methods: {
    handleImportSuccess(response, file, fileList) {
      console.log('Import successful', response);
    },
    handleImportError(err, file, fileList) {
      console.error('Import failed', err);
    },
    submitUpload() {
      this.$refs.upload.submit();
    }
  }
}
</script>

<template>
  <el-button size="small" type="warning" @click="exportData">导出数据</el-button>
</template>

<script>
export default {
  methods: {
    exportData() {
      window.location.href = 'http://your-backend-service/export';
    }
  }
}
</script>

CREATE TABLE users (
    id INT PRIMARY KEY,
    name VARCHAR(100),
    email VARCHAR(100)
);

import java.sql.*;

public class UserDao {
    private Connection connect = null;
    private PreparedStatement preparedStatement = null;
    private ResultSet resultSet = null;

    public UserDao() {
        try {
            // 加载数据库驱动
            Class.forName("com.mysql.cj.jdbc.Driver");
            // 建立数据库连接
            connect = DriverManager.getConnection("jdbc:mysql://localhost:3306/database_name", "username", "password");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 增加用户
    public boolean insert(User user) {
        try {
            String query = "INSERT INTO users (name, email) VALUES (?, ?)";
            preparedStatement = connect.prepareStatement(query);
            preparedStatement.setString(1, user.getName());
            preparedStatement.setString(2, user.getEmail());
            return preparedStatement.executeUpdate() > 0;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    // 删除用户
    public boolean delete(int id) {
        try {
            String query = "DELETE FROM users WHERE id = ?";
            preparedStatement = connect.prepareStatement(query);
            preparedStatement.setInt(1, id);
            return preparedStatement.executeUpdate() > 0;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    // 修改用户
    public boolean update(User user) {
        try {
            String query = "UPDATE users SET name = ?, email = ? WHERE id = ?";
            preparedStatement = connect.prepareStatement(query);
            preparedStatement.setString(1, user.getName());
            preparedStatement.setString(2, user.getEmail());
            preparedStatement.setInt(3, user.getId());
            return preparedStatement.executeUpdate() > 0;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    // 查询用户
    public User search(int id) {
        try {
            String query = "SELECT * FROM users WHERE id = ?";
            preparedStatement = connect.prepareStatement(query);
            preparedStatement.setInt(1

<template>
  <el-upload
    action="http://localhost:8080/upload"
    list-type="picture-card"
    :on-preview="handlePreview"
    :on-success="handleSuccess"
    :file-list="fileList"
  >
    <i class="el-icon-plus"></i>
  </el-upload>
  <el-dialog :visible.sync="dialogVisible">
    <img width="100%" :src="dialogImageUrl" alt="">
  </el-dialog>
</template>

<script>
export default {
  data() {
    return {
      fileList: [],
      dialogImageUrl: '',
      dialogVisible: false
    };
  },
  methods: {
    handlePreview(file) {
      this.dialogImageUrl = file.url;
      this.dialogVisible = true;
    },
    handleSuccess(response, file, fileList) {
      file.url = `http://localhost:8080/download/${response.data}`;
    }
  }
};
</script>

import org.springframework.web.bind.annotation.*;
import org.springframework.core.io.Resource;
import org.springframework.core.io.UrlResource;
import org.springframework.http.ResponseEntity;
import org.springframework.web.multipart.MultipartFile;

import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

@RestController
public class FileUploadController {

    private static final String UPLOAD_DIR = System.getProperty("user.home") + "/.upload/";

    @PostMapping("/upload")
    public ResponseEntity<String> uploadFile(@RequestParam("file") MultipartFile file) {
        try {
            Path uploadDir = Paths.get(UPLOAD_DIR);
            if (!Files.exists(uploadDir)) {
                Files.createDirectories(uploadDir);
            }
            String filename = file.getOriginalFilename();
            Path filePath = uploadDir.resolve(filename);
            Files.copy(file.getInputStream(), filePath);
            return ResponseEntity.ok("File uploaded successfully: " + filename);
        } catch (Exception e) {
            return ResponseEntity.unprocessableEntity().body("Failed to upload the file");
        }
    }

    @GetMapping("/download/{filename:.+}")
    public ResponseEntity<Resource> downloadFile(@PathVariable String filename) {
        try {
            Path filePath = Paths.get(UPLOAD_DIR + filename);
            Resource resource = new UrlResource(filePath.toUri());
            if (resource.exists() || resource.isReadable()) {
                return ResponseEntity.ok().body(resource);

import org.eclipse.paho.client.mqttv3.*;
import org.eclipse.paho.client.mqttv3.persist.MemoryPersistence;

public class EMQXClientExample {

    public static void main(String[] args) {
        String broker = "tcp://your-emqx-host:1883";
        String clientId = "JavaClient";
        MemoryPersistence persistence = new MemoryPersistence();

        try {
            MqttClient sampleClient = new MqttClient(broker, clientId, persistence);
            MqttConnectOptions connOpts = new MqttConnectOptions();
            connOpts.setCleanSession(true);
            System.out.println("Connecting to broker: " + broker);
            sampleClient.connect(connOpts);
            System.out.println("Connected");

            String topic = "emqx/test";
            String content = "message from Java client";
            MqttMessage message = new MqttMessage(content.getBytes());
            message.setQos(2);
            sampleClient.publish(topic, message);
            System.out.println("Message is published");

            sampleClient.disconnect();
            System.out.println("Disconnected");
            System.exit(0);

        } catch (MqttException me) {
            System.out.println("reason " + me.getReasonCode());
            System.out.println("msg " + me.getMessage());
            System.out.println("loc " + me.getLocalizedMessage());
            System.out.println("cause " + me.getCause());
            System.out.println("exiting with code " + 1);
        }
    }
}

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.reactive.config.CorsRegistry;
import org.springframework.web.reactive.config.WebFluxConfigurer;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.reactive.CorsWebFilter;
import org.springframework.web.cors.reactive.UrlBasedCorsConfigurationSource;

@Configuration
public class CorsGlobalConfiguration {

    @Bean
    public CorsWebFilter corsFilter() {
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        CorsConfiguration config = new CorsConfiguration();
        config.setAllowCredentials(true);
        config.addAllowedOrigin("*");
        config.addAllowedHeader("*");
        config.addAllowedMethod("*");
        source.registerCorsConfiguration("/**", config);
        return new CorsWebFilter(source);
    }
}

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-validation</artifactId>
</dependency>

import javax.validation.constraints.Min;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;

public class UserRequest {

    @NotNull
    private Long id;

    @NotBlank
    private String name;

    @Min(18)
    private int age;

    // getters and setters
}

import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
@Validated
public class UserController {

    @PostMapping("/user")
    public String createUser(@RequestBody @Valid UserRequest userRequest) {
        return "User created: " + userRequest.getName();
    }
}