docs/_docs/code-snippets/java/src/main/java/org/apache/ignite/snippets/WorkingWithBinaryObjects.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.ignite.snippets;

import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import org.apache.ignite.Ignite;
import org.apache.ignite.IgniteBinary;
import org.apache.ignite.IgniteCache;
import org.apache.ignite.Ignition;
import org.apache.ignite.binary.BinaryField;
import org.apache.ignite.binary.BinaryIdMapper;
import org.apache.ignite.binary.BinaryNameMapper;
import org.apache.ignite.binary.BinaryObject;
import org.apache.ignite.binary.BinaryObjectBuilder;
import org.apache.ignite.binary.BinaryObjectException;
import org.apache.ignite.binary.BinaryReader;
import org.apache.ignite.binary.BinarySerializer;
import org.apache.ignite.binary.BinaryTypeConfiguration;
import org.apache.ignite.binary.BinaryWriter;
import org.apache.ignite.cache.CacheEntryProcessor;
import org.apache.ignite.configuration.BinaryConfiguration;
import org.apache.ignite.configuration.IgniteConfiguration;

public class WorkingWithBinaryObjects {

    public static void runAll() {
        binaryObjectsDemo();
        binaryFieldsExample();
        configuringBinaryObjects();
    }

    public static void binaryObjectsDemo() {
        try (Ignite ignite = Ignition.start()) {
            IgniteCache<Integer, Person> cache = ignite.createCache("personCache");

            //tag::enablingBinary[]
            // Create a regular Person object and put it into the cache.
            Person person = new Person(1, "FirstPerson");
            ignite.cache("personCache").put(1, person);

            // Get an instance of binary-enabled cache.
            IgniteCache<Integer, BinaryObject> binaryCache = ignite.cache("personCache").withKeepBinary();
            BinaryObject binaryPerson = binaryCache.get(1);
            //end::enablingBinary[]
            System.out.println("Binary object:" + binaryPerson);

            //tag::binaryBuilder[]
            BinaryObjectBuilder builder = ignite.binary().builder("org.apache.ignite.snippets.Person");

            builder.setField("id", 2L);
            builder.setField("name", "SecondPerson");

            binaryCache.put(2, builder.build());
            //end::binaryBuilder[]
            System.out.println("Value from binary builder:" + cache.get(2).getName());

            //tag::cacheEntryProc[]
            // The EntryProcessor is to be executed for this key.
            int key = 1;
            ignite.cache("personCache").<Integer, BinaryObject>withKeepBinary().invoke(key, (entry, arguments) -> {
                // Create a builder from the old value.
                BinaryObjectBuilder bldr = entry.getValue().toBuilder();

                //Update the field in the builder.
                bldr.setField("name", "Ignite");

                // Set new value to the entry.
                entry.setValue(bldr.build());

                return null;
            });
            //end::cacheEntryProc[]
            System.out.println("EntryProcessor output:" + cache.get(1).getName());
        }
    }

    public static void binaryFieldsExample() {
        try (Ignite ignite = Ignition.start()) {
            //tag::binaryField[]
            Collection<BinaryObject> persons = getPersons();

            BinaryField salary = null;
            double total = 0;
            int count = 0;

            for (BinaryObject person : persons) {
                if (salary == null) {
                    salary = person.type().field("salary");
                }

                total += (float) salary.value(person);
                count++;
            }

            double avg = total / count;
            //end::binaryField[]
            System.out.println("binary fields example:" + avg);
        }
    }

    private static Collection<BinaryObject> getPersons() {
        IgniteBinary binary = Ignition.ignite().binary();
        Person p1 = new Person(1, "name1");
        p1.setSalary(1);
        Person p2 = new Person(2, "name2");
        p2.setSalary(2);
        return Arrays.asList(binary.toBinary(p1), binary.toBinary(p2));
    }

    public static void configuringBinaryObjects() {
        //tag::cfg[]
        IgniteConfiguration igniteCfg = new IgniteConfiguration();

        BinaryConfiguration binaryConf = new BinaryConfiguration();
        binaryConf.setNameMapper(new MyBinaryNameMapper());
        binaryConf.setIdMapper(new MyBinaryIdMapper());

        BinaryTypeConfiguration binaryTypeCfg = new BinaryTypeConfiguration();
        binaryTypeCfg.setTypeName("org.apache.ignite.snippets.*");
        binaryTypeCfg.setSerializer(new ExampleSerializer());

        binaryConf.setTypeConfigurations(Collections.singleton(binaryTypeCfg));

        igniteCfg.setBinaryConfiguration(binaryConf);
        //end::cfg[]

    }

    private static class MyBinaryNameMapper implements BinaryNameMapper {

        @Override
        public String typeName(String clsName) {
            return clsName;
        }

        @Override
        public String fieldName(String fieldName) {
            return fieldName;
        }
    }

    private static class MyBinaryIdMapper implements BinaryIdMapper {

        @Override
        public int typeId(String typeName) {
            return typeName.hashCode();
        }

        @Override
        public int fieldId(int typeId, String fieldName) {
            return typeId + fieldName.hashCode();
        }
    }

    private static class ExampleSerializer implements BinarySerializer {

        @Override
        public void writeBinary(Object obj, BinaryWriter writer) throws BinaryObjectException {

        }

        @Override
        public void readBinary(Object obj, BinaryReader reader) throws BinaryObjectException {

        }
    }
}