基于本地redis、protostuff序列化对于数据层的优化及java中对于泛型的使用

此次对于redis、protostuff的应用是在一个高并发的秒杀系统中实现的。

在高并发的秒杀系统的优化中主要有以下几个方面：

1.对于获取秒杀地址的接口的优化

每次获取秒杀接口我们都要访问数据库，在高并发的系统中我们可以使用redis缓存进行优化，不需要每次都访问数据库，从而减小数据库的压力。而同时使用Protostuff对于需要传递的数据进行序列化，这样传递的数据量就会大大减小。从而减少并发时间。

2.对于秒杀操作的优化

秒杀操作是和数据库事务有关的，在秒杀操作中我们主要执行insert和update两条语句。

而对同一条数据进行update操作的时候，mysql存在行级锁等待的情况，一条update语句必须等待前一天update执行完之后才可以拿到lock锁。

所以这里优化主要针对的是行级锁事务的等待，网络的延迟和GC回收！

这次我们主要讲的是对于秒杀地址的优化。

实体类Seckill，记录了秒杀商品id，商品name，商品库存，开始时间结束时间，创建时间。

public class Seckill
{
private long seckillId;
private String name;
private int number;
private Date startTime;
private Date endTime;
private Date createTime;

public long getSeckillId() {
return seckillId;
}

public void setSeckillId(long seckillId) {
this.seckillId = seckillId;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public int getNumber() {
return number;
}

public void setNumber(int number) {
this.number = number;
}

public Date getStartTime() {
return startTime;
}

public void setStartTime(Date startTime) {
this.startTime = startTime;
}

public Date getEndTime() {
return endTime;
}

public void setEndTime(Date endTime) {
this.endTime = endTime;
}

public Date getCreateTime() {
return createTime;
}

public void setCreateTime(Date createTime) {
this.createTime = createTime;
}

@Override
public String toString() {
return "Seckill{" +
"seckillId=" + seckillId +
", name='" + name + '\'' +
", number=" + number +
", startTime=" + startTime +
", endTime=" + endTime +
", createTime=" + createTime +
'}';
}
}

实体类Exposer，存放了是否秒杀，MD5加密，当前系统时间，秒杀开始时间、秒杀结束时间等信息

/**
* Created by yliu on 18/03/27.
* 暴露秒杀地址(接口)DTO
*/
public class Exposer {

//是否开启秒杀
private boolean exposed;

//加密措施
private String md5;

private long seckillId;

//系统当前时间(毫秒)
private long now;

//秒杀的开启时间
private long start;

//秒杀的结束时间
private long end;

//构造函数。秒杀成功则返回true，已经经过md5加密后的地址，以及商品id，表示该商品已经开启秒杀
public Exposer(boolean exposed, String md5, long seckillId) {
this.exposed = exposed;
this.md5 = md5;
this.seckillId = seckillId;
}

//构造函数。若失败则返回false，可以返回商品id和系统时间、开始时间、结束时间、判断秒杀何时开启
public Exposer(boolean exposed, long seckillId,long now, long start, long end) {
this.exposed = exposed;
this.seckillId=seckillId;
this.now = now;
this.start = start;
this.end = end;
}
//构造函数
public Exposer(boolean exposed, long seckillId) {
this.exposed = exposed;
this.seckillId = seckillId;
}

public boolean isExposed() {
return exposed;
}

public void setExposed(boolean exposed) {
this.exposed = exposed;
}

public String getMd5() {
return md5;
}

public void setMd5(String md5) {
this.md5 = md5;
}

public long getSeckillId() {
return seckillId;
}

public void setSeckillId(long seckillId) {
this.seckillId = seckillId;
}

public long getNow() {
return now;
}

public void setNow(long now) {
this.now = now;
}

public long getStart() {
return start;
}

public void setStart(long start) {
this.start = start;
}

public long getEnd() {
return end;
}

public void setEnd(long end) {
this.end = end;
}

@Override
public String toString() {
return "Exposer{" +
"exposed=" + exposed +
", md5='" + md5 + '\'' +
", seckillId=" + seckillId +
", now=" + now +
", start=" + start +
", end=" + end +
'}';
}
}

实体类：秒杀结果类，里面存放了请求是否成功，成功则返回一个泛型T的数据，失败则返回错误信息：

/**
* Created by yliu on 18/03/28.
*/
//将所有的ajax请求返回类型，全部封装成json数据
public class SeckillResult<T> {

//请求是否成功
private boolean success;
private T data;
private String error;

public SeckillResult(boolean success, T data) {
this.success = success;
this.data = data;
}

public SeckillResult(boolean success, String error) {
this.success = success;
this.error = error;
}

public boolean isSuccess() {
return success;
}

public void setSuccess(boolean success) {
this.success = success;
}

public T getData() {
return data;
}

public void setData(T data) {
this.data = data;
}

public String getError() {
return error;
}

public void setError(String error) {
this.error = error;
}
}

RedisDao中定义了put、get redis中数据的方法：

/**
* Created by yliu on 18/3/27.
*/
public class RedisDao {
private final JedisPool jedisPool;//redis连接池

//redisDao的构造器，传入redis的地址和端口，实现连接池的初始化
public RedisDao(String ip, int port) {
jedisPool = new JedisPool(ip, port);
}

//Protostuff序列化所要传入的参数
private RuntimeSchema<Seckill> schema = RuntimeSchema.createFrom(Seckill.class);

public Seckill getSeckill(long seckillId) {
//redis操作逻辑
try {
Jedis jedis = jedisPool.getResource();
try {
String key = "seckill:" + seckillId;
//并没有实现哪部序列化操作
//采用自定义序列化 protostuff: pojo.
//通过key得到存放在redis中经过序列化后的Seckill类，经过序列化后存放的是字节类型的数据
byte[] bytes = jedis.get(key.getBytes());
//缓存重获取到
if (bytes != null) {
Seckill seckill=schema.newMessage();
ProtostuffIOUtil.mergeFrom(bytes,seckill,schema);
//反序列化得到Seckill 并返回

return seckill;
}
}finally {
//最后不要忘记关闭redis连接
jedis.close();
}
}catch (Exception e) {

}
return null;
}

public String putSeckill(Seckill seckill) {
try {
Jedis jedis = jedisPool.getResource();
try {
String key = "seckill:" + seckill.getSeckillId();
//将seckill类序列化成字节，大小为默认的大小
byte[] bytes = ProtostuffIOUtil.toByteArray(seckill, schema,
LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE));
//超时缓存
int timeout = 60 * 60;//1小时
//将序列化后的字节存放在redis中，存放时间为1小时，返回string类型的result，根据返回的结果可判断存放是否成功
String result = jedis.setex(key.getBytes(),timeout,bytes);

return result;
}finally {
jedis.close();
}
}catch (Exception e) {

}

return null;
}
}

暴露秒杀接口地址的方法，会返回一个Exposer的类型：

//加入一个混淆字符串(秒杀接口)的salt，为了我避免用户猜出我们的md5值，值任意给，越复杂越好
private final String salt="shsdssljdd'l.";
public Exposer exportSeckillUrl(long seckillId) {
//优化点:缓存优化:超时的基础上维护一致性
//1。首先访问redis,如果redis中存放了秒杀接口的数据，则直接从redis中取出，如果没有存放，则从数据库中取出数据，并存放到redis中，方便下次获取秒杀接口。

Seckill seckill = redisDao.getSeckill(seckillId);
if (seckill == null) {
//2.访问数据库
seckill = seckillDao.queryById(seckillId);
if (seckill == null) {//说明查不到这个秒杀产品的记录
//返回商品id 和false表示该商品未开启秒杀
return new Exposer(false, seckillId);
}else {
//3,放入redis
redisDao.putSeckill(seckill);
}

}

//根据返回的seckill 类中存放的秒杀开启时间判断是否开启秒杀
Date startTime=seckill.getStartTime();
Date endTime=seckill.getEndTime();
//系统当前时间
Date nowTime=new Date();
if (startTime.getTime()>nowTime.getTime() || endTime.getTime()<nowTime.getTime())
{
//系统当前时间比开始时间小，或者超过结束时间，说明没有开启秒杀，返回false及其他参数
return new Exposer(false,seckillId,nowTime.getTime(),startTime.getTime(),endTime.getTime());
}

//秒杀开启，返回秒杀商品的id、用给接口加密的md5
String md5=getMD5(seckillId);
return new Exposer(true,md5,seckillId);
}

//对秒杀商品的id进行加密，通过与salt盐值的拼接，返回复杂的md5
private String getMD5(long seckillId)
{
String base=seckillId+"/"+salt;
//调用spring中自带的md5工具
String md5= DigestUtils.md5DigestAsHex(base.getBytes());
return md5;
}

控制器controller中

@RequestMapping(value = "/{seckillId}/exposer",
method = RequestMethod.GET,
produces = {"application/json;charset=UTF-8"})
@ResponseBody
public SeckillResult<Exposer> exposer(@PathVariable("seckillId") Long seckillId)
{
//返回类型是seckillResult并设置了泛型Exposer，则在实体类中seckillResult所定义的泛型变量data是Exposer类型的数据
SeckillResult<Exposer> result;
try{
//根据秒杀商品id返回商品exposer类变量，中存放了是否开启秒杀，秒杀开启时间，md5等数据
Exposer exposer=seckillService.exportSeckillUrl(seckillId);
//在seckillResult定义了构造函数
/* public SeckillResult(boolean success, T data) {
this.success = success;
this.data = data;
} */
result=new SeckillResult<Exposer>(true,exposer);//请求成功 返回秒杀商品的信息，即是否开启秒杀等信息
}catch (Exception e)
{
//请求错误，抛出异常，并返回错误信息
e.printStackTrace();
result=new SeckillResult<Exposer>(false,e.getMessage());
}

return result;
}

在不确定返回参数类型的时候，可以使用泛型，等返回参数确定之后，再给其绑定类型。