javaredis序列化

㈠ redis 存储java对象是json字符串还是序列化

如果是数据完全可以使用JSON方式。毕竟redis直接set、get使用起
来门槛低很多。redis是没有提供专用的设置对象方法，需要自己进行改写。如果是担心JSON转对象会消耗资源的情况，这个问题需要考量几个地方，第一
点：就是使用的JSON转换lib是否就会存在性能问题。第二点：就是数据的数据量级别，如果是存储百万级的大数据对象，建议采用存储序列化对象方式。如
果是少量的数据级对象，或者是数据对象字段不多，还是建议采用JSON转换成String方式。毕竟redis对存储字符类型这部分优化的非常好。具体采
用的方式与方法，还要看你所使用的场景。

㈡ 如何用redis来生成唯一Id

构造方法一：
public RedisAtomicLong(java.lang.String redisCounter,
RedisConnectionFactory factory)
1
2
1
2
该实例对应的自动增长的主键的key的名字为为redisCounter，如果redis中存在key的name为redisCounter的键值对，那么，则取其值；否则，将redisCounter对应的key值设置为0；

构造方法二：
public RedisAtomicLong(java.lang.String redisCounter,
RedisConnectionFactory factory,
long initialValue)
1
2
3
1
2
3
创建一个新的RedisAtomicLong实例，该实例对应的自动增长的主键的key的名字为为redisCounter，并将key name为redisCounter的值设置为initialValue；

RedisAtomicLong类有以下几个主要的方法：

方法一：
public long get();//返回当前的值
1
1
方法二：
public void set(long newValue);//设置当前实例的值为newValue
1
1
方法三：
public long incrementAndGet()；//将当前实例的key值加一并且返回
1
1
那么，我们如何获得一个RedisAtomicLong实例呢？楼主提供以下两个方法：

在获取实例之前，我们需要设置好jedis的配置。
在application.xml文件中，加入以下配置：

<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
<property name="maxTotal" value="${redis.pool.maxTotal}" />
<property name="maxIdle" value="${redis.pool.maxIdle}" />
<property name="testOnBorrow" value="${redis.pool.testOnBorrow}" />
</bean>

<!-- jedis服务器配置 -->
<bean id="jedisShardInfo" class="redis.clients.jedis.JedisShardInfo">
<constructor-arg index="0" value="${redis.ip}" />
<constructor-arg index="1" value="${redis.port}" type="int" />
</bean>

<bean id="jedisConnFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"
p:host-name="${redis.ip}" p:port="${redis.port}" p:password="${redis.pass}" p:pool-config-ref="jedisPoolConfig"/>

<bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
<property name="connectionFactory" ref="jedisConnFactory"/>
<property name="keySerializer" ref="keySerializer"/>
<property name="enableTransactionSupport" value="false"/>
</bean>

<!-- redis 序列化-->
<bean id="keySerializer"
class="org.springframework.data.redis.serializer.StringRedisSerializer" />

㈢ redis 存储java对象是json字符串还是序列化

是进行序列化存储的。
Redis存储对象时，要对这个对象进行序列化。序列化还有一个作用是可以将对象序列化之后通过socket进行传输。那么，JSON也是一个进行数据交换的格式。何不将对象转为JSON字符串然后当作String存在Value中也是可以的。

㈣ redis中为什么要序列化key

如果是数据完全可以使用JSON方式。毕竟redis直接set、get使用起来门槛低很多。redis是没有提供专用的设置对象方法，需要自己进行改写。如果是担心JSON转对象会消耗资源的情况，这个问题需要考量几个地方，第一点：就是使用的JSON转换lib是否就会存在性能问题。第二点：就是数据的数据量级别，如果是存储百万级的大数据对象，建议采用存储序列化对象方式。如果是少量的数据级对象，或者是数据对象字段不多，还是建议采用JSON转换成String方式。毕竟redis对存储字符类型这部分优化的非常好。具体采用的方式与方法，还要看你所使用的场景。

㈤ redis怎么序列化

redis序列化数据有多重方式:

• JacksonJsonRedisSerializer

• OxmSerializer

这里前两种测试

1．StringSerializer.java

• public enum StringSerializer implements RedisSerializer<String> {


• INSTANCE;


• public byte[] serialize(String s) throws SerializationException {


• return (null != s ? s.getBytes() : new byte[0]);


• }



• public String deserialize(byte[] bytes) throws SerializationException {


• if (bytes.length > 0) {


• return new String(bytes);


• } else {


• return null;


• }


• }


• }1234567891011121314



2．测试类

• public RedisConnectionFactory redisConnectionFactory() {


• JedisConnectionFactory cf = new JedisConnectionFactory();


• cf.setHostName("172.16.28.214");


• cf.setPort(6379);


• //cf.setPassword("123456");


• cf.afterPropertiesSet();


• return cf;


• }


• @Test


• public void test() {


• try {


• RedisConnectionFactory connectionFactory = redisConnectionFactory();


• RedisTemplate<String, Serializable> redis = new RedisTemplate<String, Serializable>();


• redis.setConnectionFactory(connectionFactory);


• redis.setKeySerializer(StringSerializer.INSTANCE);


• // redis.setValueSerializer(new ());


• redis.setValueSerializer(new JacksonJsonRedisSerializer<TestUser>(TestUser.class));


• redis.afterPropertiesSet();



• ValueOperations<String, Serializable> ops = redis.opsForValue();


• TestUser user1 = new TestUser();


• user1.setName("lisi");


• user1.setId(20L);


• // ops.set("lisi", user1);



• TestUser user = (TestUser) ops.get("lisi");


• System.out.println(user.getName());



• } catch (Exception e) {


• // TODO Auto-generated catch block


• e.printStackTrace();


• }


• }

㈥ java开发中如何巧妙的使用Redis提高性能

楼主您好
把Redis作为缓存，将一些热点数据放到Redis中，读取时先读redis，载读db。
至于减少内存，注意：Redis中数据的过期策略；选择合适的数据结构，例如:选择hash而非string；数据存储进redis前使用序列化工具压缩，推荐MsgPack。
推荐知乎：https://www.hu.com/question/29548367

㈦ redis消息队列还有其他吗

基于Redis消息队列-实现短信服务化

1.Redis实现消息队列原理

常用的消息队列有RabbitMQ,ActiveMQ，个人觉得这种消息队列太大太重，本文介绍下基于Redis的轻量级消息队列服务。
一般来说，消息队列有两种模式，一种是发布者订阅模式，另外一种是生产者和消费者模式。Redis的消息队列，也是基于这2种原理的实现。
发布者和订阅者模式：发布者发送消息到队列，每个订阅者都能收到一样的消息。
生产者和消费者模式：生产者将消息放入队列，多个消费者共同监听，谁先抢到资源，谁就从队列中取走消息去处理。注意，每个消息只能最多被一个消费者接收。

2.Redis消息队列使用场景

在我们的项目中，使用消息队列来实现短信的服务化，任何需要发送短信的模块，都可以直接调用短信服务来完成短信的发送。比如用户系统登录注册短信，订单系统的下单成功的短信等。

3.SpringMVC中实现Redis消息队列

因为我们短信只需要发送一次，所以我们使用的是消息队列的生产者和消费者模式。

3.1引入Maven依赖

引入Redis相应的maven依赖，这里需要spring-data-redis和jedis

//pom.xml <dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-redis</artifactId>
<version>1.6.0.RELEASE</version>
</dependency>

<!-- jedis -->
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>2.5.1</version>
</dependency>12345678910111213

3.2配置redis生成者消费者模式

//applicationContext-redis.xml <?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop" xmlns:cache="http://www.springframework.org/schema/cache"
xmlns:redis="http://www.springframework.org/schema/redis"
xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-34.0.xsd
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache-4.0.xsd
http://www.springframework.org/schema/redis http://www.springframework.org/schema/redis/spring-redis-1.0.xsd">
<description>spring-data-redis配置</description>

<bean id="redisConnectionFactory"
class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
<property name="hostName" value="${redis.host}"></property>
<property name="port" value="${redis.port}"></property>
<property name="usePool" value="true"></property>
</bean>

<bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
<property name="connectionFactory" ref="redisConnectionFactory"></property>
</bean>

<bean id="jdkSerializer"
class="org.springframework.data.redis.serializer." />

<bean id="smsMessageListener"
class="org.springframework.data.redis.listener.adapter.MessageListenerAdapter">
<property name="delegate" ref="smsMessageDelegateListener" />
<property name="serializer" ref="jdkSerializer" />
</bean>

<bean id="sendMessage" class="com.djt.common.cache.redis.queue.SendMessage">
<property name="redisTemplate" ref="redisTemplate"/>
</bean>

<redis:listener-container>
<redis:listener ref="smsMessageListener" method="handleMessage"
serializer="jdkSerializer" topic="sms_queue_web_online" />
</redis:listener-container>

<!-- jedis -->
<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
<property name="maxIdle" value="300" /> <!-- 最大能够保持idel状态的对象数 -->
<property name="maxTotal" value="60000" /> <!-- 最大分配的对象数 -->
<property name="testOnBorrow" value="true" /> <!-- 当调用borrow Object方法时，是否进行有效性检查 -->
</bean>

<bean id="jedisPool" class="redis.clients.jedis.JedisPool">
<constructor-arg index="0" ref="jedisPoolConfig" />
<constructor-arg index="1" value="${redis.host}" />
<constructor-arg index="2" value="${redis.port}" type="int" />
</bean></beans>

主要的配置说明：
1.序列化：一般我们向Redis发送一个消息定义的Java对象，这个对象需要序列化。这里使用：

<bean id="jdkSerializer" class="org.springframework.data.redis.serializer." />1

2.发送者：

<bean id="sendMessage" class="com.djt.common.cache.redis.queue.SendMessage">
<property name="redisTemplate" ref="redisTemplate"/>
</bean>123

3.监听者：

<bean id="smsMessageListener"
class="org.springframework.data.redis.listener.adapter.MessageListenerAdapter">
<property name="delegate" ref="smsMessageDelegateListener" />
<property name="serializer" ref="jdkSerializer" />
</bean>
<redis:listener-container>
<redis:listener ref="smsMessageListener" method="handleMessage"
serializer="jdkSerializer" topic="sms_queue_web_online" />
</redis:listener-container>123456789

smsMessageListener：消息监听器
redis:listener-container：定义消息监听，method：监听消息执行的方法，serializer：序列化，topic：监听主题（可以理解为队列名称）

3.3代码实现

1.定义短信消息对象SmsMessageVo

public class SmsMessageVo implements Serializable {
//id
private Integer smsId; //手机号
private String mobile; //类型，1：验证码 2：订单通知
private Byte type; //短信创建时间
private Date createDate; //短信消息处理时间
private Date processTime; //短信状态，1：未发送 2：发送成功 3：发送失败
private Byte status; //短信内容
private String content; //省略setter和getter方法
...

2.定义消息队列发送对象SendMessage

//SendMessage.javapublic class SendMessage { private RedisTemplate<String, Object> redisTemplate; public RedisTemplate<String, Object> getRedisTemplate() { return redisTemplate;
} public void setRedisTemplate(RedisTemplate<String, Object> redisTemplate) { this.redisTemplate = redisTemplate;
} public void sendMessage(String channel, Serializable message) {
redisTemplate.convertAndSend(channel, message);
}
}

3.发送消息

String smsContent = templateToContent(template.getContent(),
regMsgCode);
SmsMessageVo smsMessageVo = new SmsMessageVo();
smsMessageVo.setMobile(mobile);
smsMessageVo.setType((byte) SmsType.VERIFICATION.getType());
smsMessageVo.setChannelId(1);
smsMessageVo.setContent(smsContent);
smsMessageVo.setCreateDate(new Date());
smsMessageVo.setStatus((byte) SmsSendStatus.TO_SEND.getType());
smsMessageVo.setTemplateId(1);

//先把待发送的短信存入数据库
SmsQueue smsQueue = new SmsQueue();
BeanUtils.Properties(smsQueue, smsMessageVo);
smsQueueService.addSmsQueue(smsQueue);

//异步发送短信到redis队列
sendMessage.sendMessage(Constants.REDIS_QUEUE_SMS_WEB, smsMessageVo);
//Constants.REDIS_QUEUE_SMS_WEB = "sms_queue_web_online",和applicationContext-redis中topic配置一样

4.监听消息

//SmsMessageDelegateListener.java@Component("smsMessageDelegateListener")public class SmsMessageDelegateListener {

@Autowired
private SmsQueueService smsQueueService; //监听Redis消息
public void handleMessage(Serializable message){ if(message instanceof SmsMessageVo){
SmsMessageVo messageVo = (SmsMessageVo) message; //发送短信
SmsSender smsSender = SmsSenderFactory.buildEMaySender();
smsSender.setMobile(messageVo.getMobile());
smsSender.setContent(messageVo.getContent()); boolean sendSucc = false; //判断短信类型
//验证码短信
if(messageVo.getType() == (byte)SmsType.VERIFICATION.getType()){
sendSucc = smsSender.send();
} if(!sendSucc){ return;
} // 异步更新短信表状态为发送成功
final Integer smsId = messageVo.getSmsId();
Executor executor = Executors.newSingleThreadExecutor();
executor.execute(new Runnable() { public void run() {
SmsQueue smsQueue = new SmsQueue();
smsQueue.setSmsId(smsId);
smsQueue.setStatus((byte)SmsSendStatus.SEND.getType());
smsQueue.setProcessTime(new Date());
smsQueueService.updateSmsQueue(smsQueue);
}
});

}
}
}04142434445

4.总结

下面使用一张流程图，来总结Redis消息队列和短信服务。

阅读全文

㈧ java连接redis超时问题怎么解决

应该是redis本身的服务有问题了
本文所针对的连接超时问题所涉及的相关元素如下:
Redis客户端: Jedis (java)
Redis版本 :2.8.12
Redis部署操作系统类型:Linux

正文开始:

No 1.Redis执行大命令(时间复杂度为O(N)的命令)
问题剖析:
a.Redis服务器端通过单线程处理命令,一旦有大命令被执行,Redis将无法及时响应来自客户端的任何命令
关于Redis大命令的监控,可以查看slowlog来观察
b.在使用jedis作为redis客户端时,当redis连接池的配置参数testOnBorrow=true时,默认会在获取redis连接
时,先执行redis的ping方法,而基于原因a,此时redis将无法及时响应,自然会报出time out异常
如何解决:
a.尽量避免使用时间复杂度为O(N)的命令
b.如果无法避免使用时间复杂度为O(N)的命令,则应降低其使用频率,避免在业务高峰期时使用

No 2.Redis单次操作数据包过大
问题分析
a.单次操作数据包过大,且操作频繁,极有可能会导致网络拥堵
b.在使用jedis作为redis客户端时,当redis连接池的配置参数testOnBorrow=true时,默认会在获取redis连接
时,先执行redis的ping方法,而基于原因a,此时redis将无法及时响应,自然会报出time out异常
如何解决:
a.排查代码,确定是否存在大数据(数据条目过多/单条数据过大)操作,将其进行改造,改造方案有两个:
a1.数据拆分,变更数据类型(常见的情况是将java中的collection类型序列化后存入redis的String数据
类型中),如将String数据类型调整为hash/list/set等,这常用于解决单条数据量过大的情况
a2.调整业务逻辑,减少单次数据查询范围(常见的情况如将redis中的整个hash数据取回,在应用程序内存中获取需要的entry),如使用hget等单条查询命令替换hgetall命令

㈨ redis什么时候插入数据需要做序列化

java把对象从内存放到硬盘为啥需要序列化?内存可能是用堆栈、寄存器存储的，断电后消失（RAM）；但是磁盘不一样，磁盘固化数据（ROM）。

需
要序列化，主要是一种针对需要I/O操作的，此时写入磁盘恰巧需要I/O。让类实现serializable接口，此类的对象就可以被序列化了。针对对象
的对象流：ObjectOutputStream，调用writeObject()/readObject()可以实现序列化、反序列化。