Java >> Java tutorial >  >> Java

Hurtig start med In memory Data Grid, Apache Ignite

IMDG eller In memory data grid er ikke en in-memory relationel database, en NOSQL database eller en relationel database. Det er en anden type softwaredatalager. Datamodellen er fordelt på tværs af mange servere på en enkelt lokation eller på tværs af flere lokationer. Denne fordeling er kendt som et datavæv. Denne distribuerede model er kendt som en 'delt intet'-arkitektur. IMDG har følgende egenskaber:

  1. Alle servere kan være aktive på hvert websted.
  2. Alle data gemmes i servernes RAM.
  3. Servere kan tilføjes eller fjernes uden forstyrrelser for at øge mængden af ​​tilgængelig RAM.
  4. Datamodellen er ikke-relationel og er objektbaseret.
  5. Distribuerede applikationer skrevet på det platformsuafhængige sprog.
  6. Datastrukturen er modstandsdygtig og tillader ikke-forstyrrende automatisk registrering og gendannelse af en enkelt server eller flere servere.

Mest af alle tider bruger vi IMDG til websessionsstyring af applikationsserver og som en distribueret cache eller L2 cache. Hazelcast community-tilføjelse var vores alle tiders foretrukne IMDG-værktøjer, men fra de sidste par realiser af hazelcast community-udgaven, er det slet ikke tilfreds med vores ydeevne. Som et hurtigt alternativ til HazelCast besluttede vi at prøve med
Apache ignite. Dette indlæg er dedikeret til apache ignite og bruges til hurtig opstartsguide. Til installation vil jeg bruge 2 virtuelle maskiner af Redhat operativsystem med følgende konfigurationer:

  • CPU:2
  • RAM:4
  • HDD:25 GB
  • OS:Redhat Santiago

Fra mange funktioner i Apache ignite6 vil vi kun undersøge følgende funktioner:

  1. Forbered operativsystemet
  2. Brug af Spring til brug af DataGrid
  3. MyBatis Cache-konfiguration
  4. Forårscaching

Installation af apache ignite

Forudgående krav:

  1. Java 1.7 og nyere
  2. åbne porte:47500..47509, 8080 (til Rest-grænseflade), 47400, 47100:47101, 48100:48101, 31100:31101Efter installation af JDK i operativsystemet, er vi nødt til at åbne ovennævnte porte. Ved at følge kommandoer kan vi manipulere iptables.
    vi /etc/sysconfig/iptables
    -A INPUT -m state --state NEW -m tcp -p tcp --dport 47500:47509 -j ACCEPT
    -A INPUT -m state --state NEW -m tcp -p tcp --dport 47400 -j ACCEPT
    -A INPUT -m state --state NEW -m tcp -p tcp --dport 47100 -j ACCEPT
    -A INPUT -m state --state NEW -m tcp -p tcp --dport 47101 -j ACCEPT
    -A INPUT -m state --state NEW -m tcp -p tcp --dport 48100 -j ACCEPT
    -A INPUT -m state --state NEW -m tcp -p tcp --dport 48101 -j ACCEPT
    -A INPUT -m state --state NEW -m tcp -p tcp --dport 31100 -j ACCEPT
    -A INPUT -m state --state NEW -m tcp -p tcp --dport 31101 -j ACCEPT
    
    /etc/init.d/iptables restart

Installation af Apache ignite på få maskiner

  1. Lad os downloade den endelige version af ignite 1.5.0 fra følgende links.
  2. Udpak arkivet hvor som helst i os, såsom /opt/apache-ignite
  3. Tilføj miljøsti IGNITE_HOME til hjemmemappen for apache ignite.
  4. kopier mappen $IGNITE_HOME/libs/optional/ignite-rest-http til /home/user/apache-ignite-fabric-1.5.0/libs, det vil aktivere apache ignite through rest interface.
  5. Kør kommandoen ignite.sh examples/config/example-cache.xml for at starte apache ignite.

    Hvis alt går fint, bør du se følgende log i din konsol:

    [12:32:01] Ignite node started OK (id=ceb614ca)
    [12:32:01] Topology snapshot [ver=4, servers=2, clients=0, CPUs=3, heap=2.0GB]

    og ignite er også tilgængelig via http via URL http://host:port/ignite?cmd=version

Brug af Spring til brug af DataGrid

Først og fremmest skal vi bygge et maven-projekt for at skrive en masse kode ned for at undersøge funktionerne i apache Ignite.

    • Tilføj følgende afhængigheder til pom.xml
      <dependency>
                  <groupId>org.apache.ignite</groupId>
                  <artifactId>ignite-core</artifactId>
                  <version>${ignite.version}</version>
              </dependency>
              <dependency>
                  <groupId>org.apache.ignite</groupId>
                  <artifactId>ignite-spring</artifactId>
                  <version>${ignite.version}</version>
              </dependency>
              <dependency>
                  <groupId>org.apache.ignite</groupId>
                  <artifactId>ignite-indexing</artifactId>
                  <version>${ignite.version}</version>
              </dependency>
              <!-- myBatis -->
              <dependency>
                  <groupId>org.mybatis.caches</groupId>
                  <artifactId>mybatis-ignite</artifactId>
                  <version>1.0.0-beta1</version>
              </dependency>
              <dependency>
                  <groupId>org.mybatis</groupId>
                  <artifactId>mybatis-spring</artifactId>
                  <version>1.2.4</version>
              </dependency>
              <dependency>
                  <groupId>org.mybatis</groupId>
                  <artifactId>mybatis</artifactId>
                  <version>3.3.1</version>
              </dependency>
              <!-- Oracle 12-->
              <dependency>
                  <groupId>com.oracle</groupId>
                  <artifactId>ojdbc6</artifactId>
                  <version>11.2.0.3</version>
              </dependency>

      Bemærk venligst, at Oracle JDBC-klientkrukken skal være i lokale maven-lagre. I mit tilfælde bruger jeg Oracle 11.2.02 klient.

    • Tilføj filen spring-context.xml i ressourcebiblioteket med følgende kontekster:
      <beans xmlns="http://www.springframework.org/schema/beans"
             xmlns:context="http://www.springframework.org/schema/context"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xmlns:mvc="http://www.springframework.org/schema/mvc"
             xmlns:cache="http://www.springframework.org/schema/cache"
             xsi:schemaLocation="
              http://www.springframework.org/schema/beans
              http://www.springframework.org/schema/beans/spring-beans.xsd
              http://www.springframework.org/schema/cache
              http://www.springframework.org/schema/cache/spring-cache-3.1.xsd
              http://www.springframework.org/schema/context
              http://www.springframework.org/schema/context/spring-context.xsd ">
          <!-- Enable annotation-driven caching. -->
          <cache:annotation-driven/>
      
          <context:property-placeholder location="classpath:jdbc.properties"/>
          <!-- beans -->
      
          <bean id="ignite.cfg" class="org.apache.ignite.configuration.IgniteConfiguration">
              <property name="gridName" value="TestGrid"/>
              <!-- Enable client mode. -->
              <property name="clientMode" value="true"/>
      
              <property name="cacheConfiguration">
                  <list>
                      <!-- Partitioned cache example configuration (Atomic mode). -->
                      <bean class="org.apache.ignite.configuration.CacheConfiguration">
                          <!--<property name="atomicityMode" value="ATOMIC"/>-->
                          <!-- Set cache mode. -->
                          <property name="cacheMode" value="PARTITIONED"/>
                          <property name="backups" value="1"/>
                          <property name="statisticsEnabled" value="true" />
                      </bean>
                  </list>
              </property>
              <!-- Explicitly configure TCP discovery SPI to provide list of initial nodes. -->
              <property name="discoverySpi">
                  <bean class="org.apache.ignite.spi.discovery.tcp.TcpDiscoverySpi">
                      <property name="ipFinder">
                          <!-- Uncomment static IP finder to enable static-based discovery of initial nodes. -->
                          <!--<bean class="org.apache.ignite.spi.discovery.tcp.ipfinder.vm.TcpDiscoveryVmIpFinder">-->
                          <bean class="org.apache.ignite.spi.discovery.tcp.ipfinder.multicast.TcpDiscoveryMulticastIpFinder">
                              <property name="addresses">
                                  <list>
                                      <!-- In distributed environment, replace with actual host IP address. -->
                                      <value>Add your node ip address</value>
                                      <value>add your node ip address</value>
                                  </list>
                              </property>
                          </bean>
                      </property>
                  </bean>
              </property>
          </bean>
          <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
              <property name="dataSource" ref="dataSource" />
              <property name="mapperLocations" value="classpath*:com/blu/ignite/dao/*Mapper.xml"/>
          </bean>
          <bean id="dataSource" class="oracle.jdbc.pool.OracleDataSource" destroy-method="close">
              <property name="URL" value="${jdbc.url}" />
              <property name="user" value="${jdbc.username}"/>
              <property name="password" value="${jdbc.password}"/>
              <property name="connectionCachingEnabled" value="true"/>
          </bean>
      </beans>

      Lad os undersøge nogle få konfigurationsegenskaber:

      • egenskabsnavn=”clientMode” value=”true” – denne egenskab vil tvinge den aktuelle applikation til at køre som klient.
      • egenskabsnavn=”cacheMode” value=”PARTITIONED” – cachetilstand vil blive opdelt, cachetilstand kan også replikeres.
      • egenskabsnavn=”backups” værdi=”1″ – der vil altid være ét redundant element af cache i en anden node.
      • egenskabsnavn=”statisticsEnabled” value=”true” – denne egenskab vil aktivere cachestatistikken.
    • Lad os nu skrive nogle:
      public class SpringIgniteRun {
          public static void main(String[] args) throws Exception{
              System.out.println("Run Spring example!!");
              ApplicationContext ctx = new ClassPathXmlApplicationContext("spring-core.xml");
      
              IgniteConfiguration igniteConfiguration = (IgniteConfiguration) ctx.getBean("ignite.cfg");
              Ignite ignite = Ignition.start(igniteConfiguration);
              // get or create cache
              IgniteCache cache = ignite.getOrCreateCache("myCacheName");
              for(int i = 1; i < 1000; i++){
                  cache.put(i, Integer.toString(i));
              }
              for(int i =1; i<1000;i++){
                  System.out.println("Cache get:"+ cache.get(i));
              }
              Thread.sleep(20000); // sleep for 20 seconds
              // statistics
              System.out.println("Cache Hits:"+ cache.metrics(ignite.cluster()).getCacheHits());
              ignite.close();
          }
      }

      ovenstående kode er selvforklaret, vi opretter bare en cache med navnet "myCacheName" og tilføjer 1000 String-værdien af ​​Integer. Efter at have indsat værdien til cache, læser vi også elementerne fra cachen og tjekker statistikken. gennem ignitevisorcmd kan du også overvåge datagitteret, følgende kan du finde skærmbillede af statistikken for nettet

MyBatis Cache-konfiguration

Lad os nu tilføje MyBatis ORM l2-cache og undersøge, hvordan det virker.

<bean id="servicesBean" class="com.blu.ignite.WebServices">
        <property name="dao" ref="userServicesBean"/>
    </bean>
    <bean id="userServicesBean" class="com.blu.ignite.dao.UserServices">
        <property name="userMapper" ref="userMapper"/>
    </bean>

    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <property name="mapperLocations" value="classpath*:com/blu/ignite/dao/*Mapper.xml"/>
    </bean>
    <bean id="dataSource" class="oracle.jdbc.pool.OracleDataSource" destroy-method="close">
        <property name="URL" value="${jdbc.url}" />
        <property name="user" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
        <property name="connectionCachingEnabled" value="true"/>
    </bean>


    <bean id="userMapper" autowire="byName" class="org.mybatis.spring.mapper.MapperFactoryBean">
        <property name="mapperInterface" value="com.blu.ignite.mapper.UserMapper" />
        <property name="sqlSessionFactory" ref="sqlSessionFactory" />
    </bean>
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.blu.ignite.mapper" />
    </bean>

Vi tilføjer SQLsessionFactory, MyBatis mapper og Service Bean. Lad os nu tilføje *.Mapper.xml

<?xml version="1.0" encoding="UTF-8" ?>

<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.blu.ignite.mapper.UserMapper">

    <cache type="org.mybatis.caches.ignite.IgniteCacheAdapter" />

    <select id="getUser" parameterType="String" resultType="com.blu.ignite.dto.User" useCache="true">
      SELECT * FROM users WHERE id = #{id}
    </select>

    <select id="getUniqueJob" parameterType="String" resultType="String" useCache="false">
        select unique job from emp order by job desc
    </select>

</mapper>

Fuld sql (DDL/DML) scripts af emp og dept tabeller vil blive fundet i mappen com/blu/ignite/scripts. Jeg har lavet en simpel webservice for at få brugerne og de unikke jobs til medarbejderne. Her er koden til webtjenesten som følger:

@WebService(name = "BusinessRulesServices",
        serviceName="BusinessRulesServices",
        targetNamespace = "http://com.blu.rules/services")
public class WebServices {
    private UserServices userServices;

    @WebMethod(operationName = "getUserName")
    public String getUserName(String userId){
        User user = userServices.getUser(userId);
        return user.getuName();
    }
    @WebMethod(operationName = "getUniqueJobs")
    public List getUniqueJobs(){
        return userServices.getUniqueJobs();
    }
    @WebMethod(exclude = true)
    public void setDao(UserServices userServices){
        this.userServices = userServices;
    }

}

Påkaldelse af webmetoden getUserName vil forespørge databasen og cache forespørgselsresultatet i ignite cache.

Forår Caching

Med spring-caching kan du opnå caching af returværdien af ​​enhver springbean-metode. Apache ignite vil oprette cachen efter navnet på cachen, som du vil angive ved annotationen @Cacheable(“returnHello”) For eksempel, hvis jeg har en sådan metode som følger:

@Cacheable("returnHello")
    public String sayhello(String str){
        System.out.println("Client says:"+ str);

        return "hello"+str;
    }

Første gang, hvor metoden vil blive påkaldt, vil en replikeret cache med argumentnavn oprettes i ignite, næste gang vil hver påkaldelse af ovenstående metode returnere værdien fra cachen.

  • For nu er det nok. Snart vender jeg tilbage med nogle nye funktioner i apache ignite. Den fulde kildekode for projektet findes i github.

Java tag