Conflux的存储抵押机制

背景介绍

近期有社区的小伙伴在开发智能合约并部署到Conflux网络时遇到了关于给智能合约发送交互时进行抵押一部分cfx，并在交互后返还一部分cfx的问题。

正如烤仔回答的那样，在区块链中由于需要根据调用者对智能合约空间占用的情况收取一定数量的存储押金，这笔费用通常高过实际的需要，当空间释放时，就会返回给操作者一定数量的GAS费用。

Conflux在其协议规范中专门对这一机制进行了详细的介绍（参见第28页）。

理论介绍

在Conflux中引入了Collateral for storage（简称CFS）机制，作为使用存储的定价方式，相比Ethereum中的一次性存储费用，CFS机制会更加公平合理。原则上，这种机制需要锁定一笔资金，作为占用存储空间的抵押物。在相应的存储空间被释放或被他人覆盖前，抵押物都会被锁定，而被锁定的抵押物所产生的相应利息会直接分配给矿工，用于存储空间的维护。因此，Conflux的存储成本也取决于空间占用的时间长短。

在Conflux网络中，每个存储条目占用空间是64B（B为Bytes，字节），这也是世界状态下键/值对的大小，需要说明的是在区块链中键一般为256bits长，值也是256bits长（各自都是32B长，合起来为64B长）。储存所需的押金与能够覆盖所有储存物品的64B的最小倍数成正比。对于每一个存储条目，最后向该条目写入的账户称为该存储条目的所有者。如果某存储条目是在执行合约C时所写，且有担保人提供担保，那么C被视为该条目的写者，也相应地成为所有者（详见7.1节）。在世界状态下，一个存储条目的整个生命周期内，该条目的所有者必须锁定固定数量的CFX作为占用存储空间的存储押金。具体来说，每一个大小为64B的存储条目，其主人会被锁定1/16CFX。而占用1KB空间则支付1CFX作为押金，其对应公式如下：

$$\left(\frac{1024}{64}\right)×\left(\frac{1}{16}\right)=1（CFX）$$

在账户α成为一个存储条目的所有者时（无论是创建还是修改），α应立即为该条目锁定1/16 CFX。如果α有足够的余额，那么就会自动锁定所需的押金，否则如果α没有足够的余额，操作就会失败，α无法创建或修改该条目。

当一个存储条目从世界状态中被删除时，相应的1/16 CFX押金将被解锁并返回到该条目所有者的余额中。如果一个存储条目的所有权发生变化，旧所有者的1/16 CFX押金被解锁，而新的所有者必须同时锁定1/16 CFX作为押金。

为了方便处理，Conflux中引入了函数CFS，它将一个帐户地址α和一个世界状态σ作为输入，并返回 在世界状态σ下，账户α存储的锁定押金总额。 如果世界状态σ从上下文中明确，为了简洁起见，我们用CFS(α)代替CFS(α;σ)，其公式如下：

$$CFS(α)≡CFS(α;σ)≡账户a在世界状态σ下拥有的存储条目总数×\left(\frac{1}{16}\right)（CFX）$$

特别的，对于一个由α=S(T)发送的交易T（或α=Tα如果T调用的是地址Tα处的赞助合约），令σ为T执行前后的世界状态，σ'是交易执行结束后的世界状态，针对存储限制字段Tl有一个CFS(α;σ)≤CFS(α;σ)+Tl/1018的断言。

#

关键点：想弄清楚调用合约质押的CFX有多少，一定要弄清楚合约中变量的条目数，以及在通过函数调用合约进行操作时有多少条目被修改，且改动的数目被记录到了区块链中！

Solidity内存管理机制

根据Solidity文档对于其内存管理的描述及Conflux存储押金机制，我们能够发现，合约存储需要有key和value进行维护，一般情况下：key的长度为256bits，value的长度同样为256bits，按一个智能合约的存储空间按照如下表格进行组织，其中{0,1}256表示256位比特串(比特串中只有0或1两个值)，每个key/value对就可以被理解为一个条目：

条目 键/地址({0,1}256) 值({0,1}256)
1 0...00000 0
2 0...00001 1
3 0...00002 2
... ... ...
2256 f...fffff 0

由于256bits=32bytes，两个256bits对应的长度为：
$$32+32=64（Bytes）$$

Solidity中常见变量及其对应的条目数整理

变量 长度 定义方式
普通变量 1个普通变量对应1个条目 uint public count=0;
mapping mapping的每1个key都对应于1个条目 mapping(address => uint) public balances;
array 数组每1个元素对应于1个条目，数组长arr.length是额外的1个条目 uint[5] fixedArr = [1,2,3,4,5]; string productname;
struct struct内每个field对应条目数的累加 struct Person {uint age;uint stuID;string name;}

Conflux的存储押金机制描述

在 Conflux 的网络中，存储押金的费用是每 1024 字节 1 CFX。由于每个条目占用 64 字节，因此，每个条目的押金费用就是 1/16 CFX. 每笔交易执行期间，新产生的押金费用会在交易执行结束的时统一收取。如果一个存储条目被其他人改写了，改写的人将缴纳存储押金，而原先的押金缴纳者将得到退回的押金。值得一提的是，押金退回是“悄悄”加在余额里的，并没有转账交易可供查询。

Conflux 的每笔交易中，需要填写一个存储上限（单位是字节）。该上限规定了，押金缴纳者在交易执行前后押金增量不得超过存储上限乘 1/1024 CFX. 如果这个值填写得过低，会导致执行后押金超过上限，执行失败。如果填写的过高，导致发送者余额不足以支付押金，也会导致交易失败。

部署合约

请参考链接，尝试部署和调用智能合约。

实例讲解

1. 一个含有1个普通uint变量的例子

智能合约代码如下：

pragma solidity ^0.5.0;

contract Counter {
    uint public count=0;
    event SelfEvent(address indexed sender, uint current);

    constructor() public {
    }

    function inc(uint num) public returns (uint){
        return count += num;
    }

    function self() public {
        emit SelfEvent(msg.sender, count);
    }
}

由于该智能合约中只有 uint public count=0; 一个变量，只对应于1个条目，按照之前的公式分析：
$$CFS(α)≡CFS(α;σ)≡账户a在世界状态σ下拥有的存储条目总数×\left(\frac{1}{16}\right)（CFX）$$

正是由于 uint public count=0 变量正好对应于一个64B的条目，结合所以之前我们给定的实例，真正质押的数额为：0.0625 CFX
$$\left(\frac{1}{16}\right)=0.0625（CFX）$$

下面结合对合约的实际调用进行验证：
调用合约代码的案例如下（文件名为：call_calc.js）：

const { Conflux, util } = require('js-conflux-sdk');
// 这个地址是上面打印出来的 receipt.contractCreated 
const public_address = '0x17b38613e633c2b8fb4686a3a62b9b782ac5e0ca';
const contractAddress = '0x845dd6f64bb3d2771a8f30dc85bb14f5ac26b75e';
const PRIVATE_KEY1 = '0x2772b19636f1d183a9a2a0d27da2a1d0efb97637b425********************';
const PRIVATE_KEY2 = '0x2adba218d5eacb5bc9bbb4c6fdecef7d1719c8184812********************';
const compiled = require(`./build/Counter.json`)
async function main() {
  const cfx = new Conflux({
    url: 'http://main.confluxrpc.org',
  });
  const contract = cfx.Contract({
    address : contractAddress,
    abi: compiled.abi,
  });
  
  const before_call_balance = await cfx.getBalance(public_address);
  console.log("before account1 call the current drip:"+before_call_balance.toString());
  console.log("before account1 call the current cfx:"+util.unit.fromDripToCFX(before_call_balance));
  
  let inc = await contract.inc(10);
  console.log("输出："  + inc.toString());
  
  const account1 = cfx.Account(PRIVATE_KEY1);//使用私钥创建账户
  
  // 进行记录并花费CFX
  await contract.inc(10).sendTransaction({ from: account1 }).confirmed();
  
  const after_call_balance = await cfx.getBalance(public_address);
  console.log("after account1 call inc(10) the current drip:"+after_call_balance.toString());
  console.log("after account1 call inc(10) the current cfx:"+util.unit.fromDripToCFX(after_call_balance));
    
  //创建account2，并尝试调用合约希望释放account1的cfx
  const account2 = cfx.Account(PRIVATE_KEY2);//使用私钥创建账户
  
  const before_account2_call_balance = await cfx.getBalance(public_address);
  console.log("before account2 call inc(5) the current drip:"+after_call_balance.toString());
  console.log("before account2 call inc(5) the current cfx:"+util.unit.fromDripToCFX(after_call_balance));
  await contract.inc(5).sendTransaction({ from: account2 }).confirmed();
  
  const after_account2_call_balance = await cfx.getBalance(public_address);
  console.log("after account2 call inc(10) the current drip:"+after_account2_call_balance.toString());
  console.log("after account2 call inc(10) the current cfx:"+util.unit.fromDripToCFX(after_account2_call_balance));
  
  
}
main().catch(e => console.error(e));

调用方式为：

node call_calc.js

为了方便描述，将参与调用合约的账户用account1和account2进行表示，被调用的合约用contract进行表示，将其账户信息和对应的账户地址进行汇总 ，所列表格如下：

账户名 账户地址
account1 0x17b38613e633c2b8fb4686a3a62b9b782ac5e0ca
account2 0x1941E3137aDDf02514cBFeC292710463d41e8196
countract 0x845dd6f64bb3d2771a8f30dc85bb14f5ac26b75e

为方便表示，后文使用上表中账户名指代各账户

在调用前，使用confluxscan查account1对应的CFX余额，发现余额为：1994.680912261955354268 CFX。

Conflux的存储抵押机制_第1张图片

（1）使用account1进行第一次合约调用：

Conflux的存储抵押机制_第2张图片

由于account1调用合约占用了空间，需要上交CFX作为押金

在程序启动后：首先显示account1的账户余额：1994.680912261955383167 CFX。

程序会使用account1调用contract.inc(10)向合约发起交互，调用完成后发现account1的账户余额会变为：1994.618412261955356217 CFX。

Conflux的存储抵押机制_第3张图片

也就是说经过account1与合约contract的这一次交互操作，其账户扣除了：
$$1994.680912261955383167-1994.618412261955356217=0.06250000000002695（CFX）‬$$

这说明由于调用contract.inc(10)与合约进行交互。account1上交了0.06250000000002695的CFX。

使用account2调用合约，以帮助account1释放空间

程序会继续运行，并使用account2通过调用contract.inc(5)向合约发起交互

在调用前，account1的账户余额为：1994.618412261955356217 CFX，与步骤（1）结束时account1的账户余额保持一致。

account2调用合约后，account1的CFX余额变为：1994.680912261955356217 CFX

sub_call2

也就是说，经过account2对合约的调用后，account1的账户CFX余额变动为：
$$1994.618412261955356217-1994.680912261955356217=-0.0625（CFX）‬$$

这意味着，由于account1占用的64Bytes合约空间被释放，0.0625 CFX会被退还到了account1的账户中。按照步骤（1）中计算得到的付款额：0.06250000000002695 CFX，我们能够推测，account1调用contract.inc(10)实际所消耗的费用为：
$$0.06250000000002695-0.0625=0.00000000000002695（CFX）$$

调用合约前，程序显示的account1的CFX余额为：1994.618412261955437067 CFX。

而调用合约后，对应账户的CFX余额为：1994.618412261955410117 CFX。

也就是说经过这次与合约的交互操作，账户扣除了0.00000000000002695个CFX，其计算公式如下：
$$1994.618412261955437067-1994.618412261955410117=0.00000000000002695（CFX）$$

这也间接佐证了，account1中数据存储所占用的合约空间就是1个64Bytes：
$$0.0625×16=1（个）‬$$

此时我们再去confluxscan处查看账户account1对应的余额为：1994.680912261955327318 CFX
Conflux的存储抵押机制_第4张图片
按照计算公式：
$$1994.680912261955354268-1994.680912261955327318=0.00000000000002695 (CFX)‬$$
这同时也佐证了：account1调用contract.inc(10)与合约进行交互时，其账户实际消耗了0.00000000000002695 CFX

2. 一个含有1个长度为5（且在调用时修改5个元素值）的定长数组的例子

合约代码如下：

pragma solidity ^0.5.0;

contract Test {
    uint[5] arr = [1,2,3,4,5];
    event SelfEvent(address indexed sender, uint[5] current,uint length);
    
    function init() public{
        arr[0] = 100;
        arr[1] = 200;   
    }
    
    function getArrayContent() public returns(uint[5] memory){
        return arr;
    }
  
    function getArrayLength() public returns(uint){
        return arr.length;
    }
    
    function increment (uint data) public{
        for(uint i=0;i

由于该智能合约中只有 uint [] arr = [1,2,3,4,5]; 这个长度为5的数组，数组内数据对应了5个条目，数组长度5同时也对应了1个条目，共6个条目，由于调用合约中的 increment() 函数会修改数组中的每一个元素，但没有改动数组长度，因此按照之前的公式分析：
$$CFS(α)≡CFS(α;σ)≡账户a在世界状态σ下拥有的存储条目总数×\left(\frac{1}{16}\right)（CFX）$$

正是由于 uint [] arr = [1,2,3,4,5]; 数组内元素及数组长度正好对应了6个64B长度的条目，但由于数组长度没有改变并写入区块链，结合之前我们给定的实例分析，质押的数额应当为：0.3125 CFX
$$\left(\frac{1}{16}\right)×5=0.3125（CFX）$$

调用合约的代码如下所示：

const { Conflux, util } = require('js-conflux-sdk');
// 这个地址是上面打印出来的 receipt.contractCreated 
const public_address = '0x17b38613e633c2b8fb4686a3a62b9b782ac5e0ca';
const contractAddress = '0x822ebe7eb36cdf159d6d544f6321e1a5c6619dc2';
const PRIVATE_KEY1 = '0x2772b19636f1d183a9a2a0d27da2a1d0efb97637b425*';
const PRIVATE_KEY2 = '0x2adba218d5eacb5bc9bbb4c6fdecef7d1719c8184812*';
const compiled = require(`./build/Test.json`)
async function main() {
  const cfx = new Conflux({
    url: 'http://main.confluxrpc.org',
  });
  const contract = cfx.Contract({
    address : contractAddress,
    abi: compiled.abi,
  });
  
  let inc = await contract.getGrade();
  console.log("output:"  + inc.toString());
  
  const before_call_balance = await cfx.getBalance(public_address);
  console.log("before account1 call the current drip:"+before_call_balance.toString());
  console.log("before account1 call the current cfx:"+util.unit.fromDripToCFX(before_call_balance));
  
  const account1 = cfx.Account(PRIVATE_KEY1);//使用私钥创建账户
  
  // 进行记录并花费CFX
  await contract.increment(1).sendTransaction({ from: account1 }).confirmed();
  
  const after_call_balance = await cfx.getBalance(public_address);
  console.log("after account1 call increment() the current drip:"+after_call_balance.toString());
  console.log("after account1 call increment() the current cfx:"+util.unit.fromDripToCFX(after_call_balance));
    
  //创建account2，并尝试调用合约希望释放account1的cfx
  const account2 = cfx.Account(PRIVATE_KEY2);//使用私钥创建账户
  
  const before_account2_call_balance = await cfx.getBalance(public_address);
  console.log("before account2 call increment() the current drip:"+after_call_balance.toString());
  console.log("before account2 call increment() the current cfx:"+util.unit.fromDripToCFX(after_call_balance));
  await contract.increment(2).sendTransaction({ from: account2 }).confirmed();
  
  const after_account2_call_balance = await cfx.getBalance(public_address);
  console.log("after account2 call increment() the current drip:"+after_account2_call_balance.toString());
  console.log("after account2 call increment() the current cfx:"+util.unit.fromDripToCFX(after_account2_call_balance));
}
main().catch(e => console.error(e));

为了方便描述，将参与调用合约的账户用account1和account2进行表示，被调用的合约用contract进行表示，将其账户信息和对应的账户地址进行汇总 ，所列表格如下：

账户名 账户地址
account1 0x17b38613e633c2b8fb4686a3a62b9b782ac5e0ca
account2 0x1941E3137aDDf02514cBFeC292710463d41e8196
countract 0x822ebe7eb36cdf159d6d544f6321e1a5c6619dc2

为方便表示，后文使用上表中账户名指代各账户

在调用前，使用confluxscan查account1对应的CFX余额，发现余额为：1986.673099761952452902 CFX。

Conflux的存储抵押机制_第5张图片

（1）使用account1进行第一次合约调用：

由于account1调用的increment()函数修改了合约存储的记录占用了存储空间，且修改的数据被区块链记录，所以需要上交CFX作为押金

在程序启动后：首先显示account1的账户余额：1986.673099761952481801 CFX。

程序会使用account1调用contract.increment(1)向合约发起交互，该函数会对数组中的每个元素进行加1操作，调用完成后发现account1的账户余额会变为：1986.360599761952433413 CFX。

Conflux的存储抵押机制_第6张图片

也就是说经过account1与合约contract的这一次交互操作，其账户扣除了：
$$1986.673099761952481801-1986.360599761952433413=0.312500000000048388（CFX）‬$$

这说明通过调用contract.increment(1)与合约进行交互对数据进行修改并将日志写入区块链。account1上交了0.312500000000048388的CFX。

使用account2调用合约，以帮助account1释放空间

程序会继续运行，并使用account2通过调用contract.increment(2)向合约发起交互

在调用前，account1的账户余额为：1986.360599761952433413 CFX，与上一操作结束时account1的账户余额保持一致。

account2调用合约后，account1的CFX余额变为：1986.673099761952433413 CFX

sub_call2

也就是说，经过account2对合约的调用后，account1的账户CFX余额变动为：
$$1986.360599761952433413-1986.673099761952433413=-0.3125（CFX）‬$$

这意味着，由于account1调用increment函数改动并占用的320Bytes大小的合约空间被释放，0.3125 CFX会被退还到了account1的账户中。按照步骤（1）中计算得到的付款额：0.06250000000002695 CFX，我们能够推测，account1调用contract.increment(1)实际所消耗的费用为：
$$0.312500000000048388-0.3125=0.000000000000048388（CFX）$$

程序中account1调用合约前，程序显示的account1的CFX余额为：1986.673099761952481801 CFX。

程序中account2调用合约后，account1账户的CFX余额为：1986.673099761952433413 CFX。

也就是说经过这次与合约的交互操作，account1账户扣除了0.000000000000048388个CFX，其计算公式如下：
$$1986.673099761952481801-1986.673099761952433413=0.000000000000048388（CFX）$$

此时我们再去confluxscan处查看账户account1对应的余额为：1986.673099761952404514 CFX
Conflux的存储抵押机制_第7张图片
w=559&h=159&f=png&s=23450)

按照计算公式：
$$1986.673099761952452902-1986.673099761952404514=0.000000000000048388 (CFX)‬$$
这同时也佐证了：account1调用contract.incement(1)与合约进行交互时，其账户实际消耗了0.000000000000048388 CFX

3. 一个内含 string 和 uint （且在调用时修改uint）的struct样例

合约代码如下：

pragma solidity ^0.5.0;

contract Struct_test {

    struct Animal {
        string name;
        uint age;
    }
    event SelfEvent(address indexed sender,uint current);
    event SelfEvent_string(address indexed sender,string current);
    Animal animal1 = Animal("英短",5);
    Animal animal2 = Animal("美短",5);
    
    
    function getAnimal(uint inc) public{
        animal1.age+=inc;
        animal2.age-=inc;
    }
    function get() public view returns(uint256){
        return animal1.age;
    }
    function self() public {
        emit SelfEvent(msg.sender, animal1.age);
        emit SelfEvent(msg.sender, animal2.age);
        emit SelfEvent_string(msg.sender, animal1.name);
        emit SelfEvent_string(msg.sender, animal2.name);
    }    
}

由于该智能合约中有一个包含 string name; 和 uint age; 的结构体变量 Animal ，其中string对应变长数组，对应条目数根据实际设置的内容为准，而uint对应于1个条目。在合约中调用 getAnimal() 函数会修改实例化的animal1和animal2的age变量，改动的条目数为2，因此按照之前的公式分析：
$$CFS(α)≡CFS(α;σ)≡账户a在世界状态σ下拥有的存储条目总数×\left(\frac{1}{16}\right)（CFX）$$

正是由于 animal1.age+=inc; 和 animal2.age-=inc; 调用改动了2个64B长度的条目，并将改变记录进区块链，结合之前给定的实例进行分析，质押的数额应当是改动的结构体实例元素内的age变量，正好对应了2个64B长度的条目，由于没有改动name，结合之前我们给定的实例分析，质押的数额应当为：0.125 CFX
$$\left(\frac{1}{16}\right)×2=0.125（CFX）$$

调用合约的代码如下所示：

const { Conflux, util } = require('js-conflux-sdk');
// 这个地址是上面打印出来的 receipt.contractCreated 
const public_address = '0x17b38613e633c2b8fb4686a3a62b9b782ac5e0ca';
const contractAddress = '0x84dd09cd48e07426c4ac50a389930c034be6c82a';
const PRIVATE_KEY1 = '0x2772b19636f1d183a9a2a0d27da2a1d0efb97637b425*';
const PRIVATE_KEY2 = '0x2adba218d5eacb5bc9bbb4c6fdecef7d1719c8184812*';
const compiled = require(`./build/Struct_test`)
async function main() {
  const cfx = new Conflux({
    url: 'http://main.confluxrpc.org',
  });
  const contract = cfx.Contract({
    address : contractAddress,
    abi: compiled.abi,
  });
  
  const before_call_balance = await cfx.getBalance(public_address);
  console.log("before account1 call the current drip:"+before_call_balance.toString());
  console.log("before account1 call the current cfx:"+util.unit.fromDripToCFX(before_call_balance));
  
  const account1 = cfx.Account(PRIVATE_KEY1);//使用私钥创建账户
  
  // 进行记录并花费CFX
  await contract.getAnimal(3).sendTransaction({ from: account1 }).confirmed();
  
  const after_call_balance = await cfx.getBalance(public_address);
  console.log("after account1 call getAnimal() the current drip:"+after_call_balance.toString());
  console.log("after account1 call getAnimal() the current cfx:"+util.unit.fromDripToCFX(after_call_balance));
    
  //创建account2，并尝试调用合约希望释放account1的cfx
  const account2 = cfx.Account(PRIVATE_KEY2);//使用私钥创建账户
  
  const before_account2_call_balance = await cfx.getBalance(public_address);
  console.log("before account2 call getAnimal() the current drip:"+after_call_balance.toString());
  console.log("before account2 call getAnimal() the current cfx:"+util.unit.fromDripToCFX(after_call_balance));
  await contract.getAnimal(3).sendTransaction({ from: account2 }).confirmed();
  
  const after_account2_call_balance = await cfx.getBalance(public_address);
  console.log("after account2 call getAnimal() the current drip:"+after_account2_call_balance.toString());
  console.log("after account2 call getAnimal() the current cfx:"+util.unit.fromDripToCFX(after_account2_call_balance));
}
main().catch(e => console.error(e));

为了方便描述，将参与调用合约的账户用account1和account2进行表示，被调用的合约用contract进行表示，将其账户信息和对应的账户地址进行汇总 ，所列表格如下：

账户名 账户地址
account1 0x17b38613e633c2b8fb4686a3a62b9b782ac5e0ca
account2 0x1941E3137aDDf02514cBFeC292710463d41e8196
countract 0x84dd09cd48e07426c4ac50a389930c034be6c82a

为方便表示，后文使用上表中账户名指代各账户

在调用前，使用confluxscan查account1对应的CFX余额，发现余额为：1983.472904449450987608 CFX。

Conflux的存储抵押机制_第8张图片

（1）使用account1进行第一次合约调用：

由于account1调用的getAnimal()函数修改了合约存储的记录占用了存储空间，且修改的数据被区块链记录，所以需要上交CFX作为押金

在程序启动后：首先显示account1的账户余额：1983.472904449451016507 CFX。

程序会使用account1调用contract.getAnimal(3)向合约发起交互，该函数会对animal1.age进行加3操作，对animal2.age进行减3操作，调用完成后发现account1的账户余额会变为：1983.347904449450984359 CFX。

sample3_sub_call1

也就是说经过account1与合约contract的这一次交互操作，其账户扣除了：
$$1983.472904449451016507-1983.347904449450984359=0.125000000000032148（CFX）‬$$

这说明通过调用contract.getAnimal(3)与合约进行交互对数据进行修改并将日志写入区块链。account1上交了额度为0.125000000000032148的CFX。

使用account2调用合约，以帮助account1释放空间

调用合约的程序会继续运行，并使用account2通过调用contract.getAnimal(3)向合约发起交互

在调用前，account1的账户余额为：1983.347904449450984359 CFX，与上一操作结束时account1的账户余额保持一致。

account2调用合约后，account1的CFX余额变为：1983.472904449450984359 CFX

sample3_sub_call2

也就是说，经过account2对合约的调用后，account1的账户CFX余额变动为：
$$1983.347904449450984359-1983.472904449450984359=-0.125（CFX）‬$$

这意味着，由于account1调用getAnimal()函数改动并占用的128Bytes大小的合约空间被account2对合约的调用所释放，0.125 CFX会被退还到了account1的账户中。按照步骤（1）中计算得到的付款额：0.125000000000032148 CFX，我们能够推测，account1调用contract.getAnimal(3)实际所消耗的费用为：
$$0.125000000000032148-0.125=0.000000000000032148（CFX）$$

程序中account1调用合约前，程序显示的account1的CFX余额为：1983.472904449451016507 CFX。

程序中account2调用合约后，account1账户的CFX余额为：1983.472904449450984359 CFX。

也就是说经过这次与合约的交互操作，account1账户扣除了0.000000000000032148个CFX，其计算公式如下：
$$1986.673099761952481801-1986.673099761952433413=0.000000000000032148（CFX）$$

此时我们再去confluxscan处查看账户account1对应的余额为：1983.47290444945095546 CFX

Conflux的存储抵押机制_第9张图片

按照计算公式：
$$1983.472904449450987608-1983.47290444945095546=0.000000000000032148 (CFX)‬$$
这同时也佐证了：account1调用contract.getAnimal(3)与合约进行交互时，其账户实际消耗了0.000000000000032148 CFX

4. 一个含有mapping的例子

合约代码如下：

pragma solidity ^0.5.0;

contract mapping_test {
    mapping(address => uint) public balances;
    event SelfEvent(address indexed sender,uint current);
    function update(uint newBalance) public {
        balances[msg.sender] = newBalance;
    }
    function self() public {
        emit SelfEvent(msg.sender, balances[msg.sender]);
    }    
}

这段合约中使用到了 mapping 结构，由于该智能合约中有一个包含 mapping(address => uint) balance; ，并且调用相关函数时，会更新 address 对应条目的数据，调用改动了1个64B长度的条目，并将改变记录进区块链，结合之前给定的实例进行分析，应当质押了0.0625个CFX。

调用合约代码如下：

const { Conflux, util } = require('js-conflux-sdk');
// 这个地址是上面打印出来的 receipt.contractCreated 
const public_address = '0x17b38613e633c2b8fb4686a3a62b9b782ac5e0ca';
const contractAddress = '0x8433f943dd6a4cbf13209b9e8674c08349872ce8';
const PRIVATE_KEY1 = '0x2772b19636f1d183a9a2a0d27da2a1d0efb977';
const PRIVATE_KEY2 = '0x2adba218d5eacb5bc9bbb4c6fdecef7d1719c';
const compiled = require(`./build/mapping_test`)
async function main() {
  const cfx = new Conflux({
    url: 'http://main.confluxrpc.org',
  });
  const contract = cfx.Contract({
    address : contractAddress,
    abi: compiled.abi,
  });
  
  const before_call_balance = await cfx.getBalance(public_address);
  console.log("before account1 call the current drip:"+before_call_balance.toString());
  console.log("before account1 call the current cfx:"+util.unit.fromDripToCFX(before_call_balance));
  
  const account1 = cfx.Account(PRIVATE_KEY1);//使用私钥创建账户
  
  // 进行记录并花费CFX
  await contract.update(3).sendTransaction({ from: account1 }).confirmed();
  
  const after_call_balance = await cfx.getBalance(public_address);
  console.log("after account1 call update() the current drip:"+after_call_balance.toString());
  console.log("after account1 call update() the current cfx:"+util.unit.fromDripToCFX(after_call_balance));
    
  //创建account2，并尝试调用合约希望释放account1的cfx
  const account2 = cfx.Account(PRIVATE_KEY2);//使用私钥创建账户
  
  const before_account2_call_balance = await cfx.getBalance(public_address);
  console.log("before account2 call update() the current drip:"+after_call_balance.toString());
  console.log("before account2 call update() the current cfx:"+util.unit.fromDripToCFX(after_call_balance));
  await contract.update(5).sendTransaction({ from: account2 }).confirmed();
  
  const after_account2_call_balance = await cfx.getBalance(public_address);
  console.log("after account2 call update() the current drip:"+after_account2_call_balance.toString());
  console.log("after account2 call update() the current cfx:"+util.unit.fromDripToCFX(after_account2_call_balance));
  
  
}
main().catch(e => console.error(e));

为了方便描述，将参与调用合约的账户用account1进行表示，被调用的合约用contract进行表示，将其账户信息和对应的账户地址进行汇总 ，所列表格如下：

账户名 账户地址
account1 0x17b38613e633c2b8fb4686a3a62b9b782ac5e0ca
account2 0x1941E3137aDDf02514cBFeC292710463d41e8196
countract 0x8433f943dd6a4cbf13209b9e8674c08349872ce8

为方便表示，后文使用上表中账户名指代各账户

调用时的输出情况如下所示：

Conflux的存储抵押机制_第10张图片

在程序启动后：首先显示account1的账户余额：98.955078124999570464 CFX。

程序会使用account1调用contract.update(5)向合约发起交互，该函数会对balances[msg.sender]进行设置新值的操作，调用完成后发现account1的账户余额会变为：98.892578124999543647 CFX。

也就是说经过account1与合约contract的这一次交互操作，其账户扣除了：
$$98.955078124999570464-98.892578124999543647=0.062500000000026817（CFX）‬$$

由于存储抵押的条目为1，所以质押0.0625 CFX是正确的，而调用该合约花费了0.000000000000026817 (CFX)

你可能感兴趣的:(区块链区块链开发)

  • 【加密社】Solidity 中的事件机制及其应用 加密社 闲侃区块链智能合约区块链
    加密社引言在Solidity合约开发过程中，事件（Events）是一种非常重要的机制。它们不仅能够让开发者记录智能合约的重要状态变更，还能够让外部系统（如前端应用）监听这些状态的变化。本文将详细介绍Solidity中的事件机制以及如何利用不同的手段来触发、监听和获取这些事件。事件存储的地方当我们在Solidity合约中使用emit关键字触发事件时，该事件会被记录在区块链的交易收据中。具体而言，事件
  • 在一台Ubuntu计算机上构建Hyperledger Fabric网络 落叶无声9 区块链超级账本Hyperledgerfabric区块链ubuntu构建hyperledgerfabric
    在一台Ubuntu计算机上构建HyperledgerFabric网络Hyperledgerfabric是一个开源的区块链应用程序平台，为开发基于区块链的应用程序提供了一个起点。当我们提到HyperledgerFabric网络时，我们指的是使用HyperledgerFabric的正在运行的系统。即使只使用最少数量的组件，部署Fabric网络也不是一件容易的事。Fabric社区创建了一个名为Cello
  • Go编程语言前景怎么样？参加培训好就业吗 QFdongdong
    Go语言专门针对多处理器系统应用程序的编程进行了优化，使用Go编译的程序可以媲美C或C++代码的速度，而且更加安全、支持并行进程。不仅可以开发web,可以开发底层，目前知乎就是用golang开发。区块链首选语言就是go,以-太坊，超级账本都是基于go语言，还有go语言版本的btcd.Go的目标是希望提升现有编程语言对程序库等依赖性(dependency)的管理，这些软件元素会被应用程序反复调用。由
  • 区块链～我的念 夜未央0075460
    世界上最快的速度不是光，不是电，而是我们的「念」。一念起，万水千山；一念灭，沧海桑田。念起念灭当随缘，切莫执迷。执念区块链
  • 以太坊DApp开发指南 Kirn
    DApp架构设计DApp架构.png如上图，DApp的架构我们可以简单分为以上三种类型：轻钱包模式、重钱包模式和兼容模式。轻钱包模式轻钱包模式下我们需要有一个开放HttpRPC协议的节点与钱包通信，这个节点可以是任意链上的节点。轻钱包通常会作为一个浏览器插件存在，插件在运行时会自动注入Web3框架，DApp可以通过Web3与区块链节点通信。当DApp只是单纯的获取数据时是不需要钱包介入的，但是当D
  • 【数字化供应链】数字化供应链架构、全景管理、全流程贯通方案 数字化建设方案 数字化转型数据治理主数据数据仓库供应链数字仓储智慧物流智慧仓储物流园区架构微服务数据挖掘大数据人工智能
    原文《数字化供应链架构、全景管理、全流程贯通方案》PPT格式。主要从供应链管理全景、智慧供应链建设总体目标、供应链总体业务流程、供应链总体功能架构、供应链总体技术架构、供应链全流程贯通、供应链全领域管理、供应链数据数据分析、供应链决策中台等进行建设。本文仅对主要内容进行介绍。来源网络公开渠道，旨在交流学习，如有侵权联系速删，更多参考公众号：优享智库基于先进IT技术、大数据能力、物联网应用、区块链平
  • 区块链私有链new qis_qis 区块链区块链以太坊数字货币
    {“config”:{“chainld”:666,“homesteadBlock”:0,“eip150Block”:0,“eip150Hash”:“0x0000000000000000000000000000000000000000000000000000000000000000”,“eip155Block”:0,“eip158Block”:0,“byzantiumBlock”:0,“consta
  • 区块链私有链 qis_qis 区块链区块链以太坊数字货币
    {"config":{"chainld":666,"homesteadBlock":0,"eip150Block":0,"eip150Hash":"0x0000000000000000000000000000000000000000000000000000000000000000","eip155Block":0,"eip158Block":0,"byzantiumBlock":0,"consta
  • 数字化（电子化）招标采购平台系统核心功能详细介绍 xinyuan_123456 oracle
    数智化招标采购平台覆盖全业务类型、全采购流程、全采购方式，是郑州信源公司运用“互联网+”、大数据、人工智能、区块链、物联网等新兴技术，结合供应链管理理念，以招标采购为核心，提供交易、管理、数据、服务、监管为一体的高标准采购管理平台，赋能政企用户实现采购业务全流程的电子化、数字化、智慧化。根据产品功能及应用领域，产品包括：企业数智化招采供应链平台、金融数智化招采平台、政府数智化采购平台、公共资源数智
  • 【老韭菜区块链日记】第32篇 定投是牛市最佳投机方式 铁予
    2021年2月19日星期五定投是牛市最佳投机方式牛市里，怎样才能轻松赚到钱？追涨杀跌？高抛低吸？想法很美满，现实很骨感。技术不够硬，行情不配合的情况下，追涨杀跌，高抛低吸只会让账户分分钟缩水归零。牛市里，其实不管买神马币，拿住了，都会等来自己的春天。关键在于，拿住！这个拿住，并不是说起来那么简单，当看到其他币种一天拉几十个点，自己的币不涨就算了，还在阴跌，这样的情况若是一天两天还好，若是持续了三四
  • 万字长文聊聊Web3的组成架构 Keegan小钢 web3架构区块链
    本文首发于公众号：Keegan小钢Web3发展至今，生态已然初具雏形，如果将当前阶段的Web3生态组成架构抽象出一个鸟瞰图，由下而上可划分为四个层级：区块链网络层、中间件层、应用层、访问层。下面我们来具体看看每一层级都有什么。另外，此章节会涉及到很多项目的名称，因为篇幅原因不会一一进行介绍，有兴趣的可以另外去查阅相关资料进行深入了解。区块链网络层最底层是「区块链网络层」，也是Web3的基石层，主要
  • Web3入门指南：从基础概念到实际应用 dingzd95 去中心化web3区块链人工智能智能合约
    Web3，即“去中心化的第三代互联网”，正在逐步改变我们对互联网的传统认知。从最初的静态网页（Web1.0）到互动平台和社交媒体为主的互联网（Web2.0），Web3的目标是让用户重新掌握对数据和数字资产的控制权。什么是Web3？Web3被视为互联网的下一代发展阶段，其核心是去中心化。与以往依赖中心化服务器和大公司控制的数据模式不同，Web3通过区块链技术实现了数据的分布式存储和处理。这一去中心化
  • 智能合约系统DAPP开发 I592O929783 智能合约区块链
    智能合约系统DAPP（去中心化应用）的开发是一个复杂且综合性的过程，它结合了区块链技术、智能合约编程、前端开发以及安全性等多方面的知识和技能。以下是对智能合约系统DAPP开发过程的详细概述：一、需求分析明确应用场景：首先，需要明确DAPP的应用场景，如金融、游戏、社交等。功能需求：确定DAPP需要实现的具体功能，包括数据处理、用户交互等。用户群体：了解目标用户群体的需求和习惯，以便更好地设计DAP
  • 一切皆是映射：AI的去中心化：区块链技术的融合 AI大模型应用之禅 计算科学神经计算深度学习神经网络大数据人工智能大型语言模型AIAGILLMJavaPython架构设计AgentRPA
    一切皆是映射：AI的去中心化：区块链技术的融合作者：禅与计算机程序设计艺术/ZenandtheArtofComputerProgramming关键词：AI，区块链，去中心化，智能合约，共识机制，数据安全，隐私保护，分布式账本技术，机器学习，数据隐私1.背景介绍1.1问题的由来随着人工智能（AI）技术的快速发展，其在各个领域的应用越来越广泛，从自动驾驶、智能医疗到金融服务，AI正在改变着我们的生活。
  • 比特币，跨时代的产物 宇智波士郎
    图片发自App2017，随着比特币价格大爆发，创造出了一大批财富神话。吸引无数人前往币圈，无数数字货币诞生，价格疯狂到让人失了智。区块链，比特币运行的底层机制。有人认为，区块链对人类的发展比比特币自身更为重要。有些政府甚至只要区块链，而不要比特币。但是，区块链最为重要的特性便是去中心化，比特币的奖励机制完美的解决了去中心化这个问题。所以比特币比区块链更为重要，比特币就是中本聪先生，为了反抗现代金融
  • 专访徐小平：AI已进入日常生活 没有泡沫只有彩虹 网易智能
    ▼点击上方蓝字关注网易智能为你解读AI领域大公司大事件，新观点新应用从共享单车到新零售，从人工智能到区块链，从直播答题到内容创业，移动互联网时代，每一次商业机遇的新风口周期在变得越来越短，无论对于创业者还是投资人，一上场就出现“留给选手的时间不多了”已成了常态。2018年春，网易科技联合起风了推出“Top中国投资人”深度访谈节目，将分别就当下热点方向，邀请国内顶级机构若干位资深合伙人共同探索未来一
  • LSP协议：技术创新背后的团队与愿景 BTColdman1 区块链
    随着去中心化金融（DeFi）和区块链技术的迅猛发展，创新性的项目层出不穷，LSP协议（LiquiditySlicingProtocolforNodeStaking）以其独特的技术优势和市场定位迅速成为行业焦点。在这背后，项目的成功离不开核心团队的领导与执行力，特别是CEOMichaelRey的卓越贡献。突破质押流动性瓶颈LSP协议作为全球首个专注于节点质押流动性的切片协议，其独特卖点在于实现了DP
  • 有舍社区-我有一个梦想 有舍社区
    刚才有个电商项目在某群热议，无数人帮助分析，在这个时候我把有舍社区的白皮书发出来，没有人看，真的很难受。电商项目以发币为目的，还谈梦想。有舍社区是有梦想的，如果把项目方，交易所，媒体，比作富人，普通投资者比做穷人，那么有舍社区是一个穷人的队伍。有舍社区能做什么呢？精选优质平台，为投资者提供便捷的服务。为用户提供有价值的项目，媒体，钱包等服务平台追踪行业趋势，引导区块链最前沿趋势解决用户在投资中遇到
  • 区块链之变：揭秘Web3对互联网的改变 清 晨 web3web3去中心化区块链人工智能
    传统游戏中，玩家的虚拟资产（如角色、装备）通常由游戏公司控制，玩家无法真正拥有这些资产或进行交易。而在区块链游戏中，虚拟资产通过去中心化技术记录在区块链上，玩家对其拥有完全的所有权，并能够自由交易或转移。Web3的去中心化特点为区块链游戏带来了更高的透明性和公平性。智能合约自动执行游戏规则，确保所有玩家在相同条件下进行游戏，并消除了作弊和规则篡改的风险。这种透明性不仅增强了玩家的信任，也为开发者提
  • 【加密社】深入理解TON智能合约 (FunC语法) 加密社 闲侃Nethereum教程区块链智能合约
    king:摘要：在TON（TheOpenNetwork）区块链平台中，智能合约扮演着举足轻重的角色。本文将通过分析一段TON智能合约代码带领读者学习dict（字典）和list（列表）在FunC语言中的用法，以及如何在实际场景中实现高效的验证者选举。一、引言TON区块链平台的智能合约采用FunC语法一、引言TON区块链平台的智能合约采用FunC语言编写，该语言提供了丰富的数据结构，如dict和lis
  • 区块链如何大规模落地？ 西门锤靴
    区块链要实现大规模的落地应用，有三个前提，一是技术本身的进步，二是要有保护商业安全和利益的机制，三是要能够服务于实体经济。以下针对这三点分别来阐述。技术本身，区块链在过去几年的发展很迅速，但从技术革命的角度来看，现在还是处于很早期的阶段：1）首当其冲的是性能问题，即使是EOS，号称能做到百万TPS，但还是有待时间验证。区块链作为一个去中心化技术，自然也受到类似于分布式系统的CAP定律的制约。CAP
  • 《图说区块链》（一） 馨思遇
    未来五年最有前景的行业之一。掌掌握它你讲无往而不胜失去它，你将错失金融业的未来。取区块链如瑞士仪表般精密，如互联网般，惊世骇俗，他在以神一般的节奏颠覆社会，当新兴技术来临时。作作者徐明星okcoian必行okimk。创始人兼ceo。全球区块链商业理事会中国分中心副主席，中国区块链应用研究中心创始理事兼理事长，曾担任豆丁网，CTO和雅虎开发工程师。七区块链能实现价值转移，是超越信息的第二代互联网区块
  • Golang学习路线图及go-starter.md knight11112 golang开发语言后端
    Golang学习路线图及go-starter.md背景为什么要学习golang最早接触golang是因为对区块链感兴趣，因为golang的并发和内置的网络库还有大公司的支持，先天比较适合区块链，很多著名的框架都是golang写，比如geth再后来，到新加坡Shopee工作，技术栈从Java切换成了golang，更要好好学习golang的语言特性了如下是之前列的一个学习路线图1.数据类型（含stru
  • Meta Force原力元宇宙区块链驱动的财富新引擎 口碑信息传播者
    在数字化浪潮席卷全球的今天，区块链技术以其去中心化、透明性和不可篡改的特性，正逐渐改变着传统行业的运营模式。其中，MetaForce2.0原力元宇宙作为区块链技术应用的佼佼者，以其独特的矩阵玩法和智能合约机制，成为了市场竞争的新宠。本文将详细解析MetaForce2.0原力元宇宙的运作机制，以及它如何为参与者带来丰厚的收益。13分钟视频内容讲明白原力元宇宙创富项目，中国区运营服务对接微信：Forc
  • 跨界创新，走向财富成功：原力元宇宙项目助你实现 口碑信息传播者
    在这个数字化时代，随着技术的不断进步和创新，我们正处于一个前所未有的机遇时刻。原力元宇宙项目，作为一项跨界创新的先驱，为您提供了实现财富成功的独特机会。本文将为您详细介绍原力元宇宙项目的特点和优势，以及如何利用它来实现财富增长和个人成功。13分钟视频内容讲明白原力元宇宙创富项目，中国区运营服务对接微信：ForceZen背景介绍原力元宇宙项目是一项基于区块链和虚拟现实技术的创新项目。它将现实世界与虚
  • 区块链的可伸缩性以及面临的挑战 Mindfulness code 区块链开发区块链
    1.可伸缩性在过去的几年中，可伸缩性（Scalability,也称为可扩展性)问题一直是激烈辩论、严格研究和媒体关注的焦点。这是一个至关重要的问题，因为它可能意味着区块链不适于广泛应用，而仅限于联盟许可的私有网络。在经过对该领域的大量研究之后，人们提出了许多解决方案，下面将详细介绍这些解决方案。从理论上讲，解决可伸缩性问题的一般方法通常围绕协议级别的强化。例如，通常提到的比特比可伸缩性解决方案是增
  • 区块链当前发展和未来展望 Mindfulness code 区块链开发区块链
    1.区块链技术发展的新兴趋势由于学术界和商业界对区块链技术的浓厚兴趣，该技术正处于快速变化和蓬勃发展状态中。随着区块链技术的日益成熟，出现了一些新兴趋势。例如，在金融领域出现了区块链的特定用例，引起了人们的较大关注。此外，企业区块链也演变成一个新趋势，旨在开发满足企业级效率、安全性和集成要求的区块链解决方案。1.1专用区块链目前出现了一种专用区块链（Application-SpecificBloc
  • 读《区块链从数字货币到信用社会》——数字货币17 读书游轮
    第五章区块链怎么玩一、数字货币(一)总量恒定型：比特币发行依照收敛曲线这些特性来看，比特币类似黄金。黄金总量有限、开采需要一定成本。然而，比特币可以跨地域转移、几乎可无限分割、可编程、易保管等特性完胜黄金这种几千年来人类世界共通的价值存储手段。（二）锚定型：比特股（三）政府发行型：中央数字货币
  • 元宇宙的重要底层技术 区块链董叔
    在元宇宙中，人们可以通过数字分身、化身（可理解为虚拟化身）、社交媒体化身和智能代理进行交互，这背后都需要底层技术支持。元宇宙的底层技术主要包括：VR/AR、5G/6G、区块链和人工智能。VR/AR是元宇宙的主要交互设备，它将人的视觉、听觉、触觉等感官直接映射到虚拟世界中。5G是元宇宙的连接通道，它将物理世界和数字世界紧密相连，为VR/AR提供了稳定的网络连接，支持多人在虚拟世界中实时互动。1.VR
  • 第二部分：Web3的核心技术 4. 智能合约 紫队安全研究 web3智能合约区块链
    4.智能合约智能合约是Web3的核心组件之一，基于区块链技术自动执行协议条款。智能合约可以在没有中介的情况下自动完成交易、协议执行等任务，确保各方权益，并减少人工干预。以下将详细介绍智能合约的概念与原理、如何使用Solidity编写和部署智能合约，以及现实中的智能合约应用案例。智能合约的概念与原理智能合约是指存储在区块链上的一段代码，它能够在满足特定条件时自动执行某些操作。智能合约通过预设的条件和
  • 关于旗正规则引擎中的MD5加密问题 何必如此 jspMD5规则加密
    一般情况下，为了防止个人隐私的泄露，我们都会对用户登录密码进行加密，使数据库相应字段保存的是加密后的字符串，而非原始密码。 在旗正规则引擎中，通过外部调用，可以实现MD5的加密，具体步骤如下： 1.在对象库中选择外部调用，选择“com.flagleader.util.MD5”，在子选项中选择“com.flagleader.util.MD5.getMD5ofStr({arg1})”； 2.在规
  • 【Spark101】Scala Promise/Future在Spark中的应用 bit1129 Promise
    Promise和Future是Scala用于异步调用并实现结果汇集的并发原语，Scala的Future同JUC里面的Future接口含义相同，Promise理解起来就有些绕。等有时间了再仔细的研究下Promise和Future的语义以及应用场景，具体参见Scala在线文档：http://docs.scala-lang.org/sips/completed/futures-promises.html
  • spark sql 访问hive数据的配置详解 daizj spark sqlhivethriftserver
    spark sql 能够通过thriftserver 访问hive数据，默认spark编译的版本是不支持访问hive，因为hive依赖比较多，因此打的包中不包含hive和thriftserver,因此需要自己下载源码进行编译，将hive，thriftserver打包进去才能够访问，详细配置步骤如下：   1、下载源码   2、下载Maven,并配置 此配置简单，就略过
  • HTTP 协议通信 周凡杨 javahttpclienthttp通信
                            一：简介  HTTPCLIENT，通过JAVA基于HTTP协议进行点与点间的通信！     二： 代码举例      测试类： import java
  • java unix时间戳转换 g21121 java
    把java时间戳转换成unix时间戳： Timestamp appointTime=Timestamp.valueOf(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())) SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd hh:m
  • web报表工具FineReport常用函数的用法总结（报表函数） 老A不折腾 web报表finereport总结
    说明：本次总结中，凡是以tableName或viewName作为参数因子的。函数在调用的时候均按照先从私有数据源中查找，然后再从公有数据源中查找的顺序。   CLASS CLASS(object):返回object对象的所属的类。   CNMONEY CNMONEY(number,unit)返回人民币大写。 number:需要转换的数值型的数。 unit:单位，
  • java jni调用c++ 代码 报错 墙头上一根草 javaC++jni
    # # A fatal error has been detected by the Java Runtime Environment: # #  EXCEPTION_ACCESS_VIOLATION (0xc0000005) at pc=0x00000000777c3290, pid=5632, tid=6656 # # JRE version: Java(TM) SE Ru
  • Spring中事件处理de小技巧 aijuans springSpring 教程Spring 实例Spring 入门Spring3
    Spring 中提供一些Aware相关de接口，BeanFactoryAware、 ApplicationContextAware、ResourceLoaderAware、ServletContextAware等等，其中最常用到de匙ApplicationContextAware.实现ApplicationContextAwaredeBean，在Bean被初始后，将会被注入 Applicati
  • linux shell ls脚本样例 annan211 linuxlinux ls源码linux 源码
    #! /bin/sh - #查找输入文件的路径 #在查找路径下寻找一个或多个原始文件或文件模式 # 查找路径由特定的环境变量所定义 #标准输出所产生的结果 通常是查找路径下找到的每个文件的第一个实体的完整路径 # 或是filename :not found 的标准错误输出。 #如果文件没有找到 则退出码为0 #否则 即为找不到的文件个数 #语法 pathfind [--
  • List,Set,Map遍历方式 (收集的资源,值得看一下) 百合不是茶 listsetMap遍历方式
    List特点：元素有放入顺序，元素可重复 Map特点：元素按键值对存储，无放入顺序 Set特点：元素无放入顺序，元素不可重复（注意：元素虽然无放入顺序，但是元素在set中的位置是有该元素的HashCode决定的，其位置其实是固定的） List接口有三个实现类：LinkedList，ArrayList，Vector LinkedList：底层基于链表实现，链表内存是散乱的，每一个元素存储本身
  • 解决SimpleDateFormat的线程不安全问题的方法 bijian1013 javathread线程安全
    在Java项目中，我们通常会自己写一个DateUtil类，处理日期和字符串的转换，如下所示： public class DateUtil01 { private SimpleDateFormat dateformat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); public void format(Date d
  • http请求测试实例（采用fastjson解析） bijian1013 http测试
            在实际开发中，我们经常会去做http请求的开发，下面则是如何请求的单元测试小实例，仅供参考。 import java.util.HashMap; import java.util.Map; import org.apache.commons.httpclient.HttpClient; import
  • 【RPC框架Hessian三】Hessian 异常处理 bit1129 hessian
    RPC异常处理概述   RPC异常处理指是，当客户端调用远端的服务，如果服务执行过程中发生异常，这个异常能否序列到客户端？   如果服务在执行过程中可能发生异常，那么在服务接口的声明中，就该声明该接口可能抛出的异常。   在Hessian中，服务器端发生异常，可以将异常信息从服务器端序列化到客户端，因为Exception本身是实现了Serializable的
  • 【日志分析】日志分析工具 bit1129 日志分析
    1. 网站日志实时分析工具 GoAccess http://www.vpsee.com/2014/02/a-real-time-web-log-analyzer-goaccess/ 2. 通过日志监控并收集 Java 应用程序性能数据(Perf4J) http://www.ibm.com/developerworks/cn/java/j-lo-logforperf/ 3.log.io 和
  • nginx优化加强战斗力及遇到的坑解决 ronin47 nginx 优化
    　　　先说遇到个坑，第一个是负载问题，这个问题与架构有关，由于我设计架构多了两层，结果导致会话负载只转向一个。解决这样的问题思路有两个：一是改变负载策略，二是更改架构设计。 　　　由于采用动静分离部署，而nginx又设计了静态，结果客户端去读nginx静态，访问量上来，页面加载很慢。解决：二者留其一。最好是保留apache服务器。   　　　来以下优化：   　　　
  • java-50-输入两棵二叉树A和B，判断树B是不是A的子结构 bylijinnan java
    思路来自： http://zhedahht.blog.163.com/blog/static/25411174201011445550396/ import ljn.help.*; public class HasSubtree { /**Q50. * 输入两棵二叉树A和B，判断树B是不是A的子结构。 例如，下图中的两棵树A和B，由于A中有一部分子树的结构和B是一
  • mongoDB 备份与恢复 开窍的石头 mongDB备份与恢复
    Mongodb导出与导入 1: 导入/导出可以操作的是本地的mongodb服务器,也可以是远程的. 所以,都有如下通用选项: -h host   主机 --port port    端口 -u username 用户名 -p passwd   密码 2: mongoexport 导出json格式的文件
  • [网络与通讯]椭圆轨道计算的一些问题 comsci 网络
         如果按照中国古代农历的历法，现在应该是某个季节的开始，但是由于农历历法是3000年前的天文观测数据，如果按照现在的天文学记录来进行修正的话，这个季节已经过去一段时间了。。。。。       也就是说，还要再等3000年。才有机会了，太阳系的行星的椭圆轨道受到外来天体的干扰，轨道次序发生了变
  • 软件专利如何申请 cuiyadll 软件专利申请
    软件技术可以申请软件著作权以保护软件源代码，也可以申请发明专利以保护软件流程中的步骤执行方式。专利保护的是软件解决问题的思想，而软件著作权保护的是软件代码（即软件思想的表达形式）。例如，离线传送文件，那发明专利保护是如何实现离线传送文件。基于相同的软件思想，但实现离线传送的程序代码有千千万万种，每种代码都可以享有各自的软件著作权。申请一个软件发明专利的代理费大概需要5000-8000申请发明专利可
  • Android学习笔记 darrenzhu android
    1.启动一个AVD 2.命令行运行adb shell可连接到AVD,这也就是命令行客户端 3.如何启动一个程序   am start -n package name/.activityName   am start -n com.example.helloworld/.MainActivity 启动Android设置工具的命令如下所示： # am start -
  • apache虚拟机配置，本地多域名访问本地网站 dcj3sjt126com apache
    现在假定你有两个目录，一个存在于 /htdocs/a，另一个存在于 /htdocs/b 。 现在你想要在本地测试的时候访问 www.freeman.com 对应的目录是 /xampp/htdocs/freeman ,访问 www.duchengjiu.com 对应的目录是 /htdocs/duchengjiu。 1、首先修改C盘WINDOWS\system32\drivers\etc目录下的
  • yii2 restful web服务[速率限制] dcj3sjt126com PHPyii2
    速率限制 为防止滥用，你应该考虑增加速率限制到您的API。 例如，您可以限制每个用户的API的使用是在10分钟内最多100次的API调用。 如果一个用户同一个时间段内太多的请求被接收， 将返回响应状态代码 429 (这意味着过多的请求)。 要启用速率限制, [[yii\web\User::identityClass|user identity class]] 应该实现 [[yii\filter
  • Hadoop2.5.2安装——单机模式 eksliang hadoophadoop单机部署
    转载请出自出处：http://eksliang.iteye.com/blog/2185414 一、概述        Hadoop有三种模式 单机模式、伪分布模式和完全分布模式，这里先简单介绍单机模式 ，默认情况下，Hadoop被配置成一个非分布式模式，独立运行JAVA进程，适合开始做调试工作。   二、下载地址 Hadoop 网址http:
  • LoadMoreListView+SwipeRefreshLayout（分页下拉）基本结构 gundumw100 android
    一切为了快速迭代 import java.util.ArrayList; import org.json.JSONObject; import android.animation.ObjectAnimator; import android.os.Bundle; import android.support.v4.widget.SwipeRefreshLayo
  • 三道简单的前端HTML/CSS题目 ini htmlWeb前端css题目
    使用CSS为多个网页进行相同风格的布局和外观设置时，为了方便对这些网页进行修改，最好使用（ ）。http://hovertree.com/shortanswer/bjae/7bd72acca3206862.htm   在HTML中加入<table style=”color:red; font-size:10pt”>，此为（ ）。http://hovertree.com/s
  • overrided方法编译错误 kane_xie override
    问题描述： 在实现类中的某一或某几个Override方法发生编译错误如下： Name clash: The method put(String) of type XXXServiceImpl has the same erasure as put(String) of type XXXService but does not override it   当去掉@Over
  • Java中使用代理IP获取网址内容（防IP被封，做数据爬虫） mcj8089 免费代理IP代理IP数据爬虫JAVA设置代理IP爬虫封IP
    推荐两个代理IP网站：   1. 全网代理IP：http://proxy.goubanjia.com/   2. 敲代码免费IP：http://ip.qiaodm.com/   Java语言有两种方式使用代理IP访问网址并获取内容，   方式一，设置System系统属性   // 设置代理IP System.getProper
  • Nodejs Express 报错之 listen EADDRINUSE qiaolevip 每天进步一点点学习永无止境nodejs纵观千象
    当你启动 nodejs服务报错： >node app Express server listening on port 80 events.js:85 throw er; // Unhandled 'error' event ^ Error: listen EADDRINUSE at exports._errnoException (
  • C++中三种new的用法 _荆棘鸟_ C++new
    转载自：http://news.ccidnet.com/art/32855/20100713/2114025_1.html 作者: mt 其一是new operator，也叫new表达式；其二是operator new，也叫new操作符。这两个英文名称起的也太绝了，很容易搞混，那就记中文名称吧。new表达式比较常见，也最常用，例如： string* ps = new string("
  • Ruby深入研究笔记1 wudixiaotie Ruby
    module是可以定义private方法的 module MTest def aaa puts "aaa" private_method end private def private_method puts "this is private_method" end end
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他