def home(request):
# if request.method=='GET': # 这样写
# 优化,使用redis进行缓存,降低数据库的访问压力
# 有序集合,无序集合,字符串,hash,列表
# hash: key field value
# hash: goods mainwheels MainWheelSerializer(main_wheels, many=True).data,
# goods main_navs 'main_navs': MainNavSerializer(main_navs, many=True).data,
# 使用原生redis, redis.Redis(host,port,..)
conn = get_redis_connection()
if not conn.hget('goods','main_wheels'): # 若从redis获取不到
mainwheels = MainWheel.objects.all() # 从mysql数据库取出数据
value = MainWheelSerializer(mainwheels, many=True).data #序列化
value = json.dumps(value)
conn.hset('goods', 'main_wheels', value) # 存入redis
redis_main_wheels = json.loads(conn.hget('goods', 'main_wheels'))
if not conn.hget('goods', 'main_navs'): # 若从redis获取不到
mainnavs = MainNav.objects.all() # 从mysql数据库获取对象
value = MainNavSerializer(mainnavs, many=True).data #将对象序列化
# 将序列化后的字典形式转换为json格式数据,再存入
value = json.dumps(value)
conn.hset('goods', 'main_navs', value) # 存入redis
# 取出时,将json格式数据转为字典形式
redis_main_navs = json.loads(conn.hget('goods', 'main_navs')) # 从redis取出数据
if not conn.hget('goods', 'main_mustbuys'): # 若从redis获取不到
mainmustbuys = MainMustBuy.objects.all() # 从mysql数据库获取
value = MainMustBuySerializer(mainmustbuys, many=True).data
value = json.dumps(value)
conn.hset('goods', 'main_mustbuys', value)
redis_main_mustbuys = json.loads(conn.hget('goods', 'main_mustbuys'))
if not conn.hget('goods', 'main_shops'): # 若从redis获取不到
mainshops = MainShop.objects.all() # 从mysql数据库获取
value = MainShopSerializer(mainshops, many=True).data
value = json.dumps(value)
conn.hset('goods', 'main_shops', value)
redis_main_shops = json.loads(conn.hget('goods', 'main_shops'))
if not conn.hget('goods', 'main_shows'): # 若从redis获取不到
mainshows = MainShow.objects.all() # 从mysql数据库获取
value = MainShowSerializer(mainshows, many=True).data
value = json.dumps(value)
conn.hset('goods', 'main_shows', value)
redis_main_shows = json.loads(conn.hget('goods', 'main_shows'))
res = {
'main_wheels': MainWheelSerializer(redis_main_wheels, many=True).data,
'main_navs': MainNavSerializer(redis_main_navs, many=True).data,
'main_mustbuys': MainMustBuySerializer(redis_main_mustbuys, many=True).data,
'main_shops': MainShopSerializer(redis_main_shops, many=True).data,
'main_shows': MainShowSerializer(redis_main_shows, many=True).data,
}
return Response(res)
def home(request):
# TODO: 如何优化查询, 如何设置存储的格式（默认为bytes）, json
# 如果使用redis缓存数据，类型: hash散列
# hset key field value
# hset goods main_wheels MainWheelSerializer(main_wheels, many=True).data
# hset goods main_navs MainNavSerializer(main_navs, many=True).data
conn = get_redis_connection()
redis_main_wheels = conn.hget('goods', 'main_wheels')
if not redis_main_wheels:
main_wheels = MainWheel.objects.all()
new_main_wheels = MainWheelSerializer(main_wheels, many=True).data
# 存储结果为json格式数据，json.dumps()
value_wheels = json.dumps(new_main_wheels)
conn.hset('goods', 'main_wheels', value_wheels)
redis_main_wheels = conn.hget('goods', 'main_wheels')
# 存储为字符串类型的结果值，需转换为字典，json.loads()
old_main_wheels = json.loads(redis_main_wheels)
# main_wheels = MainWheel.objects.all()
main_navs = MainNav.objects.all()
main_mustbuys = MainMustBuy.objects.all()
main_shops = MainShop.objects.all()
main_shows = MainShow.objects.all()
res = {
'main_wheels': old_main_wheels,
'main_navs': MainNavSerializer(main_navs, many=True).data,
'main_mustbuys': MainMustBuySerializer(main_mustbuys, many=True).data,
'main_shops': MainShopsSerializer(main_shops, many=True).data,
'main_shows': MainShowsSerialzier(main_shows, many=True).data
}
return Response(res)
def home(request):
# 优化，使用redis进行缓存
# 有序集合，无序集合，字符串，hash，列表
# hash: key field value
# hash: goods main_wheels MainWheelSerializer(main_wheels, many=True).data
# goods main_navs MainNavSerializer(main_navs, many=True).data
# 使用redis, redis.Redis(port, host, password)
conn = get_redis_connection()
if not conn.hget('goods', 'main_wheels'):
mainwheels = MainWheel.objects.all()
value = MainWheelSerializer(mainwheels, many=True).data
# 将字典转换为json格式数据
value = json.dumps(value)
conn.hset('goods', 'main_wheels', value)
# 取值，将json格式数据转换为字典
redis_main_wheels = json.loads(conn.hget('goods', 'main_wheels'))
# main_wheels = MainWheel.objects.all()
main_navs = MainNav.objects.all()
main_mustbuys = MainMustBuy.objects.all()
main_shops = MainShop.objects.all()
main_shows = MainShow.objects.all()
res = {
'main_wheels': redis_main_wheels,
'main_navs': MainNavSerializer(main_navs, many=True).data,
'main_mustbuys': MainMustBuySerialzier(main_mustbuys, many=True).data,
'main_shops': MainShopsSerializer(main_shops, many=True).data,
'main_shows': MainShowsSerializer(main_shows, many=True).data,
}
return Response(res)
def home(request):
# 如何优化查询, 如何设置存储的格式(默认为bytes), json
# main_wheels
conn = get_redis_connection()
redis_main_wheels = conn.hget('goods', 'main_wheels')
if not redis_main_wheels:
main_wheels = MainWheel.objects.all()
new_main_wheels = MainWheelSerializer(main_wheels, many=True).data
# 存储结果为json格式数据 (字符串), json.dumps
value_wheels = json.dumps(new_main_wheels)
conn.hset('goods', 'main_wheels', value_wheels)
redis_main_wheels = conn.hget('goods', 'main_wheels')
main_wheels = json.loads(redis_main_wheels)
# main_navs
conn1 = get_redis_connection()
redis_main_navs = conn1.hget('goods', 'main_navs')
if not redis_main_navs:
old_main_navs = MainNav.objects.all()
new_main_navs = MainNavSerializer(old_main_navs, many=True).data
value_navs = json.dumps(new_main_navs)
conn1.hset('goods', 'main_navs', value_navs)
redis_main_navs = conn1.hget('goods', 'main_navs')
main_navs = json.loads(redis_main_navs)
# main_mustbuys
conn2 = get_redis_connection()
redis_main_mustbuys = conn2.hget('goods', 'main_mustbuys')
if not redis_main_mustbuys:
main_mustbuys = MainMustBuy.objects.all()
new_main_mustbuys = MainMustBuySerializer(main_mustbuys, many=True).data
value_mustbuys = json.dumps(new_main_mustbuys)
conn2.hset('goods', 'main_mustbuys', value_mustbuys)
redis_main_mustbuys = conn2.hget('goods', 'main_mustbuys')
main_mustbuys = json.loads(redis_main_mustbuys)
main_shops = MainShop.objects.all()
main_shows = MainShow.objects.all()
res = {
'main_wheels': main_wheels,
'main_navs': main_navs,
'main_mustbuys': main_mustbuys,
'main_shops': MainShopSerializer(main_shops, many=True).data,
'main_shows': MainShowSerializer(main_shows, many=True).data,
}
return Response(res)
def home(request):
main_wheels = MainWheel.objects.all()
main_navs = MainNav.objects.all()
main_shows = MainShow.objects.all()
res = {
'main_wheels': MainWheelSerializer(main_wheels, many=True).data,
'main_navs': MainNavSerializer(main_navs, many=True).data,
'main_shows': MainShowSerializer(main_shows, many=True).data
}
return Response(res)
def home(request):
# 这三组是取得三个模型内的所有的数据
main_wheels = MainWheel.objects.all()
main_navs = MainNav.objects.all()
main_shows = MainShow.objects.all()
res = {
# 将数据序列化并返回
'main_wheels': MainWheelSerializer(main_wheels, many=True).data,
'main_navs': MainNavSerializer(main_navs, many=True).data,
'main_shows': MainShowSerializer(main_shows, many=True).data,
}
return Response(res)
def get(self,request):
main_wheels = MainWheel.objects.all()
main_navs = MainNav.objects.all()
main_mustbuys = MainMustBuy.objects.all()
main_shops = MainShop.objects.all()
main_shows = MainShow.objects.all()
res = {
'main_wheels': MainWheelSerializer(main_wheels, many=True).data,
'main_navs': MainNavSerializer(main_navs, many=True).data,
'main_mustbuys': MainMustBuySerializer(main_mustbuys, many=True).data,
'main_shops': MainShopSerializer(main_shops, many=True).data,
'main_shows': MainShowSerializer(main_shows, many=True).data,
}
return Response(res)
def home(request):
# 优化，redis缓存， 用hash的数据结构
# hash ： goods main_wheels MainWheelSerializer(main_wheels, many=True).data
# 获取redis原声对象from django_redis import get_redis_connection
# 使用redis 创建连接对象redis.Redis(port,host,password)
conn = get_redis_connection()
# 取值
if not conn.hget('goods', ' main_wheels'):
# 获取数据
mainwheels = MainWheel.objects.all()
# 添加数据
value = MainWheelSerializer(mainwheels, many=True).data
# 字典转换json
value = json.dumps(value)
conn.hset('goods', 'main_wheels', value)
redis_main_wheels = json.loads(
conn.hget('goods', 'main_wheels').decode('utf8'))
if not conn.hget('goods', 'main_navs'):
# 获取数据
main_navs = MainNav.objects.all()
# 添加数据
value = MainNavSerializer(main_navs, many=True).data
value = json.dumps(value)
conn.hset('goods', 'main_navs', value)
redis_main_navs = json.loads(
conn.hget('goods', 'main_navs').decode('utf8'))
if not conn.hget('goods', 'main_mustbuy'):
# 获取数据
main_mustbuy = MainMustBuy.objects.all()
# 添加数据
value = MainMustBuySerializer(main_mustbuy, many=True).data
value = json.dumps(value)
conn.hset('goods', 'main_mustbuy', value)
redis_main_mustbuy = json.loads(
conn.hget('goods', 'main_mustbuy').decode('utf8'))
if not conn.hget('goods', 'main_shops'):
# 获取数据
main_shops = MainShop.objects.all()
# 添加数据
value = MainShopSerializer(main_shops, many=True).data
value = json.dumps(value)
conn.hset('goods', 'main_shops', value)
redis_main_shops = json.loads(
conn.hget('goods', 'main_shops').decode('utf8'))
if not conn.hget('goods', 'main_shows'):
# 获取数据
main_shows = MainShow.objects.all()
# 添加数据
value = MainShowSerializer(main_shows, many=True).data
value = json.dumps(value)
conn.hset('goods', 'main_shows', value)
redis_main_shows = json.loads(
conn.hget('goods', 'main_shows').decode('utf8'))
# 获取资源
# main_wheels = MainWheel.objects.all()
# main_navs = MainNav.objects.all()
# main_mustbuy = MainMustBuy.objects.all()
# main_shops = MainShop.objects.all()
# main_shows = MainShow.objects.all()
# 进行序列化serializer
res = {
'main_wheels':
redis_main_wheels, # MainWheelSerializer(main_wheels, many=True).data,
'main_navs':
redis_main_navs, # MainNavSerializer(main_navs, many=True).data,
'main_mustbuy':
redis_main_mustbuy, # MainMustBuySerializer(main_mustbuy, many=True).data,
'main_shops':
redis_main_shops, # MainShopSerializer(main_shops, many=True).data,
'main_shows':
redis_main_shows, # MainShowSerializer(main_shows, many=True).data,
}
return Response(res)