spring-boot整合hazelcast实现高频交易撮合引擎缓存部分入门级

简介：
官网：https://hazelcast.com/
一.可用性
Hazelcast的分布式架构为连续群集正常运行时间提供冗余，并始终提供可用数据，以满足最苛刻的应用需求。容量随着需求弹性增长，而不会影响性能或可用性。
二.速度
Hazelcast In-Memory解决方案可以更快地补充数据库和数量级。时间就是金钱; 为您的新应用提供推动业务发展所需的微秒响应时间。将数据保留保留在数据库中，并利用Hazelcast以数字速度进行数据处理。
三.用户体验
在数字时代，用户不会等待。无论是复杂的电子商务交易还是机器学习驱动的客户自助服务门户，速度都是一切。Hazelcast客户实际上利用我们的速度在其微小的处理窗口中创造更多时间，以便在更多更深层次的服务中分层，创造卓越的商业价值，同时提供业界最佳的用户体验。
四.风险缓解
有足够的速度和规模，有更多的时间来更彻底地过滤风险。运行更严格的欺诈检测，实时审查策略风险，运行机器学习算法，而不会影响用户体验。Hazelcast实现了无法想象的应用程序。
五.安全
可以说是您业务中最重要的一部分。获得安全错误，其他一切都受到影响。Hazelcast内存解决方案为安全支持带来了全新的功能，正如世界上一些最苛刻的客户环境所证明的那样。
1.导入依赖

<dependency>
            <groupId>com.hazelcast</groupId>
            <artifactId>hazelcast-all</artifactId>
            <version>3.9.4</version>
        </dependency>
<dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.9</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-collections4</artifactId>
            <version>4.3</version>
        </dependency>

2.创建Employee

public class Employee implements Serializable {
    private String name;
    private int age;
    private boolean active;
    private double salary;

    public Employee(String name, int age, boolean active, double salary) {
        this.name = name;
        this.age = age;
        this.active = active;
        this.salary = salary;
    }

    public Employee() {
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public double getSalary() {
        return salary;
    }

    public boolean isActive() {
        return active;
    }

}

3.服务端Demo
3.1 不包含事物

public static void demo() {
        Config cfg = new Config();
        HazelcastInstance instance = Hazelcast.newHazelcastInstance(cfg);
        IMap<String, Employee> mapCustomers = instance.getMap("employee");
        mapCustomers.put("active3", new Employee("zhang",20,true,1.0));
        mapCustomers.put("active4", new Employee("zhang4",20,true,1.0));
        mapCustomers.put("active1", new Employee("zhang1",30,true,1.0));
        mapCustomers.put("active2",  new Employee("zhang3",38,true,1.0));
    }

3.2 包含事物

public static void demo() {
        Config cfg = new Config();
        HazelcastInstance hazelcastInstance = Hazelcast.newHazelcastInstance(cfg);
        TransactionOptions options = new TransactionOptions()
                .setTransactionType( TransactionOptions.TransactionType.ONE_PHASE );
        TransactionContext context = hazelcastInstance.newTransactionContext( options );
        context.beginTransaction();
        TransactionalMap<String, Employee> map = context.getMap( "employee" );
        try {
            map.put("active3", new Employee("zhang",20,true,1.0));
            map.put("active4", new Employee("zhang4",20,true,1.0));
            map.put("active1", new Employee("zhang1",30,true,1.0));
            map.put("active2",  new Employee("zhang3",38,true,1.0));
            context.commitTransaction();
        } catch ( Throwable t ) {
            context.rollbackTransaction();
        }
    }

4.客户端Demo

@Test
    public void demo() {
        ClientConfig clientConfig = new ClientConfig();
        //clientConfig.addAddress("127.0.0.1:5701");
        HazelcastInstance client = HazelcastClient.newHazelcastClient(clientConfig);
        IMap<String, Employee> map = client.getMap( "employee" );
        BidiMap<String, String> bidiMap=new DualTreeBidiMap<>();
        map.forEach((k,v)->bidiMap.put(k, JSON.toJSONString(v)));
        //对value的操作 value为对象
        //第一种方式
        Predicate namePredicate = Predicates.equal( "age", 20 );
        Collection<Employee> employees = map.values( namePredicate );
        for (Employee employee : employees) {
            System.out.println(employee.getName());
        }
        //第二种方式
        //active == 代表对象中的active是否启用
        Collection<Employee> employeess =  map.values( new SqlPredicate( "active AND age <= 30" ) );
        for (Employee employee : employeess) {
            String key=bidiMap.getKey(JSON.toJSONString(employee));
            System.out.println("key: "+key);
            map.remove(key);
            System.out.println(employee.getName());
        }
        //第三种方式
        //active == 代表对象中的active是否启用
        EntryObject e = new PredicateBuilder().getEntryObject();
        Predicate predicate = e.is( "active" ).and( e.get( "age" ).lessEqual( 30 ) );
        Collection<Employee> employeessss = map.values( predicate );
        for (Employee employee : employeessss) {
            System.out.println(employee.getName());
        }
        //对key的操作
        Predicate predicate1 = new SqlPredicate("__key like a%");
        Collection<Employee> employeesss = map.values(predicate1);
        for (Employee employee : employeesss) {
            System.out.println(employee.getName());
        }
    }

如果客户端和服务端在同一个服务中就不需要配置

clientConfig.addAddress("127.0.0.1:5701");

5.如果想要初步实现缓存撮合可以使用客户端端例子中的对value操作的第二和第三种方式
6.该例子目前只是入门级，博客中会逐渐深入解析hazelcast如何实现高频撮合系统中的缓存部分。