写给Java程序员的Solidity合约快速入门

前段时间有个项目要用到智能合约，合约的载体是类以太的某链，采用Solidity作为语言，因为疫情原因拉了公司一个Java来写，于是有了这篇Solidity快速入门。

我首先要说的是Java开发写solidity合约是基本可行的，大体思路和解决方案都类似，甚至我认为比通常的Java开发还要简单一些。当然公链开发要再学习一些优化技巧，这些我们就不在这里聊了。

准备工作

要做Solidity开发，首先要有一个趁手的工具，REMIX 是Ethernum官方一直推荐的IDE，用起来很方便，建议通过这个入手。

我让我的JAVA开发首先做的事情是通过这个IDE编写一个简单的加法合约，也就是实现输入a，b，输出出a+b的简单合约。

通过这个合约，我们要达到了解以下语法结构的目的：

1. 基本的语法逻辑
2. 基础的工具用法

那通过这个过程，JAVA开发会很容易发现，整体Solidity和Java的语法很类似：

1. 一个合约就是一个类，只是类的关键字改成了contract
2. 合约中可以定义类变量和函数。函数采用function开头，returns放到最后，可以返回多个变量，是否是public函数，声明放到returns之前

类似产出这样：

pragma solidity ^0.4.13;

contract XxxContract {
    
    function func1(int256 a, int256 b) public returns (int256) {
        return a+b;
    }

}
1
2
3
4
5
6
7
8
9

其中第一行是编译版本声明，而语法部分就很类似了。

而关于工具使用，据反馈，主要参考了以下的两篇文章，这里就不多讲了。

Remix的使用
Solidity教程一

其中第二篇文章是solidity的语法说明。

开始正式的合约编写

我们的Java开发做完这步就被我拉去上场了……，在这段时间里，他达到了以下的目标：

• 完成了简单a+b合约的书写
• 知道了Remix里如何编译，如何测试
• 熟悉了基础语法结构

那上面的简易合约要变成一个正式的可以使用的合约，我们还需要三个步骤：

学会存储变量

首先我们开始将a+b合约逻辑升级成为：

• 提供一个setA函数存储a
• 提供一个setB函数存储b
• 提供一个无入参的getAplusB函数用于获得a+b的结果

这里面，重要的事情是，a和b要以变量的形式存储起来。

其实改起来很简单了，大概是这个样子：

pragma solidity ^0.8.7;

contract Storage {
    int256 a;
    int256 b;

    function setA(int256 num) public {
        a = num;
    }

    function setB(int256 num) public {
        b = num;
    }

    function getAplusB() public returns (int256) {
        return a + b;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

那这个可能你会说和前面的也类似啊，没什么区别。

那这里面我们要给Java开发两个概念：

1. 没有其他的存储设备需要使用。
2. 合约的数据存储基本就是依靠变量了。

可能一个开发后台的小伙伴就会很疑惑这个事情，因为通常我们的数据的持久化会依靠数据库等持久化存储设备，为什么这个地方仅仅依靠变量，那这些变量又是怎么持久化的呢？

这个问题的回答说起来就不是入门的问题了，我们可以简单的理解，区块链把程序每一次执行都进行了快照，下一次执行就是通过在上一次快照的基础上进行进一步的执行，来达到存储数据的目的。

所以我们可以简单的理解

合约就是程序，合约就是存储

因此，我们可以这么理解：写合约就是类似写service层或者mapper层，通过setter和getter来达到存储数据的目的。

学会存储Map

那接下来，我们基本就理解了合约怎么存储数据，那大家可能要问，那合约是怎么做成货币的呢，里面又是怎么存储账户余额的呢？

其实就很简答了，就是通过我们经常见到的map结果，solidity里面是mapping，写法如下：

mapping(int256 => Account) accounts;
1

这里面还用到了一个自定义结构体Account，加在一起就是

    struct Account {
        bool existed;
        int256 a;
        int256 b;
    }
    //存储用户id和具体分数的关系
    mapping(int256 => Account) accounts;
1
2
3
4
5
6
7

这样一个结构就可以达到输入为int256类型用户id的所有用户存储数据的目的，那我们可以把上面的a+b合约再次升级成：支持多个用户存储独立a，b值，按用户返回a+b数据的目的，类似

pragma solidity ^0.8.7;

contract Storage {
    struct Account {
        int256 a;
        int256 b;
    }

    mapping(int256 => Account) accounts;

    function setA(int256 id, int256 num) public {
        accounts[id].a = num;
    }

    function setB(int256 id, int256 num) public {
        accounts[id].b = num;
    }

    function getAplusB(int256 id) public view returns (int256) {
        return  accounts[id].a +  accounts[id].b;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

这样，我们就基本完成了存储多个id的不同数据的目的了。

搞定业务逻辑

有了上面的基础，其实合约的书写就变得很简答，无非是根据不同的要求，修改Account的内容，比如string用于存证类应用，int用于各种的账户类应用，基本的逻辑都是通过存储和调用map中的数值达到存储和使用数据的目的。

那这个基础上，我们就可以去完成一些所谓”合约”的业务了，这些其实就是加强函数功能而已，比如把上述的简单a+b改成一些带判断逻辑的结构，比如增加一个函数，返回a+b最大的用户id等，这些就不多讲了，就是函数中的if，else，循环等逻辑的添加了。

常见的一些入门级坑

那我们的java工程师在项目中也顺利的完成了多个存证合约的书写，逻辑很清楚了，修改Account的结构达到存储和使用的目的， 那对于同样想做这件事情的Java工程师来讲，我们还要讲一些常见的坑，以避免在初步接触这个阶段遇到一些莫名奇妙的问题。

Stack too deep

这个限制经常出现在复杂函数中，比如我们希望通过一个setInfo函数将Account需要的多个变量都传进去，实际来讲，通常会遇到错误(Stack too deep, try using fewer variables)。这个坑是个跟内部编译有关系的坑,和过程中用到的变量值，出参计算涉及的变量值都有关系。

比如下面这个会报错的函数

    function setInfo(int256 id, int256 numA, int256 numB, int256 numC, int256 numD, int256 numE, int256 numF, int256 numG, string memory numH,string memory numI,string memory numJ,string memory info) public returns (int256) {
        var account = accounts[id];
        account.a = numA;
        account.b = numB;
        account.c = numC;
        account.d = numD;
        account.e = numE;
        account.f = numF;
        account.g = numG;
        account.h = numH;
        account.i = numI;
        account.info = info;
        return numA+numB+numC+numD+numE;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

可以通过减少return中涉及的变量，或者减少入参来达到目的，总数上限应该是16个。如果超出了，只能通过修改数据结构来达到目的了。（如果是存证，可以考虑干脆就要求应用上传json字符串）

map没有不包含一说

这个什么意思呢，就是map拿任意key去取值，都会取出来一个对应的值，只是如果是没有存储的，会返回默认值，没有通常语言常用的IsExists等判断是否有对应值的操作。

所以我们常常把struct中默认带一个existed变量

struct Account {
        bool existed;
        int256 a;
        int256 b;
    }
mapping(int256 => Account) accounts;

function setAccount(int256 user_id,int256 numa, int256 numb) public {
    Account memory account = accounts[user_id];
    //如果该用户并没有被创建
    if (!account .existed) {
      account = Account (true, numa,num b);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

更多语法说明

那这个时候我们还会遇到一些新的语法问题，比如storage和memory的声明，pure、views等的函数限制说明，这个根据ide提示来添加就好了。

进一步深入

当然，如果要写更好的solidity区块链应用，我们可能会需要了解更多的东西，比如日志的写法，多合约的调用，有了这些的帮助，我们才能够在合约的基础上去附加更多的比如统计操作等。

另外，针对应用开发，合理的上层架构架构开发也是很重要的部分，比如合理利用交易和查询来进行提速等，这些都是后话了。

个人觉得，做到除这一章之外的其他部分，我们就可以去写一些存证应用等区块链应用了，是不是很简单？