sql复制代码CREATE TABLE  'user' (
 'id' bigint(20) CHARACTER SET utf8 COLLATE utf8_bin NOT NULL DEFAULT ''
) ENGINE = MyISAM

sql复制代码mysql> use mysql;
Database changed
mysql> show table status like 'user' \G ;
*************************** 1. row ***************************
          Name: user
        Engine: MyISAM
      Version: 10
    Row_format: Dynamic
          Rows: 3
Avg_row_length: 128
  Data_length: 384
Max_data_length: 281474976710655
  Index_length: 4096
    Data_free: 0
Auto_increment: NULL
  Create_time: 2018-06-11 09:51:16
  Update_time: 2018-06-11 09:53:08
    Check_time: NULL
    Collation: utf8_bin
      Checksum: NULL
Create_options: 
      Comment: Users and global privileges
1 row in set (0.00 sec)

csharp复制代码mysql> select * from information_schema.tables where table_name = 'user' and TABLE_SCHEMA='mysql' \G;

kotlin复制代码if (this.remotingServer != null) {
    this.remotingServer.start();
}

scss复制代码        // ServerBootstrap：netty服务启动的辅助类
        ServerBootstrap childHandler =
            this.serverBootstrap.group(this.eventLoopGroupBoss, this.eventLoopGroupSelector)
                .channel(useEpoll() ? EpollServerSocketChannel.class : NioServerSocketChannel.class)
                .option(ChannelOption.SO_BACKLOG, 1024)
                .option(ChannelOption.SO_REUSEADDR, true)
                .option(ChannelOption.SO_KEEPALIVE, false)
                .childOption(ChannelOption.TCP_NODELAY, true)
                .childOption(ChannelOption.SO_SNDBUF, nettyServerConfig.getServerSocketSndBufSize())
                .childOption(ChannelOption.SO_RCVBUF, nettyServerConfig.getServerSocketRcvBufSize())
                .localAddress(new InetSocketAddress(this.nettyServerConfig.getListenPort()))
                .childHandler(new ChannelInitializer<SocketChannel>() { // Handler：理解为业务逻辑处理器
                    @Override
                    public void initChannel(SocketChannel ch) throws Exception {
                        ch.pipeline() // pipeline：一组 Handler 的链条
                            .addLast(defaultEventExecutorGroup, HANDSHAKE_HANDLER_NAME, handshakeHandler)
                            .addLast(defaultEventExecutorGroup,
                                encoder,
                                new NettyDecoder(),
                                new IdleStateHandler(0, 0, nettyServerConfig.getServerChannelMaxIdleTimeSeconds()),
                                connectionManageHandler,
                                serverHandler  // ☆☆ 处理发送过来的消息的核心处理逻辑
                            );
                    }
                });

scala复制代码    @ChannelHandler.Sharable
    class NettyServerHandler extends SimpleChannelInboundHandler<RemotingCommand> {
​
        @Override
        protected void channelRead0(ChannelHandlerContext ctx, RemotingCommand msg) throws Exception {
            processMessageReceived(ctx, msg);
        }
    }

ini复制代码 SendMessageRequestHeader requestHeader = parseRequestHeader(request);

scss复制代码    public CompletableFuture<PutMessageStatus> submitFlushRequest(AppendMessageResult result, MessageExt messageExt) {
        // Synchronization flush   同步刷盘
        if (FlushDiskType.SYNC_FLUSH == this.defaultMessageStore.getMessageStoreConfig().getFlushDiskType()) {
            final GroupCommitService service = (GroupCommitService) this.flushCommitLogService;
            if (messageExt.isWaitStoreMsgOK()) { // 是否需要等待消息存储完成才返回给生产者发送成功的响应
                GroupCommitRequest request = new GroupCommitRequest(result.getWroteOffset() + result.getWroteBytes(),
                        this.defaultMessageStore.getMessageStoreConfig().getSyncFlushTimeout());
                service.putRequest(request);
                return request.future();
            } else {
                service.wakeup(); // 不需要则唤醒服务并立即返回给生产者发送成功的响应
                return CompletableFuture.completedFuture(PutMessageStatus.PUT_OK);
            }
        }
        // Asynchronous flush    异步刷盘
        else {
            // 判断是否启动堆外内存 transientStorePoolEnable 默认是 false
            if (!this.defaultMessageStore.getMessageStoreConfig().isTransientStorePoolEnable()) {
                // 不开启时，采用 MappedByteBuffer 刷盘
                flushCommitLogService.wakeup();
            } else  {
                // 开启时，通过 FileChannel 刷盘
                commitLogService.wakeup();
            }
            return CompletableFuture.completedFuture(PutMessageStatus.PUT_OK);
        }
    }

kotlin复制代码//设置CommitLog内存中最大偏移量
this.reputMessageService.setReputFromOffset(maxPhysicalPosInLogicQueue);
//启动
this.reputMessageService.start();

javascript复制代码版本：
[root@controller ~]# cat /etc/redhat-release 
CentOS Linux release 7.0.1406 (Core) 

镜像：
CentOS-7.0-1406-x86_64-Everything.iso

javascript复制代码systemctl stop firewalld && systemctl disable firewalld && setenforce 0 && sed -i 's/=enforcing/=disabled/g' /etc/selinux/config && systemctl stop NetworkManager && systemctl disable NetworkManager

javascript复制代码hostnamectl set-hostname xx.xx.xx

javascript复制代码cd /etc/yum.repos.d/ && mkdir back && mv * back 
vi ftp.repo
[base]
name=base
baseurl=ftp://a:a@192.168.222.240/7/os/x86_64/
enabled=1
gpgcheck=0

[updates]
name=updates
baseurl=ftp://a:a@192.168.222.240/7/updates/x86_64/
enabled=1
gpgcheck=0

[extras]
name=extras
baseurl=ftp://a:a@192.168.222.240/7/extras/x86_64/
enabled=1
gpgcheck=0

[epel]
name=epel
baseurl=ftp://a:a@192.168.222.240/7/epel
enabled=1
gpgcheck=0

[rdo]
name=rdo
baseurl=ftp://a:a@192.168.222.240/7/rdo
enabled=1
gpgcheck=0

yum clean all && yum makecache && yum -y install yum-plugin-priorities && yum upgrade

2、安装NTP服务进行配置
[root@controller ~]# yum install -y ntp

[root@controller ~]# vim /etc/ntp.conf 
 # Hosts on local network are less restricted.
restrict 192.168.222.0 mask 255.255.255.0 nomodify notrap

# Use public servers from the pool.ntp.org project.
# Please consider joining the pool (http://www.pool.ntp.org/join.html).
#server 0.centos.pool.ntp.org iburst
#server 1.centos.pool.ntp.org iburst
#server 2.centos.pool.ntp.org iburst
#server 3.centos.pool.ntp.org iburst
server 127.127.1.0
fudge 127.127.1.0 stratum 10

[root@controller ~]# systemctl restart ntpd
[root@controller ~]# systemctl enable ntpd
ln -s '/usr/lib/systemd/system/ntpd.service' '/etc/systemd/system/multi-user.target.wants/ntpd.service'

3、配置主机解析文件
[root@controller ~]# vim /etc/hosts
127.0.0.1   localhost localhost.localdomain localhost4 localhost4.localdomain4
::1         localhost localhost.localdomain localhost6 localhost6.localdomain6
192.168.222.5 controller.nice.com
192.168.222.6 network.nice.com
192.168.222.10 compute1.nice.com
192.168.222.20 block1.nice.com

javascript复制代码yum -y install yum-plugin-priorities && yum -y install http://dl.fedoraproject.org/pub/epel/7/x86_64/e/epel-release-7-2.noarch.rpm && yum -y install http://rdo.fedorapeople.org/openstack-juno/rdo-release-juno.rpm

python复制代码class product_img_info(Base):
    __tablename__ = 'product_param_img'  # 数据库中的表名
    id = Column(Integer, primary_key=True, autoincrement=True)
    name = Column(String(), nullable=False)
    title = Column(String())
    category_id = Column(String())
    product_id = Column(String())
    info = Column(String())
    img_path = Column(String())
    price = Column(String())
    discount_price = Column(String())
    created_at = Column(DateTime, default=datetime.now)
    updated_at = Column(DateTime, default=datetime.now)
    deleted_at = Column(DateTime, default = None)

    def __repr__(self):
        return """
            <product_img_info(id:%s, product_id:%s>
        """ % (self.id,self.product_id)

python复制代码def getHTMLText(url):
    try:
        header = {
            'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.141 Safari/537.36',
            'cookie': '' # 到浏览器复制cookie
        }
        r = requests.get(url, timeout=30, headers=header)
        r.raise_for_status()
        r.encoding = r.apparent_encoding
        # print(r.text)
        return r.text
    except:
        return ""

def parsePage(html):
    view_prices = re.findall(r'\"view_price\"\:\"[\d\.]*\"', html)
    view_fees = re.findall(r'\"view_fee\"\:\"[\d\.]*\"', html)
    raw_titles = re.findall(r'\"raw_title\"\:\".*?\"', html)
    titles = re.findall(r'\"title\"\:\".*?\"', html)
    user_ids = re.findall(r'\"user_id\"\:\"[\d\.]*\"',html)
    pic_urls = re.findall(r'\"pic_url\"\:\".*?\"',html)
    detail_urls = re.findall(r'\"detail_url\"\:\".*?\"',html)
    for view_price,view_fee,title,raw_title,user_id,pic_url,detail_url in zip(view_prices,view_fees,titles,raw_titles,user_ids,pic_urls,detail_urls):
        price=eval(view_price.split(':')[1])
        discount_price=eval(view_fee.split(':')[1])
        name=eval(title.split(':')[1])
        a4=eval(raw_title.split(':')[1])
        product_id=eval(user_id.split(':')[1])
        img_path=eval(pic_url.split(':')[1])
        persopn = product_img_info(name=name,title=name,product_id=product_id,category_id="6",info=name,img_path=img_path,price=price,discount_price=discount_price)
        session.add(persopn)  # 增加一个
        session.commit() # 提交到数据库中

# 1手机 2女装 3电脑 4杯子 5零食 6耳机

def main():
    goods = '耳机'
    depth = 1
    start_url = 'https://s.taobao.com/search?q=' + goods
    for i in range(depth):
        try:
            url = start_url + '&s=' + str(44 * i)
            html = getHTMLText(url)
            parsePage(html)
        except:
            continue

if __name__ == '__main__':
   # Base.metadata.create_all()       # 创建表需要执行这行代码，如果表存在则不创建
    #sqlOperation()
    main()

go复制代码//User 用户模型
type User struct {
	gorm.Model
	UserName       string `gorm:"unique"`
	Email          string //`gorm:"unique"`
	PasswordDigest string
	Nickname       string `gorm:"unique"`
	Status         string
	Limit          int   // 0 非管理员  1 管理员
	Type           int    // 0表示用户  1表示商家
	Avatar         string `gorm:"size:1000"`
	Monery 		   int
}

go复制代码//商品模型
type Product struct {
	gorm.Model
	ProductID     string `gorm:"primary_key"`
	Name          string
	CategoryID    int
	Title         string
	Info          string `gorm:"size:1000"`
	ImgPath       string
	Price         string
	DiscountPrice string
	OnSale 		  string
	Num 		  int
	BossID        int
	BossName      string
	BossAvatar    string
}

go复制代码func (service *UpProductService) UpProduct() serializer.Response {
	var product model.Product
	code := e.SUCCESS
	err := model.DB.First(&product,service.ID).Error
	if err != nil {
		logging.Info(err)
		code = e.ErrorDatabase
		return serializer.Response{
			Status: code,
			Msg:    e.GetMsg(code),
			Error:  err.Error(),
		}
	}
	product.OnSale = service.OnSale
	err = model.DB.Save(&product).Error
	if err != nil {
		logging.Info(err)
		code = e.ErrorDatabase
		return serializer.Response{
			Status: code,
			Msg:    e.GetMsg(code),
			Error:  err.Error(),
		}
	}
	return serializer.Response{
		Status: code,
		Data:   serializer.BuildProduct(product),
		Msg:    e.GetMsg(code),
	}
}

go复制代码//更新商品
func (service *UpdateProductService) Update() serializer.Response {
	product := model.Product{
		Name:          service.Name,
		CategoryID:    service.CategoryID,
		Title:         service.Title,
		Info:          service.Info,
		ImgPath:       service.ImgPath,
		Price:         service.Price,
		DiscountPrice: service.DiscountPrice,
		OnSale: 	   service.OnSale,
	}
	product.ID = service.ID
	code := e.SUCCESS
	err := model.DB.Save(&product).Error
	if err != nil {
		logging.Info(err)
		code = e.ErrorDatabase
		return serializer.Response{
			Status: code,
			Msg:    e.GetMsg(code),
			Error:  err.Error(),
		}
	}
	return serializer.Response{
		Status: code,
		Msg:    e.GetMsg(code),
	}
}

js复制代码import axios from 'axios'

// 创建商品
const postProduct = form =>
  	axios.post('/api/v1/products', form).then(res => res.data)

// 读商品详情
const showProduct = id =>
  	axios.get(`/api/v1/products/${id}`).then(res => res.data)

// 读取商品列表
const listProducts = (category_id, start, limit) =>
  axios
    .get('/api/v1/products', { params: { category_id, start, limit } })
    .then(res => res.data)
    
//读取商品的图片
const showPictures = id => axios.get(`/api/v1/imgs/${id}`).then(res => res.data)

//搜索商品
const searchProducts = form =>
  	axios.post('/api/v1/searches', form).then(res => res.data)

export {
  	postProduct,
  	showProduct,
  	listProducts,
  	showPictures,
  	searchProducts
}

css复制代码输入：adjacentPairs = [[2,1],[3,4],[3,2]]

输出：[1,2,3,4]

解释：数组的所有相邻元素对都在 adjacentPairs 中。
特别要注意的是，adjacentPairs[i] 只表示两个元素相邻，并不保证其 左-右 顺序。

css复制代码输入：adjacentPairs = [[4,-2],[1,4],[-3,1]]

输出：[-2,4,1,-3]

解释：数组中可能存在负数。
另一种解答是 [-3,1,4,-2] ，也会被视作正确答案。

lua复制代码输入：adjacentPairs = [[100000,-100000]]

输出：[100000,-100000]

Java复制代码class Solution {
    public int[] restoreArray(int[][] aps) {
        int m = aps.length, n = m + 1;
        Map<Integer, Integer> cnts = new HashMap<>();
        Map<Integer, List<Integer>> map = new HashMap<>();
        for (int[] ap : aps) {
            int a = ap[0], b = ap[1];
            cnts.put(a, cnts.getOrDefault(a, 0) + 1);
            cnts.put(b, cnts.getOrDefault(b, 0) + 1);
            List<Integer> alist = map.getOrDefault(a, new ArrayList<>());
            alist.add(b);
            map.put(a, alist);
            List<Integer> blist = map.getOrDefault(b, new ArrayList<>());
            blist.add(a);
            map.put(b, blist);
        }
        int start = -1;
        for (int i : cnts.keySet()) {
            if (cnts.get(i) == 1) {
                start = i;
                break;
            }
        }
        int[] ans = new int[n];
        ans[0] = start;
        ans[1] = map.get(start).get(0);
        for (int i = 2; i < n; i++) {
            int x = ans[i - 1];
            List<Integer> list = map.get(x);
            for (int j : list) {
                if (j != ans[i - 2]) ans[i] = j;
            }
        }
        return ans;
    }
}

Python复制代码class Solution:
    def restoreArray(self, adjacentPairs: List[List[int]]) -> List[int]:
        m = n = len(adjacentPairs)
        n += 1
        cnts = defaultdict(int)
        hashmap = defaultdict(list)
        for a, b in adjacentPairs:
            cnts[a] += 1
            cnts[b] += 1
            hashmap[a].append(b)
            hashmap[b].append(a)
        start = -1
        for i, v in cnts.items():
            if v == 1:
                start = i
                break
        ans = [0] * n
        ans[0] = start
        ans[1] = hashmap[start][0]
        for i in range(2, n):
            x = ans[i - 1]
            for j in hashmap[x]:
                if j != ans[i - 2]:
                    ans[i] = j
        return ans

Java复制代码class Solution {
    static int N = (int)1e6+10;
    static int[] q = new int[N];
    public int[] restoreArray(int[][] aps) {
        int m = aps.length, n = m + 1;
        Map<Integer, List<Integer>> map = new HashMap<>();
        for (int[] ap : aps) {
            int a = ap[0], b = ap[1];
            List<Integer> alist =  map.getOrDefault(a, new ArrayList<>());
            alist.add(b);
            map.put(a, alist);
            List<Integer> blist = map.getOrDefault(b, new ArrayList<>());
            blist.add(a);
            map.put(b, blist);
        }
        int l = N / 2, r = l + 1;
        int std = aps[0][0];
        List<Integer> list = map.get(std);
        q[l--] = std;
        q[r++] = list.get(0);
        if (list.size() > 1) q[l--] = list.get(1);
        while ((r - 1) - (l + 1) + 1 < n) {
            List<Integer> alist = map.get(q[l + 1]);
            int j = l;
            for (int i : alist) {
                if (i != q[l + 2]) q[j--] = i;
            }
            l = j;

            List<Integer> blist = map.get(q[r - 1]);
            j = r;
            for (int i : blist) {
                if (i != q[r - 2]) q[j++] = i;
            }
            r = j;
        }
        int[] ans = new int[n];
        for (int i = l + 1, idx = 0; idx < n; i++, idx++) {
            ans[idx] = q[i];
        }
        return ans;
    }
}

Python复制代码class Solution:
    N = 10 ** 6 + 10
    q = [0] * N

    def restoreArray(self, adjacentPairs: List[List[int]]) -> List[int]:
        m = len(adjacentPairs)
        n = m + 1
        hashmap = defaultdict(list)
        for a, b in adjacentPairs:
            hashmap[a].append(b)
            hashmap[b].append(a)
        l = self.N // 2
        r = l + 1
        std = adjacentPairs[0][0]
        lt = hashmap[std]
        self.q[l] = std
        l -= 1
        self.q[r] = lt[0]
        r += 1
        if len(lt) > 1:
            self.q[l] = lt[1]
            l -= 1
        while (r-1)-(l+1)+1<n:
            alt = hashmap[self.q[l+1]]
            j = l
            for i in alt:
                if i != self.q[l+2]:
                    self.q[j] = i
                    j -= 1
            l = j
            
            blt = hashmap[self.q[r-1]]
            j = r
            for i in blt:
                if i != self.q[r - 2]:
                    self.q[j] = i
                    j += 1
            r = j
        ans = [0] * n
        for idx in range(n):
            ans[idx] = self.q[idx+l+1]
        return ans

java复制代码@DubboService
public class DemoServiceImpl implements DemoService {
    private static final Logger logger = LoggerFactory.getLogger(DemoServiceImpl.class);

    @Override
    public String sayHello(String name) {
        logger.info("Hello " + name + ", request from consumer: " + RpcContext.getServiceContext().getRemoteAddress());
        return "Hello " + name + ", response from provider: " + RpcContext.getServiceContext().getLocalAddress();
    }

    @Override
    public CompletableFuture<String> sayHelloAsync(String name) {
        return null;
    }

}


// 核心主要是 @DubboService
// 实现接口并不是Dubbo 流程上的必需点 ,只是为了保证规范 ,  Client 端的 @Reference 如果与此接口不匹配 , 会相对抛出异常

java复制代码// ChannelEventRunnable 的注册是在调用时进行 , 首先构建了一个 NettyServerHandler 进行 Netty 服务器的创建
C- NettyServerHandler # channelActive
C- AbstractServer # connected
C- AllChannelHandler # connected : Channel 连接处理
C- ChannelEventRunnable # ChannelEventRunnable : 构造器加载 ChannelEventRunnable

// PS : 更之前通过 DubboBootstrap # exportServices 发起的 
//  经过 DubboProtocol # createServer 逻辑 
// 最终创建了 NettyServer , 这里先不深入

java复制代码// 接收到数据
- ChannelState.RECEIVED       <--->  handler.received(channel, message)
// Channel 连接
- ChannelState.CONNECTED      <--->  handler.connected(channel)
// Channel 连接失败
- ChannelState.DISCONNECTED   <--->  handler.disconnected(channel)
// Channel 发送状态
- ChannelState.SENT           <--->   handler.sent(channel, message)
// 出现异常
- ChannelState.CAUGHT         <--->  handler.caught(channel, exception)

// Step 1 : 调用 CONNECTED 建立连接
channel -> [id: 0xb761cccc, L:/192.168.181.2:20880 - R:/192.168.181.2:52575]
url : dubbo://192.168.181.2:20880/org.apache.dubbo.demo.DemoService?anyhost=true&application=dubbo-demo-annotation-provider&bind.ip=192.168.181.2&bind.port=20880&channel.readonly.sent=true&codec=dubbo&deprecated=false&dubbo=2.0.2&dynamic=true&generic=false&heartbeat=60000&interface=org.apache.dubbo.demo.DemoService&metadata-type=remote&methods=sayHello,sayHelloAsync&pid=5676&release=&side=provider&threadname=DubboServerHandler-192.168.181.2:20880&timestamp=1627140229352

// Step 2 : 接收消息
handler.received(channel, message)

JAVA复制代码// C- DecodeHandler # received : 接受消息
public void received(Channel channel, Object message) throws RemotingException {
    // Step 1 :  省略对 message 进行 decode 转换逻辑 ...
    
    // Step 2 : 调用 Handler 处理
    handler.received(channel, message);
}

channel -> NettyChannel [channel=[id: 0x665df7bf, L:/192.168.181.2:20880 - R:/192.168.181.2:61537]]
message -> Request 
[id=1, version=2.0.2, twoway=true, event=false, broken=false, data=RpcInvocation 
    [methodName=sayHello, parameterTypes=[class java.lang.String], arguments=[world], 
        attachments=
        {
            input=272, dubbo=2.0.2, path=org.apache.dubbo.demo.DemoService, version=0.0.0, 
            remote.application=dubbo-demo-annotation-consumer, 
            interface=org.apache.dubbo.demo.DemoService
        }
    ]
]

java复制代码C- HeaderExchangeHandler
    M- received : 
	- HeaderExchangeChannel.getOrAddChannel(channel)
	1- handlerEvent(channel, request)
	2- handleRequest(exchangeChannel, request)
	3- handler.received(exchangeChannel, request.getData())
	4- handleResponse(channel, (Response) message)
	5- channel.send(echo)
    

public void received(Channel channel, Object message) throws RemotingException {
	final ExchangeChannel exchangeChannel = HeaderExchangeChannel.getOrAddChannel(channel);
    // 通过具体的类型进行分别的处理 , 前面的 message 已经进行过 Decode
    // 这里分开做可以看到很明显的解耦想法
    if (message instanceof Request) {
        // handle request.
        Request request = (Request) message;
        // 针对事件或者双向标识(是否 response ,ack )进行分别处理 , 默认直接转向下层 Handler
        if (request.isEvent()) {
            handlerEvent(channel, request);
        } else {
            if (request.isTwoWay()) {
                handleRequest(exchangeChannel, request);
            } else {
                handler.received(exchangeChannel, request.getData());
            }
        }
    } else if (message instanceof Response) {
        handleResponse(channel, (Response) message);
    } else if (message instanceof String) {
        // 单纯的异常处理 ,说明什么类型都不是
        if (isClientSide(channel)) {
            Exception e = new Exception("Dubbo client can not supported string message: " + message + " in channel: " + channel + ", url: " + channel.getUrl());
            logger.error(e.getMessage(), e);
        } else {
            String echo = handler.telnet(channel, (String) message);
            if (echo != null && echo.length() > 0) {
                channel.send(echo);
            }
        }
    } else {
        handler.received(exchangeChannel, message);
    }
}

java复制代码void handleRequest(final ExchangeChannel channel, Request req) throws RemotingException {

    // 准备 Response 进行返回
   Response res = new Response(req.getId(), req.getVersion());
   if (req.isBroken()) {
        // ... 此处是出现异常 , 省略构建异常的相关逻辑
        
        // channle 返回 response
       channel.send(res);
       return;
   }
   // 从 messsage 中获取 InvokeMehod
   Object msg = req.getData();
   try {
       // 此处构建了一个 CompletableFuture , 用于发起异步处理 -> DubboProtocol
       CompletionStage<Object> future = handler.reply(channel, msg);
       future.whenComplete((appResult, t) -> {
           try {
               if (t == null) {
                   res.setStatus(Response.OK);
                   res.setResult(appResult);
               } else {
                   res.setStatus(Response.SERVICE_ERROR);
                   res.setErrorMessage(StringUtils.toString(t));
               }
               // 处理完成后直接返回 , 舒服
               channel.send(res);
           } catch (RemotingException e) {
               
           }
       });
   } catch (Throwable e) {
       res.setStatus(Response.SERVICE_ERROR);
       res.setErrorMessage(StringUtils.toString(e));
       channel.send(res);
   }
}

java复制代码C- DubboProtocol
    P- requestHandler : 注意 ,这是一个属性 , 在创建 DubboProtocol 时完成创建的
    
    
private ExchangeHandler requestHandler = new ExchangeHandlerAdapter() {

    // 这才是流程中调用的方法
    @Override
    public CompletableFuture<Object> reply(ExchangeChannel channel, Object message) throws RemotingException {

        if (!(message instanceof Invocation)) {
            throw new RemotingException(....);
        }

        // 构建代理类
        Invocation inv = (Invocation) message;
        // Step 2 : 核心逻辑 , 获取 Invoke 代理类
        Invoker<?> invoker = getInvoker(channel, inv);
        // 如果是回调，需要考虑向后兼容性
        if (Boolean.TRUE.toString().equals(inv.getObjectAttachments().get(IS_CALLBACK_SERVICE_INVOKE))) {
            String methodsStr = invoker.getUrl().getParameters().get("methods");
            boolean hasMethod = false;
            if (methodsStr == null || !methodsStr.contains(",")) {
                hasMethod = inv.getMethodName().equals(methodsStr);
            } else {
                String[] methods = methodsStr.split(",");
                for (String method : methods) {
                    if (inv.getMethodName().equals(method)) {
                        hasMethod = true;
                        break;
                    }
                }
            }
            if (!hasMethod) {
                return null;
            }
        }
        
        // 配置容器消息 : RemoteAddress
        RpcContext.getServiceContext().setRemoteAddress(channel.getRemoteAddress());
        
        // Step 3 : 注意 . 此处开始的是拦截器链 -> 2.4 Filter 体系
        // invoker : FilterChainBuilder$FilterChainNode
        Result result = invoker.invoke(inv);
        
        // 处理完成 ,Future 返回
        return result.thenApply(Function.identity());
    }


    @Override
    public void received(Channel channel, Object message) throws RemotingException {
        if (message instanceof Invocation) {
            reply((ExchangeChannel) channel, message);

        } else {
            super.received(channel, message);
        }
    }

    // 在第一步连接的时候 ,就会调用该方法 , 此时不会做 invoke 处理 
    // 但是, 我认为这里应该有定制的途径 ,后面有机会看一下
    @Override
    public void connected(Channel channel) throws RemotingException {
        invoke(channel, ON_CONNECT_KEY);
    }
    @Override
    public void disconnected(Channel channel) throws RemotingException {
        invoke(channel, ON_DISCONNECT_KEY);
    }

    private void invoke(Channel channel, String methodKey) {
        // 创建代理 ,代理不为空 ,才会继续逻辑
        Invocation invocation = createInvocation(channel, channel.getUrl(), methodKey);
        if (invocation != null) {
            try {
                received(channel, invocation);
            } catch (Throwable t) {
                logger.warn("Failed to invoke event method " + invocation.getMethodName() + "(), cause: " + t.getMessage(), t);
            }
        }
    }

    // channel.getUrl()总是绑定到一个固定的服务，并且这个服务是随机的
    private Invocation createInvocation(Channel channel, URL url, String methodKey) {
        // 此处会从 url 获取对应的属性 , 常量有 : onconnect , ondisconnect , 此时不会创建代理
        String method = url.getParameter(methodKey);
        if (method == null || method.length() == 0) {
            return null;
        }
        
        // 通过
        RpcInvocation invocation = new RpcInvocation(method, url.getParameter(INTERFACE_KEY), "", new Class<?>[0], new Object[0]);
        invocation.setAttachment(PATH_KEY, url.getPath());
        invocation.setAttachment(GROUP_KEY, url.getGroup());
        invocation.setAttachment(INTERFACE_KEY, url.getParameter(INTERFACE_KEY));
        invocation.setAttachment(VERSION_KEY, url.getVersion());
        if (url.getParameter(STUB_EVENT_KEY, false)) {
            invocation.setAttachment(STUB_EVENT_KEY, Boolean.TRUE.toString());
        }

        return invocation;
    }
};


// Step 2 : 具体的方法调用 , 该方法中解析出 ServiceKey , 并且查询出 Invoke
Invoker<?> getInvoker(Channel channel, Invocation inv) throws RemotingException {
    boolean isCallBackServiceInvoke = false;
    boolean isStubServiceInvoke = false;
    
    // Step 2-1 : 准备标识数据
    // 拿到端口 : 20880
    int port = channel.getLocalAddress().getPort();
    // 拿到需要的配置类型 : org.apache.dubbo.metadata.MetadataService
    String path = (String) inv.getObjectAttachments().get(PATH_KEY);

    // Step 2-2 : 判断它是否为客户端的回调服务
    isStubServiceInvoke = Boolean.TRUE.toString().equals(inv.getObjectAttachments().get(STUB_EVENT_KEY));
    if (isStubServiceInvoke) {
        port = channel.getRemoteAddress().getPort();
    }

    // 是否有回调代理
    isCallBackServiceInvoke = isClientSide(channel) && !isStubServiceInvoke;
    if (isCallBackServiceInvoke) {
        path += "." + inv.getObjectAttachments().get(CALLBACK_SERVICE_KEY);
        inv.getObjectAttachments().put(IS_CALLBACK_SERVICE_INVOKE, Boolean.TRUE.toString());
    }
    
    // Step 2-3 : 获取 ServiceKey
    // dubbo-demo-annotation-provider/org.apache.dubbo.metadata.MetadataService:1.0.0:20880
    String serviceKey = serviceKey(
            port,
            path,
            (String) inv.getObjectAttachments().get(VERSION_KEY),
            (String) inv.getObjectAttachments().get(GROUP_KEY)
    );
    
    // Step 2-4 : 查询对应的 DubboExporter
    DubboExporter<?> exporter = (DubboExporter<?>) exporterMap.get(serviceKey);

    if (exporter == null) {
        throw new RemotingException(....;
    }

    // Step 2-5 : 返回 invoke 类
    return exporter.getInvoker();
}

// 补充 Step 2-3 : 
protected static String serviceKey(int port, String serviceName, String serviceVersion, String serviceGroup) {
        return ProtocolUtils.serviceKey(port, serviceName, serviceVersion, serviceGroup);
}

java复制代码C- FilterChainBuilder
    
public Result invoke(Invocation invocation) throws RpcException {
    Result asyncResult;
    try {
        // filter 链的处理
        asyncResult = filter.invoke(nextNode, invocation);
    } catch (Exception e) {
       // 省略 ,主要是进行 Listerner 的监听 , 又在玩异步
        throw e;
    } finally {

    }
    return asyncResult.whenCompleteWithContext((r, t) -> {
        // 处理完成后 ,还是要通知监听器
        if (filter instanceof ListenableFilter) {
            ListenableFilter listenableFilter = ((ListenableFilter) filter);
            Filter.Listener listener = listenableFilter.listener(invocation);
            try {
                if (listener != null) {
                    if (t == null) {
                        listener.onResponse(r, originalInvoker, invocation);
                    } else {
                        listener.onError(t, originalInvoker, invocation);
                    }
                }
            } finally {
                listenableFilter.removeListener(invocation);
            }
        } else if (filter instanceof FILTER.Listener) {
            FILTER.Listener listener = (FILTER.Listener) filter;
            if (t == null) {
                listener.onResponse(r, originalInvoker, invocation);
            } else {
                listener.onError(t, originalInvoker, invocation);
            }
        }
    });
}

java复制代码C- AbstractProxyInvoker

// 反正就是各种异步和 Future , 用的已经炉火纯青了
public Result invoke(Invocation invocation) throws RpcException {
        try {
            // 调用 JavassistProxyFactory 处理方法
            Object value = doInvoke(proxy, invocation.getMethodName(), invocation.getParameterTypes(), invocation.getArguments());
            CompletableFuture<Object> future = wrapWithFuture(value);
            CompletableFuture<AppResponse> appResponseFuture = future.handle((obj, t) -> {
                AppResponse result = new AppResponse(invocation);
                //.....
                return result;
            });
            return new AsyncRpcResult(appResponseFuture, invocation);
        } catch (InvocationTargetException e) {
            return AsyncRpcResult.newDefaultAsyncResult(null, e.getTargetException(), invocation);
        } catch (Throwable e) {
            throw new RpcException(....);
        }
}

// PS : AsyncRpcResult 的作用 (有必要后面再看)
这个类表示一个未完成的RPC调用，它将保存这个调用的一些上下文信息，例如RpcContext和Invocation
因此，当调用结束并返回结果时，它可以保证恢复的所有上下文与调用任何回调之前发出调用时相同。



// C- JavassistProxyFactory : 也没啥看头了 , 基本上东西前面都准备好了 , 这里反射处理就行
public <T> Invoker<T> getInvoker(T proxy, Class<T> type, URL url) {
    // TODO Wrapper cannot handle this scenario correctly: the classname contains '$'
    final Wrapper wrapper = Wrapper.getWrapper(proxy.getClass().getName().indexOf('$') < 0 ? proxy.getClass() : type);
    return new AbstractProxyInvoker<T>(proxy, type, url) {
        @Override
        protected Object doInvoke(T proxy, String methodName,
                                  Class<?>[] parameterTypes,
                                  Object[] arguments) throws Throwable {
            return wrapper.invokeMethod(proxy, methodName, parameterTypes, arguments);
        }
    };
}

- proxy : 被代理的类
- methodName : 调用的方法
- parameterTypes : 属性类型

java复制代码public class InternalRunnable implements Runnable{
    private final Runnable runnable;

    public InternalRunnable(Runnable runnable){
        this.runnable=runnable;
    }

    /**
     * After the task execution is completed, it will call {@link InternalThreadLocal#removeAll()} to clear
     * unnecessary variables in the thread.
     */
    @Override
    public void run() {
        try{
            runnable.run();
        }finally {
            InternalThreadLocal.removeAll();
        }
    }
    
}


// 调用的路径
public class NamedInternalThreadFactory extends NamedThreadFactory {
    @Override
    public Thread newThread(Runnable runnable) {
        String name = mPrefix + mThreadNum.getAndIncrement();
        InternalThread ret = new InternalThread(mGroup, InternalRunnable.Wrap(runnable), name, 0);
        ret.setDaemon(mDaemon);
        return ret;
    }
}

java复制代码// 从 Netty 传入的参数是这样的 :
{
	"broken": false,
	"data": {
		"arguments": ["world"],
		"attachments": {
			"input": "272",
			"path": "org.apache.dubbo.demo.DemoService",
			"remote.application": "dubbo-demo-annotation-consumer",
			"dubbo": "2.0.2",
			"interface": "org.apache.dubbo.demo.DemoService",
			"version": "0.0.0"
		},
		"methodName": "sayHello",
		"objectAttachments": {
			"input": "272",
			"dubbo": "2.0.2",
			"path": "org.apache.dubbo.demo.DemoService",
			"version": "0.0.0",
			"remote.application": "dubbo-demo-annotation-consumer",
			"interface": "org.apache.dubbo.demo.DemoService"
		},
		"parameterTypesDesc": "Ljava/lang/String;",
		"targetServiceUniqueName": "org.apache.dubbo.demo.DemoService:0.0.0"
	},
	"event": false,
	"heartbeat": false,
	"id": 1,
	"twoWay": true,
	"version": "2.0.2"
}

// 这里可以看到 , 从Netty 传入的参数中就已经携带了方法信息 , 也就是说方法信息是 Client 端发送的 , 
// 注意 , 这个 methodName 并不是后置校验 , 在项目初始化的时候 , 就进行了校验 , 这个位置以后细说 , 只跟到最后校验的地方

C- ReferenceConfig
protected synchronized void init() {
    // 前置流程省略 : DubboBootstrap 初始化和配置初始胡啊
    
    // 校验 Invoke 
    checkInvokerAvailable();
}



// Step 2 ：检验是否正确
private void checkInvokerAvailable() throws IllegalStateException {
	if (shouldCheck() && !invoker.isAvailable()) {
		invoker.destroy();
	throw new IllegalStateException("Failed to check the status of the service "......);
	}
}

java复制代码/**
 *
 * @AUTHOR ZRH
 * @DATE 2021/4/10
 */
@Component
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface RpcService {

    /**
     * 远程服务名称
     */
    String service();

    /**
     * 端口
     */
    String port();
}

java复制代码/**
 *
 * @AUTHOR ZRH
 * @DATE 2021/4/10
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Post {

    /**
     * 接口路由
     *
     * @return
     */
    String value();
}

/**
 *
 * @AUTHOR ZRH
 * @DATE 2021/4/10
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Get {

    /**
     * 接口路由
     *
     * @return
     */
    String value();
}

java复制代码/**
 * @AUTHOR ZRH
 * @DATE 2021/4/10
 */
@Slf4j
@Aspect
@Component
public class AopRpcHandler {

    private final static String HTTP = "http://";

    @Around(value = "@annotation(post)")
    public String aopPost(JoinPoint joinPoint, Post post) {
        String result = null;
        String url = null;
        try {
            RpcService rpcService = (RpcService) joinPoint.getSignature().getDeclaringType().getAnnotation(RpcService.class);
            url = HTTP + rpcService.service() + ":" + rpcService.port() + "/" + post.value();
            Object[] args = joinPoint.getArgs();
            result = OkHttpUtils.post(url, JSON.toJSONString(args[0]));
        } catch (Throwable throwable) {
            log.error("服务调用异常，url = [{}]", url);
        }
        return result;
    }

    @Around(value = "@annotation(get)")
    public String aopGet(JoinPoint joinPoint, Get get) {
        String result = null;
        String url = null;
        try {
            RpcService rpcService = (RpcService) joinPoint.getSignature().getDeclaringType().getAnnotation(RpcService.class);
            url = HTTP + rpcService.service() + ":" + rpcService.port() + "/" + get.value();

            MethodSignature signature = (MethodSignature) joinPoint.getSignature();
            Parameter[] parameters = signature.getMethod().getParameters();
            if (parameters != null && parameters.length > 0) {
                Object[] args = joinPoint.getArgs();
                int length = parameters.length;
                url += "?";
                for (int i = 0; i < length; i++) {
                    url += parameters[i] + "=" + args[i];
                    if (i != length - 1) {
                        url += "&";
                    }
                }
            }
            result = OkHttpUtils.get(url);
        } catch (Throwable throwable) {
            log.error("服务调用异常，url = [{}]", url);
        }
        return result;
    }
}

java复制代码/**
 * @AUTHOR ZRH
 * @DATE 2021/4/10 0010 1:06
 */
@RpcService(service = "demo-order", port = "18002")
public class AopRpcDemo {

    @Post("post")
    public String post(String param) {
        return "1";
    }
}

sql复制代码/**
 * @AUTHOR ZRH
 * @DATE 2021/4/10 0010 0:42
 */
@RestController
public class DemoController {

    @Autowired
    private AopRpcDemo aopRpcDemo;

    @PostMapping("post")
    public String post() {
        String post = aopRpcDemo.post("zrh.post");
        System.out.println("调用远程接口方法返回结= " + post);
        return "ok";
    }
}

java复制代码        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
            <version>3.0.2</version>
        </dependency>

java复制代码/**
 * @AUTHOR ZRH
 * @DATE 2021/4/10 0010 1:15
 */
@FeignClient(name = "demo-user", url = "demo-user:18001")
public interface UserFeign {

    @PostMapping("hello")
    String hello(@RequestBody String param);
}

sh复制代码sudo wget -O /etc/yum.repos.d/jenkins.repo https://pkg.jenkins.io/redhat-stable/jenkins.repo
sudo rpm --import https://pkg.jenkins.io/redhat-stable/jenkins.io.key

# 安装
yum install jenkins -y

# 启动
systemctl daemon-reoload
systemctl start jenkins
# 查看状态，如果没有问题的话，状态应该是running
systemctl status jenkins

sh复制代码# 修改jenkins的配置文件中的java的路径
vim /etc/init.d/jenkins

sh复制代码ssh-keygen -t rsa -C "xxx@xxx.com"
生成公钥和私钥
cat ~/.ssh/id_rsa.pub    # 写入到github的settings => SSH and GPG keys
cat ~/.ssh/id_rsa        # 写入到jenkins的配置中

sh复制代码#!/bin/bash
VENV_DIR=/usr/local/src/jenkins
JENKINS_PROJECT_DIR=/var/lib/jenkins/workspace/jenkinsdemo
# 构建环境中的脚本命令
echo "Congratulations! Build Success!"
# 先判断一下进程是否在，在的话就不用管了，不在的话需要执行激活操作
PROCESS_EXIST=`netstat -anp | grep 8899 | grep -v "grep" | awk '{print $7///}'`
# 如果长度为0的话此时需要激活环境，否则直接跳过
if [ -z $PROCESS_EXIST ]
then
	# 进入到venv环境中需要激活环境
	source $VENV_DIR/bin/activate
	# 进入到具体的代码的workspace空间中
	cd $JENKINS_PROJECT_DIR
	# 启动当前项目
	python manage.py runserver 0.0.0.0:8899 &
	echo -ne "\n"
	sleep 3
	# 将环境注销
	# deactivate
	# 提示启动成功
	echo "the project run success"
fi
echo "The project reload success"

java复制代码@SpringBootApplication
@MapperScan("com.bobo.mapper")
public class SpringBootVipDemoApplication {
    public static void main(String[] args) {
        // 基于配置文件的方式
        ApplicationContext ac1 = new ClassPathXmlApplicationContext("");
        // 基于Java配置类的方式
        ApplicationContext ac2 = new AnnotationConfigApplicationContext(SpringBootVipDemoApplication.class);
		// run 方法的返回对象是 ConfigurableApplicationContext 对象
        ConfigurableApplicationContext ac3 = SpringApplication.run(SpringBootVipDemoApplication.class, args);
    }
}

java复制代码@SpringBootApplication
@MapperScan("com.bobo.mapper")
public class SpringBootVipDemoApplication {

    public static void main(String[] args) {
        // 基于配置文件的方式
        ApplicationContext ac1 = new ClassPathXmlApplicationContext("");
        // 基于Java配置类的方式
        ApplicationContext ac2 = new AnnotationConfigApplicationContext(SpringBootVipDemoApplication.class);
        // run 方法执行完成后返回的是一个 ApplicationContext 对象
        // 到这儿我们是不是可以猜测 run 方法的执行 其实就是Spring的初始化操作[IoC]
        ApplicationContext ac3 = SpringApplication.run(SpringBootVipDemoApplication.class, args);
    }

}

less复制代码@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(
    excludeFilters = {@Filter(
    type = FilterType.CUSTOM,
    classes = {TypeExcludeFilter.class}
), @Filter(
    type = FilterType.CUSTOM,
    classes = {AutoConfigurationExcludeFilter.class}
)}
)

less复制代码@Target({ElementType.TYPE}) // 表明 修饰的注解的位置 TYPE 表示只能修饰类
@Retention(RetentionPolicy.RUNTIME) // 表明注解的作用域
@Documented // API 文档抽取的时候会将该注解 抽取到API文档中
@Inherited  // 表示注解的继承

less复制代码@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
// 上面是3个元注解
// @Configuration 注解修饰的Java类是一个配置类
@Configuration
// @Indexed
@Indexed
public @interface SpringBootConfiguration {
    @AliasFor(
        annotation = Configuration.class
    )
    boolean proxyBeanMethods() default true;
}

less复制代码@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import({AutoConfigurationImportSelector.class})
public @interface EnableAutoConfiguration {
    String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";

    Class<?>[] exclude() default {};

    String[] excludeName() default {};
}

kotlin复制代码    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        if (!this.isEnabled(annotationMetadata)) {
            return NO_IMPORTS;
        } else {
            AutoConfigurationImportSelector.AutoConfigurationEntry autoConfigurationEntry = this.getAutoConfigurationEntry(annotationMetadata);
            // 返回的就是需要注册到IoC容器中的对象对应的类型的全类路径名称的字符串数组
            // ["com.bobo.pojo.User","com.bobo.pojo.Person", ....]
            return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
        }
    }

kotlin复制代码    protected AutoConfigurationImportSelector.AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
        if (!this.isEnabled(annotationMetadata)) {
            return EMPTY_ENTRY;
        } else {
            // 获取注解的属性信息
            AnnotationAttributes attributes = this.getAttributes(annotationMetadata);
            // 获取候选配置信息 加载的是 当前项目的classpath目录下的 所有的 spring.factories 文件中的 key 为
            // org.springframework.boot.autoconfigure.EnableAutoConfiguration 的信息
            List<String> configurations = this.getCandidateConfigurations(annotationMetadata, attributes);
            configurations = this.removeDuplicates(configurations);
            Set<String> exclusions = this.getExclusions(annotationMetadata, attributes);
            this.checkExcludedClasses(configurations, exclusions);
            configurations.removeAll(exclusions);
            configurations = this.getConfigurationClassFilter().filter(configurations);
            this.fireAutoConfigurationImportEvents(configurations, exclusions);
            return new AutoConfigurationImportSelector.AutoConfigurationEntry(configurations, exclusions);
        }
    }

kotlin复制代码    protected AutoConfigurationImportSelector.AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
        if (!this.isEnabled(annotationMetadata)) {
            return EMPTY_ENTRY;
        } else {
            AnnotationAttributes attributes = this.getAttributes(annotationMetadata);
            List<String> configurations = this.getCandidateConfigurations(annotationMetadata, attributes);
            // 因为会加载多个 spring.factories 文件，那么就有可能存在同名的，
            // removeDuplicates方法的作用是 移除同名的
            configurations = this.removeDuplicates(configurations);
            // 获取我们配置的 exclude 信息
            // @SpringBootApplication(exclude = {RabbitAutoConfiguration.class})
            // 显示的指定不要加载那个配置类
            Set<String> exclusions = this.getExclusions(annotationMetadata, attributes);
            this.checkExcludedClasses(configurations, exclusions);
            configurations.removeAll(exclusions);
            // filter的作用是 过滤掉咱们不需要使用的配置类。
            configurations = this.getConfigurationClassFilter().filter(configurations);
            this.fireAutoConfigurationImportEvents(configurations, exclusions);
            return new AutoConfigurationImportSelector.AutoConfigurationEntry(configurations, exclusions);
        }
    }

java复制代码//1、通过redisTemplate设置值
redisTemplate.boundValueOps("StringKey").set("StringValue");
redisTemplate.boundValueOps("StringKey").set("StringValue",1, TimeUnit.MINUTES);
//2、通过BoundValueOperations设置值
BoundValueOperations stringKey = redisTemplate.boundValueOps("StringKey");
stringKey.set("StringVaule");
stringKey.set("StringValue",1, TimeUnit.MINUTES);
//3、通过ValueOperations设置值
ValueOperations ops = redisTemplate.opsForValue();
ops.set("StringKey", "StringVaule");
ops.set("StringValue","StringVaule",1, TimeUnit.MINUTES);

java复制代码//1、通过redisTemplate获取值
String str1 = (String) redisTemplate.boundValueOps("StringKey").get();
//2、通过BoundValueOperations获取值
BoundValueOperations stringKey = redisTemplate.boundValueOps("StringKey");
String str2 = (String) stringKey.get();
//3、通过ValueOperations获取值
ValueOperations ops = redisTemplate.opsForValue();
String str3 = (String) ops.get("StringKey");

java复制代码//删除key
redisTemplate.delete(keys);
//指定key的失效时间
redisTemplate.expire(key,time,TimeUnit.MINUTES);
//根据key获取过期时间
Long expire = redisTemplate.getExpire(key);
//判断key是否存在
redisTemplate.hasKey(key);
//顺序递增
redisTemplate.boundValueOps("StringKey").increment(3L);
//顺序递减
redisTemplate.boundValueOps("StringKey").increment(-3L);

java复制代码//1、通过redisTemplate设置值
redisTemplate.boundHashOps("HashKey").put("SmallKey", "HashVaue");
//2、通过BoundValueOperations设置值
BoundHashOperations hashKey = redisTemplate.boundHashOps("HashKey");
hashKey.put("SmallKey", "HashVaue");
//3、通过ValueOperations设置值
HashOperations hashOps = redisTemplate.opsForHash();
hashOps.put("HashKey", "SmallKey", "HashVaue");

java复制代码redisTemplate.boundValueOps("HashKey").expire(1,TimeUnit.MINUTES);
redisTemplate.expire("HashKey",1,TimeUnit.MINUTES);

java复制代码HashMap<String, String> hashMap = new HashMap<>();
redisTemplate.boundHashOps("HashKey").putAll(hashMap);

java复制代码//1、通过redisTemplate获取值
Set keys1 = redisTemplate.boundHashOps("HashKey").keys();
//2、通过BoundValueOperations获取值
BoundHashOperations hashKey = redisTemplate.boundHashOps("HashKey");
Set keys2 = hashKey.keys();
//3、通过ValueOperations获取值
HashOperations hashOps = redisTemplate.opsForHash();
Set keys3 = hashOps.keys("HashKey");

java复制代码//1、通过redisTemplate获取值
List values1 = redisTemplate.boundHashOps("HashKey").values();
//2、通过BoundValueOperations获取值
BoundHashOperations hashKey = redisTemplate.boundHashOps("HashKey");
List values2 = hashKey.values();
//3、通过ValueOperations获取值
HashOperations hashOps = redisTemplate.opsForHash();
List values3 = hashOps.values("HashKey");

java复制代码//1、通过redisTemplate获取
String value1 = (String) redisTemplate.boundHashOps("HashKey").get("SmallKey");
//2、通过BoundValueOperations获取值
BoundHashOperations hashKey = redisTemplate.boundHashOps("HashKey");
String value2 = (String) hashKey.get("SmallKey");
//3、通过ValueOperations获取值
HashOperations hashOps = redisTemplate.opsForHash();
String value3 = (String) hashOps.get("HashKey", "SmallKey");

java复制代码//1、通过redisTemplate获取
Map entries = redisTemplate.boundHashOps("HashKey").entries();
//2、通过BoundValueOperations获取值
BoundHashOperations hashKey = redisTemplate.boundHashOps("HashKey");
Map entries1 = hashKey.entries();
//3、通过ValueOperations获取值
HashOperations hashOps = redisTemplate.opsForHash();
Map entries2 = hashOps.entries("HashKey");

java复制代码//删除小key
redisTemplate.boundHashOps("HashKey").delete("SmallKey");
//删除大key
redisTemplate.delete("HashKey");

java复制代码Boolean isEmpty = redisTemplate.boundHashOps("HashKey").hasKey("SmallKey");

java复制代码//1、通过redisTemplate设置值
redisTemplate.boundSetOps("setKey").add("setValue1", "setValue2", "setValue3");

//2、通过BoundValueOperations设置值
BoundSetOperations setKey = redisTemplate.boundSetOps("setKey");
setKey.add("setValue1", "setValue2", "setValue3");

//3、通过ValueOperations设置值
SetOperations setOps = redisTemplate.opsForSet();
setOps.add("setKey", "SetValue1", "setValue2", "setValue3");

java复制代码redisTemplate.boundValueOps("setKey").expire(1,TimeUnit.MINUTES);
redisTemplate.expire("setKey",1,TimeUnit.MINUTES);

java复制代码//1、通过redisTemplate获取值
Set set1 = redisTemplate.boundSetOps("setKey").members();

//2、通过BoundValueOperations获取值
BoundSetOperations setKey = redisTemplate.boundSetOps("setKey");
Set set2 = setKey.members();

//3、通过ValueOperations获取值
SetOperations setOps = redisTemplate.opsForSet();
Set set3 = setOps.members("setKey");

java复制代码Boolean isEmpty = redisTemplate.boundSetOps("setKey").isMember("setValue2");

java复制代码Long size = redisTemplate.boundSetOps("setKey").size();

java复制代码Long result1 = redisTemplate.boundSetOps("setKey").remove("setValue1");

java复制代码Boolean result2 = redisTemplate.delete("setKey");

java复制代码//1、通过redisTemplate设置值
redisTemplate.boundListOps("listKey").leftPush("listLeftValue1");
redisTemplate.boundListOps("listKey").rightPush("listRightValue2");

//2、通过BoundValueOperations设置值
BoundListOperations listKey = redisTemplate.boundListOps("listKey");
listKey.leftPush("listLeftValue3");
listKey.rightPush("listRightValue4");

//3、通过ValueOperations设置值
ListOperations opsList = redisTemplate.opsForList();
opsList.leftPush("listKey", "listLeftValue5");
opsList.rightPush("listKey", "listRightValue6");

java复制代码ArrayList<String> list = new ArrayList<>();
redisTemplate.boundListOps("listKey").rightPushAll(list);
redisTemplate.boundListOps("listKey").leftPushAll(list);

java复制代码redisTemplate.boundValueOps("listKey").expire(1,TimeUnit.MINUTES);
redisTemplate.expire("listKey",1,TimeUnit.MINUTES);

java复制代码List listKey1 = redisTemplate.boundListOps("listKey").range(0, 10);

java复制代码String listKey2 = (String) redisTemplate.boundListOps("listKey").leftPop();  //从左侧弹出一个元素
String listKey3 = (String) redisTemplate.boundListOps("listKey").rightPop(); //从右侧弹出一个元素

java复制代码String listKey4 = (String) redisTemplate.boundListOps("listKey").index(1);

java复制代码Long size = redisTemplate.boundListOps("listKey").size();

java复制代码redisTemplate.boundListOps("listKey").set(3L,"listLeftValue3");

java复制代码redisTemplate.boundListOps("listKey").remove(3L,"value");

java复制代码//1、通过redisTemplate设置值
redisTemplate.boundZSetOps("zSetKey").add("zSetVaule", 100D);

//2、通过BoundValueOperations设置值
BoundZSetOperations zSetKey = redisTemplate.boundZSetOps("zSetKey");
zSetKey.add("zSetVaule", 100D);

//3、通过ValueOperations设置值
ZSetOperations zSetOps = redisTemplate.opsForZSet();
zSetOps.add("zSetKey", "zSetVaule", 100D);
12345678910

java复制代码DefaultTypedTuple<String> p1 = new DefaultTypedTuple<>("zSetVaule1", 2.1D);
DefaultTypedTuple<String> p2 = new DefaultTypedTuple<>("zSetVaule2", 3.3D);
redisTemplate.boundZSetOps("zSetKey").add(new HashSet<>(Arrays.asList(p1,p2)));

java复制代码Set<String> range = redisTemplate.boundZSetOps("zSetKey").range(key, 0, -1);

java复制代码Double score = redisTemplate.boundZSetOps("zSetKey").score("zSetVaule");

java复制代码Long size = redisTemplate.boundZSetOps("zSetKey").size();

java复制代码Long COUNT = redisTemplate.boundZSetOps("zSetKey").count(0D, 2.2D);

java复制代码Set byScore = redisTemplate.boundZSetOps("zSetKey").rangeByScore(0D, 2.2D);

java复制代码Set<String> ranking2 = redisTemplate.opsForZSet().rangeByScore("zSetKey", 0D, 2.2D 1, 3);

java复制代码Set<TypedTuple<String>> tuples = redisTemplate.boundZSetOps("zSetKey").rangeWithScores(0L, 3L);
  for (TypedTuple<String> tuple : tuples) {
      System.out.println(tuple.getValue() + " : " + tuple.getScore());
  }ss

java复制代码//从小到大
Long startRank = redisTemplate.boundZSetOps("zSetKey").rank("zSetVaule");
//从大到小
Long endRank = redisTemplate.boundZSetOps("zSetKey").reverseRank("zSetVaule");
1234

java复制代码redisTemplate.boundZSetOps("zSetKey").remove("zSetVaule");

java复制代码redisTemplate.boundZSetOps("zSetKey").removeRange(0L,3L);

java复制代码redisTemplate.boundZSetOps("zSetKey").removeRangeByScorssse(0D,2.2D);