关于淘宝接口每次最多取100个,需要分页获取的封装
总体思路采取迭代器的方式来多次发送请求.
TOPCollection<TOPArticleOrder> orders = session.getArticleOrdersByNick(articleCode, start, end,nick);
size = saveOrders(orders.toList());
最终调用TOPCollection中的toList()方法,采用迭代器的方式分页获取数据
迭代器的实现为 TOPCollectionIterator 调用hasnext方法,实际调用writer.hasNext()
write的实现类 CollectionWriter 最终通过 session.execute 来执行分页发送请求的处理.
----------------------
import java.math.BigDecimal;
import java.util.Date;
import java.util.List;
import org.apache.commons.lang.StringUtils;
import com.bstek.common.bean.PropertiesMapping;
import com.bstek.common.lang.AssertUtils;
import com.bstek.common.lang.convert.ConverterUtils;
import com.hupun.crmbatch.service.top.TOPSession;
import com.hupun.crmbatch.service.top.bean.article.TOPArticleOrder;
import com.hupun.crmbatch.service.top.client.AbstractTOPSession;
import com.hupun.crmbatch.service.top.exception.TOPException;
import com.hupun.crmbatch.service.top.exception.TOPExceptionConstants;
import com.taobao.api.TaobaoRequest;
import com.taobao.api.domain.ArticleBizOrder;
import com.taobao.api.request.VasOrderSearchRequest;
import com.taobao.api.response.VasOrderSearchResponse;
/**
* TOP 应用订购订单获取器
*/
public class TOPArticleOrdersGetter extends TOPCollectionHandler<ArticleBizOrder, TOPArticleOrder, VasOrderSearchResponse> {
private String code;
private Date start;
private Date end;
protected int pageNo;
protected int pageSize;
/**
* 订购用户昵称
*/
private String nick;
/**
* 构造函数
* @param session TOP 会话
*/
public TOPArticleOrdersGetter(AbstractTOPSession session) {
super(session);
pageNo = 1;
pageSize = 200;
}
public String getCode() {
return code;
}
public Date getEnd() {
return end;
}
public String getRequesInfo() {
return TOPHandleMessages.top_article_orders_getter.format(code, start, end, pageNo);
}
public TaobaoRequest<VasOrderSearchResponse> getRequest() throws TOPException {
VasOrderSearchRequest req = new VasOrderSearchRequest();
if (AssertUtils.UNFORCE.empty(code))
throw new TOPException(TOPExceptionConstants.Exp_param_missing, TOPHandleMessages.param_article_code);
req.setArticleCode(code);
if (start != null && end != null && start.before(end)) {
req.setStartCreated(start);
req.setEndCreated(end);
}
if (!StringUtils.isEmpty(nick)){
req.setNick(nick);
}
req.setPageNo(Long.valueOf(pageNo));
req.setPageSize(Long.valueOf(pageSize));
return req;
}
public Date getStart() {
return start;
}
public boolean isPrivate() {
return true;
}
public TOPException parseError(String code, String msg, TOPSession session) {
return null;
}
public void setCode(String code) {
this.code = code;
}
public void setEnd(Date end) {
this.end = end;
}
public void setStart(Date start) {
this.start = start;
}
protected Long collectTotal(VasOrderSearchResponse response) {
return response.getTotalItem();
}
protected TOPArticleOrder createData() {
return new TOPArticleOrder();
}
protected PropertiesMapping createMapping() {
PropertiesMapping mapping = new PropertiesMapping(10);
mapping.append("articleCode", "articleCode");
mapping.append("orderId", "orderID");
mapping.append("articleName", "name");
mapping.append("create", "created");
mapping.append("fee", "fee");
mapping.append("itemCode", "itemCode");
mapping.append("orderCycleStart", "cycleStart");
mapping.append("orderCycleEnd", "cycleEnd");
mapping.append("nick", "nick");
mapping.append("totalPayFee", "payment");
return mapping;
}
protected TOPArticleOrder doTransform(ArticleBizOrder data) {
return getTransformer().transform(data);
}
protected List<ArticleBizOrder> getList(VasOrderSearchResponse response) {
return response.getArticleBizOrders();
}
protected boolean hasNext() {
return (getTotal() + (pageSize - 1)) / pageSize > pageNo;
}
protected void moveNext() {
pageNo++;
}
protected Object transform(String source, String target, Object value) throws RuntimeException {
if ("fee".equalsIgnoreCase(source)) {
return ConverterUtils.NORMAL.convert(value, BigDecimal.class).divide(BigDecimal.valueOf(100));
} else if ("totalPayFee".equalsIgnoreCase(source)) {
return ConverterUtils.NORMAL.convert(value, BigDecimal.class).divide(BigDecimal.valueOf(100));
}
return super.transform(source, target, value);
}
public String getNick() {
return nick;
}
public void setNick(String nick) {
this.nick = nick;
}
}
-----------------------------------------
import java.util.Collection;
import java.util.Iterator;
import com.bstek.common.bean.PropertiesMapping;
import com.bstek.common.lang.proxy.ProxyUtils;
import com.hupun.crmbatch.service.top.bean.TOPCollection;
import com.hupun.crmbatch.service.top.bean.TOPCollection.TOPCollectionWriter;
import com.hupun.crmbatch.service.top.client.AbstractTOPSession;
import com.taobao.api.TaobaoResponse;
/**
* TOP 平台集合数据调用处理器
*/
public abstract class TOPCollectionHandler<S, R, T extends TaobaoResponse> implements TOPHandler<TOPCollection<R>, T> {
/**
* 集合元素转换器
*/
protected class CollectionElementTransformer extends TOPDataTransformer<S, R> {
public Object transform(String source, String target, Object value) throws RuntimeException {
return TOPCollectionHandler.this.transform(source, target, value);
}
protected R createData() {
return TOPCollectionHandler.this.createData();
}
protected PropertiesMapping createMapping() {
return TOPCollectionHandler.this.createMapping();
}
}
/**
* 集合写入器
*/
protected class CollectionWriter extends TOPCollectionWriter<R> {
public void setTotal(int size) {
super.setTotal(size);
TOPCollectionHandler.this.setTotal(size);
}
protected boolean hasNext() {
return TOPCollectionHandler.this.hasNext();
}
protected void nextBatch() {
moveNext();
for (int i = 0;;) {
try {
session.execute(TOPCollectionHandler.this, isLog());
break;
} catch (Exception e) {
if (i++ >= 5) throw ProxyUtils.wrapThrowable(e, RuntimeException.class);
}
try {
Thread.sleep(500);
} catch (InterruptedException e) {
// ignore
}
}
}
}
protected final AbstractTOPSession session;
private int total;
private CollectionWriter writer;
private TOPDataTransformer<S, R> transformer;
/**
* 构造函数
* @param session TOP 会话
*/
protected TOPCollectionHandler(AbstractTOPSession session) {
this.session = session;
}
public TOPCollection<R> getResult(T response) {
if (writer == null) writer = new CollectionWriter();
Long total = collectTotal(response);
if (total != null) writer.setTotal(total.intValue());
Collection<? extends S> list = getList(response);
if (list != null) doTransform(list, writer);
return writer.getCollection();
}
/**
* 提取总数量 请求不返回总数量，返回 <code>null</code>
* @param response 请求返回结果
* @return 总数量
*/
protected abstract Long collectTotal(T response);
/**
* 创建元素对象
* @return 元素对象实例
*/
protected R createData() {
return null;
}
/**
* 创建属性映射关系
* @return 属性映射关系
*/
protected PropertiesMapping createMapping() {
return null;
}
/**
* 执行列表数据转换
* @param list 源数据集
* @param writer 集合写入器
*/
protected void doTransform(Collection<? extends S> list, CollectionWriter writer) {
for (Iterator<? extends S> it = list.iterator(); it.hasNext(); it.remove()) {
writer.add(doTransform(it.next()));
}
}
/**
* 执行数据转换
* @param data 源数据
* @return 结果数据
*/
protected abstract R doTransform(S data);
/**
* 获取结果数据列表
* @param response 请求返回结果
* @return 数据列表
*/
protected abstract Collection<? extends S> getList(T response);
/**
* 获取总数量
* @return 总数量
*/
protected int getTotal() {
return total;
}
/**
* 获取数据转换器
* @return 转换器
*/
protected TOPDataTransformer<S, R> getTransformer() {
if (transformer == null) transformer = new CollectionElementTransformer();
return transformer;
}
/**
* 是否存在下一批
* @return 是、否
*/
protected abstract boolean hasNext();
/**
* 是否记录日志
* @return 是、否
*/
protected boolean isLog() {
return true;
}
/**
* 移动条件至下一批
*/
protected abstract void moveNext();
/**
* 设置总数量
* @param size 总数量
*/
protected void setTotal(int size) {
this.total = size;
}
/**
* 转换属性值
* @param source 源属性名
* @param target 目标属性名
* @param value 属性值
* @return 目标值
* @throws RuntimeException
*/
protected Object transform(String source, String target, Object value) throws RuntimeException {
return value;
}
}
---------------------------------
package com.hupun.crmbatch.service.top.handlers;
import com.hupun.crmbatch.service.top.exception.TOPException;
import com.taobao.api.TaobaoRequest;
import com.taobao.api.TaobaoResponse;
/**
* TOP 平台调用处理器
*/
public interface TOPHandler<R, S extends TaobaoResponse> {
/**
* 获取请求描述信息
* @return 描述信息
*/
public String getRequesInfo();
/**
* 获取请求信息
* @return TOP 请求
* @throws TOPException
*/
public TaobaoRequest<S> getRequest() throws TOPException;
/**
* 获取处理结果
* @param response TOP 返回结果
* @return 处理结果
*/
public R getResult(S response);
}
---------------------------------------
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.NoSuchElementException;
/**
* TOP 数据集合体
*/
public class TOPCollection<E> implements Serializable, Iterable<E> {
/**
* TOP 数据集合体写入器
*/
public static abstract class TOPCollectionWriter<E> {
private TOPCollection<E> collection;
/**
* 构造函数
*/
protected TOPCollectionWriter() {
}
/**
* 添加 TOP 数据
* @param item TOP 数据
*/
public void add(E item) {
if (collection == null) collection = new TOPCollection(this, 10, false);
collection.add(item);
}
/**
* 获取数据集合体
* @return 集合体
*/
public TOPCollection<E> getCollection() {
if (collection == null) collection = new TOPCollection(this, 10, false);
return collection;
}
/**
* 设置总数量
* @param size 总数量
*/
public void setTotal(int size) {
if (collection == null) collection = new TOPCollection(this, size, true);
}
/**
* 是否有下一批
* @return 是、否
*/
protected abstract boolean hasNext();
/**
* 获取下一批数据
*/
protected abstract void nextBatch();
}
/**
* TOP 数据集合体迭代器
*/
protected class TOPCollectionIterator implements Iterator<E> {
private Entry current;
private long last;
protected TOPCollectionIterator() {
current = head;
last = System.currentTimeMillis();
}
@Override
public boolean hasNext() {
if (current.next == head) {
synchronized (head) {
if (current.next == head && writer.hasNext()) {
long l = System.currentTimeMillis();
if (l == last) {
try {
Thread.sleep(1);
} catch (InterruptedException e) {
}
}
writer.nextBatch();
last = System.currentTimeMillis();
return current.next != head;
} else {
return false;
}
}
} else if (current.next == null) {
return false;
}
return true;
}
@Override
public E next() {
current = current.next;
return current == null ? null : current.value;
}
@Override
public void remove() {
if (current == head) return;
Entry tmp = current.previous;
current.remove();
current = tmp;
}
}
class Entry implements Serializable {
private static final long serialVersionUID = 57961385403762668L;
private Entry next;
private Entry previous;
private final E value;
/**
* 构造函数
* @param value 元素值
*/
protected Entry(E value) {
this.value = value;
}
/**
* 移除当前元素
*/
public void remove() {
if (this == head) throw new NoSuchElementException();
synchronized (head) {
if (previous != null) previous.next = next;
if (next != null) next.previous = previous;
previous = null;
next = null;
size--;
}
}
/**
* 设置上一个元素项
* @param ele 元素项
* @param append 是否增加
*/
public void setPrevious(Entry ele, boolean append) {
if (ele == null) return;
synchronized (head) {
if (previous != null) previous.next = ele;
ele.previous = previous;
ele.next = this;
previous = ele;
if (append) size++;
}
}
}
private static final long serialVersionUID = -6163119051025582037L;
private transient int size;
private transient Entry head;
private final TOPCollectionWriter writer;
private final boolean isTotal;
protected int total;
/**
* 构造函数
*/
protected TOPCollection() {
this(null, 0, true);
}
/**
* 构造函数
* @param writer 集合体写入器
* @param initSize 初始数量
* @param isTotal 是否总计
*/
protected TOPCollection(TOPCollectionWriter<E> writer, int initSize, boolean isTotal) {
size = 0;
head = new Entry(null);
head.setPrevious(head, false);
this.isTotal = isTotal;
total = initSize;
this.writer = writer;
}
/**
* 首个元素
* @return 元素值 集合为空返回 <code>null</code>
*/
public E first() {
Iterator<E> it = iterator();
return it.hasNext() ? null : it.next();
}
/**
* 导入到目标列表中
* @param list 目标列表
*/
public void importTo(Collection<E> list) {
for (Iterator<E> it = iterator(); it.hasNext();) {
list.add(it.next());
}
}
/**
* 是否为空
* @return 是、否
*/
public boolean isEmpty() {
return !iterator().hasNext();
}
@Override
public Iterator<E> iterator() {
return new TOPCollectionIterator();
}
/**
* 获取数量
* @return 数量
*/
public int size() {
if (isTotal) {
return total;
} else {
throw new UnsupportedOperationException();
}
}
/**
* 转换为列表
* @return 列表
*/
public List<E> toList() {
List<E> list = new ArrayList(size);
importTo(list);
return list;
}
/**
* 添加元素
* @param o 元素
*/
protected void add(E o) {
Entry ele = new Entry(o);
head.setPrevious(ele, true);
}
/**
* 序列化读取
* @param s 序列化输入流
* @throws java.io.IOException
* @throws ClassNotFoundException
*/
private void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException {
s.defaultReadObject();
int size = s.readInt();
head = new Entry(null);
head.setPrevious(head, false);
for (int i = 0; i < size; i++)
head.setPrevious(new Entry((E) s.readObject()), true);
}
/**
* 序列化写入
* @param s 序列化输出流
* @throws java.io.IOException
*/
private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException {
s.defaultWriteObject();
s.writeInt(size);
for (Entry e = head.next; e != head; e = e.next)
s.writeObject(e.value);
}
}