java高并发
java高并发

教你利用Java语言创建区块链

对区块链技术感到新奇的我们，都想知道区块链在代码上是怎么实现的，所以本文是实战向的，毕竟理论我们都看了不少，但是对于区块链具体的实现还不是很清楚，本文就使用Java语言来实现一个简单的区块链。

但是要完全搞懂区块链并非易事，对于一门较为陌生的技术，我们需要在理论+实践中学习，通过写代码来学习技术会掌握得更牢固，构建一个区块链可以加深对区块链的理解。

准备工作

掌握基本的JavaSE以及JavaWeb开发，能够使用Java开发简单的项目，并且需要了解HTTP协议。

我们知道区块链是由区块的记录构成的不可变、有序的链结构，记录可以是交易、文件或任何你想要的数据，重要的是它们是通过哈希值（hashes）链接起来的。

如果你还不是很了解哈希是什么，可以查看这篇文章

环境描述

  • JDK1.8
  • Tomcat 9.0
  • Maven 3.5
  • JSON 20160810
  • javaee-api 7.0

pom.xml文件配置内容：

     
        
            javax
            javaee-api
            7.0
            provided
        
        
            org.json
            json
            20160810

然后还需要一个HTTP客户端，比如Postman，Linux命令行下的curl或其它客户端，我这里使用的是Postman。

Blockchain类

首先创建一个Blockchain类，在构造器中创建了两个主要的集合，一个用于储存区块链，一个用于储存交易列表，本文中所有核心的主要代码都写在这个类里，方便随时查看，在实际开发则不宜这么做，应该把代码拆分仔细降低耦合度。

以下是Blockchain类的框架代码：

package org.zero01.core;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
public class BlockChain {
    // 存储区块链
    private List chain;
    // 该实例变量用于当前的交易信息列表
    private List currentTransactions;
    public BlockChain() {
        // 初始化区块链以及当前的交易信息列表
        this.chain = new ArrayList();
        this.currentTransactions= new ArrayList();
    }
    public List getChain() {
        return chain;
    }
    public void setChain(List chain) {
        this.chain = chain;
    }
    public List getCurrentTransactions() {
        return currentTransactions;
    }
    public void setCurrentTransactions(List currentTransactions) {
        this.currentTransactions = currentTransactions;
    }
    public Object lastBlock() {
        return null;
    }
    public HashMap newBlock() {
        return null;
    }
    public int newTransactions() {
        return 0;
    }
    public static Object hash(HashMap block) {
        return null;
    }
}
 
 
Blockchain类用来管理区块链，它能存储交易，加入新块等，下面我们来进一步完善这些方法。
 
 
区块的结构
 
 
首先需要说明一下区块的结构，每个区块包含属性：索引（index），时间戳（timestamp），交易列表（transactions），工作量证明（稍后解释）以及前一个区块的Hash值。
 
 
以下是一个区块的结构：
 
 
block = {
    'index': 1,
    'timestamp': 1506057125.900785,
    'transactions': [
        {
            'sender': "8527147fe1f5426f9dd545de4b27ee00",
            'recipient': "a77f5cdfa2934df3954a5c7c7da5df1f",
            'amount': 5,
        }
    ],
    'proof': 324984774000,
    'previous_hash': "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824"
}

 
 
到这里，区块链的概念就清楚了，每个新的区块都包含上一个区块的Hash，这是关键的一点，它保障了区块链不可变性。如果***者破坏了前面的某个区块，那么后面所有区块的Hash都会变得不正确。不理解的话，慢慢消化，可以参考区块链记账原理。
 
 
由于需要计算区块的hash，所以我们得先编写一个用于计算hash值的工具类：
 
 
package org.zero01.util;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
public class Encrypt {
    /**
     * 传入字符串，返回 SHA-256 加密字符串
     * 
     * @param strText
     * @return
     */
    public String getSHA256(final String strText) {
        return SHA(strText, "SHA-256");
    }
    /**
     * 传入字符串，返回 SHA-512 加密字符串
     * 
     * @param strText
     * @return
     */
    public String getSHA512(final String strText) {
        return SHA(strText, "SHA-512");
    }
    /**
     * 传入字符串，返回 MD5 加密字符串
     * 
     * @param strText
     * @return
     */
    public String getMD5(final String strText) {
        return SHA(strText, "SHA-512");
    }
    /**
     * 字符串 SHA 加密
     * 
     * @param strSourceText
     * @return
     */
    private String SHA(final String strText, final String strType) {
        // 返回值
        String strResult = null;
        // 是否是有效字符串
        if (strText != null && strText.length() > 0) {
            try {
                // SHA 加密开始
                // 创建加密对象，传入加密类型
                MessageDigest messageDigest = MessageDigest.getInstance(strType);
                // 传入要加密的字符串
                messageDigest.update(strText.getBytes());
                // 得到 byte 数组
                byte byteBuffer[] = messageDigest.digest();
                // 將 byte 数组转换 string 类型
                StringBuffer strHexString = new StringBuffer();
                // 遍历 byte 数组
                for (int i = 0; i < byteBuffer.length; i++) {
                    // 转换成16进制并存储在字符串中
                    String hex = Integer.toHexString(0xff & byteBuffer[i]);
                    if (hex.length() == 1) {
                        strHexString.append('0');
                    }
                    strHexString.append(hex);
                }
                // 得到返回結果
                strResult = strHexString.toString();
            } catch (NoSuchAlgorithmException e) {
                e.printStackTrace();
            }
        }
        return strResult;
    }
}

 
 
加入交易功能
 
 
接下来我们需要实现一个交易\记账功能，所以来完善newTransactions以及lastBlock方法：
 
 
   /**
     * @return 得到区块链中的最后一个区块
     */
    public HashMap lastBlock() {
        return getChain().get(getChain().size() - 1);
    }
    /**
     * 生成新交易信息，信息将加入到下一个待挖的区块中
     * 
     * @param sender
     *            发送方的地址
     * @param recipient
     *            接收方的地址
     * @param amount
     *            交易数量
     * @return 返回存储该交易事务的块的索引
     */
    public int newTransactions(String sender, String recipient, long amount) {
        Map transaction = new HashMap();
        transaction.put("sender", sender);
        transaction.put("recipient", recipient);
        transaction.put("amount", amount);
        getCurrentTransactions().add(transaction);
        return (Integer) lastBlock().get("index") + 1;
    }

 
 
newTransactions方法向列表中添加一个交易记录，并返回该记录将被添加到的区块 (下一个待挖掘的区块)的索引，等下在用户提交交易时会有用。
 
 
创建新块
 
 
当Blockchain实例化后，我们需要构造一个创世区块（没有前区块的第一个区块），并且给它加上一个工作量证明。
 
 
每个区块都需要经过工作量证明，俗称挖矿，稍后会继续讲解。
 
 
为了构造创世块，我们还需要完善剩下的几个方法，并且把该类设计为单例：
 
 
package org.zero01.dao;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.json.JSONObject;
import org.zero01.util.Encrypt;
public class BlockChain {
    // 存储区块链
    private List> chain;
    // 该实例变量用于当前的交易信息列表
    private List> currentTransactions;
    private static BlockChain blockChain = null;
    private BlockChain() {
        // 初始化区块链以及当前的交易信息列表
        chain = new ArrayList>();
        currentTransactions = new ArrayList>();
        // 创建创世区块
        newBlock(100, "0");
    }
    // 创建单例对象
    public static BlockChain getInstance() {
        if (blockChain == null) {
            synchronized (BlockChain.class) {
                if (blockChain == null) {
                    blockChain = new BlockChain();
                }
            }
        }
        return blockChain;
    }
    public List> getChain() {
        return chain;
    }
    public void setChain(List> chain) {
        this.chain = chain;
    }
    public List> getCurrentTransactions() {
        return currentTransactions;
    }
    public void setCurrentTransactions(List> currentTransactions) {
        this.currentTransactions = currentTransactions;
    }
    /**
     * @return 得到区块链中的最后一个区块
     */
    public Map lastBlock() {
        return getChain().get(getChain().size() - 1);
    }
    /**
     * 在区块链上新建一个区块
     * 
     * @param proof
     *            新区块的工作量证明
     * @param previous_hash
     *            上一个区块的hash值
     * @return 返回新建的区块
     */
    public Map newBlock(long proof, String previous_hash) {
        Map block = new HashMap();
        block.put("index", getChain().size() + 1);
        block.put("timestamp", System.currentTimeMillis());
        block.put("transactions", getCurrentTransactions());
        block.put("proof", proof);
        // 如果没有传递上一个区块的hash就计算出区块链中最后一个区块的hash
        block.put("previous_hash", previous_hash != null ? previous_hash : hash(getChain().get(getChain().size() - 1)));
        // 重置当前的交易信息列表
        setCurrentTransactions(new ArrayList>());
        getChain().add(block);
        return block;
    }
    /**
     * 生成新交易信息，信息将加入到下一个待挖的区块中
     * 
     * @param sender
     *            发送方的地址
     * @param recipient
     *            接收方的地址
     * @param amount
     *            交易数量
     * @return 返回该交易事务的块的索引
     */
    public int newTransactions(String sender, String recipient, long amount) {
        Map transaction = new HashMap();
        transaction.put("sender", sender);
        transaction.put("recipient", recipient);
        transaction.put("amount", amount);
        getCurrentTransactions().add(transaction);
        return (Integer) lastBlock().get("index") + 1;
    }
    /**
     * 生成区块的 SHA-256格式的 hash值
     * 
     * @param block
     *            区块
     * @return 返回该区块的hash
     */
    public static Object hash(Map block) {
        return new Encrypt().getSHA256(new JSONObject(block).toString());
    }
}

 
 
通过上面的代码和注释可以对区块链有直观的了解，接下来我们来编写一些简单的测试代码来测试一下这些代码能否正常工作：
 
 
package org.zero01.test;
import java.util.HashMap;
import java.util.Map;
import org.json.JSONObject;
import org.zero01.dao.BlockChain;
public class Test {
    public static void main(String[] args) throws Exception {
        BlockChain blockChain = BlockChain.getInstance();
        // 一个区块中可以不包含任何交易记录
        Map block = blockChain.newBlock(300, null);
        System.out.println(new JSONObject(block));
        // 一个区块中可以包含一笔交易记录
        blockChain.newTransactions("123", "222", 33);
        Map block1 = blockChain.newBlock(500, null);
        System.out.println(new JSONObject(block1));
        // 一个区块中可以包含多笔交易记录
        blockChain.newTransactions("321", "555", 133);
        blockChain.newTransactions("000", "111", 10);
        blockChain.newTransactions("789", "369", 65);
        Map block2 = blockChain.newBlock(600, null);
        System.out.println(new JSONObject(block2));
        // 查看整个区块链
        Map chain = new HashMap();
        chain.put("chain", blockChain.getChain());
        chain.put("length", blockChain.getChain().size());
        System.out.println(new JSONObject(chain));
    }
}

 
 
运行结果：
 
 
// 挖出来的新区块
{
    "index": 2,
    "transactions": [],
    "proof": 300,
    "timestamp": 1519478559703,
    "previous_hash": "185b62ca1fc31285bce8878acfc970983cb561f19c63b65120d2c95148cf151f"
}
// 包含一笔交易的区块
{
    "index": 3,
    "transactions": [
        {
            "amount": 33,
            "sender": "123",
            "recipient": "222"
        }
    ],
    "proof": 500,
    "timestamp": 1519478559728,
    "previous_hash": "bce15693c0a028b1fc6d7d1c1d30494f97ef37b8b3384865559ceed9b5ff798b"
}
// 包含多笔交易的区块
{
    "index": 4,
    "transactions": [
        {
            "amount": 133,
            "sender": "321",
            "recipient": "555"
        },
        {
            "amount": 10,
            "sender": "000",
            "recipient": "111"
        },
        {
            "amount": 65,
            "sender": "789",
            "recipient": "369"
        }
    ],
    "proof": 600,
    "timestamp": 1519478656178,
    "previous_hash": "b0edde645f76fc3a6cb45b7c91b07b686e8e214cfc1dea4823bf38bda37c909c"
}
// 整个区块链，第一个是创始区块
{
    "chain": [
        {
            "index": 1,
            "transactions": [],
            "proof": 100,
            "timestamp": 1519478656153,
            "previous_hash": "0"
        },
        {
            "index": 2,
            "transactions": [],
            "proof": 300,
            "timestamp": 1519478656154,
            "previous_hash": "7925a01fa8cb67b51ea89b9cfcfa16c5febee008bb559f94c5758418e7acc670"
        },
        {
            "index": 3,
            "transactions": [
                {
                    "amount": 33,
                    "sender": "123",
                    "recipient": "222"
                }
            ],
            "proof": 500,
            "timestamp": 1519478656178,
            "previous_hash": "40ccc2f4ad97f75cb611ed69a4ecc7438eefd31afca17ca00c2ed7b5163d0831"
        },
        {
            "index": 4,
            "transactions": [
                {
                    "amount": 133,
                    "sender": "321",
                    "recipient": "555"
                },
                {
                    "amount": 10,
                    "sender": "000",
                    "recipient": "111"
                },
                {
                    "amount": 65,
                    "sender": "789",
                    "recipient": "369"
                }
            ],
            "proof": 600,
            "timestamp": 1519478656178,
            "previous_hash": "b0edde645f76fc3a6cb45b7c91b07b686e8e214cfc1dea4823bf38bda37c909c"
        }
    ],
    "length": 4
}

 
 
通过以上的测试，可以很直观的看到区块链的数据，但是现在只是完成了初步的代码编写，还有几件事情还没做，接下来我们看看区块是怎么挖出来的。
 
 
理解工作量证明
 
 
新的区块依赖工作量证明算法（PoW）来构造。PoW的目标是找出一个符合特定条件的数字，这个数字很难计算出来，但容易验证。这就是工作量证明的核心思想。
 
 
为了方便理解，举个例子：
 
 
假设一个整数 x 乘以另一个整数 y 的积的 Hash 值必须以 0 结尾，即 hash(x * y) = ac23dc…0。设变量 x = 5，求 y 的值？
 
 
用Java实现如下：
 
 
package org.zero01.test;
import org.zero01.util.Encrypt;
public class TestProof {
    public static void main(String[] args) {
        int x = 5;
        int y = 0;
        while (!new Encrypt().getSHA256((x * y) + "").endsWith("0")) {
            y++;
        }
        System.out.println("y=" + y);
    }
}

 
 
结果是 y=21 ，因为：
 
 
hash(5 * 21) = 1253e9373e...5e3600155e860

 
 
在比特币中，使用称为Hashcash的工作量证明算法，它和上面的问题很类似。矿工们为了争夺创建区块的权利而争相计算结果。通常，计算难度与目标字符串需要满足的特定字符的数量成正比，矿工算出结果后，会获得比特币奖励。
 
 
当然，在网络上非常容易验证这个结果。
 
 
实现工作量证明
 
 
让我们来实现一个相似PoW算法，规则是：寻找一个数 p，使得它与前一个区块的 proof 拼接成的字符串的 Hash 值以 4 个零开头：
 
 
    /**
     * 简单的工作量证明: 
     *   - 查找一个 p' 使得 hash(pp') 以4个0开头 
     *   - p 是上一个块的证明, p' 是当前的证明
     *   
     * @param last_proof
     *               上一个块的证明
     * @return
     */
    public long proofOfWork(long last_proof) {
        long proof = 0;
        while (!validProof(last_proof, proof)) {
            proof += 1;
        }
        return proof;
    }
    /**
     * 验证证明: 是否hash(last_proof, proof)以4个0开头?
     * 
     * @param last_proof
     *            上一个块的证明
     * @param proof
     *            当前的证明
     * @return 以4个0开头返回true，否则返回false
     */
    public boolean validProof(long last_proof, long proof) {
        String guess = last_proof + "" + proof;
        String guess_hash = new Encrypt().getSHA256(guess);
        return guess_hash.startsWith("0000");
    }

 
 
衡量算法复杂度的办法是修改零开头的个数。使用4个来用于演示，你会发现多一个零都会大大增加计算出结果所需的时间。
 
 
现在Blockchain类基本已经完成了，接下来使用Servlet接收HTTP请求来进行交互。
 
 
Blockchain作为API接口
 
 
我们将使用Java Web中的Servlet来接收用户的HTTP请求，通过Servlet我们可以方便的将网络请求的数据映射到相应的方法上进行处理，现在我们来让Blockchain运行在基于Java Web上。
 
 
我们将创建三个接口：
 
 
     
  
  • /transactions/new 创建一个交易并添加到区块
    •  
  
  • /mine 告诉服务器去挖掘新的区块
    •  
  
  • /chain 返回整个区块链
    •  
 
 
 
注册节点ID
 
 
我们的“Tomcat服务器”将扮演区块链网络中的一个节点，而每个节点都需要有一个唯一的标识符，也就是id。在这里我们使用UUID来作为节点ID，我们需要在服务器启动时，将UUID设置到ServletContext属性中，这样我们的服务器就拥有了唯一标识，这一步我们可以配置监听类来完成，首先配置web.xml文件内容如下：
 
 


    
        org.zero01.servlet.InitialID
    
 

 
 
然后编写一个类实现ServletContextListener接口，在初始化方法中把uuid设置到ServletContext的属性中：
 
 
package org.zero01.servlet;
import java.util.UUID;
import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
public class InitialID implements ServletContextListener {
    public void contextInitialized(ServletContextEvent sce) {
        ServletContext servletContext = sce.getServletContext();
        String uuid = UUID.randomUUID().toString().replace("-", "");
        servletContext.setAttribute("uuid", uuid);
    }
    public void contextDestroyed(ServletContextEvent sce) {
    }
}

 
 
创建Servlet类
 
 
我们这里没有使用任何框架，所以我们需要通过最基本的Servlet来接收并处理用户的HTTP请求：
 
 
package org.zero01.servlet;
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
// 该Servlet用于运行工作算法的证明来获得下一个证明，也就是所谓的挖矿
@WebServlet("/mine")
public class Mine extends HttpServlet{
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    }
}
package org.zero01.servlet;
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
// 该Servlet用于接收并处理新的交易信息
@WebServlet("/transactions/new")
public class NewTransaction extends HttpServlet{
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    }
}
package org.zero01.servlet;
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
// 该Servlet用于输出整个区块链的数据
@WebServlet("/chain")
public class FullChain extends HttpServlet{
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    }
}

 
 
我们先来完成最简单的FullChain的代码，这个Servlet用于向客户端输出整个区块链的数据（JSON格式）：
 
 
package org.zero01.servlet;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.HashMap;
import java.util.Map;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.json.JSONObject;
import org.zero01.core.BlockChain;
// 该Servlet用于输出整个区块链的数据
@WebServlet("/chain")
public class FullChain extends HttpServlet {
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        BlockChain blockChain = BlockChain.getInstance();
        Map response = new HashMap();
        response.put("chain", blockChain.getChain());
        response.put("length", blockChain.getChain().size());
        JSONObject jsonResponse = new JSONObject(response);
        resp.setContentType("application/json");
        PrintWriter printWriter = resp.getWriter();
        printWriter.println(jsonResponse);
        printWriter.close();
    }
}

 
 
发送交易
 
 
然后是记录交易数据的功能，每一个区块都可以记录交易数据，发送到节点的交易数据结构如下：
 
 
{
 "sender": "my address",
 "recipient": "someone else's address",
 "amount": 5
}

 
 
实现代码如下：
 
 
package org.zero01.servlet;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.json.JSONObject;
import org.zero01.core.BlockChain;
// 该Servlet用于接收并处理新的交易信息
@WebServlet("/transactions/new")
public class NewTransaction extends HttpServlet {
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        req.setCharacterEncoding("utf-8");
        // 读取客户端传递过来的数据并转换成JSON格式
        BufferedReader reader = req.getReader();
        String input = null;
        StringBuffer requestBody = new StringBuffer();
        while ((input = reader.readLine()) != null) {
            requestBody.append(input);
        }
        JSONObject jsonValues = new JSONObject(requestBody.toString());
        // 检查所需要的字段是否位于POST的data中
        String[] required = { "sender", "recipient", "amount" };
        for (String string : required) {
            if (!jsonValues.has(string)) {
                // 如果没有需要的字段就返回错误信息
                resp.sendError(400, "Missing values");
            }
        }
        // 新建交易信息
        BlockChain blockChain = BlockChain.getInstance();
        int index = blockChain.newTransactions(jsonValues.getString("sender"), jsonValues.getString("recipient"),
                jsonValues.getLong("amount"));
        // 返回json格式的数据给客户端
        resp.setContentType("application/json");
        PrintWriter printWriter = resp.getWriter();
        printWriter.println(new JSONObject().append("message", "Transaction will be added to Block " + index));
        printWriter.close();
    }
}

 
 
挖矿
 
 
挖矿正是神奇所在，它很简单，只做了以下三件事：
 
 
     
  
  • 计算工作量证明PoW
    •  
  
  • 通过新增一个交易授予矿工（自己）一个币
    •  
  
  • 构造新区块并将其添加到链中
    •  
 
 
 
代码实现如下：
 
 
package org.zero01.servlet;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.HashMap;
import java.util.Map;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.json.JSONObject;
import org.zero01.core.BlockChain;
//该Servlet用于运行工作算法的证明来获得下一个证明，也就是所谓的挖矿
@WebServlet("/mine")
public class Mine extends HttpServlet {
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        BlockChain blockChain = BlockChain.getInstance();
        Map lastBlock = blockChain.lastBlock();
        long lastProof = Long.parseLong(lastBlock.get("proof") + "");
        long proof = blockChain.proofOfWork(lastProof);
        // 给工作量证明的节点提供奖励，发送者为 "0" 表明是新挖出的币
        String uuid = (String) this.getServletContext().getAttribute("uuid");
        blockChain.newTransactions("0", uuid, 1);
        // 构建新的区块
        Map newBlock = blockChain.newBlock(proof, null);
        Map response = new HashMap();
        response.put("message", "New Block Forged");
        response.put("index", newBlock.get("index"));
        response.put("transactions", newBlock.get("transactions"));
        response.put("proof", newBlock.get("proof"));
        response.put("previous_hash", newBlock.get("previous_hash"));
        // 返回新区块的数据给客户端
        resp.setContentType("application/json");
        PrintWriter printWriter = resp.getWriter();
        printWriter.println(new JSONObject(response));
        printWriter.close();
    }
}

 
 
注意交易的接收者是我们自己的服务器节点，我们做的大部分工作都只是围绕Blockchain类的方法进行交互。到此，我们的区块链就算完成了，我们来实际运行下。
 
 
运行区块链
 
 
由于我们这里也没有写前端的web页面，只写了后端的API，所以只能使用 Postman 之类的软件去和API进行交互。首先启动Tomcat服务器，然后通过post请求 http://localhost:8089/BlockChain_Java/transactions/new来添加新的交易信息（注意我这里没有使用默认的8080端口，默认的情况下是8080端口）：
 
 
 
 
  
 
   
  
   
 
  
 
  

    image 
  
 
 
 
 
 
 
但是这时候还没有新的区块可以写入这个交易信息，所以我们还需要请求 http://localhost:8089/BlockChain_Java/mine 来进行挖矿，挖出一个新的区块来存储这笔交易：
 
 
 
  
 
   
  
   
 
  
 
  

    image 
  
 
 
 
 
在挖了两次矿之后，就有3个块了，通过请求 http://localhost:8089/BlockChain_Java/chain 可以得到所有的区块块的信息：
 
 
 {
    "chain": [
        {
            "index": 1,
            "proof": 100,
            "transactions": [],
            "timestamp": 1520928588165,
            "previous_hash": "0"
        },
        {
            "index": 2,
            "proof": 35293,
            "transactions": [
                {
                    "amount": 6,
                    "sender": "d4ee26eee15148ee92c6cd394edd974e",
                    "recipient": "someone-other-address"
                },
                {
                    "amount": 1,
                    "sender": "0",
                    "recipient": "050bbfe4ad644d008545ff490387a889"
                }
            ],
            "timestamp": 1520928734580,
            "previous_hash": "e5cf7ba38f7f0c3a93fcca5d57b624c8fd255093af4abe3c6999be61bdb81040"
        },
        {
            "index": 3,
            "proof": 35089,
            "transactions": [
                {
                    "amount": 1,
                    "sender": "0",
                    "recipient": "050bbfe4ad644d008545ff490387a889"
                }
            ],
            "timestamp": 1520928870963,
            "previous_hash": "aa64ab003d15d50a43bd59deb88c939ea43349d00d0b653abd83b42e8fa4417c"
        }
    ],
    "length": 3
}

 
 
一致性（共识）
 
 
我们已经有了一个基本的区块链可以接受交易和挖矿。但是区块链系统应该是分布式的。既然是分布式的，那么我们究竟拿什么保证所有节点有同样的链呢？这就是一致性问题，我们要想在网络上有多个节点，就必须实现一个一致性的算法。
 
 
注册节点
 
 
在实现一致性算法之前，我们需要找到一种方式让一个节点知道它相邻的节点。每个节点都需要保存一份包含网络中其它节点的记录。因此让我们新增几个接口：
 
 
     
  
  • /nodes/register 接收URL形式的新节点列表
    •  
  
  • /nodes/resolve执行一致性算法，解决任何冲突，确保节点拥有正确的链
    •  
 
 
 
我们需要修改下BlockChain的构造函数并提供一个注册节点方法：
 
 
package org.zero01.core;
...
import java.net.URL;
...
    private Set nodes;
    private BlockChain() {
        ...
        // 用于存储网络中其他节点的集合
        nodes = new HashSet();
        ...
    }
    public Set getNodes() {
        return nodes;
    }
    /**
     * 注册节点
     * 
     * @param address
     *            节点地址
     * @throws MalformedURLException
     */
    public void registerNode(String address) throws MalformedURLException {
        URL url = new URL(address);
        String node = url.getHost() + ":" + (url.getPort() == -1 ? url.getDefaultPort() : url.getPort());
        nodes.add(node);
    }
    ...

 
 
我们用 HashSet 集合来储存节点，这是一种避免出现重复添加节点的简单方法。
 
 
实现共识算法
 
 
前面提到，冲突是指不同的节点拥有不同的链，为了解决这个问题，规定最长的、有效的链才是最终的链，换句话说，网络中有效最长链才是实际的链。
 
 
我们使用以下算法，来达到网络中的共识：
 
 
...
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
...
public class BlockChain {
    ...
    /**
     * 检查是否是有效链，遍历每个区块验证hash和proof，来确定一个给定的区块链是否有效
     * 
     * @param chain
     * @return
     */
    public boolean validChain(List> chain) {
        Map lastBlock = chain.get(0);
        int currentIndex = 1;
        while (currentIndex < chain.size()) {
            Map block = chain.get(currentIndex);
            System.out.println(lastBlock.toString());
            System.out.println(block.toString());
            System.out.println("\n-------------------------\n");
            // 检查block的hash是否正确
            if (!block.get("previous_hash").equals(hash(lastBlock))) {
                return false;
            }
            lastBlock = block;
            currentIndex++;
        }
        return true;
    }
    /**
     * 共识算法解决冲突，使用网络中最长的链. 遍历所有的邻居节点，并用上一个方法检查链的有效性， 如果发现有效更长链，就替换掉自己的链
     * 
     * @return 如果链被取代返回true, 否则返回false
     * @throws IOException
     */
    public boolean resolveConflicts() throws IOException {
        Set neighbours = this.nodes;
        List> newChain = null;
        // 寻找最长的区块链
        long maxLength = this.chain.size();
        // 获取并验证网络中的所有节点的区块链
        for (String node : neighbours) {
            URL url = new URL("http://" + node + "/BlockChain_Java/chain");
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.connect();
            if (connection.getResponseCode() == 200) {
                BufferedReader bufferedReader = new BufferedReader(
                        new InputStreamReader(connection.getInputStream(), "utf-8"));
                StringBuffer responseData = new StringBuffer();
                String response = null;
                while ((response = bufferedReader.readLine()) != null) {
                    responseData.append(response);
                }
                bufferedReader.close();
                JSONObject jsonData = new JSONObject(bufferedReader.toString());
                long length = jsonData.getLong("length");
                List> chain = (List) jsonData.getJSONArray("chain").toList();
                // 检查长度是否长，链是否有效
                if (length > maxLength && validChain(chain)) {
                    maxLength = length;
                    newChain = chain;
                }
            }
        }
        // 如果发现一个新的有效链比我们的长，就替换当前的链
        if (newChain != null) {
            this.chain = newChain;
            return true;
        }
        return false;
    }
    ...

 
 
第一个方法 validChain() 用来检查是否是有效链，遍历每个块验证hash和proof.
 
 
第2个方法 resolveConflicts() 用来解决冲突，遍历所有的邻居节点，并用上一个方法检查链的有效性， 如果发现有效更长链，就替换掉自己的链
 
 
让我们添加两个Servlet，一个用来注册节点，一个用来解决冲突：
 
 
注册节点：
 
 
package org.zero01.servlet;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.json.JSONObject;
import org.zero01.core.BlockChain;
// 用于注册节点的Servlet
@WebServlet("/nodes/register")
public class NodesRegister extends HttpServlet {
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        req.setCharacterEncoding("utf-8");
        // 读取客户端传递过来的数据并转换成JSON格式
        BufferedReader reader = req.getReader();
        String input = null;
        StringBuffer requestBody = new StringBuffer();
        while ((input = reader.readLine()) != null) {
            requestBody.append(input);
        }
        JSONObject jsonValues = new JSONObject(requestBody.toString());
        // 获得节点集合数据，并进行判空
        List nodes = (List) jsonValues.getJSONArray("nodes").toList();
        if (nodes == null) {
            resp.sendError(400, "Error: Please supply a valid list of nodes");
        }
        // 注册节点
        BlockChain blockChain = BlockChain.getInstance();
        for (String address : nodes) {
            blockChain.registerNode(address);
        }
        // 向客户端返回处理结果
        Map response = new HashMap();
        response.put("message", "New nodes have been added");
        response.put("total_nodes", blockChain.getNodes().toArray());
        resp.setContentType("application/json");
        PrintWriter printWriter = resp.getWriter();
        printWriter.println(new JSONObject(response));
        printWriter.close();
    }
}

 
 
解决冲突：
 
 
package org.zero01.servlet;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.HashMap;
import java.util.Map;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.json.JSONObject;
import org.zero01.core.BlockChain;
// 用于解决冲突
@WebServlet("/nodes/resolve")
public class NodesResolve extends HttpServlet {
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        BlockChain blockChain = BlockChain.getInstance();
        boolean replaced = blockChain.resolveConflicts();
        Map response = new HashMap();
        if (replaced) {
            response.put("message", "Our chain was replaced");
            response.put("new_chain", blockChain.getChain());
        } else {
            response.put("message", "Our chain is authoritative");
            response.put("chain", blockChain.getChain());
        }
        resp.setContentType("application/json");
        PrintWriter printWriter = resp.getWriter();
        printWriter.println(new JSONObject(response));
        printWriter.close();
    }
}

 
 
 
 
我们可以在不同的机器运行节点，或在一台机机开启不同的网络端口来模拟多节点的网络，这里在同一台机器开启不同的端口演示，配置两个不同端口的服务器即可，我这里启动了两个节点：http://localhost:8089 和 http://localhost:8066。
 
 
两个节点互相进行注册：
 
 
 
  
 
   
  
   
 
  
 
  

    image 
  
 
 
 
 
然后在8066节点上挖两个块，确保是更长的链：
 
 
 
  
 
   
  
   
 
  
 
  

    image 
  
 
 
 
 
接着在8089节点上访问接口/nodes/resolve ，这时8089节点的链会通过共识算法被8066节点的链取代：
 
 
 
  
 
   
  
   
 
  
 
  

    image 
  
 
 
 
 
通过共识算法保持一致性后，两个节点的区块链数据就都是一致的了：
 
 
 
  
 
   
  
   
 
  
 
  

    image 
  
 
 
 
 
到此为止我们就完成了一个区块链的开发，虽然这只是一个最基本的区块链，而且在开发的过程中也没有考虑太多的程序设计方面的问题，而是以最基本、原始的方式进行开发的。但是我们不妨以这个简单的区块链为基础，发挥自己的能力动手去重构、扩展、完善这个区块链程序，直至成为自己的一个小项目。
 
 
 
  
 
   
  
   
 
  
 
  
 
 
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(教你利用Java语言创建区块链)

        

            

                
    
                    
  • 机器学习与深度学习间关系与区别
                        ℒℴѵℯ心·动ꦿ໊ོ꫞
人工智能学习深度学习python
                        
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
    
                    
    • 
                    
  • UI学习——cell的复用和自定义cell
                        Magnetic_h
ui学习
                        
    目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
    
                    
    • 
                    
  • 微服务下功能权限与数据权限的设计与实现
                        nbsaas-boot
微服务java架构
                        
    在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
    
                    
    • 
                    
  • Linux下QT开发的动态库界面弹出操作（SDL2）
                        13jjyao
QT类qt开发语言sdl2linux
                        
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
    
                    
    • 
                    
  • 2021-08-26
                        影幽

                        
    在生活中，女人与男人的感悟往往有所不同。人生最大的舞台就是生活，大幕随时都可能拉开，关键是你愿不愿意表演都无法躲避。在生活中，遇事不要急躁，不要急于下结论，尤其生气时不要做决断，要学会换位思考，大事化小小事化了，把复杂的事情尽量简单处理，千万不要把简单的事情复杂化。永远不要扭曲，别人善意，无药可救。昨天是张过期的支票，明天是张信用卡，只有今天才是现金，要善加利用！执着的攀登者不必去与别人比较自己的
    
                    
    • 
                    
  • Pyecharts数据可视化大屏：打造沉浸式数据分析体验
                        我的运维人生
信息可视化数据分析数据挖掘运维开发技术共享
                        
    Pyecharts数据可视化大屏：打造沉浸式数据分析体验在当今这个数据驱动的时代，如何将海量数据以直观、生动的方式展现出来，成为了数据分析师和企业决策者关注的焦点。Pyecharts，作为一款基于Python的开源数据可视化库，凭借其丰富的图表类型、灵活的配置选项以及高度的定制化能力，成为了构建数据可视化大屏的理想选择。本文将深入探讨如何利用Pyecharts打造数据可视化大屏，并通过实际代码案例
    
                    
    • 
                    
  • Goolge earth studio 进阶4——路径修改与平滑
                        陟彼高冈yu
Googleearthstudio进阶教程旅游
                        
    如果我们希望在大约中途时获得更多的城市鸟瞰视角。可以将相机拖动到这里并创建一个新的关键帧。camera_target_clip_7EarthStudio会自动平滑我们的路径，所以当我们通过这个关键帧时，不是一个生硬的角度，而是一个平滑的曲线。camera_target_clip_8路径上有贝塞尔控制手柄，允许我们调整路径的形状。右键单击，我们可以选择“平滑路径”，这是默认的自动平滑算法，或者我们可
    
                    
    • 
                    
  • Google earth studio 简介
                        陟彼高冈yu
旅游
                        
    GoogleEarthStudio是一个基于Web的动画工具，专为创作使用GoogleEarth数据的动画和视频而设计。它利用了GoogleEarth强大的三维地图和卫星影像数据库，使用户能够轻松地创建逼真的地球动画、航拍视频和动态地图可视化。网址为https://www.google.com/earth/studio/。GoogleEarthStudio是一个基于Web的动画工具，专为创作使用G
    
                    
    • 
                    
  • linux中sdl的使用教程,sdl使用入门
                        Melissa Corvinus
linux中sdl的使用教程
                        
    本文通过一个简单示例讲解SDL的基本使用流程。示例中展示一个窗口，窗口里面有个随机颜色快随机移动。当我们鼠标点击关闭按钮时间窗口关闭。基本步骤如下：1.初始化SDL并创建一个窗口。SDL_Init()初始化SDL_CreateWindow()创建窗口2.纹理渲染存储RGB和存储纹理的区别：比如一个从左到右由红色渐变到蓝色的矩形，用存储RGB的话就需要把矩形中每个点的具体颜色值存储下来；而纹理只是一
    
                    
    • 
                    
  • 509. 斐波那契数(每日一题)
                        lzyprime

                        
    lzyprime博客(github)创建时间：2021.01.04qq及邮箱：2383518170leetcode笔记题目描述斐波那契数，通常用F(n)表示，形成的序列称为斐波那契数列。该数列由0和1开始，后面的每一项数字都是前面两项数字的和。也就是：F(0)=0，F(1)=1F(n)=F(n-1)+F(n-2)，其中n>1给你n，请计算F(n)。示例1：输入：2输出：1解释：F(2)=F(1)+
    
                    
    • 
                    
  • 【加密社】Solidity 中的事件机制及其应用
                        加密社
闲侃区块链智能合约区块链
                        
    加密社引言在Solidity合约开发过程中，事件（Events）是一种非常重要的机制。它们不仅能够让开发者记录智能合约的重要状态变更，还能够让外部系统（如前端应用）监听这些状态的变化。本文将详细介绍Solidity中的事件机制以及如何利用不同的手段来触发、监听和获取这些事件。事件存储的地方当我们在Solidity合约中使用emit关键字触发事件时，该事件会被记录在区块链的交易收据中。具体而言，事件
    
                    
    • 
                    
  • 从0到500+，我是如何利用自媒体赚钱？
                        一列脚印

                        
    运营公众号半个多月，从零基础的小白到现在慢慢懂了一些运营的知识。做好公众号是很不容易的，要做很多事情；排版、码字、引流…通通需要自己解决，业余时间全都花费在这上面涨这么多粉丝是真的不容易，对比知乎大佬来说，我们这种没资源，没人脉，还没钱的小透明来说，想要一个月涨粉上万，怕是今天没睡醒（不过你有的方法，算我piapia打脸）至少我是清醒的，自己慢慢努力，实现我的万粉目标！大家快来围观、支持我吧！孩子
    
                    
    • 
                    
  • 利用Requests Toolkit轻松完成HTTP请求
                        nseejrukjhad
http网络协议网络python
                        
    RequestsToolkit的力量：轻松构建HTTP请求Agent在现代软件开发中，API请求是与外部服务交互的核心。RequestsToolkit提供了一种便捷的方式，帮助开发者构建自动化的HTTP请求Agent。本文旨在详细介绍RequestsToolkit的设置、使用和潜在挑战。引言RequestsToolkit是一个强大的工具包，可用于构建执行HTTP请求的智能代理。这对于想要自动化与外
    
                    
    • 
                    
  • 利用LangChain的StackExchange组件实现智能问答系统
                        nseejrukjhad
langchainmicrosoft数据库python
                        
    利用LangChain的StackExchange组件实现智能问答系统引言在当今的软件开发世界中，StackOverflow已经成为程序员解决问题的首选平台之一。而LangChain作为一个强大的AI应用开发框架，提供了StackExchange组件，使我们能够轻松地将StackOverflow的海量知识库集成到我们的应用中。本文将详细介绍如何使用LangChain的StackExchange组件
    
                    
    • 
                    
  • 在一台Ubuntu计算机上构建Hyperledger Fabric网络
                        落叶无声9
区块链超级账本Hyperledgerfabric区块链ubuntu构建hyperledgerfabric
                        
    在一台Ubuntu计算机上构建HyperledgerFabric网络Hyperledgerfabric是一个开源的区块链应用程序平台，为开发基于区块链的应用程序提供了一个起点。当我们提到HyperledgerFabric网络时，我们指的是使用HyperledgerFabric的正在运行的系统。即使只使用最少数量的组件，部署Fabric网络也不是一件容易的事。Fabric社区创建了一个名为Cello
    
                    
    • 
                    
  • Python快速入门 —— 第三节：类与对象
                        孤华暗香
Python快速入门python开发语言
                        
    第三节：类与对象目标：了解面向对象编程的基础概念，并学会如何定义类和创建对象。内容：类与对象：定义类：class关键字。类的构造函数：__init__()。类的属性和方法。对象的创建与使用。示例：classStudent:def__init__(self,name,age,major):self.name&#
    
                    
    • 
                    
  • 2022现在哪个打车软件比较好用又便宜 实惠的打车软件合集
                        高省APP珊珊

                        
    这是一个信息高速传播的社会。信息可以通过手机，微信，自媒体，抖音等方式进行传播。但同时这也是一个交通四通发达的社会。高省APP，是2022年推出的平台，0投资，0风险、高省APP佣金更高，模式更好，终端用户不流失。【高省】是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几百万篇报道，也期待你的加入。珊珊导师，高省邀请码777777，注册送2皇冠会员，送万元推广大礼包，教你如何1年做到百万团队。高
    
                    
    • 
                    
  • 阶段总结反思
                        轻争

                        
    马上就要进入10月份了，今天做一下前段时间的总结和反思。前段时间，日更、英语、健身、护肤坚持的比较好。阅读、书法坚持的不好。1.中间被迫停更半个多月，其余时间一直在坚持日更挑战。偶尔也有不想写的时候，就做一下摘抄。因为阅读（输入）没跟上来，所以写作（输出）质量有待进一步加强。2.英语做到了一周至少学习5天，每次不少于30分钟，但是小班课没有跟上更新速度，下一步要争取利用零碎时间补听小班课。3.减肥
    
                    
    • 
                    
  • Python爬虫解析工具之xpath使用详解
                        eqa11
python爬虫开发语言
                        
    文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门
    
                    
    • 
                    
  • 【Git】常见命令(仅笔记)
                        好想有猫猫
GitLinux学习笔记git笔记elasticsearchlinuxc++
                        
    文章目录创建/初始化本地仓库添加本地仓库配置项提交文件查看仓库状态回退仓库查看日志分支删除文件暂存工作区代码远程仓库使用`.gitigore`文件让git不追踪一些文件标签创建/初始化本地仓库gitinit添加本地仓库配置项gitconfig-l#以列表形式显示配置项gitconfiguser.name"ljh"#配置user.namegitconfiguser.email"[email protected]
    
                    
    • 
                    
  • Linux MariaDB使用OpenSSL安装SSL证书
                        Meta39
MySQLOracleMariaDBLinuxWindowsssllinuxmariadb
                        
    进入到证书存放目录，批量删除.pem证书警告：确保已经进入到证书存放目录find.-typef-iname\*.pem-delete查看是否安装OpenSSLopensslversion没有则安装yuminstallopensslopenssl-devel开启SSL编辑/etc/my.cnf文件（没有的话就创建，但是要注意，在/etc/my.cnf.d/server.cnf配置了datadir的，
    
                    
    • 
                    
  • Python中深拷贝与浅拷贝的区别
                        yuxiaoyu.

                        
    转自：http://blog.csdn.net/u014745194/article/details/70271868定义：在Python中对象的赋值其实就是对象的引用。当创建一个对象，把它赋值给另一个变量的时候，python并没有拷贝这个对象，只是拷贝了这个对象的引用而已。浅拷贝：拷贝了最外围的对象本身，内部的元素都只是拷贝了一个引用而已。也就是，把对象复制一遍，但是该对象中引用的其他对象我不复
    
                    
    • 
                    
  • 一文掌握python常用的list（列表）操作
                        程序员neil
pythonpython开发语言
                        
    目录一、创建列表1.直接创建列表：2.使用list()构造器3.使用列表推导式4.创建空列表二、访问列表元素1.列表支持通过索引访问元素，索引从0开始：2.还可以使用切片操作访问列表的一部分：三、修改列表元素四、添加元素1.append()：在末尾添加元素2.insert()：在指定位置插入元素五、删除元素1.del：删除指定位置的元素2.remove()：删除指定值的第一个匹配项3.pop()：
    
                    
    • 
                    
  • python中的深拷贝与浅拷贝
                        anshejd70787
python
                        
    深拷贝和浅拷贝浅拷贝的时候，修改原来的对象，浅拷贝的对象不会发生改变。1、对象的赋值对象的赋值实际上是对象之间的引用：当创建一个对象，然后将这个对象赋值给另外一个变量的时候，python并没有拷贝这个对象，而只是拷贝了这个对象的引用。当对对象做赋值或者是参数传递或者作为返回值的时候，总是传递原始对象的引用，而不是一个副本。如下所示：>>>aList=["kel","abc",123]>>>bLis
    
                    
    • 
                    
  • 京券东券优惠券领取网站-点击进入
                        高省爱氧惠

                        
    嘿，小伙伴们，你们知道吗？京东商城可是有好多超值优惠券等着我们领取哦！不论是京券还是东券，都有好多好多的优惠等着我们呢！氧惠APP（带货领导者）——是与以往完全不同的抖客+淘客app！2024全新模式，我的直推也会放到你下面。主打：带货高补贴，深受各位带货团队长喜爱（每天出单带货几十万单）。注册即可享受高补贴+0撸+捡漏等带货新体验。送万元推广大礼包，教你如何1年做到百万团队。想要领取这些优惠券，
    
                    
    • 
                    
  • 上班族可以做线上副业兼职有哪些？盘点7个适合上班族做的副业兼职！
                        高省APP大九

                        
    对于许多上班族来说，工资往往不能满足他们的生活需求，因此许多人开始寻找副业来增加收入。以下是一些适合普通人的副业赚钱路子，希望能给您带来一些灵感。1、做好物推荐现在很多职场人其实有大量的个人时间，只不过这些个人时间比较碎片化，他们不能够很好的利用起来，其实可以利用这些碎片化的时间去做副业，比如做好物推荐。在网上有很多的平台，比如头条抖音等等都开通了一个商品的分销功能，只要你发布相关的视频或者文章，
    
                    
    • 
                    
  • mac 备份android 手机通讯录导入iphone,iphone如何导出通讯录（轻松教你iPhone备份通讯录的方法）...
                        weixin_39762838
mac备份android手机通讯录导入iphone
                        
    在日新月异的手机更替中，换手机已经成为一个非常稀松平常的事情，但将旧手机上面的通讯录导入到新手机还是让不少小伙伴为难，本篇将给大家详细讲解这方面的知识：“苹果手机通讯录怎么导入到新手机”及“安卓手机通讯录导入到新手机”的方法。一、苹果手机通讯录导入到新手机常用方法(SIM卡导入)在苹果手机主频幕上找到“设置”，单击进入设置菜单，下拉菜单列表，点击“邮件、通讯录、日历”，然后找到“导入SIM卡通讯录
    
                    
    • 
                    
  • 手机上有什么兼职可以做？网上兼职 一单一结 手机就可以做？
                        优惠券高省

                        
    建议上班族和全职宝妈把空闲时间拿出来一点做做副业，什么也不耽搁还能多一笔收入！推荐大家一定要试一试！！！只要有手机就可以做，下面小编就为大家推荐用手机就可以做的三类网上兼职工作。一，高省APP高省APP佣金更高，模式更好，终端用户不流失。【高省】是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几百万篇报道，也期待你的加入。万方导师高省邀请码005500，注册送双皇冠会员，送万元推广大礼包，教你如
    
                    
    • 
                    
  • springboot+vue项目实战一-创建SpringBoot简单项目
                        苹果酱0567
面试题汇总与解析springboot后端java中间件开发语言
                        
    这段时间抽空给女朋友搭建一个个人博客，想着记录一下建站的过程，就当做笔记吧。虽然复制zjblog只要一个小时就可以搞定一个网站，或者用cms系统，三四个小时就可以做出一个前后台都有的网站，而且想做成啥样也都行。但是就是要从新做，自己做的意义不一样，更何况，俺就是专门干这个的，嘿嘿嘿要做一个网站，而且从零开始，首先呢就是技术选型了，经过一番思量决定选择-SpringBoot做后端，前端使用Vue做一
    
                    
    • 
                    
  • JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）
                        跳房子的前端
前端面试javascript开发语言ecmascript
                        
    在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
    
                    
    • 
                                
  • java杨辉三角
                                    3213213333332132
java基础
                                    
    
package com.algorithm;

/**
 * @Description 杨辉三角
 * @author FuJianyong
 * 2015-1-22上午10:10:59
 */
public class YangHui {
	public static void main(String[] args) {
		//初始化二维数组长度
		int[][] y
    
                                
    • 
                                
  • 《大话重构》之大布局的辛酸历史
                                    白糖_
重构
                                    
    《大话重构》中提到“大布局你伤不起”，如果企图重构一个陈旧的大型系统是有非常大的风险，重构不是想象中那么简单。我目前所在公司正好对产品做了一次“大布局重构”，下面我就分享这个“大布局”项目经验给大家。 
  
 
 背景 
 
        公司专注于企业级管理产品软件，企业有大中小之分，在2000年初公司用JSP/Servlet开发了一套针对中
    
                                
    • 
                                
  • 电驴链接在线视频播放源码
                                    dubinwei
源码电驴播放器视频ed2k
                                    
    本项目是个搜索电驴（ed2k）链接的应用,借助于磁力视频播放器（官网： 
http://loveandroid.duapp.com/ 开放平台），可以实现在线播放视频，也可以用迅雷或者其他下载工具下载。 
项目源码： 
http://git.oschina.net/svo/Emule,动态更新。也可从附件中下载。 
项目源码依赖于两个库项目，库项目一链接： 
http://git.oschina.
    
                                
    • 
                                
  • Javascript中函数的toString()方法
                                    周凡杨
JavaScriptjstoStringfunctionobject
                                    
    简述 
    The toString() method returns a string representing the source code of the function. 
    简译之，Javascript的toString()方法返回一个代表函数源代码的字符串。 
句法 
    function.
    
                                
    • 
                                
  • struts处理自定义异常
                                    g21121
struts
                                    
    很多时候我们会用到自定义异常来表示特定的错误情况，自定义异常比较简单，只要分清是运行时异常还是非运行时异常即可，运行时异常不需要捕获，继承自RuntimeException，是由容器自己抛出，例如空指针异常。 
非运行时异常继承自Exception，在抛出后需要捕获，例如文件未找到异常。 
此处我们用的是非运行时异常，首先定义一个异常LoginException: 
/**
 * 类描述：登录相
    
                                
    • 
                                
  • Linux中find常见用法示例
                                    510888780
linux
                                    
    Linux中find常见用法示例 
 
·find   path   -option   [   -print ]   [ -exec   -ok   command ]   {} \; 
 
 
 
 
find命令的参数；
    
                                
    • 
                                
  • SpringMVC的各种参数绑定方式
                                    Harry642
springMVC绑定表单
                                    
    1. 基本数据类型(以int为例，其他类似)： 
Controller代码： 
 

    @RequestMapping("saysth.do")
    public void test(int count) {
    }
 
表单代码： 
 

<form action="saysth.do" method="post&q
    
                                
    • 
                                
  • Java 获取Oracle ROWID
                                    aijuans
javaoracle
                                    
      
A ROWID is an identification tag unique for each row of an Oracle Database table. The ROWID can be thought of as a virtual column, containing the ID for each row. 
The oracle.sql.ROWID class i
    
                                
    • 
                                
  • java获取方法的参数名
                                    antlove
javajdkparametermethodreflect
                                    
    reflect.ClassInformationUtil.java 
package reflect;

import javassist.ClassPool;
import javassist.CtClass;
import javassist.CtMethod;
import javassist.Modifier;
import javassist.bytecode.CodeAtt
    
                                
    • 
                                
  • JAVA正则表达式匹配 查找 替换 提取操作
                                    百合不是茶
java正则表达式替换提取查找
                                    
    正则表达式的查找;主要是用到String类中的split(); 
      String str; 
     str.split();方法中传入按照什么规则截取,返回一个String数组 
  
常见的截取规则: 
str.split("\\.")按照.来截取

str.
    
                                
    • 
                                
  • Java中equals()与hashCode()方法详解
                                    bijian1013
javasetequals()hashCode()
                                    
    一.equals()方法详解 
    equals()方法在object类中定义如下：  
public boolean equals(Object obj) {
    return (this == obj);
}
 
   很明显是对两个对象的地址值进行的比较（即比较引用是否相同）。但是我们知道，String 、Math、I
    
                                
    • 
                                
  • 精通Oracle10编程SQL(4)使用SQL语句
                                    bijian1013
oracle数据库plsql
                                    
    --工资级别表
create table SALGRADE
(
  GRADE    NUMBER(10),
  LOSAL    NUMBER(10,2),
  HISAL    NUMBER(10,2)
)

insert into SALGRADE values(1,0,100);
insert into SALGRADE values(2,100,200);
inser
    
                                
    • 
                                
  • 【Nginx二】Nginx作为静态文件HTTP服务器
                                    bit1129
HTTP服务器
                                    
     Nginx作为静态文件HTTP服务器 
 
  在本地系统中创建/data/www目录，存放html文件(包括index.html) 
 创建/data/images目录，存放imags图片 
 在主配置文件中添加http指令 
 
  
http {
    server {
        listen       80;
        server_name  
    
                                
    • 
                                
  • kafka获得最新partition offset
                                    blackproof
kafkapartitionoffset最新
                                    
    kafka获得partition下标，需要用到kafka的simpleconsumer 
  
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.
    
                                
    • 
                                
  • centos 7安装docker两种方式
                                    ronin47

                                    
          第一种是采用yum 方式 
             yum install -y docker 
          
    
                                
    • 
                                
  • java-60-在O(1)时间删除链表结点
                                    bylijinnan
java
                                    
    

public class DeleteNode_O1_Time {

	/**
	 * Q 60 在O(1)时间删除链表结点
	 * 给定链表的头指针和一个结点指针(!!)，在O(1)时间删除该结点
	 * 
	 * Assume the list is:
	 * head->...->nodeToDelete->mNode->nNode->..
    
                                
    • 
                                
  • nginx利用proxy_cache来缓存文件
                                    cfyme
cache
                                    
    user  zhangy users;
worker_processes 10;
error_log  /var/vlogs/nginx_error.log  crit;
pid        /var/vlogs/nginx.pid;
#Specifies the value for ma
    
                                
    • 
                                
  • [JWFD开源工作流]JWFD嵌入式语法分析器负号的使用问题
                                    comsci
嵌入式
                                    
     
    假如我们需要用JWFD的语法分析模块定义一个带负号的方程式，直接在方程式之前添加负号是不正确的，而必须这样做： 
 
    string str01 = "a=3.14;b=2.71;c=0;c-((a*a)+(b*b))" 
 
    定义一个0整数c,然后用这个整数c去
    
                                
    • 
                                
  • 如何集成支付宝官方文档
                                    dai_lm
android
                                    
    官方文档下载地址 
 
https://b.alipay.com/order/productDetail.htm?productId=2012120700377310&tabId=4#ps-tabinfo-hash 
 
集成的必要条件 
1. 需要有自己的Server接收支付宝的消息 
2. 需要先制作app，然后提交支付宝审核，通过后才能集成 
 
调试的时候估计会真的扣款，请注意 

    
                                
    • 
                                
  • 应该在什么时候使用Hadoop
                                    datamachine
hadoop
                                    
    原帖地址：http://blog.chinaunix.net/uid-301743-id-3925358.html 
 
存档，某些观点与我不谋而合，过度技术化不可取，且hadoop并非万能。 
 
--------------------------------------------万能的分割线-------------------------------- 
有人问我，“你在大数据和Hado
    
                                
    • 
                                
  • 在GridView中对于有外键的字段使用关联模型进行搜索和排序
                                    dcj3sjt126com
yii
                                    
    在GridView中使用关联模型进行搜索和排序 
首先我们有两个模型它们直接有关联:   
class Author extends CActiveRecord {
...
}
 
class Post extends CActiveRecord {
...
    function relations() {
        return array(
            '
    
                                
    • 
                                
  • 使用NSString 的格式化大全
                                    dcj3sjt126com
Objective-C
                                    
    格式定义The format specifiers supported by the NSString formatting methods and CFString formatting functions follow the IEEE printf specification; the specifiers are summarized in Table 1. Note that you c
    
                                
    • 
                                
  • 使用activeX插件对象object滚动有重影
                                    蕃薯耀
activeX插件滚动有重影
                                    
        
使用activeX插件对象object滚动有重影       <object style="width:0;" id="abc" classid="CLSID:D3E3970F-2927-9680-BBB4-5D0889909DF6" codebase="activex/OAX339.CAB#
    
                                
    • 
                                
  • SpringMVC4零配置
                                    hanqunfeng
springmvc4
                                    
    基于Servlet3.0规范和SpringMVC4注解式配置方式，实现零xml配置，弄了个小demo，供交流讨论。 
  
  
项目说明如下： 
1.db.sql是项目中用到的表，数据库使用的是oracle11g 
2.该项目使用mvn进行管理，私服为自搭建nexus,项目只用到一个第三方 jar，就是oracle的驱动； 
3.默认项目为零配置启动，如果需要更改启动方式，请
    
                                
    • 
                                
  • 《开源框架那点事儿16》：缓存相关代码的演变
                                    j2eetop
开源框架
                                    
    问题引入 
上次我参与某个大型项目的优化工作，由于系统要求有比较高的TPS，因此就免不了要使用缓冲。 
该项目中用的缓冲比较多，有MemCache，有Redis，有的还需要提供二级缓冲，也就是说应用服务器这层也可以设置一些缓冲。 
当然去看相关实现代代码的时候，大致是下面的样子。    
[java] 
view plain 
copy 
print 
?   
 
 public vo
    
                                
    • 
                                
  • AngularJS浅析
                                    kvhur
JavaScript
                                    
    概念 
 
 AngularJS is a structural framework for dynamic web apps. 
 了解更多详情请见原文链接：http://www.gbtags.com/gb/share/5726.htm 
 Directive 
扩展html，给html添加声明语句，以便实现自己的需求。对于页面中html元素以ng为前缀的属性名称，ng是angular的命名空间
    
                                
    • 
                                
  • 架构师之jdk的bug排查(一)---------------split的点号陷阱
                                    nannan408
split
                                    
    1.前言. 
   jdk1.6的lang包的split方法是有bug的,它不能有效识别A.b.c这种类型,导致截取长度始终是0.而对于其他字符,则无此问题.不知道官方有没有修复这个bug. 
2.代码 
 

String[] paths = "object.object2.prop11".split("'");
System.ou
    
                                
    • 
                                
  • 如何对10亿数据量级的mongoDB作高效的全表扫描
                                    quentinXXZ
mongodb
                                    
      本文链接: 
http://quentinXXZ.iteye.com/blog/2149440  
一、正常情况下，不应该有这种需求 
首先，大家应该有个概念，标题中的这个问题，在大多情况下是一个伪命题，不应该被提出来。要知道，对于一般较大数据量的数据库，全表查询，这种操作一般情况下是不应该出现的，在做正常查询的时候，如果是范围查询，你至少应该要加上limit。 
说一下，
    
                                
    • 
                                
  • C语言算法之水仙花数
                                    qiufeihu
c算法
                                    
    /**
* 水仙花数
*/
#include <stdio.h>
#define N 10
int main()
{
    int x,y,z;
    for(x=1;x<=N;x++)
    	for(y=0;y<=N;y++)
    		for(z=0;z<=N;z++)
    			if(x*100+y*10+z == x*x*x
    
                                
    • 
                                
  • JSP指令
                                    wyzuomumu
jsp
                                    
     
 jsp指令的一般语法格式： <%@ 指令名 属性 =”值 ” %> 
  常用的三种指令： page,include,taglib 
 page指令语法形式： <%@ page 属性 1=”值 1” 属性 2=”值 2”%> 
 include指令语法形式： <%@include file=”relative url”%> (jsp可以通过 include
    
                                
    •