redisは、オブジェクトとオブジェクトのセットを格納して読み込む

35590 ワード
ワークコードライブラリ
生産中にredisというnosqlデータストレージが頻繁に使用され、迅速なクエリーなどの操作を実現します.ネット上で関連図書資料を参考にした後、以下のredisのオブジェクトの記憶と読み取りを自分で実践することにし、後で仕事でアイデアを出すことができるようにした.redisの主なストレージタイプで最も一般的な5つのデータ型:
String
Hash
List
Set
Sorted set

redisストレージオブジェクトはシーケンス化と逆シーケンス化が必要です
なぜシーケンス化インタフェースを実装するのですか?
クラスがSerializableインタフェースを実装場合(このインタフェースはタグインタフェースのみであり、メソッド定義を含まない)、クラスがシーケンス化可能であることを示す.シーケンス化の目的は、Serializableインタフェースを実装したオブジェクトをバイトシーケンスに変換することであり、可能である.このバイトシーケンスを保存し(たとえば、1つのファイルに保存)、後でいつでもそのバイトシーケンスを元のオブジェクトに復元することができます.さらに、バイトシーケンスを他のコンピュータに配置したり、ネットワークを介して他のコンピュータに転送したりして、コンピュータプラットフォームに対応するクラスが存在する限り、正常に元のオブジェクトに復元することができます.実装:オブジェクトをシーケンス化するには、まずいくつかのOutputStreamオブジェクトを作成し、それをObjectOutputStreamオブジェクトにカプセル化し、writeObject()メソッドを呼び出してオブジェクトをシーケンス化します.逆シーケンス化も同様です.
注:オブジェクトストリームをファイルに書き込むには、オブジェクトがシーケンス化されていることを保証するだけでなく、オブジェクトのメンバーオブジェクトもシーケンス化されている必要があります.
エンティティは、シリアル化(Serializable)インタフェースを実装する必要があります.
package db;

import java.io.Serializable;
import java.util.Date;

/**
 * Created by dongzy on 2017/8/9.
 */
public class CustomerDictType implements Serializable{
    private String customerDictTypeId;
    private String tableName;
    private String remark;
    private java.util.Date updateTime;
    private String updateUser;

    public String getUpdateUser() {
        return updateUser;
    }

    public void setUpdateUser(String updateUser) {
        this.updateUser = updateUser;
    }

    public String getCustomerDictTypeId() {
        return customerDictTypeId;
    }

    public void setCustomerDictTypeId(String customerDictTypeId) {
        this.customerDictTypeId = customerDictTypeId;
    }

    public String getTableName() {
        return tableName;
    }

    public void setTableName(String tableName) {
        this.tableName = tableName;
    }

    public String getRemark() {
        return remark;
    }

    public void setRemark(String remark) {
        this.remark = remark;
    }

    public Date getUpdateTime() {
        return updateTime;
    }

    public void setUpdateTime(Date updateTime) {
        this.updateTime = updateTime;
    }
}

ユニットテストコード:
 @Test
    public void test1(){
        CustomerDictTypeDao customerDictTypeDao = new CustomerDictTypeDao();
        List customerDictTypeEntityList = (List) customerDictTypeDao.addOrderByField
                (CustomerDictTypeDao.CUSTOMER_DICT_TYPE_ID,true).getEntities();
        for(CustomerDictTypeEntity customerDictTypeEntity : customerDictTypeEntityList){
            //redis    
            redisClient.set(customerDictTypeEntity,customerDictTypeEntity.getCustomerDictTypeId());
        }
        //redis    
        CustomerDictTypeEntity customerDictType = (CustomerDictTypeEntity) redisClient.get(customerDictTypeEntityList.get(0).getCustomerDictTypeId());
        System.out.print(customerDictType.getTableName());
        //redis      
        redisClient.setList((List>) customerDictTypeEntityList,"test");
        //redis      
        List customerDictTypes = (List) redisClient.getList("test");
        System.out.print(customerDictTypes.toString());
    }

redisClientクラスコード(getsetメソッド):
package redisTest;

import db.CustomerDictTypeEntity;
import redis.clients.jedis.Jedis;

import java.io.ByteArrayOutputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * Created by dongzy on 2017/6/7.
 */
public class RedisClient {
    private static Jedis redisClient;
    private static int dbindex;

    /**
     *      
     * @param dbIndex
     */
    public RedisClient(int dbIndex){
        this.dbindex = dbIndex;
    }

    /**
     *      
     */
    public RedisClient(){
        this.dbindex = 0;
    }
    public static void set(Object object,String key)
    {

        try
        {
            redisClient = RedisClientPool.jedisPool.getResource();
            redisClient.select(dbindex);
            redisClient.set(key.getBytes(), SerializeUtil.serialize(object));
        }
        catch (Exception e)
        {
            //     
            RedisClientPool.jedisPool.returnBrokenResource(redisClient);
        }
        finally
        {
            //       
            RedisClientPool.jedisPool.returnResource(redisClient);
        }
    }
    public static void setList(List> object,String key)
    {
        try
        {
            redisClient = RedisClientPool.jedisPool.getResource();
            redisClient.select(dbindex);
            redisClient.set(key.getBytes(), SerializeUtil.serializeList(object));
        }
        catch (Exception e)
        {
            //     
            RedisClientPool.jedisPool.returnBrokenResource(redisClient);
        }
        finally
        {
            //       
            RedisClientPool.jedisPool.returnResource(redisClient);
        }
    }
    public static List> getList(String key)
    {
        List object = null;
        try
        {
            redisClient = RedisClientPool.jedisPool.getResource();
            redisClient.select(dbindex);
            byte[] ob = redisClient.get(key.getBytes());
            object = SerializeUtil.unserializeList(ob);
            return object;
        }
        catch (Exception e)
        {
            //     
            RedisClientPool.jedisPool.returnBrokenResource(redisClient);
        }
        finally
        {
            //       
            RedisClientPool.jedisPool.returnResource(redisClient);
        }
        return null;
    }
    public static Object get(String key)
    {
        Object object = null;
        try
        {
            redisClient = RedisClientPool.jedisPool.getResource();
            redisClient.select(dbindex);
            byte[] ob = redisClient.get(key.getBytes());
            object = SerializeUtil.unserialize(ob);
            return object;
        }
        catch (Exception e)
        {
            //     
            RedisClientPool.jedisPool.returnBrokenResource(redisClient);
        }
        finally
        {
            //       
            RedisClientPool.jedisPool.returnResource(redisClient);
        }
        return null;
    }
    /**
     *             Map
     * 
     * 
     * @param flag
     * @param mapData
     * @see [ 、 #  、 #  ]
     */
    public static void setMapDataToRedis(String flag,Map mapData)
    {
        try
        {
            redisClient = RedisClientPool.jedisPool.getResource();
            redisClient.select(dbindex);
            redisClient.hmset(flag,mapData);
        }
        catch (Exception e)
        {
            //     
            RedisClientPool.jedisPool.returnBrokenResource(redisClient);
        }
        finally
        {
            //       
            RedisClientPool.jedisPool.returnResource(redisClient);
        }
    }

    /**
     *             key-value
     * 
     * 
     * @param flag
     * @param field
     * @param value
     * @see [ 、 #  、 #  ]
     */
    public static void setDataToRedis(String flag,String field,String value)
    {
        try
        {
            redisClient = RedisClientPool.jedisPool.getResource();
            redisClient.select(dbindex);
            redisClient.hset(flag, field, value);
        }
        catch (Exception e)
        {
            //     
            RedisClientPool.jedisPool.returnBrokenResource(redisClient);
        }
        finally
        {
            //       
            RedisClientPool.jedisPool.returnResource(redisClient);
        }
    }

    /**
     *    Map  
     * 
     * 
     * @param flag
     * @return
     * @see [ 、 #  、 #  ]
     */
    public static Map getMapData(String flag)
    {
        Map dataMap = null;

        try
        {
            redisClient = RedisClientPool.jedisPool.getResource();
            redisClient.select(dbindex);
            dataMap = redisClient.hgetAll(flag);
        }
        catch (Exception e)
        {
            //     
            RedisClientPool.jedisPool.returnBrokenResource(redisClient);
        }
        finally
        {
            //       
            RedisClientPool.jedisPool.returnResource(redisClient);
        }
        return dataMap;
    }

    public static long deleteData(String flag)
    {
        long result = 0;
        try
        {
            redisClient = RedisClientPool.jedisPool.getResource();
            redisClient.select(dbindex);
            result = redisClient.del(flag);
        }
        catch (Exception e)
        {
            //     
            RedisClientPool.jedisPool.returnBrokenResource(redisClient);
        }
        finally
        {
            //       
            RedisClientPool.jedisPool.returnResource(redisClient);
        }

        return result;
    }

    /**
     *   key       
     * 
     * 
     * @param flag
     * @param field
     * @return
     * @see [ 、 #  、 #  ]
     */
    public static String getData(String flag,String field)
    {
        String data = null;
        try
        {
            redisClient = RedisClientPool.jedisPool.getResource();
            redisClient.select(dbindex);
            data = redisClient.hget(flag, field);
        }
        catch (Exception e)
        {
            //     
            RedisClientPool.jedisPool.returnBrokenResource(redisClient);
        }
        finally
        {
            //       
            RedisClientPool.jedisPool.returnResource(redisClient);
        }

        return data;
    }


    public static void main(String[] args)  throws Exception
    {
        RedisClient.testMap();
    }


    public void testList()
    {
        Jedis redis = RedisClientPool.jedisPool.getResource();
        //hset key field value    key   field    value。
        redis.hset("table", "field1", "value1");
        redis.hset("table", "field2", "value2");
        redis.hset("table", "field3", "value3");
        //     key ，          。
        List list = redis.hmget("table","field1","field2","field3");
        for(String tmp : list)
        {
            System.out.println(tmp);
        }
    }

    public static void testMap()
    {
        //     field - value( - )       key 。
        Map map = new ConcurrentHashMap();
        for (int i = 0;i < 10000;i++)
        {
            map.put("field"+i, "value"+i);
        }
        if (null != getData("table", "field1"))
        {
            deleteData("table");
        }
        //  map   username  
        Map maps = getMapData("table");
        System.out.println(maps.size());

        setMapDataToRedis("table",map);

        //HGETALL key     key ，      。
        maps = getMapData("table");

        System.out.println(maps.size());
    }
}

RedisClientPoolクラスコード(redis接続を取得):
package redisTest; /**
 * Created by dongzy on 2017/6/7.
 */

import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import util.PropertiesUtils;
import xmlTest.Dom4JTest;

import java.util.Map;

/**
     *   redis    
     * 
     * 
     *
     * @author  khj
     * @see  [   /  ]
     * @since  [  /    ]
     */
public class RedisClientPool
    {
        public static RedisClientPool redisClientPool = getInstance();

        public static JedisPool jedisPool;

        public static synchronized RedisClientPool getInstance()
        {
            if (null == redisClientPool)
            {
                redisClientPool = new RedisClientPool();
            }
            return redisClientPool;
        }

        public RedisClientPool()
        {
            if (null == jedisPool)
            {
                init();
            }
        }

        /**
         *      Jedis
         * 
         * 
         * @return
         * @see [ 、 #  、 #  ]
         */
        private static JedisPoolConfig initPoolConfig()
        {
            JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
            //     pool         idle jedis  
            jedisPoolConfig.setMaxIdle(1000);
            //               
            jedisPoolConfig.setMaxIdle(300);
            //     
            jedisPoolConfig.setMaxWaitMillis(1000);
            //  borrow  jedis   ，      alidate  ；   true，    jedis       ；
            jedisPoolConfig.setTestOnBorrow(true);
            //     pool ，      validate  
            jedisPoolConfig.setTestOnReturn(true);

            return jedisPoolConfig;
        }

        /**
         *    jedis   
         */
        public static void init()
        {
            JedisPoolConfig jedisPoolConfig = initPoolConfig();
            //PropertiesUtils       
            String host = PropertiesUtils.getValue("redis.host");//"localhost";
            int port = Integer.parseInt(PropertiesUtils.getValue("redis.port"));//6379;
            int timeout = Integer.parseInt(PropertiesUtils.getValue("redis.timeout"));//60000;
           /* Map map = Dom4JTest.getValue("share");
            int port = (int) map.get("port");
            int timeout = 60000;
            String host = (String) map.get("host");*/
//            int port = 6379;
//            int timeout = 60000;
//            String host = "172.16.8.32";
            //      
            jedisPool = new JedisPool(jedisPoolConfig, host, port, timeout);
        }
    }

SerializeUtilクラスコード(オブジェクト、オブジェクトセットのシーケンス化逆シーケンス化):
package redisTest;

import com.phhc.corewebservices.prescription.Exception_Exception;

import java.io.*;
import java.util.ArrayList;
import java.util.List;

/**
 * Created by dongzy on 2017/8/8.
 */
public class SerializeUtil {
    //     
    public static byte[] serialize(Object object) {
        ObjectOutputStream oos = null;
        ByteArrayOutputStream baos = null;
        try {
            //    
            baos = new ByteArrayOutputStream();
            oos = new ObjectOutputStream(baos);
            oos.writeObject(object);
            byte[] bytes = baos.toByteArray();
            oos.close();
            baos.close();
            return bytes;
        } catch (Exception e) {

        }
        return null;
    }
    //   list  
    public static byte[] serializeList(List> list){
        ObjectOutputStream oos = null;
        ByteArrayOutputStream bos = null;
        try {
            bos = new ByteArrayOutputStream();
            oos = new ObjectOutputStream(bos);
            for(Object object : list){
                oos.writeObject(object);
            }
            oos.writeObject(null);
            oos.close();
            bos.close();
            return bos.toByteArray();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }
    //      
    public static Object unserialize( byte[] bytes) {
        ByteArrayInputStream bais = null;
        try {
            //     
            bais = new ByteArrayInputStream(bytes);
            ObjectInputStream ois = new ObjectInputStream(bais);
            ois.close();
            bais.close();
            return ois.readObject();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    //    list  
    public static List unserializeList(byte[] bytes){
        List list = new ArrayList();
        ByteArrayInputStream bais = null;
        try {
            //     
            bais = new ByteArrayInputStream(bytes);
            ObjectInputStream ois = new ObjectInputStream(bais);
            if(bytes != null) {
                bais = new ByteArrayInputStream(bytes);
                ois = new ObjectInputStream(bais);
                while (true) {
                    Object object = (Object) ois.readObject();
                    if (object == null) {
                        break;
                    } else {
                        list.add(object);
                    }
                }
            }
            ois.close();
            bais.close();
            return list;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

添付ファイル1:ファイル読み込みPropertiesUtilsクラス(RedisPool取得接続列使用):
package util;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import java.io.File;
import java.io.InputStreamReader;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.Properties;

/**
 * Created by dongzy on 2017/6/7.
 */
public class PropertiesUtils {
    private static Properties properties = null;

    static {
        if(null == properties){
            properties = new Properties();
            InputStreamReader reader = null;
            try{
                reader = new InputStreamReader(PropertiesUtils.class.getClassLoader().getResourceAsStream("resources.properties"),"utf-8");
                properties.load(reader);
                reader.close();
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                if(reader != null){
                    reader = null;
                }
            }
        }
    }

    private PropertiesUtils(){}

    public static String getValue(String key){
        return properties.getProperty(key);
    }
    public static String getValue(){
        SAXReader reader = new SAXReader();
        try {
            Document doc = reader.read(new File("F:\\svn\\RedisStudy\\src\\main\\resources\\redisconnection.xml"));
            Element ele = doc.getRootElement();
            Iterator it =  ele.elementIterator();
            while(it.hasNext()){
                System.out.println(it.next());
            }
        } catch (DocumentException e) {
            e.printStackTrace();
        }
        return null;
    }
    public static void main(String args[]) throws ParseException {
        String a = null;
        try {
            if(a.equals("")){
                System.out.println("null");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        String date = "1945/1/28 0:00:00";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
        Date time = (Date) sdf.parseObject(date);
        System.out.println(time);
        //getValue();
    }



}

添付ファイル2:resources.properties 
redis.host=172.16.8.32
redis.port=6379
redis.timeout=60000
二叉木遍歴の非再帰的実現
Linuxでのredisの紹介とインストール