Spring Boot Redis 集成配置详解

spring Boot 熟悉后，集成一个外部扩展是一件很容易的事，集成Redis也很简单，看下面步骤配置：

一、添加pom依赖

<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-redis</artifactId>

</dependency>

二、创建 RedisClient.java

注意该类存放的package

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

package org.springframework.data.redis.connection.jedis;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.IOException;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

import java.io.UnsupportedEncodingException;

import org.apache.commons.lang3.StringUtils;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import redis.clients.jedis.Jedis;

import redis.clients.jedis.Protocol;

import redis.clients.jedis.exceptions.JedisException;

/**

* 工具类 RedisClient

* 因为本类中获取JedisPool调用的是JedisConnectionFactory中protected修饰的方法fetchJedisConnector()

* 所以该类需要与JedisConnectionFactory在同一个package中

*

* @author 单红宇(CSDN CATOOP)

* @create 2017年4月9日

*/

public class RedisClient {

private static Logger logger = LoggerFactory.getLogger(RedisClient.class);

private JedisConnectionFactory factory;

public RedisClient(JedisConnectionFactory factory) {

super();

this.factory = factory;

}

/**

* put操作（存储序列化对象）+ 生效时间

*

* @param key

* @param value

* @return

*/

public void putObject(final String key, final Object value, final int cacheSeconds) {

if (StringUtils.isNotBlank(key)) {

redisTemplete(key, new RedisExecute<Object>() {

@Override

public Object doInvoker(Jedis jedis) {

try {

jedis.setex(key.getBytes(Protocol.CHARSET), cacheSeconds, serialize(value));

} catch (UnsupportedEncodingException e) {

}

return null;

}

});

}

/**

* get操作（获取序列化对象）

*

* @param key

* @return

*/

public Object getObject(final String key) {

return redisTemplete(key, new RedisExecute<Object>() {

@Override

public Object doInvoker(Jedis jedis) {

try {

byte[] byteKey = key.getBytes(Protocol.CHARSET);

byte[] byteValue = jedis.get(byteKey);

if (byteValue != null) {

return deserialize(byteValue);

}

} catch (UnsupportedEncodingException e) {

return null;

}

return null;

}

});

}

/**

* setex操作

*

* @param key

* 键

* @param value

* 值

* @param cacheSeconds

* 超时时间，0为不超时

* @return

*/

public String set(final String key, final String value, final int cacheSeconds) {

return redisTemplete(key, new RedisExecute<String>() {

@Override

public String doInvoker(Jedis jedis) {

if (cacheSeconds == 0) {

return jedis.set(key, value);

}

return jedis.setex(key, cacheSeconds, value);

}

});

}

/**

* get操作

*

* @param key

* 键

* @return 值

*/

public String get(final String key) {

return redisTemplete(key, new RedisExecute<String>() {

@Override

public String doInvoker(Jedis jedis) {

String value = jedis.get(key);

return StringUtils.isNotBlank(value) && !"nil".equalsIgnoreCase(value) ? value : null;

}

});

}

/**

* del操作

*

* @param key

* 键

* @return

*/

public long del(final String key) {

return redisTemplete(key, new RedisExecute<Long>() {

@Override

public Long doInvoker(Jedis jedis) {

return jedis.del(key);

}

});

}

/**

* 获取资源

*

* @return

* @throws JedisException

*/

public Jedis getResource() throws JedisException {

Jedis jedis = null;

try {

jedis = factory.fetchJedisConnector();

} catch (JedisException e) {

logger.error("getResource.", e);

returnBrokenResource(jedis);

throw e;

}

return jedis;

}

/**

* 获取资源

*

* @return

* @throws JedisException

*/

public Jedis getJedis() throws JedisException {

return getResource();

}

/**

* 归还资源

*

* @param jedis

* @param isBroken

*/

public void returnBrokenResource(Jedis jedis) {

if (jedis != null) {

jedis.close();

}

/**

* 释放资源

*

* @param jedis

* @param isBroken

*/

public void returnResource(Jedis jedis) {

if (jedis != null) {

jedis.close();

}

/**

* 操作jedis客户端模板

*

* @param key

* @param execute

* @return

*/

public <R> R redisTemplete(String key, RedisExecute<R> execute) {

Jedis jedis = null;

try {

jedis = getResource();

if (jedis == null) {

return null;

}

return execute.doInvoker(jedis);

} catch (Exception e) {

logger.error("operator redis api fail,{}", key, e);

} finally {

returnResource(jedis);

}

return null;

}

/**

* 功能简述: 对实体Bean进行序列化操作.

*

* @param source

* 待转换的实体

* @return 转换之后的字节数组

* @throws Exception

*/

public static byte[] serialize(Object source) {

ByteArrayOutputStream byteOut = null;

ObjectOutputStream ObjOut = null;

try {

byteOut = new ByteArrayOutputStream();

ObjOut = new ObjectOutputStream(byteOut);

ObjOut.writeObject(source);

ObjOut.flush();

} catch (IOException e) {

e.printStackTrace();

} finally {

try {

if (null != ObjOut) {

ObjOut.close();

}

} catch (IOException e) {

ObjOut = null;

}

return byteOut.toByteArray();

}

/**

* 功能简述: 将字节数组反序列化为实体Bean.

*

* @param source

* 需要进行反序列化的字节数组

* @return 反序列化后的实体Bean

* @throws Exception

*/

public static Object deserialize(byte[] source) {

ObjectInputStream ObjIn = null;

Object retVal = null;

try {

ByteArrayInputStream byteIn = new ByteArrayInputStream(source);

ObjIn = new ObjectInputStream(byteIn);

retVal = ObjIn.readObject();

} catch (Exception e) {

e.printStackTrace();

} finally {

try {

if (null != ObjIn) {

ObjIn.close();

}

} catch (IOException e) {

ObjIn = null;

}

return retVal;

}

interface RedisExecute<T> {

T doInvoker(Jedis jedis);

}

三、创建Redis 配置类

RedisConfig.Java

package com.shanhy.example.redis;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;

import org.springframework.data.redis.connection.jedis.RedisClient;

import org.springframework.data.redis.core.RedisTemplate;

import org.springframework.data.redis.serializer.StringRedisSerializer;

/**

* Redis配置

*

* @author 单红宇(CSDN catoop)

* @create 2016年9月12日

*/

@Configuration

public class RedisConfig {

@Bean

public RedisTemplate<String, Object> redisTemplate(JedisConnectionFactory factory) {

RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();

template.setConnectionFactory(factory);

template.setKeySerializer(new StringRedisSerializer());

template.setValueSerializer(new RedisObjectSerializer());

template.afterPropertiesSet();

return template;

}

@Bean

public RedisClient redisClient(JedisConnectionFactory factory){

return new RedisClient(factory);

}

RedisObjectSerializer.java

package com.shanhy.example.redis;

import org.springframework.core.convert.converter.Converter;

import org.springframework.core.serializer.support.DeserializingConverter;

import org.springframework.core.serializer.support.SerializingConverter;

import org.springframework.data.redis.serializer.RedisSerializer;

import org.springframework.data.redis.serializer.SerializationException;

/**

* 实现对象的序列化接口

* @author 单红宇(365384722)

* @create 2017年4月9日

*/

public class RedisObjectSerializer implements RedisSerializer<Object> {

private Converter<Object, byte[]> serializer = new SerializingConverter();

private Converter<byte[], Object> deserializer = new DeserializingConverter();

static final byte[] EMPTY_ARRAY = new byte[0];

@Override

public Object deserialize(byte[] bytes) {

if (isEmpty(bytes)) {

return null;

}

try {

return deserializer.convert(bytes);

} catch (Exception ex) {

throw new SerializationException("Cannot deserialize", ex);

}

@Override

public byte[] serialize(Object object) {

if (object == null) {

return EMPTY_ARRAY;

}

try {

return serializer.convert(object);

} catch (Exception ex) {

return EMPTY_ARRAY;

}

private boolean isEmpty(byte[] data) {

return (data == null || data.length == 0);

}

四、创建测试方法

下面代码随便放一个Controller里

Spring Boot Redis 集成配置详解

相关文章

快网idc优惠网

相关文章

微信

快网idc优惠网

QQ交流群