[关闭]
@iamfox 2015-07-16T03:21:13.000000Z 字数 28543 阅读 1852

汇银新平台代码基本示例

汇银

1. 背景和改造思路

由于英迈思乐虎网交付的代码对持久层的封装原始且难用，进行查询需要编写大量的SQL拼接，关联查询还要依赖大量的数据库视图，对开发业务逻辑操作的效率和代码可维护性影响巨大，因此我们需要一套新的业务逻辑处理和持久化操作代码规范，通过对Hibernate进一步封装，即保留了Hibernate的开发效率高的特性，也要追求接近于Mybatis的灵活性和SQL性能。

以下以虚拟帐户模块做为演示：

虚拟帐户模块可用于管理平台内的各种可用虚拟货币和电子钱包，如红包、积分、返利余额等。

新建了三个maven工程如下：

工程 主要内容 依赖
hy-va-server 包含remote层、service、dao层 hy-va-pojo、lazypack-common
hy-va-domain 包含entity类 hy-va-pojo、lazypack-common
hy-va-pojo 包含远程调用的SOA服务接口，接口传递和返回的参数对象，各种javabean，自定义异常 lazypack-common

所有代码已提交至新的git服务器，地址是：http://192.168.19.21:8082/gitblit
开发人员可以用自己的帐号登录获取代码签出地址，帐号规则和默认密码同禅道。

2. 通用依赖

lazypack-common是一个自行开发的工具包，其最重要的功能就是围绕Hibernate封装了一套极简的操作框架，此外还有些常用工具类。

工具及基本封装类工程lazypack-common，jar包及源码包已上传至http://192.168.19.21:8081/nexus

  1. <dependency>
  2.     <groupId>lazypack</groupId>
  3.     <artifactId>lazypack-common</artifactId>
  4.     <version>0.1</version>
  5. </dependency>

3. 必要的类介绍

看完了上面的效果，现在看一下要完成这样的自动化查询效果，都需要Service层以下提供哪些类。

3.1 业务实体

以帐户表(VA_VIRTUAL_ACCOUNT)，汇银货币种类表(VA_HY_CURRENCY)为例。

两张表的关联关系是
VA_VIRTUAL_ACCOUNT与VA_HY_CURRENCY多对一, 每个币种有多个帐户，每个帐户只会使用一个币种，外键是HY_CURRENCY_ID。

以这两张表建立两个对应的主要根实体VirtualAccount，HyCurrency。

由于表字段过多，全放在一个实体类里会造成阅读和维护困难，因此HyCurrency实体进行了值对象的拆分，将字段分散到不同的组件对象里，多个对象映射一张表，如下图：
实体结构图
用户的字段被拆分到了VirtualAccountBaseInfo，VirtualAccountBalance，VirtualAccountStatus几个对象中，所有字段映射全注解。与数据库的映射使用了Hibernate的Component机制。以下贴出两个实体类的代码，其余的类似：

3.1.1 VirtualAccount
  1. package com.lehumall.va.domain.entity.account;
  3. import java.util.Date;
  5. import javax.persistence.CascadeType;
  6. import javax.persistence.Entity;
  7. import javax.persistence.FetchType;
  8. import javax.persistence.JoinColumn;
  9. import javax.persistence.ManyToOne;
  10. import javax.persistence.Table;
  12. import org.hibernate.annotations.DynamicUpdate;
  13. import org.springframework.beans.BeanUtils;
  15. import com.lehumall.base.domain.entity.DomainLink;
  16. import com.lehumall.va.command.CreateVirtualAccountCommand;
  17. import com.lehumall.va.domain.entity.M;
  18. import com.lehumall.va.domain.entity.base.HyCurrency;
  19. import com.lehumall.va.dto.HyCurrencyDTO;
  20. import com.lehumall.va.dto.VirtualAccountDTO;
  21. import com.lehumall.va.exception.VirtualAccountException;
  23. import lazypack.common.component.StringIdBaseEntity;
  24. import lazypack.common.util.MoneyUtil;
  25. import lazypack.common.util.UUIDGenerator;
  27. /**
  28.  * 虚拟帐户
  29.  * 
  30.  * @author yuxiaoxiang
  31.  * 
  32.  */
  33. @DynamicUpdate
  34. @Entity
  35. @Table(name = M.TABLE_PREFIX + "VIRTUAL_ACCOUNT")
  36. @SuppressWarnings("serial")
  37. public class VirtualAccount extends StringIdBaseEntity {
  39.     /**
  40.      * 帐户基本信息
  41.      */
  42.     private VirtualAccountBaseInfo baseInfo;
  44.     /**
  45.      * 帐户币种
  46.      */
  47.     @ManyToOne(cascade = CascadeType.DETACH, fetch = FetchType.LAZY)
  48.     @JoinColumn(name = "CURRENCY_ID", nullable = false)
  49.     private HyCurrency currency;
  51.     /**
  52.      * 所属父帐户，父帐户余额由所有子帐户余额累加
  53.      */
  54.     @ManyToOne(cascade = CascadeType.DETACH, fetch = FetchType.LAZY)
  55.     @JoinColumn(name = "PARENT_ID", nullable = true)
  56.     private VirtualAccount parent;
  58.     /**
  59.      * 帐户归属主体
  60.      */
  61.     private DomainLink onwer;
  63.     /**
  64.      * 帐户余额
  65.      */
  66.     private VirtualAccountBalance balance;
  68.     /**
  69.      * 帐户状态
  70.      */
  71.     private VirtualAccountStatus status;
  73.     /**
  74.      * 创建
  75.      * 
  76.      * @param command
  77.      */
  78.     public void create(CreateVirtualAccountCommand command,
  79.             HyCurrency hyCurrency, VirtualAccount parentAccount) {
  80.         setId(UUIDGenerator.getUUID());
  82.         setBaseInfo(new VirtualAccountBaseInfo());
  83.         getBaseInfo().setName(command.getName());
  84.         getBaseInfo().setInvalidDate(command.getInvalidDate());
  85.         getBaseInfo().setProxyAccount(hyCurrency.getProxyCurrency());
  86.         getBaseInfo().setCreateDate(new Date());
  88.         setOnwer(new DomainLink());
  89.         getOnwer().setOutId(command.getSubjectId());
  90.         getOnwer().setType(command.getSubjectType());
  91.         getOnwer().setOutName(command.getSubjectName());
  93.         setCurrency(hyCurrency);
  95.         setBalance(new VirtualAccountBalance());
  96.         getBalance().setTotalAmount(0D);
  97.         getBalance().setAvaiableAmount(0D);
  98.         getBalance().setFrozenAmount(0d);
  100.         setParent(parentAccount);
  102.         setStatus(new VirtualAccountStatus());
  103.         getStatus().setEnable(true);
  104.         getStatus().setClose(false);
  105.     }
  107.     /**
  108.      * 入帐
  109.      * 
  110.      * @param amount
  111.      * @throws VirtualAccountException
  112.      */
  113.     public void moneyIn(Double amount) throws VirtualAccountException {
  114.         checkEnable();
  116.         //  MoneyUtil提供的计算方法为将Double转成BigDecimal计算，保证精度
  117.         Double totalAmount = MoneyUtil.add(getBalance().getTotalAmount(),
  118.                 amount);
  119.         Double avaiableAmount = MoneyUtil.add(getBalance().getAvaiableAmount(),
  120.                 amount);
  121.         getBalance().setAvaiableAmount(avaiableAmount);
  122.         getBalance().setTotalAmount(totalAmount);
  123.     }
  125.     /**
  126.      * 重置帐户为0
  127.      */
  128.     public void reset() {
  129.         getBalance().setAvaiableAmount(0D);
  130.         getBalance().setTotalAmount(0D);
  131.         getBalance().setFrozenAmount(0D);
  132.     }
  134.     /**
  135.      * 从可用余额出帐
  136.      * 
  137.      * @param amount
  138.      * @throws VirtualAccountException
  139.      */
  140.     public void moneyOutFromAvaiable(Double amount)
  141.             throws VirtualAccountException {
  142.         checkEnable();
  144.         if (getBalance().getAvaiableAmount() < amount) {
  145.             throw new VirtualAccountException(
  146.                     VirtualAccountException.AVAIABLE_AMOUNT_NOT_ENOUTH,
  147.                     "可用余额不足");
  148.         }
  150.         Double totalAmount = MoneyUtil.sub(getBalance().getTotalAmount(),
  151.                 amount);
  152.         Double avaiableAmount = MoneyUtil.sub(getBalance().getAvaiableAmount(),
  153.                 amount);
  154.         getBalance().setAvaiableAmount(avaiableAmount);
  155.         getBalance().setTotalAmount(totalAmount);
  156.     }
  158.     /**
  159.      * 从冻结金额出帐
  160.      * 
  161.      * @param amount
  162.      * @throws VirtualAccountException
  163.      */
  164.     public void moneyOutFromFrozen(Double amount,
  165.             VirtualAccount frozenVirtualAccount) throws VirtualAccountException {
  166.         if (amount.doubleValue() != frozenVirtualAccount.getBalance()
  167.                 .getTotalAmount().doubleValue()) {
  168.             throw new VirtualAccountException(
  169.                     VirtualAccountException.FROZEN_AMOUNT_WRONG, "冻结金额与出帐金额不等");
  170.         }
  172.         Double totalAmount = MoneyUtil.sub(getBalance().getTotalAmount(),
  173.                 amount);
  174.         Double frozenAmount = MoneyUtil.sub(getBalance().getFrozenAmount(),
  175.                 amount);
  176.         getBalance().setTotalAmount(totalAmount);
  177.         getBalance().setFrozenAmount(frozenAmount);
  178.     }
  180.     /**
  181.      * 冻结余额
  182.      * 
  183.      * @param amount
  184.      * @throws VirtualAccountException
  185.      */
  186.     public void moneyFrozen(Double amount) throws VirtualAccountException {
  187.         checkEnable();
  189.         if (getBalance().getAvaiableAmount().doubleValue() < amount) {
  190.             throw new VirtualAccountException(
  191.                     VirtualAccountException.AVAIABLE_AMOUNT_NOT_ENOUTH,
  192.                     "可用余额不足");
  193.         }
  195.         Double frozenAmount = MoneyUtil.add(getBalance().getFrozenAmount(),
  196.                 amount);
  197.         Double avaiableAmount = MoneyUtil.sub(getBalance().getAvaiableAmount(),
  198.                 amount);
  200.         getBalance().setAvaiableAmount(avaiableAmount);
  201.         getBalance().setFrozenAmount(frozenAmount);
  202.     }
  204.     /**
  205.      * 解冻余额
  206.      * 
  207.      * @param amount
  208.      * @throws VirtualAccountException
  209.      */
  210.     public void moneyUnFreeze(Double amount) throws VirtualAccountException {
  211.         checkEnable();
  213.         if (getBalance().getAvaiableAmount().doubleValue() < amount) {
  214.             throw new VirtualAccountException(
  215.                     VirtualAccountException.AVAIABLE_AMOUNT_NOT_ENOUTH,
  216.                     "可用余额不足");
  217.         }
  219.         Double frozenAmount = MoneyUtil.sub(getBalance().getFrozenAmount(),
  220.                 amount);
  221.         Double avaiableAmount = MoneyUtil.add(getBalance().getAvaiableAmount(),
  222.                 amount);
  224.         getBalance().setAvaiableAmount(avaiableAmount);
  225.         getBalance().setFrozenAmount(frozenAmount);
  227.     }
  229.     /**
  230.      * 检查帐户正常状态
  231.      * 
  232.      * @throws VirtualAccountException
  233.      */
  234.     public void checkEnable() throws VirtualAccountException {
  235.         if (getStatus().getClose()) {
  236.             throw new VirtualAccountException(
  237.                     VirtualAccountException.ACCOUNT_CLOSE, "帐户已关闭");
  238.         }
  240.         if (!getStatus().getEnable()) {
  241.             throw new VirtualAccountException(
  242.                     VirtualAccountException.ACCOUNT_FORBIDDEN, "帐户禁用中");
  243.         }
  244.     }
  246.     /**
  247.      * 启用
  248.      */
  249.     public void enable() {
  250.         getStatus().setEnable(true);
  251.     }
  253.     /**
  254.      * 禁用
  255.      */
  256.     public void disable() {
  257.         getStatus().setEnable(false);
  258.     }
  260.     /**
  261.      * 关闭
  262.      */
  263.     public void close() {
  264.         getStatus().setClose(true);
  265.     }
  267.     /**
  268.      * 将实体转换成返回给控制层和视图层使用的POJO
  269.      */
  270.     public VirtualAccountDTO trans2DTO(boolean transCurrency,
  271.             boolean transParent) {
  273.         VirtualAccountDTO dto = new VirtualAccountDTO();
  275.         String[] ignore = new String[6];
  276.         ignore[0] = "baseInfo";
  277.         ignore[1] = "currency";
  278.         ignore[2] = "parent";
  279.         ignore[3] = "onwer";
  280.         ignore[4] = "balance";
  281.         ignore[5] = "status";
  282.         BeanUtils.copyProperties(this, dto, ignore);
  284.         dto.setBalance(getBalance().trans2DTO());
  285.         dto.setBaseInfo(getBaseInfo().trans2DTO());
  286.         dto.setOnwer(getOnwer().trans2DTO());
  287.         dto.setStatus(getStatus().trans2DTO());
  289.         if (transParent) {
  290.             VirtualAccountDTO parentDto = getParent().trans2DTO(transCurrency,
  291.                     transParent);
  292.             dto.setParent(parentDto);
  293.         }
  295.         if (transCurrency) {
  296.             HyCurrencyDTO hyCurrencyDTO = getCurrency().trans2DTO();
  297.             dto.setCurrency(hyCurrencyDTO);
  298.         }
  300.         return dto;
  301.     }
  302.     //  setter/getter省略
  304. }
3.1.2 VirtualAccountBalance
  1. package com.lehumall.va.domain.entity.account;
  3. import javax.persistence.Column;
  4. import javax.persistence.Embeddable;
  6. import org.springframework.beans.BeanUtils;
  8. import com.lehumall.base.domain.entity.M;
  9. import com.lehumall.va.dto.VirtualAccountBalanceDTO;
  11. /**
  12.  * 帐户余额
  13.  * 
  14.  * @author yuxiaoxiang
  15.  * 
  16.  */
  17. @Embeddable
  18. public class VirtualAccountBalance {
  20.     /**
  21.      * 总金额
  22.      */
  23.     @Column(name = "TOTAL_AMOUNT", columnDefinition = M.MONEY_COLUMN)
  24.     private Double totalAmount;
  26.     /**
  27.      * 可用金额
  28.      */
  29.     @Column(name = "AVAIABLE_AMOUNT", columnDefinition = M.MONEY_COLUMN)
  30.     private Double avaiableAmount;
  32.     /**
  33.      * 冻结金额
  34.      */
  35.     @Column(name = "FROZEN_AMOUNT", columnDefinition = M.MONEY_COLUMN)
  36.     private Double frozenAmount;
  38.     public VirtualAccountBalanceDTO trans2DTO() {
  39.         VirtualAccountBalanceDTO dto = new VirtualAccountBalanceDTO();
  40.         BeanUtils.copyProperties(this, dto);
  41.         return dto;
  42.     }
  44. }
3.1.3 VirtualAccountBaseInfo
  1. package com.lehumall.va.domain.entity.account;
  3. import java.util.Date;
  5. import javax.persistence.Column;
  6. import javax.persistence.Embeddable;
  8. import org.hibernate.annotations.Type;
  9. import org.springframework.beans.BeanUtils;
  11. import com.lehumall.base.domain.entity.M;
  12. import com.lehumall.va.dto.VirtualAccountBaseInfoDTO;
  14. /**
  15.  * 虚拟帐户基本信息
  16.  * 
  17.  * @author yuxiaoxiang
  18.  * 
  19.  */
  20. @Embeddable
  21. public class VirtualAccountBaseInfo {
  23.     /**
  24.      * 帐号名称
  25.      */
  26.     @Column(name = "NAME")
  27.     private String name;
  29.     /**
  30.      * 创建时间
  31.      */
  32.     @Column(name = "CREATE_DATE", columnDefinition = M.DATE_COLUMN)
  33.     private Date createDate;
  35.     /**
  36.      * 失效时间
  37.      */
  38.     @Column(name = "INVALID_DATE")
  39.     private Date invalidDate;
  41.     /**
  42.      * 是否是代理帐户
  43.      */
  44.     @Type(type = "yes_no")
  45.     @Column(name = "PROXY_ACCOUNT")
  46.     private Boolean proxyAccount;
  48.     public VirtualAccountBaseInfoDTO trans2DTO() {
  49.         VirtualAccountBaseInfoDTO dto = new VirtualAccountBaseInfoDTO();
  50.         BeanUtils.copyProperties(this, dto);
  51.         return dto;
  52.     }
  54. }
3.1.4 VirtualAccountStatus
  1. package com.lehumall.va.domain.entity.account;
  3. import javax.persistence.Column;
  4. import javax.persistence.Embeddable;
  6. import org.hibernate.annotations.Type;
  7. import org.springframework.beans.BeanUtils;
  9. import com.lehumall.va.dto.VirtualAccountStatusDTO;
  11. /**
  12.  * 帐户状态
  13.  * 
  14.  * @author yuxiaoxiang
  15.  * 
  16.  */
  17. @Embeddable
  18. public class VirtualAccountStatus {
  20.     /**
  21.      * 是否已启用
  22.      */
  23.     @Type(type = "yes_no")
  24.     @Column(name = "ENABLE")
  25.     private Boolean enable;
  27.     /**
  28.      * 是否已使用完关闭，不会再启用
  29.      */
  30.     @Type(type = "yes_no")
  31.     @Column(name = "CLOSE")
  32.     private Boolean close;
  34.     public VirtualAccountStatusDTO trans2DTO() {
  35.         VirtualAccountStatusDTO dto = new VirtualAccountStatusDTO();
  36.         BeanUtils.copyProperties(this, dto);
  37.         return dto;
  38.     }
  40.     public Boolean getEnable() {
  41.         return enable;
  42.     }
  44.     public void setEnable(Boolean enable) {
  45.         this.enable = enable;
  46.     }
  48.     public Boolean getClose() {
  49.         return close;
  50.     }
  52.     public void setClose(Boolean close) {
  53.         this.close = close;
  54.     }
  56. }
3.1.5 HyCurrency
  1. package com.lehumall.va.domain.entity.base;
  3. import javax.persistence.Column;
  4. import javax.persistence.Entity;
  5. import javax.persistence.Table;
  7. import org.hibernate.annotations.DynamicUpdate;
  8. import org.hibernate.annotations.Type;
  9. import org.springframework.beans.BeanUtils;
  11. import com.lehumall.va.domain.entity.M;
  12. import com.lehumall.va.dto.HyCurrencyDTO;
  14. import lazypack.common.component.StringIdBaseEntity;
  16. /**
  17.  * 汇银虚拟币种
  18.  * 
  19.  * @author yuxiaoxiang
  20.  * 
  21.  */
  22. @DynamicUpdate
  23. @Entity
  24. @Table(name = M.TABLE_PREFIX + "HY_CURRENCY")
  25. @SuppressWarnings("serial")
  26. public class HyCurrency extends StringIdBaseEntity {
  28.     /**
  29.      * 名称
  30.      */
  31.     @Column(name = "NAME")
  32.     private String name;
  34.     /**
  35.      * 是否启用
  36.      */
  37.     @Type(type = "yes_no")
  38.     @Column(name = "ENABLE")
  39.     private Boolean enable;
  41.     /**
  42.      * 基准汇率，多少抵1元人民币
  43.      */
  44.     @Column(name = "EXCHANGE_ONE_YUAN", columnDefinition = M.MONEY_COLUMN)
  45.     private Double exchangeOneYuan;
  47.     /**
  48.      * 单位名称
  49.      */
  50.     @Column(name = "UNIT")
  51.     private String unit;
  53.     /**
  54.      * 是否是代理币种
  55.      */
  56.     @Type(type = "yes_no")
  57.     @Column(name = "PROXY_CURRENCY")
  58.     private Boolean proxyCurrency;
  60.     public HyCurrencyDTO trans2DTO() {
  61.         HyCurrencyDTO dto = new HyCurrencyDTO();
  63.         BeanUtils.copyProperties(this, dto);
  65.         return dto;
  66.     }
  68. }

3.2 查询条件类QO

为了能从这些表里做查询，我们要把所有可用的查询条件封装到一个查询条件对象里，以方便框架能自动解析并生成SQL语句。以下列出其中两个类，其中的条件字段可以不断增加。

注：加在查询条件字段上的是一组自定义注解，有了这些注解，框架会自动解析并生成SQL，不需要再手工拼接SQL、HQL或者Criteria条件，Service和Dao也不需要自己写任何的查询方法。QO的具体用法会在后面JUNIT例子中演示。

3.2.1 VirtualAccountQO
  1.     package com.lehumall.va.qo;
  3. import lazypack.common.annotation.QueryCondition;
  4. import lazypack.common.annotation.QueryConditionType;
  5. import lazypack.common.component.BaseQO;
  7. /**
  8.  * 虚拟帐户查询条件
  9.  * 
  10.  * @author yuxiaoxiang
  11.  * 
  12.  */
  13. @SuppressWarnings("serial")
  14. public class VirtualAccountQO extends BaseQO<String> {
  16.     private HyCurrencyQO hyCurrencyQO;
  18.     @QueryCondition(name = "currency", type = QueryConditionType.FETCH_EAGER)
  19.     private Boolean fetchCurrency = false;
  21.     private VirtualAccountQO parentQO;
  23.     @QueryCondition(name = "parent", type = QueryConditionType.FETCH_EAGER)
  24.     private Boolean fetchParent = false;
  26.     /**
  27.      * 帐户归属者ID
  28.      */
  29.     @QueryCondition(name = "onwer.outId")
  30.     private String subjectId;
  32.     /**
  33.      * 帐户归属者类型
  34.      */
  35.     @QueryCondition(name = "onwer.type")
  36.     private Integer subjectType;
  38.     public final static Integer ONWER_TYPE_USER = 1; // 个人用户
  39.     public final static Integer ONWER_TYPE_MERCHANT = 2; // 商户
  40.     public final static Integer ONWER_TYPE_PLATFORM = 3; // 平台
  42.     /**
  43.      * 是否已启用
  44.      */
  45.     @QueryCondition(name = "status.enable")
  46.     private Boolean enable;
  48.     /**
  49.      * 是否已使用完关闭，不会再启用
  50.      */
  51.     @QueryCondition(name = "status.enable")
  52.     private Boolean close;
  54.     /**
  55.      * 最小总余额
  56.      */
  57.     @QueryCondition(name = "totalAmount", type = QueryConditionType.GE)
  58.     private Double geTotalAmount;
  60.     /**
  61.      * 最大总余额
  62.      */
  63.     @QueryCondition(name = "totalAmount", type = QueryConditionType.LE)
  64.     private Double leTotalAmount;
  66.     /**
  67.      * 最小可用余额
  68.      */
  69.     @QueryCondition(name = "avaiableAmount", type = QueryConditionType.GE)
  70.     private Double geAvaiableAmount;
  72.     /**
  73.      * 最大可用余额
  74.      */
  75.     @QueryCondition(name = "avaiableAmount", type = QueryConditionType.LE)
  76.     private Double leAvaiableAmount;
  78. }

注：没有QueryConditionType属性的注解，都是默认为and组装和=判断的条件。框架也有提供or条件的注解，但or条件的组装注解可能不具有通用性，在某些情况下是or，在另一些情况下可能会用and，因此建议在dao的条件组装通用方法中进行or的处理。or条件组装的注解如下：

  1.     /**
  2.      * 是否已启用
  3.      */
  4.     @QueryCondition(name = "status.enable")
  5.     @QueryConditionGroup("group1")
  6.     private Boolean enable;
  8.     /**
  9.      * 是否已使用完关闭，不会再启用
  10.      */
  11.     @QueryCondition(name = "status.enable")
  12.     @QueryConditionGroup("group1")
  13.     private Boolean close;

同在一个QueryConditionGroup中的这两个查询条件，具有and (enable = xxx or close = xxx)的效果

3.2.2 HyCurrencyQO
  1. package com.lehumall.va.qo;
  3. import lazypack.common.annotation.QueryCondition;
  4. import lazypack.common.annotation.QueryConditionType;
  5. import lazypack.common.component.BaseQO;
  7. /**
  8.  * 币种查询条件
  9.  * 
  10.  * @author yuxiaoxiang
  11.  * 
  12.  */
  13. @SuppressWarnings("serial")
  14. public class HyCurrencyQO extends BaseQO<String> {
  16.     @QueryCondition(name = "useType", type = QueryConditionType.FETCH_EAGER)
  17.     private boolean fetchUseType;
  19.     @QueryCondition(name = "specImageMap", type = QueryConditionType.FETCH_EAGER)
  20.     private boolean fetchSpecImageMap;
  22. }

3.3 操作命令类Command

Service类中的方法只接受两种参数，一种是QO，一种是Command，QO是查询条件对象，用于查询方法，Command是命令对象，用于增删改方法，它们有不同的父类，父类中定义了一些通用字段。

以下列举了部分命令和处理代码：

3.3.1 创建虚拟帐户
  1. package com.lehumall.va.command;
  3. import java.util.Date;
  5. import lazypack.common.component.BaseCommand;
  7. /**
  8.  * 创建虚拟帐户
  9.  * 
  10.  * @author yuxiaoxiang
  11.  * 
  12.  */
  13. @SuppressWarnings("serial")
  14. public class CreateVirtualAccountCommand extends BaseCommand {
  16.     /**
  17.      * 币种
  18.      */
  19.     private String hyCurrencyId;
  21.     /**
  22.      * 帐号名称
  23.      */
  24.     private String name;
  26.     /**
  27.      * 失效时间
  28.      */
  29.     private Date invalidDate;
  31.     /**
  32.      * 父帐号
  33.      */
  34.     private String parentId;
  36.     /**
  37.      * 帐号归属者名称
  38.      */
  39.     private String onwerName;
  41.     /**
  42.      * 帐号归属者ID
  43.      */
  44.     private String onwerId;
  46.     /**
  47.      * 帐号归属者类型
  48.      */
  49.     private Integer onwerType;
  51.     public final static Integer TYPE_USER = 1; // 个人用户
  52.     public final static Integer TYPE_MERCHANT = 2; // 商户
  53.     public final static Integer TYPE_PLATFORM = 3; // 平台
  55. }
  2. @Service
  3. @Transactional
  4. public class VirtualAccountServiceImpl extends
  5.         BaseServiceImpl<VirtualAccount, VirtualAccountQO, VirtualAccountDao> {
  6.     @Autowired
  7.     private VirtualAccountDao virtualAccountDao;
  8. /**
  9.      * 创建虚拟帐户
  10.      * 
  11.      * @param command
  12.      * @return
  13.      * @throws VirtualAccountException
  14.      */
  15.     @Transactional(rollbackFor = VirtualAccountException.class)
  16.     public VirtualAccount createVirtualAccount(
  17.             CreateVirtualAccountCommand command) throws VirtualAccountException {
  18.         HyCurrency currency = hyCurrencyDao.get(command.getHyCurrencyId());
  20.         VirtualAccount parentAccount = null;
  21.         if (command.getParentId() != null) {
  22.             parentAccount = virtualAccountDao.load(command.getParentId());
  23.         }
  25.         VirtualAccount virtualAccount = new VirtualAccount();
  26.         virtualAccount.create(command, currency, parentAccount);
  28.         virtualAccountDao.save(virtualAccount);
  29.         return virtualAccount;
  30.     }
  31. }
3.3.2 入帐
  1. package com.lehumall.va.command;
  3. import lazypack.common.component.BaseCommand;
  5. /**
  6.  * 入帐
  7.  * 
  8.  * @author yuxiaoxiang
  9.  * 
  10.  */
  11. @SuppressWarnings("serial")
  12. public class MoneyInCommand extends BaseCommand {
  14.     /**
  15.      * 帐户id
  16.      */
  17.     private String accountId;
  19.     /**
  20.      * 入帐的金额
  21.      */
  22.     private Double amount;
  24. }
  1. @Service
  2. @Transactional
  3. public class VirtualAccountServiceImpl extends
  4.         BaseServiceImpl<VirtualAccount, VirtualAccountQO, VirtualAccountDao> {
  5.     @Autowired
  6.     private VirtualAccountDao virtualAccountDao;
  8. /**
  9.      * 入帐
  10.      * 
  11.      * @param command
  12.      * @return
  13.      * @throws VirtualAccountException
  14.      */
  15.     public VirtualAccountBalance moneyIn(MoneyInCommand command)
  16.             throws VirtualAccountException {
  18.         VirtualAccount virtualAccount = virtualAccountDao.get(command
  19.                 .getAccountId());
  21.         if (!virtualAccount.getStatus().getEnable()) {
  22.             throw new VirtualAccountException(
  23.                     VirtualAccountException.ACCOUNT_FORBIDDEN, "帐户禁用中");
  24.         }
  26.         if (virtualAccount.getStatus().getClose()) {
  27.             throw new VirtualAccountException(
  28.                     VirtualAccountException.ACCOUNT_CLOSE, "帐户已关闭");
  29.         }
  31.         virtualAccount.moneyIn(command.getAmount());
  32.         return virtualAccount.getBalance();
  33.     }
  34. }
3.3.3 冻结
  1. package com.lehumall.va.command;
  3. import lazypack.common.component.BaseCommand;
  5. /**
  6.  * 冻结金额
  7.  * 
  8.  * @author yuxiaoxiang
  9.  * 
  10.  */
  11. @SuppressWarnings("serial")
  12. public class MoneyFrozenCommand extends BaseCommand {
  14.     /**
  15.      * 帐户id
  16.      */
  17.     private String accountId;
  19.     /**
  20.      * 冻结的金额
  21.      */
  22.     private Double amount;
  24. }
  2. @Service
  3. @Transactional
  4. public class VirtualAccountServiceImpl extends
  5.         BaseServiceImpl<VirtualAccount, VirtualAccountQO, VirtualAccountDao> {
  6.     @Autowired
  7.     private VirtualAccountDao virtualAccountDao;
  9. /**
  10.      * 冻结金额
  11.      * 
  12.      * @param command
  13.      * @return
  14.      * @throws VirtualAccountException
  15.      */
  16.     public Object[] moneyFrozen(MoneyFrozenCommand command)
  17.             throws VirtualAccountException {
  18.         VirtualAccount virtualAccount = virtualAccountDao.get(command
  19.                 .getAccountId());
  21.         virtualAccount.moneyFrozen(command.getAmount());
  23.         // 创建存冻结余额的冻结帐户
  24.         CreateVirtualAccountCommand createCommand = new CreateVirtualAccountCommand();
  25.         createCommand.setHyCurrencyId(virtualAccount.getCurrency().getId());
  26.         createCommand.setParentId(virtualAccount.getId());
  27.         createCommand.setOnwerId(virtualAccount.getOnwer().getOutId());
  28.         createCommand.setOnwerType(virtualAccount.getOnwer().getType());
  29.         createCommand.setName(virtualAccount.getBaseInfo().getName() + "冻结帐户");
  30.         createCommand.setOnwerName(virtualAccount.getOnwer().getOutName());
  32.         VirtualAccount frozenVirtualAccount = createVirtualAccount(createCommand);
  33.         frozenVirtualAccount.moneyIn(command.getAmount());
  34.         frozenVirtualAccount.moneyFrozen(command.getAmount());
  36.         getDao().save(frozenVirtualAccount);
  37.         getDao().update(virtualAccount);
  39.         Object[] results = new Object[2];
  40.         results[0] = virtualAccount.getBalance();
  41.         results[1] = frozenVirtualAccount.getId();
  42.         return results;
  43.     }
  44. ｝
3.3.4 转帐
  1. package com.lehumall.va.command;
  3. import lazypack.common.component.BaseCommand;
  5. /**
  6.  * 转帐
  7.  * 
  8.  * @author yuxiaoxiang
  9.  * 
  10.  */
  11. @SuppressWarnings("serial")
  12. public class MoneyTransferCommand extends BaseCommand {
  14.     /**
  15.      * 入帐帐户id
  16.      */
  17.     private String inAccountId;
  19.     /**
  20.      * 出帐帐户id
  21.      */
  22.     private String outAccountId;
  24.     /**
  25.      * 冻结id 有值时出帐方使用冻结的金额做扣除，金额要和冻结的对应金额相等 为空时使用出帐方可用余额扣除
  26.      */
  27.     private String frozenId;
  29.     /**
  30.      * 转帐金额
  31.      */
  32.     private Double amount;
  34. }
  1. @Service
  2. @Transactional
  3. public class VirtualAccountServiceImpl extends
  4.         BaseServiceImpl<VirtualAccount, VirtualAccountQO, VirtualAccountDao> {
  5.     @Autowired
  6.     private VirtualAccountDao virtualAccountDao;
  8.     /**
  9.      * 转帐
  10.      * 
  11.      * @param command
  12.      * @return
  13.      * @throws VirtualAccountException
  14.      */
  15.     @Transactional(rollbackFor = VirtualAccountException.class)
  16.     public VirtualAccountBalance[] moneyTransfer(MoneyTransferCommand command)
  17.             throws VirtualAccountException {
  18.         VirtualAccount inAccount = virtualAccountDao.get(command
  19.                 .getInAccountId());
  20.         VirtualAccount outAccount = virtualAccountDao.get(command
  21.                 .getOutAccountId());
  23.         inAccount.moneyIn(command.getAmount());
  24.         if (command.getFrozenId() == null) {
  25.             // 从可用余额付款
  26.             outAccount.moneyOutFromAvaiable(command.getAmount());
  27.         } else {
  28.             // 从冻结金额付款
  29.             VirtualAccount frozenVirtualAccount = virtualAccountDao.get(command
  30.                     .getFrozenId());
  31.             outAccount.moneyOutFromFrozen(command.getAmount(),
  32.                     frozenVirtualAccount);
  33.         }
  35.         VirtualAccountBalance[] virtualAccountBalances = new VirtualAccountBalance[2];
  36.         virtualAccountBalances[0] = inAccount.getBalance();
  37.         virtualAccountBalances[1] = outAccount.getBalance();
  38.         return virtualAccountBalances;
  39.     }
  40. ｝

3.4 service和dao

在具体的业务操作Service实现类中，只有接收Command对象的写操作，接收QO对象的查询操作queryUnique(QO qo)，queryList(QO qo)，queryPagination(QO qo)，queryCount(QO qo)全部都在BaseServiceImpl中。

每个具体实体泛型对应的Dao实现类，也只有一个重写BaseDao的Criteria buildCriteria(Criteria criteria, XXXQO qo)方法，该方法中组装的Criteria条件对象可复用于上述四种查询方法。

3.4.1 UserServiceImpl
  1. package com.lehumall.application.service.user;
  3. import lazypack.common.component.BaseServiceImpl;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.stereotype.Service;
  7. import org.springframework.transaction.annotation.Transactional;
  9. import com.lehumall.application.dao.user.UserDao;
  10. import com.lehumall.domain.entity.user.user.User;
  11. import com.lehumall.pojo.qo.UserQO;
  13. @Service
  14. @Transactional
  15. public class UserServiceImpl extends BaseServiceImpl<User, UserQO, UserDao> {
  17.     @Autowired
  18.     private UserDao userDao;
  20.     @Override
  21.     protected UserDao getDao() {
  22.         return userDao;
  23.     }
  25. }
3.4.2 UserGradeServiceImpl
  1. package com.lehumall.application.service.user;
  3. import lazypack.common.component.BaseServiceImpl;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.stereotype.Service;
  7. import org.springframework.transaction.annotation.Transactional;
  9. import com.lehumall.application.dao.user.UserGradeDao;
  10. import com.lehumall.domain.entity.user.usergrade.UserGrade;
  11. import com.lehumall.pojo.qo.UserGradeQO;
  13. @Service
  14. @Transactional
  15. public class UserGradeServiceImpl extends BaseServiceImpl<UserGrade, UserGradeQO, UserGradeDao> {
  17.     @Autowired
  18.     private UserGradeDao userGradeDao;
  20.     @Override
  21.     protected UserGradeDao getDao() {
  22.         return userGradeDao;
  23.     }
  25. }
3.4.3 UserDao
  1. package com.lehumall.application.dao.user;
  3. import lazypack.common.component.BaseDao;
  5. import org.hibernate.Criteria;
  6. import org.hibernate.sql.JoinType;
  7. import org.springframework.beans.factory.annotation.Autowired;
  8. import org.springframework.stereotype.Repository;
  10. import com.lehumall.domain.entity.user.user.User;
  11. import com.lehumall.pojo.qo.UserQO;
  13. @Repository
  14. public class UserDao extends BaseDao<User, UserQO> {
  16.     @Autowired
  17.     private UserGradeDao gradeDao;
  19.     @Override
  20.     protected Criteria buildCriteria(Criteria criteria, UserQO qo) {
  22.         if (qo != null) {
  23.             //  这里可以将在UserQO的注解中没有完善的更多查询条件加入criteria，实现更复杂的查询
  24.             //  ...
  25.             //  将关联表的查询条件纳入条件解析
  26.             if(qo.getUserGradeQO() != null){
  27.                 Criteria gradeCriteria = criteria.createCriteria("grade", "g", 
  28.                         JoinType.LEFT_OUTER_JOIN);
  29.                 gradeDao.buildCriteriaOut(gradeCriteria, qo.getUserGradeQO());
  30.             }
  31.             return criteria;
  32.         }
  33.         return criteria;
  34.     }
  36.     @Override
  37.     protected Class<User> getEntityClass() {
  38.         return User.class;
  39.     }
  41. }
3.4.4 UserGradeDao
  1. package com.lehumall.application.dao.user;
  3. import lazypack.common.component.BaseDao;
  5. import org.hibernate.Criteria;
  6. import org.springframework.stereotype.Repository;
  8. import com.lehumall.domain.entity.user.usergrade.UserGrade;
  9. import com.lehumall.pojo.qo.UserGradeQO;
  11. @Repository
  12. public class UserGradeDao extends BaseDao<UserGrade, UserGradeQO> {
  14.     @Override
  15.     protected Criteria buildCriteria(Criteria criteria,UserGradeQO qo) {
  17.         if (qo != null) {
  18.             //  这里可以将在UserGradeQO的注解中没有完善的更多查询条件加入criteria，实现更复杂的查询
  19.             //  ...
  20.             return criteria;
  21.         }
  22.         return criteria;
  23.     }
  25.     @Override
  26.     protected Class<UserGrade> getEntityClass() {
  27.         return UserGrade.class;
  28.     }
  30. }

4. 数据查询测试代码演示

以下代码可以直观地看出如何去使用封装好的工具，这些代码通常是写在Action或Controller中的代码，不需要往Service，Dao中添加任何方法就能运行，依赖lazypack-common的基本封装类和方法。

全部代码已经通过测试，JUNIT测试类位于hy-lehu-application工程src/test/java目录下。

4.1 单条件单条结果查询

按id查询：

  1.     VirtualAccountQO qo = new VirtualAccountQO();
  2.     //  按帐号id查询
  3.     qo.setId("001");
  4.     VirtualAccount va = virtualAccountService.queryUnique(qo);

效果:

  1.  select
  2.         this_.ID as ID1_8_0_,
  3.         this_.AVAIABLE_AMOUNT as AVAIABLE2_8_0_,
  4.         this_.FROZEN_AMOUNT as FROZEN_A3_8_0_,
  5.         this_.TOTAL_AMOUNT as TOTAL_AM4_8_0_,
  6.         this_.CREATE_DATE as CREATE_D5_8_0_,
  7.         this_.INVALID_DATE as INVALID_6_8_0_,
  8.         this_.NAME as NAME7_8_0_,
  9.         this_.PROXY_ACCOUNT as PROXY_AC8_8_0_,
  10.         this_.CURRENCY_ID as CURRENC14_8_0_,
  11.         this_.OUT_ID as OUT_ID9_8_0_,
  12.         this_.OUT_NAME as OUT_NAM10_8_0_,
  13.         this_.DOMAIN_TYPE as DOMAIN_11_8_0_,
  14.         this_.PARENT_ID as PARENT_15_8_0_,
  15.         this_.CLOSE as CLOSE12_8_0_,
  16.         this_.ENABLE as ENABLE13_8_0_ 
  17.     from
  18.         VA_VIRTUAL_ACCOUNT this_ 
  19.     where
  20.         this_.ID='001' limit 1

4.2 字段投影筛选

加上字段投影筛选：

  1.     VirtualAccountQO qo = new VirtualAccountQO();
  2.     //  按帐号id查询
  3.     qo.setId("001");
  4.     //  只查两个字段
  5.     String[] projs = {"id","baseInfo.name"};
  6.     qo.setProjectionProperties(projs);
  7.     VirtualAccount va = virtualAccountService.queryUnique(qo);

注：第二个字段写成baseInfo.userName是因为name这个属性放在VirtualAccount中的名为baseInfo的值对象中，见3.1.1。

效果：

  1.     select
  2.         this_.ID as y0_,
  3.         this_.NAME as y1_ 
  4.     from
  5.         VA_VIRTUAL_ACCOUNT this_ 
  6.     where
  7.         this_.ID='001' limit 1

4.3 多条结果查询

多条查询：

  1.     VirtualAccountQO qo = new VirtualAccountQO();
  2.     //  查状态为已启用的帐户
  3.     qo.setEnable(true);
  4.     //  只查两个字段
  5.     String[] projs = {"id","baseInfo.name"};
  6.     qo.setProjectionProperties(projs);
  7.     List<VirtualAccount> vaList = virtualAccountService.queryList(qo);

效果：

  1.     select
  2.         this_.ID as y0_,
  3.         this_.NAME as y1_ 
  4.     from
  5.         VA_VIRTUAL_ACCOUNT this_ 
  6.     where
  7.         this_.ENABLE='Y'

3.4 分页查询

分页查询：

  1.     Pagination pagination = new Pagination();
  2.     //  查第1页每页5条
  3.     pagination.setPageNo(1);
  4.     pagination.setPageSize(5);
  5.     VirtualAccountQO qo = new VirtualAccountQO();
  6.     //  查状态为已启用的帐户
  7.     qo.setEnable(true);
  8.     //  只查两个字段
  9.     String[] projs = {"id","baseInfo.name"};
  10.     qo.setProjectionProperties(projs);
  12.     pagination.setCondition(qo);
  13.     pagination = virtualAccountService.queryPagination(pagination);
  14.     System.out.println(pagination.getList());

效果：

  1.     select
  2.         count(*) as y0_ 
  3.     from
  4.         VA_VIRTUAL_ACCOUNT this_ 
  5.     where
  6.         this_.ENABLE='Y'
  1.     select
  2.         this_.ID as y0_,
  3.         this_.NAME as y1_ 
  4.     from
  5.         VA_VIRTUAL_ACCOUNT this_ 
  6.     where
  7.         this_.ENABLE='Y' limit 1

3.5 带范围条件查询

范围查询：

  1.     VirtualAccountQO qo = new VirtualAccountQO();
  2.     //  查帐户可用余额大于等于0并且小于等于10的帐户
  3.     qo.setGeAvaiableAmount(0D);
  4.     qo.setLeAvaiableAmount(10D);
  6.     String[] projs = {"id","baseInfo.name"};
  7.     qo.setProjectionProperties(projs);
  8.     virtualAccountRemoteService.queryList(qo);

效果：

  1.     select
  2.         this_.ID as y0_,
  3.         this_.NAME as y1_ 
  4.     from
  5.         VA_VIRTUAL_ACCOUNT this_ 
  6.     where
  7.         this_.AVAIABLE_AMOUNT>=0 
  8.         and this_.AVAIABLE_AMOUNT<=10

3.6 对延迟加载的关联实体做立即查询

立即加载被配置成lazy的关联实体

  1.     VirtualAccountQO qo = new VirtualAccountQO();
  2.     qo.setId("001");
  4.     qo.setFetchCurrency(true);
  5.     String[] projs = {"id","baseInfo.name"};
  6.     qo.setProjectionProperties(projs);
  7.     virtualAccountService.queryUnique(qo);

效果：

  1.     select
  2.         this_.ID as y0_,
  3.         this_.NAME as y1_ 
  4.     from
  5.         VA_VIRTUAL_ACCOUNT this_ 
  6.     where
  7.         this_.ID='001' limit 1

上面没有出现join效果，这是因为我们筛选了列，并且没有获取HyCurrency实体里的列，所以Hibernate给优化掉了。

修改上面的条件：

  1.     VirtualAccountQO qo = new VirtualAccountQO();
  2.     qo.setId("001");
  4.     qo.setFetchCurrency(true);
  5.     //  String[] projs = {"id","baseInfo.name"};
  6.     //  qo.setProjectionProperties(projs);
  7.     virtualAccountService.queryUnique(qo);

效果：

  1. select
  2.         this_.ID as ID1_8_1_,
  3.         this_.AVAIABLE_AMOUNT as AVAIABLE2_8_1_,
  4.         this_.FROZEN_AMOUNT as FROZEN_A3_8_1_,
  5.         this_.TOTAL_AMOUNT as TOTAL_AM4_8_1_,
  6.         this_.CREATE_DATE as CREATE_D5_8_1_,
  7.         this_.INVALID_DATE as INVALID_6_8_1_,
  8.         this_.NAME as NAME7_8_1_,
  9.         this_.PROXY_ACCOUNT as PROXY_AC8_8_1_,
  10.         this_.CURRENCY_ID as CURRENC14_8_1_,
  11.         this_.OUT_ID as OUT_ID9_8_1_,
  12.         this_.OUT_NAME as OUT_NAM10_8_1_,
  13.         this_.DOMAIN_TYPE as DOMAIN_11_8_1_,
  14.         this_.PARENT_ID as PARENT_15_8_1_,
  15.         this_.CLOSE as CLOSE12_8_1_,
  16.         this_.ENABLE as ENABLE13_8_1_,
  17.         hycurrency2_.ID as ID1_7_0_,
  18.         hycurrency2_.ENABLE as ENABLE2_7_0_,
  19.         hycurrency2_.EXCHANGE_ONE_YUAN as EXCHANGE3_7_0_,
  20.         hycurrency2_.NAME as NAME4_7_0_,
  21.         hycurrency2_.PROXY_CURRENCY as PROXY_CU5_7_0_,
  22.         hycurrency2_.UNIT as UNIT6_7_0_ 
  23.     from
  24.         VA_VIRTUAL_ACCOUNT this_ 
  25.     inner join
  26.         VA_HY_CURRENCY hycurrency2_ 
  27.             on this_.CURRENCY_ID=hycurrency2_.ID 
  28.     where
  29.         this_.ID='001' limit 1

3.7 对关联实体中的列进行筛选查询

两张表的所有字段都出来了，然后我们会需要筛选。要动用到关联实体的QO。

  1.     VirtualAccountQO qo = new VirtualAccountQO();
  2.         qo.setId("001");
  4.         //  立即加载帐户所用货币信息
  5.         qo.setFetchCurrency(true);
  6.         //  从帐户表查两个字段
  7.         String[] projs = {"id","baseInfo.name"};
  8.         qo.setProjectionProperties(projs);
  9.         //  从货币表查两个字段
  10.         HyCurrencyQO qo2 = new HyCurrencyQO();
  11.         String[] projs2 = {"id","name"};
  12.         qo2.setProjectionProperties(projs2);
  14.         qo.setHyCurrencyQO(qo2);
  15.         virtualAccountService.queryUnique(qo);

因为操作了关联实体的查询条件，所以我们还要在Dao里做些额外工作让上面的qo.setUserGradeQO(userGradeQO);生效。这里只有片段，完整的UserDao见4.3.3：

  1.     @Override
  2.     protected Criteria buildCriteria(Criteria criteria, VirtualAccountQO qo) {
  3.         if (qo != null) {
  4.             if (qo.getHyCurrencyQO() != null) {
  5.                 // 创建一个子查询Criteria用于组装HyCurrency实体上的查询条件
  6.                 Criteria hyCurrencyCriteria = criteria.createCriteria("currency", "hc", JoinType.LEFT_OUTER_JOIN);
  7.                 // 将yCurrencyQO里的查询条件加载到子查询Criteria里
  8.                 hyCurrencyDao.buildCriteriaOut(hyCurrencyCriteria, qo.getHyCurrencyQO());
  9.             }
  10.         }
  11.         return criteria;
  12.     }

开发人员要写的所有查询代码已经全部在上面了，没有其他要写的了。
效果：

  1.     select
  2.         this_.ID as y0_,
  3.         this_.NAME as y1_,
  4.         hc1_.ID as y2_,
  5.         hc1_.NAME as y3_ 
  6.     from
  7.         VA_VIRTUAL_ACCOUNT this_ 
  8.     left outer join
  9.         VA_HY_CURRENCY hc1_ 
  10.             on this_.CURRENCY_ID=hc1_.ID 
  11.     where
  12.         this_.ID='001' limit 1

3.8 以关联实体中的列做为条件查询

同时按User和UserGrade里的值做条件查询：

  1.     VirtualAccountQO qo = new VirtualAccountQO();
  2.     qo.setId("001");
  4.     qo.setFetchCurrency(true);
  5.     String[] projs = {"id","baseInfo.name"};
  6.     qo.setProjectionProperties(projs);
  8.     HyCurrencyQO qo2 = new HyCurrencyQO();
  9.     String[] projs2 = {"id","name"};
  10.     qo2.setProjectionProperties(projs2);
  12.     qo2.setName("积分");
  13.     qo.setHyCurrencyQO(qo2);
  14.     virtualAccountService.queryUnique(qo);

效果：

  1. select
  2.         this_.ID as y0_,
  3.         this_.NAME as y1_,
  4.         hc1_.ID as y2_,
  5.         hc1_.NAME as y3_ 
  6.     from
  7.         VA_VIRTUAL_ACCOUNT this_ 
  8.     left outer join
  9.         VA_HY_CURRENCY hc1_ 
  10.             on this_.CURRENCY_ID=hc1_.ID 
  11.     where
  12.         this_.ID='001'
  13.         and hc1_.NAME='积分' limit 1

3.9 模糊查询

  1.     VirtualAccountQO qo = new VirtualAccountQO();
  2.         qo.setId("001");
  4.         qo.setFetchCurrency(true);
  5.         String[] projs = {"id","baseInfo.name"};
  6.         qo.setProjectionProperties(projs);
  8.         qo.setName("分");
  9.         qo.setNameLike(true);
  10.         virtualAccountService.queryUnique(qo);

效果：

  1.     select
  2.         this_.ID as y0_,
  3.         this_.NAME as y1_ 
  4.     from
  5.         VA_VIRTUAL_ACCOUNT this_ 
  6.     where
  7.         this_.NAME like '%分%' 
  8.         and this_.ID='001'limit 1

4.5 总结

添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注