Redis 学习总结-02

-------------------------------------------------Redis--------------------------------------------------------
   --Redis 是一个 Key-Value 缓存存储系统。和 Memcached 类似，它支持存储的 value 类型相对更多，
   --包括 string(字符串)、hashes(hash对象)、list(链表)、 set(集合)和 zset(有序集合)。
   
   --与 memcached 一样，为了保证效率，数据都是缓存在内存中。
   --区别的是 Redis 会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，
   --并且在此基础上实现了 master-slave(主从)同步。
   
   --Key-Value Store更加注重对海量数据存取的性能、分布式、扩展性支持上，
   --并不需要传统关系数据库的一些特征，例如： Schema、事务、完整 SQL 查询支持等等
   
   
   --作为 Key-value 型数据库， Redis 也提供了键（ Key）和键值（ Value）的映射关系。但是，除
   --了常规的数值或字符串， Redis 的键值还可以是以下形式之一:
   
Hashes （哈希表）
Lists （列表）
Sets （集合）
Sorted Sets （有序集合）
  
  --同时，如果键值的类型是普通数字， Redis 则提供自增等原子操作。
   
  --一方面，是指 Key-Value Store 可以支持极大的数据的存储，它的分布式的架构决定了只要有更多的机器，
  --就能够保证存储更多的数据。
  --另一方面，是指它可以支持数量很多的并发的查询。
  
  --端口 6379
  
  --配置Redis(redis.conf)
  --如果是一个专业的 DBA，那么实例启动时会加很多的参数以便使系统运行的非常稳定，这样
  --就可能会在启动时在 Redis 后面加一个参数，以指定配置文件的路径，就象 mysql 一样的读
  --取启动配置文件的方式来启动数据库。源码编译完成后，在 redis-2.2.12 目录下有一个
  --redis.conf 文件，这个文件即是 Redis 的配置文件，用配置文件来启动 Redis 的方法如下:
  
  src/redis-server redis.conf
  --Redis 支持很多的参数，但都有默认值。
  --daemonize
  默认情况下，redis 不是在后台运行的，如果需要在后台运行，把该项的值更改为 yes
  --pidfile
  当 Redis 在后台运行的时候， Redis 默认会把 pid 文件放在/var/run/redis.pid，你可以配
  置到其他地址。当运行多个 redis 服务时，需要指定不同的 pid 文件和端口
  --bind
  指定 Redis 只接收来自于该 IP 地址的请求，如果不进行设置，那么将处理所有请求，在
  生产环境中最好设置该项
  --port
  监听端口，默认为 6379
  --timeout
  设置客户端连接时的超时时间，单位为'秒'。当客户端在这段时间内没有发出任何指令，
  那么关闭该连接
  --loglevel
  log 等级分为 4 级， debug, verbose, notice, 和 warning。生产环境下一般开启 notice
  --logfile
  配置 log 文件地址，默认使用标准输出，即打印在命令行终端的窗口上
  --databases
  设置数据库的个数，可以使用 SELECT <dbid>命令来切换数据库。默认使用的数据库是 0
  --save
  设置 Redis 进行数据库镜像的频率。
  if(在 60 秒之内有 10000 个 keys 发生变化时){
  进行镜像备份
  }else if(在 300 秒之内有 10 个 keys 发生了变化){
  进行镜像备份
  }else if(在 900 秒之内有 1 个 keys 发生了变化){
  进行镜像备份
  }
  --rdbcompression
  在进行镜像备份时，是否进行压缩
  --dbfilename
  镜像备份文件的文件名
  --dir
  数据库镜像备份的文件放置的路径。这里的路径跟文件名要分开配置是因为 Redis 在进
  行备份时，先会将当前数据库的状态写入到一个临时文件中，等备份完成时，再把该该
  临时文件替换为上面所指定的文件，而这里的临时文件和上面所配置的备份文件都会放
  在这个指定的路径当中
  --slaveof
  设置该数据库为其他数据库的从数据库
  --masterauth
  当主数据库连接需要密码验证时，在这里指定
  --requirepass
  设置客户端连接后进行任何其他指定前需要使用的密码。警告：因为 redis 速度相当快，
  所以在一台比较好的服务器下，一个外部的用户可以在一秒钟进行 150K 次的密码尝试，
  这意味着你需要指定非常非常强大的密码来防止暴力破解。
  --maxclients
  限制同时连接的客户数量。当连接数超过这个值时，redis将不再接收其他连接请求，
  客户端尝试连接时将收到error信息。
  --maxmemory 最好设置
  该参数能很好的保护好你的redis不会因为使用过多的物理内存而导致swap，最后严重影响性能甚至崩溃。
  设置 redis 能够使用的最大内存。当内存满了的时候，如果还接收到 set 命令， redis 将
  先尝试剔除设置过 expire 信息的 key，而不管该 key 的过期时间还没有到达。在删除时，
  将按照过期时间进行删除，最早将要被过期的 key 将最先被删除。如果带有 expire 信息
  的 key 都删光了，那么将返回错误。这样， redis 将不再接收写请求，只接收 get 请求。
  maxmemory 的设置比较适合于把 redis 当作于类似 memcached 的缓存来使用。
  --appendonly
  默认情况下， redis 会在后台异步的把数据库镜像备份到磁盘，但是该备份是非常耗时
  的，而且备份也不能很频繁，如果发生诸如拉闸限电、拔插头等状况，那么将造成比较
  大范围的数据丢失。所以 redis 提供了另外一种更加高效的数据库备份及灾难恢复方式。
  开启 append only 模式之后， redis 会把所接收到的每一次写操作请求都追加到
  appendonly.aof 文件中，当 redis 重新启动时，会从该文件恢复出之前的状态。但是这样
  会造成 appendonly.aof 文件过大，所以 redis 还支持了 BGREWRITEAOF 指令(异步重写追加文件)，对
  appendonly.aof 进行'重新整理'。所以我认为推荐生产环境下的做法为'关闭镜像'，开启
  'appendonly.aof'，同时可以选择在访问较少的时间每天对 appendonly.aof 进行重写一次。
  --appendfsync
  设置对 appendonly.aof 文件进行'同步的频率'。 'always' 表示每次有写操作都进行同步，
  'everysec' 表示对写操作进行累积，每秒同步一次。这个需要根据实际业务场景进行配置
  --vm-enabled 最好设置成no
  是否开启虚拟内存支持。因为 redis 是一个内存数据库，而且当内存满的时候，无法接
  收新的写请求，所以在 redis 2.0 中，提供了虚拟内存的支持。但是需要注意的是， redis
  中，所有的 key 都会放在内存中，在内存不够时，只会把 value 值放入交换区。这样保
  证了虽然使用虚拟内存，但性能基本不受影响，同时，你需要注意的是你要把
  vm-max-memory 设置到足够来放下你的所有的 key
  --vm-swap-file
  设置虚拟内存的交换文件路径
  --vm-max-memory
  这里设置开启虚拟内存之后， redis 将使用的最大物理内存的大小。默认为 0， redis 将
  把他所有的能放到交换文件的都放到交换文件中，以尽量少的使用物理内存。在生产环
  境下，需要根据实际情况设置该值，最好不要使用默认的 0
  --vm-page-size
  设置虚拟内存的页大小，如果你的 value 值比较大，比如说你要在 value 中放置博客、
  新闻之类的所有文章内容，就设大一点，如果要放置的都是很小的内容，那就设小一点。
 --vm-pages
  设置交换文件的总的 page 数量，需要注意的是， page table 信息会放在物理内存中，每
  8 个 page 就会占据 RAM 中的 1 个 byte。总的虚拟内存大小 ＝ vm-page-size * vm-pages
  --vm-max-threads
  设置 VM IO 同时使用的线程数量。因为在进行内存交换时，对数据有编码和解码的过
  程，所以尽管 IO 设备在硬件上本上不能支持很多的并发读写，但是还是如果你所保存
  的 vlaue 值比较
  --glueoutputbuf
  把小的输出缓存放在一起，以便能够在一个 TCP packet 中为客户端发送多个响应，具体
  原理和真实效果我不是很清楚。所以根据注释，你不是很确定的时候就设置成 yes
  --hash-max-zipmap-entries 默认 64 
  在 redis 2.0 中引入了 hash 数据结构。当 hash 中包含超过指定元素个数并且最大的元素
  没有超过临界时， hash 将以一种特殊的编码方式（大大减少内存使用）来存储，这里
  可以设置这两个临界值
  hash-max-zipmap-entries 64 '个'
  hash-max-zipmap-value 512 '字节'
  如果内部有64个以下的成员就是使用'线性紧凑存储'，超过该值就自动转成真正的'hashMap'。
  hash-max-zipmap-value 含义是当alue 这个map内部的每个成员值长度不超过多少字节就会采用'线性紧凑存储'来节省空间。
  以上两个条件，任意一条超过设置就会转成真正的hashmap，也就不会再节省内存了
  --activerehashing 最好设置成 yes 提升性能
  开启之后， redis 将在每 100 毫秒时使用 1 毫秒的 CPU 时间来对 redis 的 hash 表进行重
  新 hash，可以降低内存的使用。当你的使用场景中，有非常严格的实时性需要，不能
  够接受 Redis 时不时的对请求有 2 毫秒的延迟的话，把这项配置为 no。如果没有这么严
  格的实时性要求，可以设置为 yes，以便能够尽可能快的释放内存大，将该值设大一些，还是能够提升性能的
  
  --常用命令使用
  PSUBSCRIBE pattern [pattern ...] 听出版匹配给定模式的渠道的消息
  PUBLISH channel message 发布一条消息到频道
  PUNSUBSCRIBE [pattern [pattern ...]] 停止发布到匹配给定模式的渠道的消息听
  SUBSCRIBE channel [channel ...] 聆听发布途径的消息
  UNSUBSCRIBE [channel [channel ...]] 停止发布途径的消息听
  DISCARD --丢弃所有 MULTI 之后发的命令
  EXEC --执行所有 MULTI 之后发的命令
  MULTI --标记一个事务块开始
  UNWATCH --取消事务
  WATCH key [key ...] 锁定key直到执行了 MULTI/EXEC
  
  AUTH password --验证服务器
  ECHO message 回显输入的字符串
  PING Ping 服务器
  QUIT 关闭连接，退出
  SELECT index --选择数据库
  BGREWRITEAOF --异步重写追加文件
  BGSAVE 异步保存数据集到磁盘上
  CLIENT KILL ip:port关闭客户端连接
  CLIENT LIST 获得客户端连接列表
  CLIENT GETNAME 获得当前连接名称
  CLIENT SETNAME connection-name 设置当前连接的名字
  CONFIG GET parameter --获取配置参数的值
  CONFIG SET parameter value --获取配置参数的值
  CONFIG RESETSTAT 复位再分配使用info命令报告的统计
  DBSIZE --返回当前数据库里面的keys数量
  DEBUG OBJECT key获取一个key的debug信息
  DEBUG SEGFAULT 使服务器崩溃
  FLUSHALL --清空所有数据库
  FLUSHDB --清空当前的数据库
  INFO [section] 获得服务器的详细信息
  LASTSAVE 获得最后一次同步磁盘的时间
  MONITOR 实时监控服务器
  SAVE 同步数据到磁盘上
  SHUTDOWN [NOSAVE] [SAVE] 关闭服务  
  SLAVEOF host port指定当前服务器的主服务器
  SLOWLOG subcommand [argument] --管理再分配的慢查询日志
  SYNC 用于复制的内部命令
  TIME 返回当前服务器时间
  AL script numkeys key [key ...] arg [arg ...] 在服务器端执行 LUA 脚本
  EVALSHA sha1 numkeys key [key ...] arg [arg ...] 在服务器端执行 LUA 脚本
  SCRIPT EXISTS script [script ...] Check existence of scripts in the script cache.
  SCRIPT FLUSH 删除服务器缓存中所有Lua脚本。
  SCRIPT KILL 杀死当前正在运行的 Lua 脚本。
  SCRIPT LOAD script 从服务器缓存中装载一个Lua脚本。
  
    
  
  
  
  
  --下面我们来简单的操作一下数据库。
  --插入数据
  redis 127.0.0.1:6379> set name wwl
  OK
  --设置一个 key-value 对
  --查询数据
  redis 127.0.0.1:6379> get name
  "wwl"
  --取出 key 所对应的 value
  
  --删除键值
  redis 127.0.0.1:6379> del name
  --删除这个 key 及对应的 value
  
  --验证键是否存在
  redis 127.0.0.1:6379> exists name
  (integer) 0
  --其中 0，代表此 key 不存在； 1 代表存在
   
  --Redis定位于一个内存数据库，正是由于内存的快速访问特性，才使得 Redis 能够有如此高的性能，才使得 Redis 
  --能够轻松处理大量复杂的数据结构，Redis会尝试其它的存储方面的选择，但是永远不会改变它是一个内存数据库的角色
  
  --redis 的 string 可以包含任何数据， 比如 jpg 图片或者序列化的对象。 
  --从内部实现来看其实 string 可以看作 byte 数组，最大上限是 1G 字节，
   
  
  
  --设置 key 对应的值为 string 类型的 value。
  --例如我们添加一个 name= HongWan 的键值对，可以这样做:
  redis 127.0.0.1:6379> set name HongWan
  OK
  redis 127.0.0.1:6379>

  --设置 key 对应的值为 string 类型的 value。 如果 key 已经存在，返回 0， nx 是 not exist 的意思。
  --例如我们添加一个 name= HongWan_new 的键值对，可以这样做:
  redis 127.0.0.1:6379> get name
  "HongWan"
  redis 127.0.0.1:6379> setnx name HongWan_new
  (integer) 0
  redis 127.0.0.1:6379> get name
  "HongWan"
  redis 127.0.0.1:6379>
  --由于原来 name 有一个对应的值，所以本次的修改不生效，且返回码是 0。
 
  --设置指定 key 的 value 值的子字符串。
  --例如我们希望将 HongWan 的 126 邮箱替换为 gmail 邮箱，那么我们可以这样做:
  redis 127.0.0.1:6379> get name
  "[e-mail]"
  redis 127.0.0.1:6379> setrange name 8 gmail.com
  (integer) 17
  redis 127.0.0.1:6379> get name
  "[e-mail]"
  redis 127.0.0.1:6379>
  --其中的 8 是指从下标为 8（包含 8）的字符开始替换
  
  --setex
  --设置 key 对应的值为 string 类型的 value，并指定此键值对应的有效期。
  --例如我们添加一个 haircolor= red 的键值对，并指定它的有效期是 10 秒，可以这样做:
  redis 127.0.0.1:6379> setex haircolor 10 red
  OK
  redis 127.0.0.1:6379> get haircolor
  "red"
  redis 127.0.0.1:6379> get haircolor
  (nil)
  redis 127.0.0.1:6379>
  --可见由于最后一次的调用是 10 秒以后了，所以取不到 haicolor 这个键对应的值。
  
  
  --mset
  --一次设置多个 key 的值，成功返回 ok 表示所有的值都设置了，失败返回 0 表示没有任何值被设置。
  redis 127.0.0.1:6379> mset key1 HongWan1 key2 HongWan2
  OK
  redis 127.0.0.1:6379> get key1
  "HongWan1"
  redis 127.0.0.1:6379> get key2
  "HongWan2"
  redis 127.0.0.1:6379>
  
  --msetnx
  --一次设置多个 key 的值，成功返回 ok 表示所有的值都设置了，失败返回 0 表示没有任何值
  --被设置， 但是不会覆盖已经存在的 key。
  redis 127.0.0.1:6379> get key1
  "HongWan1"
  redis 127.0.0.1:6379> get key2
  "HongWan2"
  redis 127.0.0.1:6379> msetnx key2 HongWan2_new key3 HongWan3
  (integer) 0
  redis 127.0.0.1:6379> get key2
  "HongWan2"
  redis 127.0.0.1:6379> get key3
  (nil)
  --可以看出如果这条命令返回 0，那么里面操作都会回滚，都不会被执行。
  
  --getset
  --设置 key 的值，并返回 key 的旧值。
  redis 127.0.0.1:6379> get name
  "HongWan"
  redis 127.0.0.1:6379> getset name HongWan_new
  "HongWan"
  redis 127.0.0.1:6379> get name
  "HongWan_new"
  redis 127.0.0.1:6379>
  --如果键值不存在则返回nil
  
  
  --getrange
  --获取指定 key 的 value 值的子字符串。
  --具体样例如下:
  redis 127.0.0.1:6379> get name
  "[e-mail]"
  redis 127.0.0.1:6379> getrange name 0 6
  "HongWan"
  redis 127.0.0.1:6379>
  --字符串左面下标是从 0 开始的
   
  --mget
  --一次获取多个 key 的值，如果对应 key 不存在，则对应返回 nil。
  --具体样例如下:
  redis 127.0.0.1:6379> mget key1 key2 key3
  1) "HongWan1"
  2) "HongWan2"
  3) (nil)
  redis 127.0.0.1:6379>
  --key3 由于没有这个键定义，所以返回 nil。

  --incr
  --对 key 的值做加加操作,并返回新的值。注意 incr 一个不是 int 的 value 会返回错误， incr
  redis 127.0.0.1:6379> set age 20
  OK
  redis 127.0.0.1:6379> incr age
  (integer) 21
  redis 127.0.0.1:6379> get age
  "21"
  redis 127.0.0.1:6379>
  
  --incrby
  --同 incr 类似，加指定值 ， key 不存在时候会设置 key，并认为原来的 value 是 0
  redis 127.0.0.1:6379> get age
  "21"
  redis 127.0.0.1:6379> incrby age 5
  (integer) 26
  redis 127.0.0.1:6379> get name
  "[e-mail]"
  redis 127.0.0.1:6379> get age
  "26"
  redis 127.0.0.1:6379>
  
  --decr
  --对 key 的值做的是减减操作， decr 一个不存在 key，则设置 key 为-1
  redis 127.0.0.1:6379> get age
  "26"
  redis 127.0.0.1:6379> decr age
  (integer) 25
  redis 127.0.0.1:6379> get age
  "25"
  redis 127.0.0.1:6379>
  
  --decrby
  --同 decr，减指定值。
  redis 127.0.0.1:6379> get age
  "25"
  redis 127.0.0.1:6379> decrby age 5
  (integer) 20
  redis 127.0.0.1:6379> get age
  "20"
  
  --append
  --给指定 key 的字符串值追加 value,返回新字符串值的长度。
  --例如我们向 name 的值追加一个@126.com 字符串，那么可以这样做:
  redis 127.0.0.1:6379> append name @126.com
  (integer) 15
  redis 127.0.0.1:6379> get name
  "[e-mail]"
  redis 127.0.0.1:6379>
select * from dual ;
  --strlen
  --取指定 key 的 value 值的长度。
  redis 127.0.0.1:6379> get name
  "HongWan_new"
  redis 127.0.0.1:6379> strlen name
  (integer) 11
  redis 127.0.0.1:6379> get age
  "15"
  redis 127.0.0.1:6379> strlen age
  (integer) 2
  redis 127.0.0.1:6379>
  
  --strlen
  --取指定 key 的 value 值的长度。
  redis 127.0.0.1:6379> get name
  "HongWan_new"
  redis 127.0.0.1:6379> strlen name
  (integer) 11
  redis 127.0.0.1:6379> get age
  "15"
  redis 127.0.0.1:6379> strlen age
  (integer) 2
  redis 127.0.0.1:6379>

  --hash 特别适合用于存储对象

  --相较于将对象的每个字段存成单个 string 类型。将一个对象存储在 hash 类型中会占用更少的内存，并且可以更
  --方便的存取整个对象。
  
  --配置文件中指定
  hash-max-zipmap-entries 64 #配置字段最多 64 个
  hash-max-zipmap-value 512 #配置 value 最大为 512 字节

  --hset
  --设置 hash field 为指定值，如果 key 不存在，则先创建。 
  redis 127.0.0.1:6379> hset myhash field1 Hello  --myhash相当于对象值 field1相当于属性值
  (integer) 1
  redis 127.0.0.1:6379>

  --hmset
  --同时设置 hash 的多个 field。 myhash相当于一个对象的名称 field1相当于对象的属性名
  redis 127.0.0.1:6379> hmset myhash field1 Hello field2 World
  OK
  redis 127.0.0.1:6379>

  --hget
  --获取指定的 hash field。
  redis 127.0.0.1:6379> hget myhash field1
  "Hello"
  redis 127.0.0.1:6379> hget myhash field2
  "World"
  redis 127.0.0.1:6379> hget myhash field3
  (nil)
  redis 127.0.0.1:6379>

  --hmget
  --获取全部指定的 hash filed。
  redis 127.0.0.1:6379> hmget myhash field1 field2 field3
  1) "Hello"
  2) "World"
  3) (nil)
  redis 127.0.0.1:6379>
  --由于数据库没有 field3，所以取到的是一个空值 nil

  --hincrby
  --指定的 hash filed 加上给定值。
  redis 127.0.0.1:6379> hset myhash field3 20
  (integer) 1
  redis 127.0.0.1:6379> hget myhash field3
  "20"
  redis 127.0.0.1:6379> hincrby myhash field3 -8
  (integer) 12
  redis 127.0.0.1:6379> hget myhash field3
  "12"
  redis 127.0.0.1:6379>
  --在本例中我们将 field3 的值从 20 降到了 12，即做了一个减 8 的操作。

  --hexists
  --测试指定 field 是否存在。
  redis 127.0.0.1:6379> hexists myhash field1
  (integer) 1
  redis 127.0.0.1:6379> hexists myhash field9
  (integer) 0
  redis 127.0.0.1:6379>
  --通过上例可以说明 field1 存在，但 field9 是不存在的。

  --hlen
  --返回指定 hash 的 field 数量。
  redis 127.0.0.1:6379> hlen myhash
  (integer) 4
  30
  redis 127.0.0.1:6379>
  --通过上例可以看到 myhash 中有 4 个 field。

  --hdel
  --删除hash对应的键值
  redis 127.0.0.1:6379> hlen myhash
  (integer) 4
  redis 127.0.0.1:6379> hdel myhash field1
  (integer) 1
  redis 127.0.0.1:6379> hlen myhash
  (integer) 3
  redis 127.0.0.1:6379>
  
  --hkeys
  --返回 hash 的所有 field。
  redis 127.0.0.1:6379> hkeys myhash
  1) "field2"
  2) "field"
  3) "field3"
  redis 127.0.0.1:6379>
  --说明这个 hash 中有 3 个 field
  
  --hvals
  --返回 hash 的所有 value。
  redis 127.0.0.1:6379> hvals myhash
  1) "World"
  2) "Hello"
  3) "12"
  redis 127.0.0.1:6379>
  --说明这个 hash 中有 3 个 field
  
  --hgetall
  --获取某个 hash 中全部的 filed 及 value。
  redis 127.0.0.1:6379> hgetall myhash
  1) "field2"
  2) "World"
  3) "field"
  4) "Hello"
  5) "field3"
  6) "12"
  redis 127.0.0.1:6379>
  --可见，一下子将 myhash 中所有的 field 及对应的 value 都取出来了。
  --Jedis中使用hset来保存数据
  
  public class Test {
    static JedisPool pool = new JedisPool("127.0.0.1");
    static Jedis jedis = pool.getResource();
  	
    public static void main(String[] args) {
      // 密码验证
      jedis.auth("password");
  		
      Person person = new Person("123", "alan");
      try {
        saveObject(Person.class,person,"person");
      } catch (Exception e) {
        e.printStackTrace();
      }
  --		jedis.hset("person", "id", person.getId());
  --		jedis.hset("person", "name", person.getName());
    } 
    @SuppressWarnings("all")
    static void saveObject(Class clazz,Object obj,String key) throws Exception{
      for(Field field:clazz.getDeclaredFields()){
        String fieldName = field.getName() ;
        Method method = clazz.getDeclaredMethod("get"+fieldName.substring(0,1).toUpperCase()+fieldName.substring(1), null) ;
        jedis.hset(key, fieldName,(String)method.invoke(obj, null));
      }
    }
}
  
  
  
  
  
  --Redis的 list 类型其实就是一个每个子元素都是 string 类型的双向链表。链表的最大长度是(2
  --的32次方)。我们可以通过 push,pop 操作从链表的头部或者尾部添加删除元素。这使得 list既可以用作栈，也可以用作队列。
  
  --操作中 key理解为链表的名字。

  --lpush
  --在 key 对应 list 的头部添加字符串元素
  redis 127.0.0.1:6379> lpush mylist "world"
  (integer) 1
  redis 127.0.0.1:6379> lpush mylist "hello"
  (integer) 2
  redis 127.0.0.1:6379> lrange mylist 0 -1
  1) "hello"   0 -2       0 -1 说明就是把所有的数据查询出来
  2) "world"   1 -1
  redis 127.0.0.1:6379>
  --在此处我们先插入了一个 world，然后在 world 的头部插入了一个 hello。其中 lrange 是用于
  --取 mylist 的内容。
  
  --rpush
  --在 key 对应 list 的尾部添加字符串元素
  redis 127.0.0.1:6379> rpush mylist2 "hello"
  (integer) 1
  redis 127.0.0.1:6379> rpush mylist2 "world"
  (integer) 2
  redis 127.0.0.1:6379> lrange mylist2 0 -1
  1) "hello"
  2) "world"
  redis 127.0.0.1:6379>
  --在此处我们先插入了一个 hello，然后在 hello 的尾部插入了一个 world。
  
  --linsert
  --在 key 对应 list 的特定位置之前或之后添加字符串元素
  redis 127.0.0.1:6379> rpush mylist3 "hello"
  (integer) 1
  redis 127.0.0.1:6379> rpush mylist3 "world"
  (integer) 2
  redis 127.0.0.1:6379> linsert mylist3 before "world" "there"
  (integer) 3
  redis 127.0.0.1:6379> lrange mylist3 0 -1
  1) "hello"
  2) "there"
  3) "world"
  redis 127.0.0.1:6379>
  --在此处我们先插入了一个 hello，然后在 hello 的尾部插入了一个 world，然后又在 world 的
  --前面插入了 there。
  
  --lset
  --设置 list 中指定下标的元素值(下标从 0 开始)
  redis 127.0.0.1:6379> rpush mylist4 "one"
  (integer) 1
  redis 127.0.0.1:6379> rpush mylist4 "two"
  (integer) 2
  redis 127.0.0.1:6379> rpush mylist4 "three"
  (integer) 3
  redis 127.0.0.1:6379> lset mylist4 0 "four" --lset 是覆盖的意思 mylist4表示列表的名字
  OK
  redis 127.0.0.1:6379> lset mylist4 -2 "five"
  OK
  redis 127.0.0.1:6379> lrange mylist4 0 -1
  1) "four"    0 -3
  2) "five"    1 -2
  3) "three"   2 -1
  redis 127.0.0.1:6379>
  --在此处我们依次插入了 one,two,three，然后将标是 0 的值设置为 four，再将下标是-2 的值设置为 five。
  
  --lrem
  --从 key 对应 list 中删除 count 个和 value 相同的元素。
  --count>0 时，按从头到尾的顺序删除，具体如下:
  redis 127.0.0.1:6379> rpush mylist5 "hello"
  (integer) 1
  redis 127.0.0.1:6379> rpush mylist5 "hello"
  (integer) 2
  redis 127.0.0.1:6379> rpush mylist5 "foo"
  (integer) 3
  redis 127.0.0.1:6379> rpush mylist5 "hello"
  (integer) 4
  redis 127.0.0.1:6379> lrem mylist5 2 "hello"
  (integer) 2
  redis 127.0.0.1:6379> lrange mylist5 0 -1
  1) "foo"
  2) "hello"
  redis 127.0.0.1:6379>
  --count<0 时，按从尾到头的顺序删除，具体如下:
  redis 127.0.0.1:6379> rpush mylist6 "hello"
  (integer) 1
  redis 127.0.0.1:6379> rpush mylist6 "hello"
  (integer) 2
  redis 127.0.0.1:6379> rpush mylist6 "foo"
  (integer) 3
  redis 127.0.0.1:6379> rpush mylist6 "hello"
  (integer) 4
  redis 127.0.0.1:6379> lrem mylist6 -2 "hello"
  (integer) 2
  redis 127.0.0.1:6379> lrange mylist6 0 -1
  1) "hello"
  2) "foo"
  redis 127.0.0.1:6379>
  --count=0 时，删除全部，具体如下:
  redis 127.0.0.1:6379> rpush mylist7 "hello"
  (integer) 1
  redis 127.0.0.1:6379> rpush mylist7 "hello"
  (integer) 2
  redis 127.0.0.1:6379> rpush mylist7 "foo"
  (integer) 3
  redis 127.0.0.1:6379> rpush mylist7 "hello"
  (integer) 4
  redis 127.0.0.1:6379> lrem mylist7 0 "hello"
  (integer) 3
  redis 127.0.0.1:6379> lrange mylist7 0 -1
  1) "foo"
  redis 127.0.0.1:6379>
  
  
  --ltrim
  --保留指定 key 的值范围内的数据
  redis 127.0.0.1:6379> rpush mylist8 "one"
  (integer) 1
  redis 127.0.0.1:6379> rpush mylist8 "two"
  (integer) 2
  redis 127.0.0.1:6379> rpush mylist8 "three"
  (integer) 3
  redis 127.0.0.1:6379> rpush mylist8 "four"
  (integer) 4
  redis 127.0.0.1:6379> ltrim mylist8 1 -1
  OK
  redis 127.0.0.1:6379> lrange mylist8 0 -1
  1) "two"
  2) "three"
  3) "four"
  redis 127.0.0.1:6379>
    
  --lpop
  --从 list 的头部删除元素，并返回删除元素
  redis 127.0.0.1:6379> lrange mylist 0 -1
  1) "hello"
  2) "world"
  redis 127.0.0.1:6379> lpop mylist
  "hello"
  redis 127.0.0.1:6379> lrange mylist 0 -1
  1) "world"
  redis 127.0.0.1:6379>
  
  
  --rpop
  --从 list 的尾部删除元素，并返回删除元素
  redis 127.0.0.1:6379> lrange mylist2 0 -1
  1) "hello"
  2) "world"
  redis 127.0.0.1:6379> rpop mylist2
  "world"
  redis 127.0.0.1:6379> lrange mylist2 0 -1
  1) "hello"
  redis 127.0.0.1:6379>
  
  --rpoplpush
  --从第一个 list 的尾部移除元素并添加到第二个 list 的头部,最后返回被移除的元素值，整个操
  --作是原子的.如果第一个 list 是空或者不存在返回 nil
  redis 127.0.0.1:6379> lrange mylist5 0 -1
  1) "three"
  2) "foo"
  3) "hello"
  redis 127.0.0.1:6379> lrange mylist6 0 -1
  1) "hello"
  2) "foo"
  redis 127.0.0.1:6379> rpoplpush mylist5 mylist6
  "hello"
  redis 127.0.0.1:6379> lrange mylist5 0 -1
  1) "three"
  2) "foo"
  redis 127.0.0.1:6379> lrange mylist6 0 -1
  1) "hello"
  2) "hello"
  3) "foo"
  redis 127.0.0.1:6379>
  
  --lindex
  --返回名称为 key 的 list 中 index 位置的元素   
  redis 127.0.0.1:6379> lrange mylist5 0 -1
  1) "three"
  2) "foo"
  redis 127.0.0.1:6379> lindex mylist5 0
  "three"
  redis 127.0.0.1:6379> lindex mylist5 1
  "foo"
  redis 127.0.0.1:6379>  
  
  --llen
  --返回 key 对应 list 的长度
  redis 127.0.0.1:6379> llen mylist5
  (integer) 2
  redis 127.0.0.1:6379>
  
  
  
  
  --set是集合，和我们数学中的集合概念相似，对集合的操作有添加删除元素，有对多个集合
  --求交并差等操作， 操作中 key 理解为集合的名字。(基于Hashtable的原理进行设计)不能添加重复元素。
  
  --sadd
  --向名称为 key 的 set 中添加元素
  redis 127.0.0.1:6379> sadd myset "hello"
  (integer) 1
  redis 127.0.0.1:6379> sadd myset "world"
  (integer) 1
  redis 127.0.0.1:6379> sadd myset "world"
  (integer) 0
  redis 127.0.0.1:6379> smembers myset
  1) "world"
  2) "hello"
  redis 127.0.0.1:6379>
  --本例中，我们向 myset 中添加了三个元素，但由于第三个元素跟第二个元素是相同的，所以
  --第三个元素没有添加成功，最后我们用 smembers 来查看 myset 中的所有元素。

  --srem
  --删除名称为 key 的 set 中的元素 member
  redis 127.0.0.1:6379> sadd myset2 "one"
  (integer) 1
  redis 127.0.0.1:6379> sadd myset2 "two"
  (integer) 1
  redis 127.0.0.1:6379> sadd myset2 "three"
  (integer) 1
  redis 127.0.0.1:6379> srem myset2 "one"
  (integer) 1
  redis 127.0.0.1:6379> srem myset2 "four"
  (integer) 0
  redis 127.0.0.1:6379> smembers myset2
  1) "three"
  2) "two"
  redis 127.0.0.1:6379>
  --本例中，我们向 myset2 中添加了三个元素后，再调用 srem 来删除 one 和 four，但由于元素
  --中没有 four 所以，此条 srem 命令执行失败。
  
  --spop
  --随机返回并删除名称为 key 的 set 中一个元素
  redis 127.0.0.1:6379> sadd myset3 "one"
  (integer) 1
  redis 127.0.0.1:6379> sadd myset3 "two"
  (integer) 1
  redis 127.0.0.1:6379> sadd myset3 "three"
  (integer) 1
  redis 127.0.0.1:6379> spop myset3
  "three"
  redis 127.0.0.1:6379> smembers myset3
  1) "two"
  2) "one"
  redis 127.0.0.1:6379>
  --本例中，我们向 myset3 中添加了三个元素后，再调用 spop 来随机删除一个元素，可以看到three 元素被删除了。
  
  --sdiff
  --返回所有给定 key 与第一个 key 的差集
  redis 127.0.0.1:6379> smembers myset2
  1) "three"
  2) "two"
  redis 127.0.0.1:6379> smembers myset3
  1) "two"
  2) "one"
  redis 127.0.0.1:6379> sdiff myset2 myset3
  1) "three"
  redis 127.0.0.1:6379>
  --本例中，我们可以看到 myset2 中的元素与 myset3 中不同的只是 three，所以只有 three 被查
  --出来了，而不是 three 和 one，因为 one 是 myset3 的元素。
  --我们也可以将 myset2 和 myset3 换个顺序来看一下结果:
  redis 127.0.0.1:6379> sdiff myset3 myset2
  1) "one"
  redis 127.0.0.1:6379>
  --这个结果中只显示了， myset3 中的元素与 myset2 中不同的元素。
  
  --sdiffstore
  --返回所有给定 key 与第一个 key 的差集，并将结果存为另一个 key
  redis 127.0.0.1:6379> smembers myset2
  1) "three"
  2) "two"
  redis 127.0.0.1:6379> smembers myset3
  1) "two"
  2) "one"
  redis 127.0.0.1:6379> sdiffstore myset4 myset2 myset3
  (integer) 1
  redis 127.0.0.1:6379> smembers myset4
  1) "three"
  redis 127.0.0.1:6379> 
  
  --sinter
  --返回所有给定 key 的交集
  redis 127.0.0.1:6379> smembers myset2
  1) "three"
  2) "two"
  redis 127.0.0.1:6379> smembers myset3
  1) "two"
  2) "one"
  redis 127.0.0.1:6379> sinter myset2 myset3
  1) "two"
  redis 127.0.0.1:6379>
  --通过本例的结果可以看出, myset2 和 myset3 的交集 two 被查出来了
  
  --sunion
  --返回所有给定 key 的并集
  redis 127.0.0.1:6379> smembers myset2
  1) "three"
  2) "two"
  redis 127.0.0.1:6379> smembers myset3
  1) "two"
  2) "one"
  redis 127.0.0.1:6379> sunion myset2 myset3
  1) "three"
  2) "one"
  3) "two"
  redis 127.0.0.1:6379> 
  --通过本例的结果可以看出, myset2 和 myset3 的并集被查出来了
  
  --smove
  --从第一个 key 对应的 set 中移除 member 并添加到第二个对应 set 中
  redis 127.0.0.1:6379> smembers myset2
  1) "three"
  2) "two"
  redis 127.0.0.1:6379> smembers myset3
  1) "two"
  2) "one"
  redis 127.0.0.1:6379> smove myset2 myset7 three
  (integer) 1
  redis 127.0.0.1:6379> smembers myset7
  1) "three"
  redis 127.0.0.1:6379>
  --通过本例可以看到， myset2 的 three 被移到 myset7 中了
  
  --scard
  --返回名称为 key 的 set 的元素个数
  redis 127.0.0.1:6379> scard myset2
  (integer) 1
  redis 127.0.0.1:6379>
  --通过本例可以看到， myset2 的成员数量为 1
  
  --sismember
  --测试 member 是否是名称为 key 的 set 的元素
  redis 127.0.0.1:6379> smembers myset2
  1) "two"
  redis 127.0.0.1:6379> sismember myset2 two
  (integer) 1
  redis 127.0.0.1:6379> sismember myset2 one
  (integer) 0
  redis 127.0.0.1:6379>
  --通过本例可以看到， two 是 myset2 的成员，而 one 不是。
  
  --srandmember
  --随机返回名称为 key 的 set 的一个元素，但是不删除元素
  redis 127.0.0.1:6379> smembers myset3
  1) "two"
  2) "one"
  redis 127.0.0.1:6379> srandmember myset3
  "two"
  redis 127.0.0.1:6379> srandmember myset3
  "one"
  redis 127.0.0.1:6379>
  
    
  --sorted set 是 set 的一个升级版本， 它在 set 的基础上增加了一个顺序属性，这一属性在添加
  --修改元素的时候可以指定，每次指定后， zset 会自动重新按新的值调整顺序。
  
  
  --zadd
  --向名称为 key 的 zset 中添加元素 member，score用于排序。如果该元素已经存在，则根据score更新该元素的顺序
  redis 127.0.0.1:6379> zadd myzset 1 "one"
  (integer) 1
  redis 127.0.0.1:6379> zadd myzset 2 "two"
  (integer) 1
  redis 127.0.0.1:6379> zadd myzset 3 "two"
  (integer) 0
  redis 127.0.0.1:6379> zrange myzset 0 -1 withscores
  1) "one"
  2) "1"
  3) "two"
  4) "3"
  redis 127.0.0.1:6379>
  --本例中我们向 myzset 中添加了 one 和 two，并且 two 被设置了 2 次，那么将以最后一次的
  --设置为准，最后我们将所有元素都显示出来并显示出了元素的 score。
  
  --zrem
  --删除名称为 key 的 zset 中的元素 member
  redis 127.0.0.1:6379> zrange myzset 0 -1 withscores
  1) "one"
  2) "1"
  3) "two"
  4) "3"
  redis 127.0.0.1:6379> zrem myzset two
  (integer) 1
  redis 127.0.0.1:6379> zrange myzset 0 -1 withscores
  1) "one"
  2) "1"
  redis 127.0.0.1:6379>
  --可以看到 two 被删除了
  
  --zrank
  --返回名称为 key 的 zset 中 member 元素的排名(按 score 从小到大排序)即下标
  redis 127.0.0.1:6379> zrange myzset3 0 -1 withscores
  1) "one"
  2) "1"
  3) "two"
  4) "2"
  5) "three"
  6) "3"
  7) "five"
  8) "5"
  redis 127.0.0.1:6379> zrank myzset3 two
  (integer) 1
  redis 127.0.0.1:6379>
  --本例中将 two 的下标是 1，我这里取的是下标，而不是 score
  
  --zrevrank
  --返回名称为 key 的 zset 中 member 元素的排名(按 score 从大到小排序)即下标
  redis 127.0.0.1:6379> zrange myzset3 0 -1 withscores
  1) "one"
  2) "1"
  3) "two"
  4) "2"
  5) "three"
  6) "3"
  7) "five"
  8) "5"
  redis 127.0.0.1:6379> zrevrank myzset3 two
  (integer) 2
  redis 127.0.0.1:6379>
  --按从大到小排序的话 two 是第三个元素，下标是 2
  
  --zcount
  --返回集合中 score 在给定区间的数量
  redis 127.0.0.1:6379> zrange myzset3 0 -1 withscores
  1) "one"
  2) "1"
  3) "two"
  4) "2"
  5) "three"
  6) "3"
  7) "five"
  8) "5"

  redis 127.0.0.1:6379> zcount myzset3 2 3
  (integer) 2
  redis 127.0.0.1:6379>
  --本例中，计算了 score 在 2~3 之间的元素数目
  
  --zcard
  --返回集合中元素个数
  redis 127.0.0.1:6379> zrange myzset3 0 -1 withscores
  1) "one"
  2) "1"
  3) "two"
  4) "2"
  5) "three"
  6) "3"
  7) "five"
  8) "5"
  redis 127.0.0.1:6379> zcard myzset3
  (integer) 4
  redis 127.0.0.1:6379>
  --从本例看出 myzset3 这个集全的元素数量是 4
  
  --zscore
  --返回给定元素对应的 score
  redis 127.0.0.1:6379> zrange myzset3 0 -1 withscores
  1) "one"
  2) "1"
  3) "two"
  4) "2"
  5) "three"
  6) "3"
  7) "five"
  8) "5"
  redis 127.0.0.1:6379> zscore myzset3 two
  "2"
  redis 127.0.0.1:6379>
  --此例中我们成功的将 two 的 score 取出来了。
  
  --Redis 常用命令    
  
  --键值相关命令
  
 -- 返回满足给定 pattern 的所有 key
  redis 127.0.0.1:6379> keys *
  1) "myzset2"
  2) "myzset3"
  3) "mylist"
  4) "myset2"
  5) "myset3"
  6) "myset4"
  7) "k_zs_1"
  8) "myset5"
  9) "myset6"
  10) "myset7"
  11) "myhash"
  12) "myzset"
  13) "age"
  14) "myset"
  15) "mylist5"
  16) "mylist6"
  17) "mylist7"
  18) "mylist8"
  用表达式*，代表取出所有的 key
  
  --exists
  --确认一个 key 是否存在
  redis 127.0.0.1:6379> exists HongWan
  (integer) 0
  redis 127.0.0.1:6379> exists age
  (integer) 1
  redis 127.0.0.1:6379>
  --从结果来数据库中不存在 HongWan 这个 key，但是 age 这个 key 是存在的
  
  --del
  --删除一个 key
  redis 127.0.0.1:6379> del age
  (integer) 1
  redis 127.0.0.1:6379> exists age
  (integer) 0
  redis 127.0.0.1:6379>
  --从结果来数据库中不存在 HongWan 这个 key，但是 age 这个 key 是存在的
  
  --expire
  --设置一个 key 的过期时间(单位:秒)
  redis 127.0.0.1:6379> expire addr 10
  (integer) 1
  redis 127.0.0.1:6379> ttl addr
  (integer) 8
  redis 127.0.0.1:6379> ttl addr
  (integer) 1
  redis 127.0.0.1:6379> ttl addr
  (integer) -1
  redis 127.0.0.1:6379>
  --在本例中，我们设置 addr 这个 key 的过期时间是 10 秒，然后我们不断的用 ttl 来获取这个
  --key 的有效时长，直至为-1 说明此值已过期
  
  
  --move
  --将当前数据库中的 key 转移到其它数据库中
  redis 127.0.0.1:6379> select 0
  OK
  redis 127.0.0.1:6379> set age 30
  OK
  redis 127.0.0.1:6379> get age
  "30"
  redis 127.0.0.1:6379> move age 1
  (integer) 1
  redis 127.0.0.1:6379> get age
  (nil)
  redis 127.0.0.1:6379> select 1
  OK
  redis 127.0.0.1:6379[1]> get age
  "30"
  redis 127.0.0.1:6379[1]>
  --在本例中，我先显式的选择了数据库 0，然后在这个库中设置一个 key，接下来我们将这个
  --key 从数据库 0 移到数据库 1，之后我们确认在数据库 0 中无此 key 了, 但在数据库 1 中存在
  --这个 key，说明我们转移成功了
  
  --persist
  --移除给定 key 的过期时间
  redis 127.0.0.1:6379[1]> expire age 300
  (integer) 1
  redis 127.0.0.1:6379[1]> ttl age
  (integer) 294
  redis 127.0.0.1:6379[1]> persist age
  (integer) 1
  redis 127.0.0.1:6379[1]> ttl age
  (integer) -1
  redis 127.0.0.1:6379[1]>
  --在这个例子中，我们手动的将未到过期时间的 key，成功设置为过期
  
  --randomkey
  随机返回 key 空间的一个 key
  redis 127.0.0.1:6379> randomkey
  "mylist7"
  redis 127.0.0.1:6379> randomkey
  "mylist5"
  redis 127.0.0.1:6379>
  --通过结果可以看到取 key 的规则是随机的
  
  
  --rename
  --重命名 key
  redis 127.0.0.1:6379[1]> keys *
  1) "age"
  redis 127.0.0.1:6379[1]> rename age age_new
  OK
  redis 127.0.0.1:6379[1]> keys *
  1) "age_new"
  redis 127.0.0.1:6379[1]>
  age 成功的被我们改名为 age_new 了
  
  --type
  --返回值的类型
  redis 127.0.0.1:6379> type addr
  string
  redis 127.0.0.1:6379> type myzset2
  zset
  redis 127.0.0.1:6379> type mylist
  list
  redis 127.0.0.1:6379>
  --这个方法可以非常简单的判断出值的类型
  
  
  --服务器相关命令
  
  --ping
  --测试连接是否存活
  redis 127.0.0.1:6379> ping
  PONG
  --执行下面命令之前，我们停止 redis 服务器
  redis 127.0.0.1:6379> ping
  Could not connect to Redis at 127.0.0.1:6379: Connection refused
  --执行下面命令之前，我们启动 redis 服务器
  not connected> ping
  PONG
  redis 127.0.0.1:6379>
  --第一个 ping 时，说明此连接正常
  --第二个 ping 之前，我们将 redis 服务器停止，那么 ping 是失败的
  --第三个 ping 之前，我们将 redis 服务器启动，那么 ping 是成功的
 
  --echo
  --在命令行打印一些内容
  redis 127.0.0.1:6379> echo HongWan
  "HongWan"
  redis 127.0.0.1:6379>
  
  
  --select
  --选择数据库。 Redis 数据库编号从 0~15，我们可以选择任意一个数据库来进行数据的存取。
  redis 127.0.0.1:6379> select 1
  OK
  redis 127.0.0.1:6379[1]> select 16
  (error) ERR invalid DB index
  redis 127.0.0.1:6379[16]>
  --当选择 16 时，报错，说明没有编号为 16 的这个数据库
  
  --quit
  退出连接。
  redis 127.0.0.1:6379> quit
  [root@localhost redis-2.2.12]#
  
  --dbsize
  --返回当前数据库中 key 的数目。
  redis 127.0.0.1:6379> dbsize
  (integer) 18
  redis 127.0.0.1:6379>
  --结果说明此库中有 18 个 key
  
  --info
  --获取服务器的信息和统计。
  redis 127.0.0.1:6379> info
  redis_version:2.2.12
  redis_git_sha1:00000000
  redis_git_dirty:0
  arch_bits:32
  multiplexing_api:epoll
  process_id:28480
  uptime_in_seconds:2515
  uptime_in_days:0
  . . .
  redis 127.0.0.1:6379>
  --此结果用于说明服务器的基础信息，包括版本、启动时间等。
  
  
  --monitor
  --实时转储收到的请求。
  redis 127.0.0.1:6379> config get dir
  1) "dir"
  2) "/root/4setup/redis-2.2.12"
  redis 127.0.0.1:6379>
  --从结果可以看出，此服务器目前接受了命令"keys *"和"get addr"。
  
  --config get
  获取服务器配置信息。
  redis 127.0.0.1:6379> config get dir
  1) "dir"
  2) "/root/4setup/redis-2.2.12"
  redis 127.0.0.1:6379>
  --本例中我们获取了 dir 这个参数配置的值，如果想获取全部参数据的配置值也很简单，只需
  --执行” config get *”即可将全部的值都显示出来。
  
  
  --flushdb
  --删除当前选择数据库中的所有 key。
  redis 127.0.0.1:6379> dbsize
  (integer) 18
  redis 127.0.0.1:6379> flushdb
  OK
  redis 127.0.0.1:6379> dbsize
  (integer) 0
  redis 127.0.0.1:6379>
  --在本例中我们将 0 号数据库中的 key 都清除了。
  
  --flushall
  --删除所有数据库中的所有 key。
  redis 127.0.0.1:6379[1]> dbsize
  (integer) 1
  redis 127.0.0.1:6379[1]> select 0
  OK
  redis 127.0.0.1:6379> flushall
  OK
  redis 127.0.0.1:6379> select 1
  OK
  redis 127.0.0.1:6379[1]> dbsize
  (integer) 0
  redis 127.0.0.1:6379[1]>
  --在本例中我们先查看了一个 1 号数据库中有一个 key，然后我切换到 0 号库执行 flushall 命令，
  --结果 1 号库中的 key 也被清除了，说是此命令工作正常。
  
 --将一个对象转换成json字符串
 public static void main(String[] args) throws Exception {
		Test test = new Test("lanweixing");
		Test2 test2 = new Test2("lanweixing", 28);
		JSONObject obj = transferObjToJson(Test.class, test);
		System.out.println(obj.toString());
		JSONObject obj2 = transferObjToJson(Test2.class, test2);
		System.out.println(obj2.toString());
	}
  
	@SuppressWarnings("all")
	static JSONObject transferObjToJson(Class beanClass, Object srcObj) {
		JSONObject obj = new JSONObject();
		for (Field value : beanClass.getDeclaredFields()) {
        --获取属性的类型
        System.out.println(value.getType().getSimpleName());
        --将第一个字符设置成大写
				String firstChar = value.getName().substring(0, 1).toUpperCase();
				obj.put(value.getName(),
						beanClass.getMethod("get" + firstChar+ value.getName().substring(1),
						null).invoke(srcObj, null));
			}
		return obj;
	}
}