崛起于Springboot2.X之区块链单节点mysql实现交易记录(34)-CSDN博客

为什么80%的码农都做不了架构师？>>>

简介：随着今年越来越多的区块链项目更多的落地，我们自己公司也想准备着手区块链方向发展，所以领导给我们技术部要求也要落地一个区块链的项目，其实之前一两个月也接触了Hyperledger这个框架，当然我自己的博客分类中也有对Hyperledger框架的大概集成以及搭建，但是我接触几个月的时间里，懵懂，不知道作用是什么？读过好多类似这个框架有关的书，但直觉告诉我，他们对于现阶段的我，没用！包括《区块链技术进阶与实战》《区块链开发实战 hyperledger fabric 关键技术与案例分析》《深度探索区块链 Hyperledger技术与应用》《Hyperledger Fabric 开发实战》，最后一本只是看了看，没有具体细看，不过这书写的都是大同小异，雷同之处太多。然后我就在想，这个框架学习来要很久吧，毕竟自己要搞这个，我也是个java，没有接触过这方面的，即便上一个公司的区块链项目已经落地，但是技术没有接触过，只不过当时用的是python，那个产品是InsurBox，不过那也是一个类似于挖矿的小游戏，但是完全跟公司业务不同。

需求：公司是做一个类似基金股票之类的平台，用户买卖股票或者基金的话，或者体现，支付那些交易记录都要用区块链实现。

后来我自己又想了想，自己在没人带，完全靠自己，网上根本没有教材的情况下，很能短时间熟练的运用Hyperledger这本技术框架，所以我突然又想到了另外一种方案，既然Hyperledger是结合区块链的思想写出来的，那么我们的为什么不能用区块链的思想直接用java写出来，为什么还要花费那么长的时间去学习那样的技术。所以我结合公司业务以及区块链的思想，自己整出了一套简单的区块链交易记录。

区块链思想：1、去中心化【做不到共有链，这是一个关于股票基金的产品，不能共享！】

2、信息不可篡改【可以做到，安全加密】

3、多节点运行，允许1/3的节点最大程度被攻击而不破坏区块【可以做到】

4、分布式数据库。【可以做到】

综合以上所述，个人觉得，也没必要完全利用Hyperledger，所以这个技术还是慢慢学习吧，暂且不用了，成本太高。

redis+mysql+lombok 下一篇将使用mongodb替代mysql，所以目前只是一个简单的区块链交易记录，因为自我感觉也不好，所以也希望大家指出来之后多做更改！目前只是单节点，所以不存在多节点查询的算法，下一篇替换mongodb将会多节点

1、添加pom文件依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <scope>runtime</scope>
</dependency>
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>1.3.2</version>
</dependency>

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>


<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.47</version>
</dependency>
<dependency>
    <groupId>commons-collections</groupId>
    <artifactId>commons-collections</artifactId>
    <version>3.2.2</version>
</dependency>

2、mysql表结构

2.1 交易表 t_point_deal 目前只用一个记录结果代替交易过程，毕竟保密，

CREATE TABLE `t_point_deal` (
`DEAL_ID` varchar(200) NOT NULL COMMENT '交易单id',
`BUY_USER_ID` int(10) NOT NULL COMMENT '买方id',
`BUY_ORDER_ID` bigint(10) unsigned NOT NULL,
`SELL_USER_ID` int(11) NOT NULL COMMENT '卖方id',
`SELL_ORDER_ID` bigint(10) unsigned NOT NULL,
`POINT_ID` int(11) NOT NULL COMMENT '基金id号',
`DEAL_DATE` datetime NOT NULL COMMENT '交易日期',
`DEAL_NUM` int(11) unsigned NOT NULL COMMENT '交易数量',
`DEAL_UNIT_PRICE` double(8,2) unsigned NOT NULL COMMENT '交易单价',
`DEAL_PRICE` double(9,2) unsigned NOT NULL COMMENT '成交额',
PRIMARY KEY (`DEAL_ID`),
) ENGINE=InnoDB DEFAULT CHARSET=utf8 ROW_FORMAT=COMPACT

2.2 区块表 t_block

CREATE TABLE `t_block` (
`block_index` int(10) NOT NULL AUTO_INCREMENT COMMENT '区块索引号',
`block_hash` varchar(100) NOT NULL COMMENT 'hash值',
`block_stamp` varchar(40) NOT NULL COMMENT '时间戳',
`pointDeals` mediumtext COMMENT '基金交易记录',
`block_nonce` int(10) NOT NULL COMMENT '随机数',
`previousHash` varchar(100) NOT NULL COMMENT '上一个区块hash值',
PRIMARY KEY (`block_index`)
) ENGINE=MyISAM AUTO_INCREMENT=83 DEFAULT CHARSET=utf8

3、实体类Entity

@Data
@AllArgsConstructor
@NoArgsConstructor
public class PointDeal {

    private String dealId;
    private Integer buyUserId;
    private Long buyOrderId;
    private Integer sellUserId;
    private Long sellOrderId;
    private Integer pointId;
    private Date dealDate;
    private Integer dealNum;
    private Double dealUnitPrice;
    private Double dealPrice;
}

@Data
public class Block {

    /**

     * 区块索引号

     */

    private int index;

    /**

     * 当前区块的hash值,区块唯一标识

     */

    private String hash;

    /**

     * 生成区块的时间戳

     */

    private long timestamp;

    /**

     * 当前区块的交易集合

     */

    private List<PointDeal> pointDeals;

    private String data;

    /**

     * 工作量证明，计算正确hash值的次数

     */
    private int nonce;
    /**

     * 前一个区块的hash值

     */
    private String previousHash;

    public Block() {
        super();
    }

    public Block(int index, long timestamp, List<PointDeal> pointDeals, String data, int nonce, String previousHash, String hash) {
        super();
        this.index = index;
        this.timestamp = timestamp;
        this.pointDeals= pointDeals;
        this.nonce = nonce;
        this.previousHash = previousHash;
        this.hash = hash;
    }
}

4、application.properties配置

server.port=8092

#mysql:
spring.datasource.url=jdbc:mysql://localhost:3306/XX?characterEncoding=utf8&useSSL=false
spring.datasource.username=
spring.datasource.password=
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.max-idle=10
spring.datasource.max-wait=10000
spring.datasource.min-idle=5
spring.datasource.initial-size=5



mybatis.mapper-Locations=classpath:mapper/entity/*.xml
mybatis.type-aliases-package=com.dtb.trade.entity

spring.redis.database=0
spring.redis.host=localhost
spring.redis.port=6379
spring.redis.password=
spring.redis.timeout=10000ms

spring.freemarker.allow-request-override=false
spring.freemarker.cache=true
spring.freemarker.check-template-location=true
spring.freemarker.charset=UTF-8
spring.freemarker.content-type=text/html
spring.freemarker.expose-request-attributes=false
spring.freemarker.expose-session-attributes=false
spring.freemarker.expose-spring-macro-helpers=false
spring.freemarker.suffix=.html

5、启动类Application

方法上添加扫描包注解

@MapperScan(basePackages={"com.dtb.trade"})

6、加密工具类SHA256

public class EncryptUtil {

    /**
     * 对字符串加密,加密算法使用MD5,SHA-1,SHA-256,默认使用SHA-256
     *
     * @param strSrc
     *            要加密的字符串
     * @param encName
     *            加密类型
     * @return
     */
    public static String Encrypt(String strSrc) {

        MessageDigest md = null;
        String strDes    = null;
        String encName   = "SHA-256";
        byte[] bt        = strSrc.getBytes();

        try {
            md = MessageDigest.getInstance(encName);
            md.update(bt);
            strDes = bytes2Hex(md.digest()); //to HexString
        } catch (NoSuchAlgorithmException e) {
            return null;
        }

        return strDes;
    }

    public static String bytes2Hex(byte[] bts) {

        String des = "";
        String tmp = null;

        for (int i = 0; i < bts.length; i++) {
            tmp = (Integer.toHexString(bts[i] & 0xFF));
            if (tmp.length() == 1) {
                des += "0";
            }
            des += tmp;
        }
        return des;
    }
}

7、controller层

7.1 查询交易记录，根据t_point_deal 中的买方id查询

7.2 更新交易记录到区块链上

@Controller
@Slf4j
public class TradeController {


    @Autowired
    TradeService tradeService;

    @Autowired
    RedisService redisService;


    //查询区块地址
    @GetMapping(value = "/block/{id}")
    public String getBlockAdress(@PathVariable("id")String id, ModelMap modelMap){
        //获取所有区
        List<Block> list = tradeService.getAllBlock();
        int userId  = Integer.valueOf(id);
        if (list == null){
            modelMap.put("msg","区块信息为空");
            modelMap.put("success",false);
            modelMap.put("code",210);
        }

        List<PointDeal> results = new ArrayList<>();
        for (Block block:list){
            List<PointDeal> pointDeals = JSONObject.parseArray(block.getData(),PointDeal.class);
            List<PointDeal> list1 = pointDeals.stream().filter(pointDeal -> pointDeal.getBuyUserId().equals(userId)).collect(Collectors.toList());
            if (pointDeals != null){
                results.addAll(list1);
            }
        }

        modelMap.put("page",results);
        return "/blockInfo";

    }


    //测试记账
    @GetMapping(value = "/block/test")
    public void test1(){
        List<PointDeal> list = tradeService.gainAllTrade();

        if (list.size()>0){
            //获取交易块
            Block block = null;
            String index = redisService.get("blockIndex");
            if (StringUtils.isEmpty(index)){
                //直接从数据库查询
                boolean isHave = tradeService.isBlock();
                if (!isHave){
                    //生成创世区块
                    tradeService.hyperledgerTwo(firstBlock(),list);
                }
                block = tradeService.getNewBlock();
                tradeService.hyperledger(block,list);

            }else {
                //查询区块信息
                block = tradeService.selectBlock(Integer.valueOf(index));
                if (block != null){
                    tradeService.hyperledger(block,list);
                }else {
                    System.out.println("区块出现异常");
                }
            }
        }

    }


    public static Block firstBlock(){

        Block block = new Block();

        String prev = "0000000000000000000000000000000000000000000000000000000000000000";
        int index   = 1;
        int nonce   = 1;
        long time   = System.currentTimeMillis();
        String hash = EncryptUtil.Encrypt(prev+index+nonce+time);
        List<PointDeal> list = new ArrayList<>();


        block.setPreviousHash(prev);
        block.setIndex(index);
        block.setNonce(nonce);
        block.setHash(hash);
        block.setTimestamp(time);
        block.setPointDeals(null);
        block.setPointDeals(list);

        return block;
    }
}

8、service层

8.1 RedisService 这个redis我删除了多余的方法

package com.dtb.trade.service;

import com.alibaba.fastjson.JSONObject;
import org.apache.commons.collections.MapUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.*;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.util.*;
import java.util.concurrent.TimeUnit;

/**
 * @Author:Mujiutian
 * @Description:
 * @Date: Created in 下午2:18 2018/7/13
 */
@Service
public class RedisService {

    @Autowired
    StringRedisTemplate stringRedisTemplate;

    private String reidsKeyTitle = "pc_enterprise";

    public String getString(String key) {
        return stringRedisTemplate.opsForValue().get(changereidsKeyTitle(key));
    }

    /**
     * 向redis存入key和value
     * 如果key已经存在 则覆盖
     * @param key
     * @param value
     */
    public void set(String key, String value){
        ValueOperations<String, String> opsForValue = stringRedisTemplate.opsForValue();
        opsForValue.set(changereidsKeyTitle(key), value);
    }
   /**
     * 向redis指定的db中存入key和value以及设置生存时间
     * 如果key已经存在 则覆盖
     * @param key
     * @param value
     * @param time    有效时间(默认时间单位为秒)
     * @param
     */
    public void set(String key, String value, Long time){
        ValueOperations<String, String> opsForValue = stringRedisTemplate.opsForValue();
        // 默认时间单位为秒
        opsForValue.set(changereidsKeyTitle(key), value, time, TimeUnit.SECONDS);
    }

    /**
     * 通过key获取指定的value
     * @param key
     * @param
     * @return 没有返回null
     */
    public String get(String key) {
        return stringRedisTemplate.opsForValue().get(changereidsKeyTitle(key));
    }
}

8.2 TradeService 记账核心方法

@Service
public class TradeService {

    @Autowired
    TradeDao tradeDao;

    @Autowired
    RedisService redisService;

    //区块拥有交易记录的最大个数
    private static final int blockMax = 5;

    //该区块已经拥有的交易记录个数
    private static int blockNum = 0;

    //获取定时刷新的交易记录
    public List<PointDeal> gainAllTrade(){

        Map<String,Object> map = new HashMap<>();
        String today = new SimpleDateFormat("yyyy-MM-dd").format(new Date());
        map.put("start",today+" 00:00:00");
        map.put("end",today+" 23:59:59");
        return tradeDao.getAll(map);
    }

    //查询是否拥有数据块
    public boolean isBlock(){
        List<Block> list = tradeDao.isHave();
        if (list == null || list.isEmpty() || list.size()==0){
            return false;
        }
        return true;

    }

    //新增区块信息
    public boolean insertBlock(Block block){
        tradeDao.insertBlock(block);
        return true;
    }

    //更新区块信息
    public boolean updateBlock(Block block){
        tradeDao.updateBlock(block);
        return true;
    }

    //根据索引号查询区块信息
    public Block selectBlock(int index){
        return tradeDao.selectBlock(index);
    }

    //查询最新区块信息
    public Block getNewBlock(){
        Block block = tradeDao.getBlockIndex();

        block.setPointDeals(JSONObject.parseArray(block.getData(),PointDeal.class));

        return block;
    }

    //记账
    public boolean hyperledger(Block block,List<PointDeal> pointDeals){


        if (block.getPointDeals() != null){
            blockNum   = block.getPointDeals().size();
        }

        //准备记账的记忆记录个数
        int recordNum  = pointDeals.size();

        //欠缺，补足到最大区块个数
        int deficiency = blockMax - blockNum;

        //该区块是否能满足记账交易记录的个数，0刚好满足，正数绰绰有余，负数不满足，生成新的区块
        int surplusNum = deficiency-recordNum;

        if (blockNum < blockMax){
            //更新区块信息
            if (surplusNum >= 0){
                block.getPointDeals().addAll(pointDeals);
                block.setData(JSON.toJSONString(block.getPointDeals()));
                tradeDao.updateBlock(block);
            }else {
                //填补区块剩余
                for (int j =0;j<deficiency;j++){
                    block.getPointDeals().add(pointDeals.get(0));
                    pointDeals.remove(0);
                    //更新到数据库
                    block.setData(JSON.toJSONString(block.getPointDeals()));
                    tradeDao.updateBlock(block);
                    redisService.set("blockIndex",block.getIndex()+"");
                }
                //生成下一区块
                String nextPrev = block.getHash();
                int nextIndex   = block.getIndex()+1;
                int nextnonce   = block.getNonce();
                long nextTime   = System.currentTimeMillis();
                String nextHash = EncryptUtil.Encrypt(nextPrev+nextIndex+nextnonce+nextTime+block.getData());

                Block nextBlock = new Block();
                nextBlock.setTimestamp(nextTime);
                nextBlock.setPreviousHash(nextPrev);
                nextBlock.setHash(nextHash);
                nextBlock.setNonce(nextnonce);
                nextBlock.setIndex(nextIndex);
                hyperledgerTwo(nextBlock,pointDeals);
            }
        }else {
            //直接生成新区块
            String nextPrev      = block.getHash();
            int nextIndex        = block.getIndex()+1;
            int nextnonce        = block.getNonce();
            long nextTime        = System.currentTimeMillis();
            String nextHash      = EncryptUtil.Encrypt(nextPrev+nextIndex+nextnonce+nextTime+block.getData());
            List<PointDeal> list = new ArrayList<>();

            Block nextBlock = new Block();
            nextBlock.setTimestamp(nextTime);
            nextBlock.setPreviousHash(nextPrev);
            nextBlock.setHash(nextHash);
            nextBlock.setNonce(nextnonce);
            nextBlock.setIndex(nextIndex);
            nextBlock.setPointDeals(list);
            hyperledgerTwo(nextBlock,pointDeals);

        }

        return true;

    }

    //新区块记账
    public void hyperledgerTwo(Block block,List<PointDeal> pointDeals){

        int recordNum  = pointDeals.size();
        int deficiency = blockMax - blockNum;
        int surplusNum = deficiency-recordNum;

        if (surplusNum >= 0){
            //满足
            block.getPointDeals().addAll(pointDeals);
            block.setData(JSON.toJSONString(block.getPointDeals()));
            tradeDao.insertBlock(block);
            redisService.set("blockIndex",block.getIndex()+"");
        }else {
            //不满足
            for (int j =0;j<deficiency;j++){
                block.getPointDeals().add(pointDeals.get(0));
                pointDeals.remove(0);
            }
            block.setData(JSON.toJSONString(block.getPointDeals()));
            //更新到数据库
            tradeDao.insertBlock(block);

            //生成下一区块
            String nextPrev      = block.getHash();
            int nextIndex        = block.getIndex()+1;
            int nextnonce        = block.getNonce();
            long nextTime        = System.currentTimeMillis();
            String nextHash      = EncryptUtil.Encrypt(nextPrev+nextIndex+nextnonce+nextTime+block.getData());
            List<PointDeal> list = new ArrayList<>();

            Block nextBlock = new Block();
            nextBlock.setTimestamp(nextTime);
            nextBlock.setPreviousHash(nextPrev);
            nextBlock.setHash(nextHash);
            nextBlock.setNonce(nextnonce);
            nextBlock.setIndex(nextIndex);
            nextBlock.setPointDeals(list);

            hyperledgerTwo(nextBlock,pointDeals);
        }

    }

    //获取所有区块
    public List<Block> getAllBlock(){
        List<Block> blocks = tradeDao.isHave();
        if (blocks != null || blocks.size() > 0){
            return blocks;
        }
        return null;
     }

}

9、dao层

public interface TradeDao {



    @Select({
            "select * from t_point_deal where DEAL_DATE >= #{start} and DEAL_DATE <= #{end}"
    })
    @Results({
            @Result(column = "DEAL_ID",property = "dealId",jdbcType = JdbcType.VARCHAR),
            @Result(column = "BUY_USER_ID",property = "buyUserId",jdbcType = JdbcType.INTEGER),
            @Result(column = "BUY_ORDER_ID",property = "buyOrderId",jdbcType = JdbcType.BIGINT),
            @Result(column = "SELL_USER_ID",property = "sellUserId",jdbcType = JdbcType.INTEGER),
            @Result(column = "SELL_ORDER_ID",property = "sellOrderId",jdbcType = JdbcType.BIGINT),
            @Result(column = "POINT_ID",property = "pointId",jdbcType = JdbcType.INTEGER),
            @Result(column = "DEAL_DATE",property = "dealDate",jdbcType = JdbcType.DATE),
            @Result(column = "DEAL_NUM",property = "dealNum",jdbcType = JdbcType.INTEGER),
            @Result(column = "DEAL_UNIT_PRICE",property = "dealUnitPrice",jdbcType = JdbcType.DOUBLE),
            @Result(column = "DEAL_PRICE",property = "dealPrice",jdbcType = JdbcType.DOUBLE),
    })
    List<PointDeal> getAll(Map<String,Object> map);


    @Select({
            "select * from t_block"
    })
    @Results({
            @Result(column = "block_index",property = "index",jdbcType = JdbcType.INTEGER),
            @Result(column = "block_hash",property = "hash",jdbcType = JdbcType.VARCHAR),
            @Result(column = "block_stamp",property = "timestamp",jdbcType = JdbcType.TIMESTAMP),
            @Result(column = "pointDeals",property = "data",jdbcType = JdbcType.LONGVARCHAR),
            @Result(column = "block_nonce",property = "nonce",jdbcType = JdbcType.INTEGER),
            @Result(column = "previousHash",property = "previousHash",jdbcType = JdbcType.VARCHAR)
    })
    List<Block> isHave();

    @Select({
            "select * from t_block order by block_index desc limit 0,1"
    })
    @Results({
            @Result(column = "block_index",property = "index",jdbcType = JdbcType.INTEGER),
            @Result(column = "block_hash",property = "hash",jdbcType = JdbcType.VARCHAR),
            @Result(column = "block_stamp",property = "timestamp",jdbcType = JdbcType.TIMESTAMP),
            @Result(column = "pointDeals",property = "data",jdbcType = JdbcType.LONGVARCHAR),
            @Result(column = "block_nonce",property = "nonce",jdbcType = JdbcType.INTEGER),
            @Result(column = "previousHash",property = "previousHash",jdbcType = JdbcType.VARCHAR)
    })
    Block getBlockIndex();

    @Insert({
            "insert into t_block (block_hash,block_stamp,pointDeals,block_nonce,previousHash) values(#{hash},#{timestamp},#{data},#{nonce},#{previousHash})"
    })
    int insertBlock(Block block);

    @Update({
            "update t_block set pointDeals = #{data} where block_index = #{index}"
    })
    int updateBlock(Block block);


    @Select({
            "select * from t_block where block_index = #{index}"
    })
    @Results({
            @Result(column = "block_index",property = "index",jdbcType = JdbcType.INTEGER),
            @Result(column = "block_hash",property = "hash",jdbcType = JdbcType.VARCHAR),
            @Result(column = "block_stamp",property = "timestamp",jdbcType = JdbcType.TIMESTAMP),
            @Result(column = "pointDeals",property = "data",jdbcType = JdbcType.LONGVARCHAR),
            @Result(column = "block_nonce",property = "nonce",jdbcType = JdbcType.INTEGER),
            @Result(column = "previousHash",property = "previousHash",jdbcType = JdbcType.VARCHAR)
    })
    Block selectBlock(@Param("index")int index);
}

10、代码逻辑

10.1

@GetMapping(value = "/block/test")

这个rest接口代码逻辑是先从mysql block区块中判断有无区块，如果没有那么生成创世区块，如果有的话，那么在原有区块继续添加交易记录，直到区块中的交易记录数量达到限制，在重新下一个区块继续。

10.2

@GetMapping(value = "/block/{id}")

根据买方id（t_point_deal 中的字段）查询她所有的交易记录

10.3

如果自己要测试的话，那么可以在t_point_deal表中随意添加几条记录，最后执行接口，就可以看到区块信息了，如图：

10.4 查询的话，那么直接查询接口，然后在templates下创建新的blockInfo.html，因为是freemaker技术嘛

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>区块记录</title>
</head>
<body>

Tx:
<table>
    <thead>
    Block: <span></span><br/>
    Nonce: <span></span><br/>
    <tr>
        <th width="10%">交易id</th>
        <th width="10%">买方id</th>
        <th width="10%">卖方id</th>
        <th width="20%">交易日期</th>
        <th width="10%">交易数量</th>
        <th width="10%">交易单价</th>
        <th width="10%">成交额</th>
    </tr>
    </thead>
    <#if page?size gt 0>
    <tbody>
    <#list page as pointDeals>
    <tr>
        <td width="10%">${pointDeals.dealId!'_'}</td>
        <td width="10%">${pointDeals.buyUserId!'-'}</td>
        <td width="10%">${pointDeals.sellUserId!'_'}</td>
        <td width="20%">${pointDeals.dealDate?string('yyyy-MM-dd HH:mm:ss')!'_'}</td>
        <td width="10%">${pointDeals.dealNum!'_'}</td>
        <td width="10%">${pointDeals.dealUnitPrice!'_'}</td>
        <td width="10%">${pointDeals.dealPrice!'_'}</td>
    </tr>
    </#list>
    </tbody>
    </#if>
</table>
</body>
</html>

执行查询如图：