Nicksxs's Blog

package MilvusDemo;

import com.google.gson.Gson;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import io.milvus.v2.client.ConnectConfig;
import io.milvus.v2.client.MilvusClientV2;
import io.milvus.v2.common.DataType;
import io.milvus.v2.common.IndexParam;
import io.milvus.v2.service.collection.request.AddFieldReq;
import io.milvus.v2.service.collection.request.CreateCollectionReq;
import io.milvus.v2.service.index.request.CreateIndexReq;
import io.milvus.v2.service.vector.request.InsertReq;

import java.util.ArrayList;
import java.util.List;

/**
 * @author shixuesen
 * @date 2024/7/21
 */
public class Demo {

    public static void main(String[] args) {
        ConnectConfig connectConfig = ConnectConfig.builder()
                        .uri("http://127.0.0.1:19530")
                                .build();
        // 连接配置
        MilvusClientV2 clientV2 = new MilvusClientV2(connectConfig);
        // define a Collection Schema
        CreateCollectionReq.CollectionSchema collectionSchema = clientV2.createSchema();
// add two fileds, id and vector
        Integer dim = 5;
        // 这里的 CollectionSchema 就类似于mysql的数据库表结构
        collectionSchema.addField(AddFieldReq.builder().fieldName("my_id").dataType(DataType.Int64).isPrimaryKey(Boolean.TRUE).autoID(Boolean.FALSE).description("id").build());
        collectionSchema.addField(AddFieldReq.builder().fieldName("my_vector").dataType(DataType.FloatVector).dimension(dim).build());

        CreateCollectionReq req = CreateCollectionReq
                .builder()
                .collectionSchema(collectionSchema)
                .collectionName("quick_setup")
                .dimension(dim).build();
        //  通过schema 生成 Collection，就类似于mysql中的表
        clientV2.createCollection(req);

        // 然后可以对字段创建索引
        IndexParam indexParam = IndexParam.builder()
                .fieldName("my_id")
                .build();
        IndexParam vertorIndexParam = IndexParam.builder()
                        .fieldName("my_vector")
                                .indexType(IndexParam.IndexType.AUTOINDEX)
                                        .metricType(IndexParam.MetricType.IP)
                                                .build();
        List<IndexParam> indexParamList = new ArrayList<>();
        indexParamList.add(indexParam);
        indexParamList.add(vertorIndexParam);


        // 接着创建索引
        clientV2.createIndex(CreateIndexReq.builder()
                .collectionName("quick_setup")
                .indexParams(indexParamList)
                .build());
        JsonObject jsonObject  = JsonParser.parseString("{\"my_id\": 0, \"my_vector\": [0.3580376395471989, -0.6023495712049978, 0.18414012509913835, -0.26286205330961354, 0.9029438446296592], \"color\": \"pink_8682\"}").getAsJsonObject();
        List<JsonObject> jsonData = new ArrayList<>();
        jsonData.add(jsonObject);
        // 然后插入数据
        clientV2.insert(InsertReq.builder().collectionName("quick_setup")
                .data(jsonData).build());

        // 插入之后我们想进行查询，就用向量进行搜索，不过要先加载Collection
        clientV2.loadCollection(LoadCollectionReq.builder().collectionName("quick_setup").build());
        SearchResp searchResp = clientV2.search(SearchReq.builder()
                .collectionName("quick_setup")
                .data(Collections.singletonList(new FloatVec(new float[]{0.3580376395471989F, -0.6023495712049978F, 0.18414012509913835F, -0.26286205330961354F, 0.9029438446296592F})))
                .topK(10)
                .outputFields(Collections.singletonList("*"))
                .build()
        );
        for (List<SearchResp.SearchResult> searchResult : searchResp.getSearchResults()) {
            System.out.println(searchResult);
        }


    }
}

[SearchResp.SearchResult(entity={my_id=0, $meta={"color":"pink_8682"}, my_vector=[0.35803765, -0.6023496, 0.18414013, -0.26286206, 0.90294385]}, score=1.4093276, id=0)]

public interface SmartLifecycle extends Lifecycle, Phased {
    int DEFAULT_PHASE = Integer.MAX_VALUE;

    default boolean isAutoStartup() {
        return true;
    }

    default void stop(Runnable callback) {
        this.stop();
        callback.run();
    }

    default int getPhase() {
        return Integer.MAX_VALUE;
    }
}

public interface Lifecycle {
    void start();

    void stop();

    boolean isRunning();
}

@Component
public class MySmartLifecycle implements SmartLifecycle {

    private volatile boolean isRunning;

    @Override
    public void start() {
        System.out.println("my smart life cycle start");
        isRunning = true;
    }

    @Override
    public void stop() {
        System.out.println("my smart life cycle end");
        isRunning = false;
    }

    @Override
    public boolean isRunning() {
        return isRunning;
    }
}

protected void finishRefresh() {
    this.clearResourceCaches();
    this.initLifecycleProcessor();
    this.getLifecycleProcessor().onRefresh();
    this.publishEvent((ApplicationEvent)(new ContextRefreshedEvent(this)));
    if (!NativeDetector.inNativeImage()) {
        LiveBeansView.registerApplicationContext(this);
    }

}

public void onRefresh() {
    this.startBeans(true);
    this.running = true;
}

private void startBeans(boolean autoStartupOnly) {
    // 获取这些bean
    Map<String, Lifecycle> lifecycleBeans = this.getLifecycleBeans();
    Map<Integer, LifecycleGroup> phases = new TreeMap();
    lifecycleBeans.forEach((beanName, bean) -> {
        if (!autoStartupOnly || bean instanceof SmartLifecycle && ((SmartLifecycle)bean).isAutoStartup()) {
            int phase = this.getPhase(bean);
            ((LifecycleGroup)phases.computeIfAbsent(phase, (p) -> {
                return new LifecycleGroup(phase, this.timeoutPerShutdownPhase, lifecycleBeans, autoStartupOnly);
            })).add(beanName, bean);
        }

    });
    if (!phases.isEmpty()) {
        phases.values().forEach(LifecycleGroup::start);
    }

}

@FunctionalInterface
public interface BiFunction<T, U, R> {

    /**
     * Applies this function to the given arguments.
     *
     * @param t the first function argument
     * @param u the second function argument
     * @return the function result
     */
    R apply(T t, U u);

    /**
     * Returns a composed function that first applies this function to
     * its input, and then applies the {@code after} function to the result.
     * If evaluation of either function throws an exception, it is relayed to
     * the caller of the composed function.
     *
     * @param <V> the type of output of the {@code after} function, and of the
     *           composed function
     * @param after the function to apply after this function is applied
     * @return a composed function that first applies this function and then
     * applies the {@code after} function
     * @throws NullPointerException if after is null
     */
    default <V> BiFunction<T, U, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t, U u) -> after.apply(apply(t, u));
    }
}

BiFunction<String, String, String> biDemo = (s1, s2) -> s1 + s2;
System.out.println(biDemo.apply("hello ", "world"));

Function<String, Integer> funcDemo = String::length;
System.out.println(biDemo.andThen(funcDemo).apply("hello ", "world"));

public <T1, T2, R1, R2> R2 combination(T1 t1, T2 t2, BiFunction<T1, T2, R1> biFunction, Function<R1, R2> function) {
    return biFunction.andThen(function).apply(t1, t2);
}