import org.springframework.util.DigestUtils;

public String encryptMD5(String password) {
    return DigestUtils.md5DigestAsHex(password.getBytes()).toUpperCase();
}

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

public String encryptSHA1(String password) {
    try {
        MessageDigest sha1 = MessageDigest.getInstance("SHA-1");
        byte[] bytes = sha1.digest(password.getBytes());
        return bytesToHex(bytes);
    } catch (NoSuchAlgorithmException e) {
        throw new RuntimeException(e);
    }
}

private String bytesToHex(byte[] bytes) {
    StringBuilder hexString = new StringBuilder();
    for (byte b : bytes) {
        String hex = Integer.toHexString(0xff & b);
        if (hex.length() == 1) hexString.append('0');
        hexString.append(hex);
    }
    return hexString.toString();
}

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

public String encryptSHA256(String password) {
    try {
        MessageDigest sha256 = MessageDigest.getInstance("SHA-256");
        byte[] bytes = sha256.digest(password.getBytes());
        return bytesToHex(bytes);
    } catch (NoSuchAlgorithmException e) {
        throw new RuntimeException(e);
    }
}

import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;

public String encryptBCrypt(String password) {
    BCryptPasswordEncoder encoder = new BCryptPasswordEncoder();
    return encoder.encode(password);
}

import de.mkammerer.argon2.Argon2Argon2ad;
import de.mkammerer.argon2.Argon2Argon2id;

public String encryptArgon2(String password) {
    Argon2Argon2id argon2 = new Argon2Argon2id();
    return argon2.hash(1, 65536, 2, password.getBytes());
}

// 用户实体类User的一部分代码，展示了如何使用@Data和@Builder注解简化构造函数
@Data
@Builder
public class User {
    private Long id;
    private String username;
    private String password; // 密码应该加密存储
    private String email;
    private Boolean enabled;
    // ...其他属性和方法
}

// 角色实体类Role的一部分代码，展示了如何使用@Data和@Builder注解简化构造函数
@Data
@Builder
public class Role {
    private Long id;
    private String name;
    private String description;
    // ...其他属性和方法
}

// 用户服务UserService接口的一部分代码，展示了如何定义服务层的接口
public interface UserService {
    UserDetails loadUserByUsername(String username) throws UsernameNotFoundException;
    User saveUser(User user);
    User updateUser(User user);
    // ...其他方法
}

// 用户服务UserServiceImpl的一部分代码，展示了如何实现服务层的接口
@Service
public class UserServiceImpl implements UserService {
    @Autowired
    private UserRepository userRepository;
    @Autowired
    private RoleRepository roleRepository;
    @Autowired
    private BCryptPasswordEncoder passwordEncoder;

    @Transactional
    public User saveUser(User user) {
        user.setPassword(passwordEncoder.encode(user.getPassword())); // 加密密码
        return userRepository.save(user);
    }

    // ...其他方法的实现
}

import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.stereotype.Repository;

@Repository
public interface YourEntityRepository extends JpaRepository<YourEntity, Long> {
    // 假设你的查询是根据某个字段查询
    @Query("SELECT ye FROM YourEntity ye WHERE ye.someField = ?1")
    Page<YourEntity> findBySomeField(String fieldValue, Pageable pageable);
}

// 在你的服务层或者控制器中使用这个方法
public Page<YourEntity> getEntities(String fieldValue, int page, int size) {
    Pageable pageable = PageRequest.of(page, size);
    return yourEntityRepository.findBySomeField(fieldValue, pageable);
}

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

import org.springframework.stereotype.Service;
import org.springframework.web.reactive.function.client.WebClient;

@Service
public class ChatXiaoIService {

    private final WebClient webClient = WebClient.create("http://api.xiaoai.cn/");

    public String sendMessage(String message) {
        // 这里的URL和参数需要根据实际的API文档来设置
        return webClient.get()
                .uri(uriBuilder -> uriBuilder.path("/endpoint").queryParam("message", message).build())
                .retrieve()
                .bodyToMono(String.class)
                .block();
    }
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ChatXiaoIController {

    private final ChatXiaoIService chatXiaoIService;

    @Autowired
    public ChatXiaoIController(ChatXiaoIService chatXiaoIService) {
        this.chatXiaoIService = chatXiaoIService;
    }

    @GetMapping("/ask")
    public String ask(@RequestParam String message) {
        return chatXiaoIService.sendMessage(message);
    }
}

import org.apache.catalina.LifecycleException;
import org.apache.catalina.startup.Tomcat;

public class TomcatExample {
    public static void main(String[] args) {
        // 创建Tomcat服务器实例
        Tomcat tomcatServer = new Tomcat();

        // 设置端口号，默认为8080
        tomcatServer.setPort(8080);

        // 添加Web应用
        // 参数1：应用的路径；参数2：应用的虚拟路径
        tomcatServer.addWebapp("/myapp", "/path/to/my/web/app");

        // 启动Tomcat服务器
        try {
            tomcatServer.start();
            System.out.println("Tomcat服务器已启动");

            // 保持服务器运行，等待关闭
            tomcatServer.getServer().await();
        } catch (LifecycleException e) {
            e.printStackTrace();
        }
    }
}

#!/bin/bash
export CATALINA_HOME=/path/to/tomcat
export JAVA_HOME=/path/to/java
$CATALINA_HOME/bin/startup.sh

import io.milvus.client.MilvusClient;
import io.milvus.client.ConnectParam;
import io.milvus.client.HasCollectionParam;
import io.milvus.client.InsertParam;
import io.milvus.client.R;
import io.milvus.client.ShowCollectionsParam;
import io.milvus.client.IndexParam;
import io.milvus.client.SearchParam;
import io.milvus.client.SearchResult;

@Configuration
public class MilvusConfig {
    @Value("${milvus.host}")
    private String host;

    @Value("${milvus.port}")
    private int port;

    @Bean
    public MilvusClient milvusClient() {
        ConnectParam connectParam = new ConnectParam.Builder()
                .withHost(host)
                .withPort(port)
                .build();
        return new MilvusClient(connectParam);
    }
}

@Service
public class MilvusService {
    @Autowired
    private MilvusClient milvusClient;

    public void hasCollection(String collectionName) {
        HasCollectionParam param = new HasCollectionParam.Builder(collectionName).build();
        R<Boolean> response = milvusClient.hasCollection(param);
        // handle response
    }

    public void createCollection(String collectionName, String dimension) {
        // create collection logic
    }

    public void insertData(String collectionName, List<Float> vector) {
        InsertParam insertParam = new InsertParam.Builder(collectionName, vector).build();
        R<InsertParam.Response> response = milvusClient.insert(insertParam);
        // handle response
    }

    public void createIndex(String collectionName, String indexType, int dimension) {
        IndexParam indexParam = new IndexParam.Builder(collectionName, indexType, dimension).build();
        R<String> response = milvusClient.createIndex(indexParam);
        // handle response
    }

    public SearchResult search(String collectionName, List<Float> vector, int topK) {
        SearchParam searchParam = new SearchParam.Builder(collectionName, vector)
                .withTopK(topK)
                .build();
        R<SearchResult> response = milvusClient.search(searchParam);
        // handle response
        retur