import java.io.IOException;
import java.io.OutputStream;
import java.util.concurrent.CompletableFuture;

import org.apache.commons.exec.CommandLine;
import org.apache.commons.exec.DefaultExecutor;
import org.apache.commons.exec.ExecuteWatchdog;
import org.apache.commons.exec.PumpStreamHandler;
import org.apache.commons.exec.ShutdownHookProcessDestroyer;

public class CmdHelper {
	/**
	 * 执行外部命令，等待返回结果
	 * 
	 * @param commandLine: 命令行
	 * @param out:         输出流，为空默认标准输出
	 * @param timeout:     超时，不大于0则不限超时
	 * @return CmdHandler based on DefaultExecuteResultHandler
	 */
	public static CmdHandler run(CommandLine commandLine, OutputStream out, long timeout) {
		PumpStreamHandler pumpStreamHandler = null;
		if (null == out) {
			pumpStreamHandler = new PumpStreamHandler();
		} else {
			pumpStreamHandler = new PumpStreamHandler(out);
		}

		DefaultExecutor executor = new DefaultExecutor();
		CmdHandler cmdHandler = new CmdHandler(executor);
		executor.setStreamHandler(pumpStreamHandler);
		ShutdownHookProcessDestroyer processDestroyer = new ShutdownHookProcessDestroyer();
		executor.setProcessDestroyer(processDestroyer);// 随主进程退出

		if (timeout <= 0) {
			timeout = ExecuteWatchdog.INFINITE_TIMEOUT;
		}
		ExecuteWatchdog watchdog = new ExecuteWatchdog(timeout);
		executor.setWatchdog(watchdog);// 控制超时

		try {
			executor.execute(commandLine, cmdHandler);
			cmdHandler.waitFor();// 等待返回结果
		} catch (IOException | InterruptedException e) {
			e.printStackTrace();
		}
		return cmdHandler;
	}

	/**
	 * 异步执行外部命令
	 * 
	 * @param commandLine: 命令行
	 * @param out:         输出流，为空默认标准输出
	 * @param timeout:     超时，不大于0则不限超时
	 * @return CompletableFuture<CmdHandler>
	 */
	public static CompletableFuture<CmdHandler> exec(CommandLine commandLine, OutputStream out, long timeout) {
		CompletableFuture<CmdHandler> cf = new CompletableFuture<>();
		PumpStreamHandler pumpStreamHandler = null;
		if (null == out) {
			pumpStreamHandler = new PumpStreamHandler();
		} else {
			pumpStreamHandler = new PumpStreamHandler(out);
		}

		DefaultExecutor executor = new DefaultExecutor();
		CmdHandler cmdHandler = new CmdHandler(executor);
		cmdHandler.setCallback(() -> {
			cf.complete(cmdHandler);// 执行完成后回调
		});
		executor.setStreamHandler(pumpStreamHandler);
		ShutdownHookProcessDestroyer processDestroyer = new ShutdownHookProcessDestroyer();
		executor.setProcessDestroyer(processDestroyer);// 随主进程退出

		if (timeout <= 0) {
			timeout = ExecuteWatchdog.INFINITE_TIMEOUT;
		}
		ExecuteWatchdog watchdog = new ExecuteWatchdog(timeout);
		executor.setWatchdog(watchdog);// 控制超时

		try {
			executor.execute(commandLine, cmdHandler);
		} catch (IOException e) {
			e.printStackTrace();
		}
		return cf;
	}

	public static void main(String[] args) throws InterruptedException {
		CommandLine command = CommandLine.parse("ping 127.0.0.1 -t");

		// 测试同步执行
		CmdHandler result = CmdHelper.run(command, null, 3000);
		System.out.println(result.resultString());

		// 测试异步执行
		CmdHelper.exec(command, null, 0).thenAccept(cmdHandler -> {
    		System.out.println(cmdHandler.resultString());
		});
	}
}

import org.apache.commons.exec.DefaultExecuteResultHandler;
import org.apache.commons.exec.ExecuteException;
import org.apache.commons.exec.ExecuteWatchdog;
import org.apache.commons.exec.Executor;

public class CmdHandler extends DefaultExecuteResultHandler {
	Executor executor;
	Runnable callback;
	
	public CmdHandler(Executor executor) {
		this.executor = executor;
	}
	
	public void setCallback(Runnable callback) {
		this.callback = callback;
	}
	
	public Executor getExecutor() {
		return this.executor;
	}
	
	public ExecuteWatchdog getWatchdog() {
		if (this.executor == null) return null;
		return this.executor.getWatchdog();
	}
	
	public String resultString() {
		String retMsg = "complete";
		if (this.getException() != null) {
			ExecuteWatchdog watchdog = this.getWatchdog();
			if (watchdog != null && watchdog.killedProcess()) {
				retMsg = "timeout";
			} else {
				retMsg = this.getException().getMessage();
			}
		}
		return this.getExitValue() + ":" + retMsg;
	}

	@Override
	public void onProcessComplete(int exitValue) {
		super.onProcessComplete(exitValue);
		if (callback != null) {
			callback.run();
		}
	}

	@Override
	public void onProcessFailed(ExecuteException e) {
		super.onProcessFailed(e);
		if (callback != null) {
			callback.run();
		}
	}
}

public class WeixinSercice {
	final static String URL_SNS_TOKEN = "https://api.weixin.qq.com/sns/oauth2/access_token?appid=%s&secret=%s&code=%s&grant_type=authorization_code";
	final static String URL_ACCESS_TOKEN = "https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid=%s&secret=%s";
	final static String URL_JSAPI_TICKET = "https://api.weixin.qq.com/cgi-bin/ticket/getticket?access_token=%s&type=jsapi";
										
	final static String URL_ORDER_QUERY = "https://api.mch.weixin.qq.com/pay/orderquery";
	final static String URL_UNIFIED_ORDER = "https://api.mch.weixin.qq.com/pay/unifiedorder";

	public static final String TRADE_TYPE_H5 = "MWEB";
	public static final String TRADE_TYPE_JS = "JSAPI";

	final static String KEY_SIGN = "sign";
	
	@Value("${weixin.appid}")
	private String appId;
	@Value("${weixin.secret}")
	private String appSecret;
	@Value("${weixin.mch_id}")
	private String mchId;
	@Value("${weixin.mch_key}")
	private String mchKey;
	@Value("${weixin.notify_url}")
	private String notifyUrl;
	
	@Autowired
	RestTemplate restTemplate;
    @Autowired
	OrderService orderService;
	@Resource
	private CacheManager cacheManager;
	private static final String CACHE_NAME_WEIXIN = "myapp:weixin";
	private static final String CACHE_KEY_ACCESS_TOKEN = "actoken";
	private static final String CACHE_KEY_JSAPI_TICKET = "jsticket";
	private Cache getCache() {
		return cacheManager.getCache(CACHE_NAME_WEIXIN);
	}

	// 微信网页认证：通过code获取token
	public WxWebToken fetchWebTokenByCode(String code) {
		String url = String.format(URL_SNS_TOKEN, appId, appSecret, code);
		String content = restTemplate.getForObject(url, String.class);
		WxWebToken token = JSON.parse(content, WxWebToken.class);
		return token;
	}

	// 微信JSSDK：获取指定url的config
	public WxJsdkConfig genJsdkConfig(String url) {
		WxJsdkConfig config = new WxJsdkConfig();
		config.setAppId(appId);
		config.setNonceStr(StringUtils.uuid());
		config.setTimestamp(DateTimeUtils.secondsOf(LocalDateTime.now()));
		
		String ticket = getJsapiTicket(url);
		if (StringUtils.isNotBlank(ticket)) {
			String string = "jsapi_ticket=" + ticket +
					"&noncestr=" + config.getNonceStr() +
					"&timestamp=" + config.getTimestamp() +
					"&url=" + url;
			String signature = StringUtils.SHA1(string);
			
			if (StringUtils.isNotBlank(signature)) {
				config.setSignature(signature);
			}
		} else {
			config.setErrcode(1);
			config.setErrmsg("invalid ticket");
		}
		log.debug("genJsdkConfig for {} return {}", url, config.getSignature());
		return config;
	}
	
	//get cached jsapi_ticket
	private String getJsapiTicket(String url) {
		String cacheKey = CACHE_KEY_JSAPI_TICKET+StringUtils.MD5(url);
		WxJsapiTicket ticket = getCache().get(cacheKey, WxJsapiTicket.class);
		if (ticket == null || ticket.getExpired()) {
			ticket = fetchJsapiTicket();
			if (ticket != null && !ticket.getExpired()) {
				getCache().put(cacheKey, ticket);
			}else {
				return null;
			}
		} else {
			log.debug("return cached {} for key {}", CACHE_NAME_WEIXIN, cacheKey);
		}
		return ticket.getTicket();
	}
	
	private WxJsapiTicket fetchJsapiTicket() {
		String accessToken = getAccessToken();
		if (StringUtils.isBlank(accessToken)) {
			return null;
		}
		
		String url = String.format(URL_JSAPI_TICKET, accessToken);
		String content = restTemplate.getForObject(url, String.class);
		WxJsapiTicket ticket = JSON.parse(content, WxJsapiTicket.class);
		if (ticket != null) {
			Long expires = ticket.getExpires_in();
			if (expires != null) {//把过期秒数转化为世纪秒
				expires += DateTimeUtils.secondsOf(LocalDateTime.now());
			}else{
				expires = 0L;
			}
			ticket.setExpires_in(expires);
			log.debug("fetchJsapiTicket return {}-{}", ticket.getErrcode(), ticket.getErrmsg());
		}
		return ticket;
	}
	
	// get cached access_token
	private String getAccessToken() {
		WxAccessToken token = getCache().get(CACHE_KEY_ACCESS_TOKEN, WxAccessToken.class);
		if (token == null || token.getExpired()) {
			token = fetchAccessToken();
			if (token != null && !token.getExpired()) {
				getCache().put(CACHE_KEY_ACCESS_TOKEN, token);
			}
		} else {
			log.debug("return cached {} for key {}", CACHE_NAME_WEIXIN, CACHE_KEY_ACCESS_TOKEN);
		}
		return token.getAccess_token();
	}
	
	private WxAccessToken fetchAccessToken() {
		String url = String.format(URL_ACCESS_TOKEN, appId, appSecret);
		String content = restTemplate.getForObject(url, String.class);
		WxAccessToken token = JSON.parse(content, WxAccessToken.class);
		if (token != null) {
			Long expires = token.getExpires_in();
			if (expires != null) {//把过期秒数转化为世纪秒
				expires += DateTimeUtils.secondsOf(LocalDateTime.now());
			}else{
				expires = 0L;
			}
			token.setExpires_in(expires);
			if (StringUtils.isNotBlank(token.getErrmsg())){
				log.debug("fetchAccessToken return {}-{}", token.getErrcode(), token.getErrmsg());
			}else{
				log.debug("fetchAccessToken return {}", token.getAccess_token());
			}
		} else {
			log.debug("fetchAccessToken return null");
		}
		return token;
	}
	
	
	//处理订单
	public Order processOrder(Order order) {
		if (StringUtils.isNotBlank(order.getId())) {
			Order dbOrder = orderService.findById(order.getId());
			if (dbOrder != null && dbOrder.getStatus()>=Order.STATUS_PAYED) {
				return dbOrder;//已支付
			}
		}
		order = orderService.upsert(order);
		Map<String, String> map = placeOrder(order);
		if (map != null) {
			String returnCode = map.get("return_code");
			order.setReturnCode(returnCode);
			if ("SUCCESS".equals(returnCode)) {
				order.setStatus(Order.STATUS_ORDER);
			}
			order.setReturnMsg(map.get("return_msg"));
			order.setMwebUrl(map.get("mweb_url"));
			order.setPrepayId(map.get("prepay_id"));
			orderService.save(order);
			orderService.sendNotify(order);
			if (TRADE_TYPE_JS.equals(order.getTradeType())) {
				Map<String, String> signs = new TreeMap<>();
				signs.put("appId", appId);
				signs.put("nonceStr", StringUtils.uuid());
				signs.put("package", "prepay_id="+map.get("prepay_id"));
				signs.put("signType", "MD5");
				signs.put("timeStamp", String.valueOf(DateTimeUtils.secondsOf(LocalDateTime.now())));
				signs.put("paySign", genSign(signs));
				order.setSigns(signs);
			}
		}
		return order;
	}

	//下单
	private Map<String, String> placeOrder(Order order) {
	    Map<String, String> map = null;
	    String tradeType = order.getTradeType();
	    if (TRADE_TYPE_H5.equals(tradeType)) {
	    	map = prepareH5Order(order.getTradeNo(), order.getProductId(), order.getProductName(), order.getTotalFee(), order.getIpaddr());
	    }else{
	    	map = prepareJsOrder(order.getTradeNo(), order.getProductId(), order.getProductName(), order.getTotalFee(), order.getIpaddr(), order.getOpenid());
	    }
	    HttpEntity<String> request = genXmlRequest(map);
	    String res = restTemplate.postForObject(URL_UNIFIED_ORDER, request, String.class);
	    log.debug(res);
	    return XmlUtils.parse(res);
	}
	
	// H5支付下单数据
	private Map<String, String> prepareH5Order(String tradeNo, String productId, String productName, Long amount, String ip) {
		Map<String, String> order = newOrderMap();
		order.put("trade_type", TRADE_TYPE_H5);//H5支付的交易类型为MWEB
		order.put("notify_url", notifyUrl);//回调地址, 不能携带参数。
		order.put("scene_info", "{\"h5_info\": {\"type\":\"WAP\",\"wap_url\": \"\",\"wap_name\": \"\"}}");//用于上报支付的场景信息
		order.put("spbill_create_ip", ip);//用户端IP,支持ipv4、ipv6格式
		order.put("out_trade_no", tradeNo);//自定义交易单号
		order.put("product_id", productId);//自定义商品
		order.put("body", productName);//网页的主页title名-商品概述
		order.put("fee_type", "CNY");//境内只支持CNY，默认可不传
		order.put("total_fee", String.valueOf(amount));//订单总金额，单位为分
		//签名
		order.put(KEY_SIGN, genSign(order));
		return order;
	}
	
	// JSAPI支付下单数据
	private Map<String, String> prepareJsOrder(String tradeNo, String productId, String productName, Long amount, String ip, String openid) {
		Map<String, String> order = newOrderMap();
		order.put("trade_type", TRADE_TYPE_JS);//交易类型为JSAPI
		order.put("notify_url", notifyUrl);//回调地址, 不能携带参数。
		//order.put("scene_info", "{\"h5_info\": {\"type\":\"WAP\",\"wap_url\": \"\",\"wap_name\": \"\"}}");//用于上报支付的场景信息
		order.put("openid", openid);
		order.put("spbill_create_ip", ip);//用户端IP,支持ipv4、ipv6格式
		order.put("out_trade_no", tradeNo);//自定义交易单号
		order.put("product_id", productId);//自定义商品
		order.put("body", productName);//网页的主页title名-商品概述
		order.put("fee_type", "CNY");//境内只支持CNY，默认可不传
		order.put("total_fee", String.valueOf(amount));//订单总金额，单位为分
		//签名
		order.put(KEY_SIGN, genSign(order));
		return order;
	}

	// 下单数据准备：公用部分
	private Map<String, String> newOrderMap() {
		Map<String, String> order = new TreeMap<>();
		order.put("appid", appId);
		order.put("mch_id", mchId);
		order.put("nonce_str", StringUtils.uuid());
		return order;
	}
	
	// 构造xml request
	private HttpEntity<String> genXmlRequest(Object data) {
		HttpHeaders headers = new HttpHeaders();
	    headers.setContentType(MediaType.APPLICATION_XML);
	    String body = XmlUtils.stringify(data, "xml");
	    return new HttpEntity<String>(body, headers);
	}
	
	// 生成签名
	private String genSign(Map<String, String> paramMap) {
		StringBuilder sb = new StringBuilder();
		paramMap.entrySet().stream().sorted(Map.Entry.comparingByKey()).forEach((a) -> {
			if (StringUtils.isBlank(a.getKey()) || KEY_SIGN.equals(a.getKey())) {
				return;
			}
			if (StringUtils.isBlank(a.getValue())) {
				return;
			}
			sb.append(a.getKey()); sb.append("="); sb.append(a.getValue()); sb.append("&");
		});
		sb.append("key="); sb.append(mchKey);
		String signStr = sb.toString();
		log.debug(signStr);
		return StringUtils.MD5(signStr).toUpperCase();
	}
	
	//微信支付结果回调处理
	@Synchronized // TODO: 避免重入仅这样不够，还需要锁定订单记录
	public String processCallback(String data) {
		Map<String, String> map = XmlUtils.parse(data);
		String sign = genSign(map);
		if (!sign.equals(map.get(KEY_SIGN))) {
			return returnCodeMsg("FAIL", "SIGNERROR");
		};
		String tradeNo = map.get("out_trade_no");
		Order order = orderService.findByTradeNo(tradeNo);
		if (order == null) {
			return returnCodeMsg("FAIL", "NOTFOUND");
		}
		if (order.getStatus() >= Order.STATUS_PAYED) {
			return returnCodeMsg("SUCCESS", "OK!");
		}
		String tradeType = map.get("trade_type");
		long totalFee = NumberUtils.parse(map.get("total_fee"), Long.class, 0L);
		if (totalFee != order.getTotalFee() || !StringUtils.equals(tradeType, order.getTradeType())) {
			return returnCodeMsg("FAIL", "TRADEINFOERROR");
		}
		
		order.setTransactionId(map.get("transaction_id"));
		order.setReturnCode(map.get("return_code"));
		order.setResultCode(map.get("result_code"));
		order.setBankType(map.get("bank_type"));
		order.setTimeEnd(map.get("time_end"));
		order.setStatus(Order.STATUS_PAYED);
		orderService.save(order);
		
		return returnCodeMsg("SUCCESS", "OK");
	}
	
	private String returnCodeMsg(String code, String msg) {
		return String.format("<xml><return_code><![CDATA[%s]]></return_code><return_msg><![CDATA[%s]]></return_msg></xml>", code, msg);
	}

}

## WxResponse.java
```java
@Data
public class WxResponse implements Serializable {
	private Integer errcode;
	private String errmsg;
}

@Data
public class WxResexpire extends WxResponse implements Serializable {
	Long expires_in;
	public Boolean getExpired() {
		return expires_in == null || expires_in <= DateTimeUtils.secondsOf(LocalDateTime.now());
	}
}

@Data
public class WxAccessToken extends WxResexpire implements Serializable {
	String access_token;
}

@Data
public class WxWebToken extends WxAccessToken implements Serializable {
	String refresh_token;
	String openid;
	String scope;
}

@Data
public class WxJsapiTicket extends WxResexpire implements Serializable {
	String ticket;
}

@Data
@JsonInclude(value = Include.NON_NULL)
public class WxJsdkConfig extends WxResponse implements Serializable {
	String appId;
	Long timestamp;
	String nonceStr;
	String signature;
}

public static String getWebBasePath() {
  RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
  if (requestAttributes == null) return null;//防止意外
  HttpServletRequest request = ((ServletRequestAttributes) requestAttributes).getResponse();
  if (request == null) return null;//防止意外
  return String.format("%s://%s:%s%s/", request.getScheme(), request.getServerName(), request.getServerPort(), request.getContextPath());
}

@Resource
private Environment env; //环境变量

@Resource
private void configureThymeleafStaticVars(ThymeleafViewResolver viewResolver) {
  if(viewResolver != null) {
    Map<String, Object> vars = new HashMap<>();
    vars.put("libBasePath", env.getProperty("basepath.lib"));//静态库配置
    viewResolver.setStaticVariables(vars);
  }
}

import java.time.Instant;
import java.time.LocalDateTime;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedQueue;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;
import lombok.Synchronized;

@Service
public class ConvertService {
	@Autowired
	ConvertConfig convertConfig;
	@Autowired
	ConvertTaskDao convertTaskDao;
	@Autowired
	ConvertHelper convertHelper;
	@Autowired
	RestTemplate restTemplate;
	
	private static Thread convertThread = null;
	private static Thread notifyThread = null;
	private static ConcurrentLinkedQueue<ConvertTask> queueTasks = new ConcurrentLinkedQueue<>();
	private static ConcurrentHashMap<String, ConvertTask> convertingTasks = new ConcurrentHashMap<>();
	private static ConcurrentLinkedQueue<ConvertTask> notifyTasks = new ConcurrentLinkedQueue<>();
	
	@Synchronized
	public ConvertTask addTask(ConvertTask task) {
		ConvertTask save = convertTaskDao.save(task);
		queueTasks.add(save);
		startConvert();
		return task;
	}
	
	@Synchronized
	private int doConvert() {
		if (convertingTasks.size() >= 4) {
			return 1;
		}
		ConvertTask task = queueTasks.poll();
		if (task == null) {
			return 10;
		}
		try {
			if (convertingTasks.containsKey(task.getSrc())) {//重复
				task.setStatus(ConvertTask.STATUS_IGNORE);
				convertTaskDao.save(task);
				return 0;
			}
			convertingTasks.put(task.getSrc(), task);
			task.setStatus(ConvertTask.STATUS_START);
			task.setStartAt(Instant.now());
			convertTaskDao.save(task);
			
			CompletableFuture<ConvertTask> process = convertHelper.process(task);
			process.thenAccept((retTask) -> {
				retTask.setStatus(ConvertTask.STATUS_FINISH);
				retTask.setEndAt(Instant.now());
				convertTaskDao.save(retTask);
				convertingTasks.remove(task.getSrc());
				notifyTasks.add(retTask);
				startNotify();
				System.out.println(retTask);
			});
		} catch(Exception e) {
			e.printStackTrace();
		}
		return 0;
	}
	
	@Synchronized
	private int doNotify() {
		ConvertTask task = notifyTasks.poll();
		if (task == null) {
			return 10;
		}
		int sleep = 0;
		try {
			ResponseEntity<String> response = restTemplate.postForEntity(convertConfig.getNotify(), task, String.class);
			String success = response.getBody();
			System.out.println(success);
			if (!StringUtils.isNullOrEmpty(success) && success.contains("success")) {
				task.setStatus(ConvertTask.STATUS_NOTIFIED);
				task.setNotify(LocalDateTime.now()+","+success);
			} else {
				task.setNotify(LocalDateTime.now()+",empty");
				notifyTasks.add(task);
				sleep = 1;
			}
		} catch(Exception e) {
			e.printStackTrace();
			task.setNotify(LocalDateTime.now()+","+e.getMessage());
			notifyTasks.add(task);
			sleep = 2;
		}
		convertTaskDao.save(task);
		return sleep;
	}
	
	public void startConvert() {
		if (convertThread != null) {
	        convertThread.interrupt();
			return;
		}
		convertThread = new Thread(() -> {
			while (convertThread == Thread.currentThread()) {
				System.out.println("Convert "+convertThread + " running at " + LocalDateTime.now());
				int sleep = doConvert();
				try {
					Thread.sleep(sleep*1000);
				} catch (InterruptedException e) {
					System.out.println("Convert "+Thread.currentThread() +" "+ e.getMessage());
				}
			}
			System.out.println("Convert "+Thread.currentThread()+" stoped at " + LocalDateTime.now());
		});
		convertThread.start();
		System.out.println("Convert "+convertThread+" started at " + LocalDateTime.now());
		
	}
	
	public void startNotify() {
		if (notifyThread != null) {
			notifyThread.interrupt();
			return;
		}
		notifyThread = new Thread(() -> {
			while (notifyThread == Thread.currentThread()) {
				System.out.println("Notify "+notifyThread + " running at " + LocalDateTime.now());
				int sleep = doNotify();
				try {
					Thread.sleep(sleep*1000);
				} catch (InterruptedException e) {
					System.out.println("Notify "+Thread.currentThread() +" "+ e.getMessage());
				}
			}
			System.out.println("Notify "+Thread.currentThread()+" stoped at " + LocalDateTime.now());
		});
		notifyThread.start();
		System.out.println("Notify "+notifyThread+" started at " + LocalDateTime.now());
	}
	
	@PostConstruct
	private void init() {
		List<ConvertTask> tasks = convertTaskDao.findByStatus(ConvertTask.STATUS_START);
		tasks.forEach(task -> {
			queueTasks.add(task);
		});
		tasks = convertTaskDao.findByStatus(ConvertTask.STATUS_INITIAL);
		tasks.forEach(task -> {
			queueTasks.add(task);
		});
		tasks = convertTaskDao.findByStatus(ConvertTask.STATUS_FINISH);
		tasks.forEach(task -> {
			notifyTasks.add(task);
		});
		startConvert();
		startNotify();
		System.out.println(convertConfig);
	}
	
	@PreDestroy
	public void stop() {
		if (convertThread != null) {
	        convertThread.interrupt();
	        convertThread = null;
		}
		if (notifyThread != null) {
			notifyThread.interrupt();
			notifyThread = null;
		}
	}
}

import java.util.List;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.repository.query.Param;

public interface ConvertTaskDao  extends JpaRepository<ConvertTask, Integer>{
	List<ConvertTask> findByStatus(@Param("status") Integer status);
}

public class ConvertTask implements Serializable{
	private static final long serialVersionUID = 1418649194096365375L;
    //状态常量
	public static final Integer STATUS_IGNORE = -1;
	public static final Integer STATUS_INITIAL = 0;
	public static final Integer STATUS_START = 1;
	public static final Integer STATUS_FINISH = 2;
	public static final Integer STATUS_NOTIFIED = 3;
	
	@Id
	Integer id;
	String name;
	Instant createdAt;
	Instant startAt;
	Instant endAt;
	Integer status = STATUS_INITIAL;
	String src;//源文件
	String out;//输出文件
	String img;//缩略图
	String ret;//转换结果
	String notify;//通知结果
}

import java.awt.image.BufferedImage;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.util.concurrent.CompletableFuture;

import javax.imageio.ImageIO;

import org.apache.commons.exec.CommandLine;
import org.apache.pdfbox.io.IOUtils;
import org.apache.pdfbox.pdmodel.PDDocument;
import org.apache.pdfbox.rendering.PDFRenderer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class ConvertHelper {
	static final String EXT_PDF = ".pdf";
	static final String EXT_MP4 = ".mp4";
	static final String EXT_AVI = ".avi";
	static final String EXT_DOC_STR = ".doc,.docx,.ppt,.pptx,.xls,.xlsx,";// 文档后缀
	static final String EXT_VIDEO_FFMPEG_STR = ".avi,.mpg,.wmv,.3gp,.mov,.asf,.asx,.flv,.f4v,.vob,.mkv,.ts,";// ffmpeg能解码的文件格式
	static final String EXT_VIDEO_MENCODER_STR = ".wmv9,.rm,.rmvb,.mpeg,";// 需要先mencoder解码的文件格式。.mpeg无法直接截取图片，所以需要中转

	@Autowired
	ConvertConfig convertConfig;
	
	public static String getExt(String filename) {
		if (StringUtils.isNullOrEmpty(filename)) return "";
		int pos = filename.lastIndexOf(".");
		if (pos < 0) return "";
		return filename.substring(pos).toLowerCase();
	}
	
	public static boolean isDoc(String ext) {
		return EXT_DOC_STR.contains(ext + ',');
	}

	public static boolean isVideo(String ext) {
		return EXT_VIDEO_FFMPEG_STR.contains(ext + ',') || needMEncoder(ext);
	}

	public static boolean needMEncoder(String ext) {
		return EXT_VIDEO_MENCODER_STR.contains(ext + ',');
	}

	public CompletableFuture<ConvertTask> process(ConvertTask task) {
		CompletableFuture<ConvertTask> cf = new CompletableFuture<>();
		new Thread(() -> {
			String srcFile = task.getSrc();
			String dotExt = getExt(srcFile);
			String outFile = null;
			CmdHandler cmdHandler = null;
			FileOutputStream logStream = null;
			try {
				File logFile = new File(convertConfig.getLog() + srcFile + ".log");
				logStream = new FileOutputStream(logFile);
				if (isDoc(dotExt)) {
					outFile = srcFile + EXT_PDF;
					cmdHandler = doc2pdf(convertConfig.getSrc() + srcFile, convertConfig.getOut() + outFile, logStream);
					if (cmdHandler.getException() == null) {
						if (pdf2png(convertConfig.getOut() + outFile, convertConfig.getOut() + task.getSrc() + ".png")) {
							task.setImg(task.getSrc() + ".png");
						}
					}
				} else if (isVideo(dotExt)) {
					if (needMEncoder(dotExt)) {
						outFile = srcFile + EXT_AVI;
						cmdHandler = video2avi(convertConfig.getSrc() + srcFile, convertConfig.getOut() + outFile, logStream);
						task.setRet(cmdHandler.resultString());
						if (cmdHandler.getException() != null) {
							cf.complete(task);
							return;
						}
						srcFile = outFile;
					}
					cmdHandler = video2jpg(convertConfig.getSrc() + srcFile, convertConfig.getOut() + task.getSrc() + ".jpg", logStream);
					if (cmdHandler.getException() == null) {
						task.setImg(task.getSrc() + ".jpg");
					}
					outFile = task.getSrc() + EXT_MP4;
					cmdHandler = video2mp4(convertConfig.getSrc() + srcFile, convertConfig.getOut() + outFile, logStream);
				} else {
					task.setRet("-1:unsupport");
					cf.complete(task);
					return;
				}
			} catch (FileNotFoundException e) {
				e.printStackTrace();
			} finally {
				IOUtils.closeQuietly(logStream);
			}

			task.setOut(outFile);
			task.setRet(cmdHandler.resultString());
			if (cmdHandler.getException() != null) {
				task.setOut(null);
			}
			cf.complete(task);
		}).start();
		return cf;
	}

	CmdHandler doc2pdf(String srcFile, String outFile, OutputStream cmdOut) {
		CommandLine cmd = new CommandLine(convertConfig.getUnoconv());
		cmd.addArgument("-f");
		cmd.addArgument("pdf");
		cmd.addArgument("-o");
		cmd.addArgument(outFile);
		cmd.addArgument(srcFile);
		return CmdHelper.run(cmd, cmdOut, 0);
	}

	boolean pdf2png(String srcFile, String outFile) {
		try {
			File file = new File(srcFile);
			PDDocument doc;
			doc = PDDocument.load(file);
			PDFRenderer renderer = new PDFRenderer(doc);
			BufferedImage image = renderer.renderImageWithDPI(1, 144); // Windows native DPI
			BufferedImage tag = new BufferedImage(64, 64, BufferedImage.TYPE_INT_RGB);
			tag.getGraphics().drawImage(image, 0, 0, 64, 64, null);
			ImageIO.write(tag, "PNG", new File(outFile));
			return true;
		} catch (IOException e) {
			e.printStackTrace();
			return false;
		}
	}

	CmdHandler video2mp4(String srcFile, String outFile, OutputStream cmdOut) {
		CommandLine cmd = new CommandLine(convertConfig.getFfmpeg());
		cmd.addArgument("-i");
		cmd.addArgument(srcFile);
		cmd.addArgument("-ar");
		cmd.addArgument("22050");
		cmd.addArgument("-vcodec");
		cmd.addArgument("libx264");
		cmd.addArgument("-q:v");
		cmd.addArgument("6");
		cmd.addArgument("-r");
		cmd.addArgument("25");
		cmd.addArgument("-flags");
		cmd.addArgument("+loop");
		cmd.addArgument("-crf");
		cmd.addArgument("24");
		cmd.addArgument("-bt");
		cmd.addArgument("256k");
		cmd.addArgument("-af");
		cmd.addArgument("volume=2");
		cmd.addArgument("-y");
		cmd.addArgument(outFile);
		return CmdHelper.run(cmd, cmdOut, 0);
	}

	CmdHandler video2jpg(String srcFile, String outFile, OutputStream cmdOut) {
		CommandLine cmd = new CommandLine(convertConfig.getFfmpeg());
		cmd.addArgument("-i");
		cmd.addArgument(srcFile);
		cmd.addArgument("-f");
		cmd.addArgument("image2");
		cmd.addArgument("-ss");
		cmd.addArgument("15");
		cmd.addArgument("-t");
		cmd.addArgument("0.001");
		cmd.addArgument("-s");
		cmd.addArgument("64x64");
		cmd.addArgument("-y");
		cmd.addArgument(outFile);
		return CmdHelper.run(cmd, cmdOut, 0);
	}

	CmdHandler video2avi(String srcFile, String outFile, OutputStream cmdOut) {
		CommandLine cmd = new CommandLine(convertConfig.getMencoder());
		cmd.addArgument(srcFile);
		cmd.addArgument("-oac");
		cmd.addArgument("mp3lame");
		cmd.addArgument("-lameopts");
		cmd.addArgument("preset=64");
		cmd.addArgument("-ovc");
		cmd.addArgument("xvid");
		cmd.addArgument("-xvidencopts");
		cmd.addArgument("bitrate=600");
		cmd.addArgument("-of");
		cmd.addArgument("avi");
		cmd.addArgument("-o");
		cmd.addArgument(outFile);
		return CmdHelper.run(cmd, cmdOut, 0);
	}
}

@Data
@Configuration
@ConfigurationProperties(prefix = "convert")
public class ConvertConfig {
	String src;
	String out;
	String log;
	String ffmpeg;
	String unoconv;
	String mencoder;
	String notify;
}