Java 调用系统命令
 
操作
 
通过 java.lang.Runtime 类用操作系统命令
然后调用run.exec()进程来执行命令程序
 
package com.framework.test;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.nio.charset.Charset;

/**
 * Java 调用系统命令
 * 通过 java.lang.Runtime 类用操作系统命令
 * 然后调用run.exec()进程来执行命令程序
 *  cmd /c dir 是执行完dir命令后结束程序。
 *  cmd /k dir 是执行完dir命令后不结束程序。
 *  cmd /c start dir 会打开一个新窗口后执行dir指令，原程序结束。
 *  cmd /k start dir 会打开一个新窗口后执行dir指令，原程序不结束。 
 *  可用cmd /k start cmd /? 查看系统帮助
 *  说白了 加 start 就是打开命令窗口操作  不加start 就是在控制台查看
 * @author lrd
 *
 */
public class CmdTest {
	   public static void main(String[] args)  {  

		   Runtime run = Runtime.getRuntime();
		   
	        try {  
	        	//可打开exe程序，也可执行cmd命令，注意 路径\要使用\\，表示转义
	            // Process p = run.exec("E:\\一卡通测试工具\\串口调试助手\\kComm.exe");  //执行exe程序
	        	Process p = run.exec("cmd /k  ping 127.0.0.1");                  //执行CMD命令
	        	
	            BufferedReader br = new BufferedReader(new InputStreamReader(p.getInputStream(),Charset.forName("GBK"))); 
	            String lineMes;  
	            while ((lineMes = br.readLine()) != null)
	                System.out.println(lineMes);// 打印输出信息  
	            
	            //检查命令是否执行失败。  
	            if (p.waitFor() != 0) {  
	                if (p.exitValue() == 1)//0表示正常结束，1：非正常结束  
	                    System.err.println("命令执行失败!");  
	            }  
	            br.close();  
	        } catch (Exception e) {  
	            e.printStackTrace();  
	        }  
	    }  

}

有时候，我们在使用Java做一些操作时，可能性能上并不能达到我们满意的效果，就拿最近工作中的遇到的一个场景来说，需要对大量的小文件进行合并成一个大文件。
 
最开始的想法是使用Java做文件操作，遍历所有小文件然后往一个文件写（可以做成并发写），但是发现操作过程中遇到个问题，写一千多个小文件在本机Windows下需要花费几十秒的时间，即使在Linux环境下高配置的机器也需要将近十秒，这明显对接口的响应时间产生重要影响。这块怎么优化下呢？
 
我们都知道在Linux下可以进行大文件的分割和合并，分别采用split和cat命令，于是做了个实验，在Linux下对相同的一个1G文件进行切割成1000个小文件，然后对这一千多个小文件进行合并。效果是惊人的！！！竟然瞬间就能合成完成了！这更加让我坚定了应该使用系统命令进行批量小文件进行合并的想法。
 
我们这里封装一个类，用来调用系统命令，然后得到系统调用的返回结果。
 
我们先封装了一个返回结果类：
 
package com.majing.learning.fileupload.common.process;

public class ProcessResult {
	private boolean success = false;
	private String errorMessage;
	private String outputMessage;
	public boolean isSuccess() {
		return success;
	}
	public void setSuccess(boolean success) {
		this.success = success;
	}
	public String getErrorMessage() {
		return errorMessage;
	}
	public void setErrorMessage(String errorMessage) {
		this.errorMessage = errorMessage;
	}
	public String getOutputMessage() {
		return outputMessage;
	}
	public void setOutputMessage(String outputMessage) {
		this.outputMessage = outputMessage;
	}
	
}
 
接着我们给出封装的系统调用实现类：
 
package com.majing.learning.fileupload.common.process;

import java.io.IOException;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;

import org.apache.commons.lang3.StringUtils;

public class CommandUtils {
	
	public static ProcessResult runCmdTest(ExecutorService executorService, String command) throws IOException, InterruptedException {
		StringBuilder queryInputResult = new StringBuilder();
		StringBuilder queryErroInputResult = new StringBuilder();
		ProcessResult processResult = new ProcessResult();
		String[] cmd = { "/bin/sh", "-c", command};
		Process pro = Runtime.getRuntime().exec(cmd);
		CountDownLatch lock = new CountDownLatch(2);
		executorService.submit(new ProcessCheckTask(queryInputResult, lock, pro.getInputStream()));
		executorService.submit(new ProcessCheckTask(queryErroInputResult, lock, pro.getErrorStream()));
		boolean done = false;
		while (!done) {
			lock.await();
			done = true;
		}
		processResult.setOutputMessage(queryInputResult.toString());
		processResult.setErrorMessage(queryErroInputResult.toString());
		processResult.setSuccess(StringUtils.isBlank(processResult.getErrorMessage()));
		return processResult;
	}
}
 
其中ProcessCheckTask类如下：
 
package com.majing.learning.fileupload.common.process;

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.concurrent.CountDownLatch;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.majing.learning.fileupload.common.ConstValues;

public class ProcessCheckTask implements Runnable {
	
	private static Logger logger = LoggerFactory.getLogger(ProcessCheckTask.class);

	/** 锁 */
	private CountDownLatch lock;

	/** 执行结果输入流 */
	private InputStream inputStream;

	/** 字符拼接 */
	private StringBuilder queryInputResult;

	public ProcessCheckTask(StringBuilder queryInputResult, CountDownLatch lock, InputStream inputStream) {
		super();
		this.lock = lock;
		this.inputStream = inputStream;
		this.queryInputResult = queryInputResult;
	}

	@Override
	public void run() {
		try {
			BufferedReader bf = new BufferedReader(new InputStreamReader(inputStream));
			String line = null;
			while ((line = bf.readLine()) != null && line.length() > 0) {
				queryInputResult.append(line).append("\n");
			}
		} catch (Exception e) {
			logger.error(ConstValues.EXCEPTION_OCCURED, e);
		} finally {
			lock.countDown();
		}
	}
}
 
上面是一个简单实现，但是可能会存在一个问题，那就是执行系统命令的时间如果本身比较长，如果不想一直等待到系统命令执行完，而是在一段时间没有返回就直接认为失败，所以需要增加过期时间的考虑。这里我借助于Future框架，将上面的调用系统命令的方法封装成一个Callable对象。
 
package com.majing.learning.fileupload.common.process;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;

public class CommandTask implements Callable<ProcessResult>{
	
	private ExecutorService executorService;
	
	private String command;
	
	public CommandTask(ExecutorService executorService, String command){
		this.executorService = executorService;
		this.command = command;
	}

	@Override
	public ProcessResult call() throws Exception {
		return CommandUtils.runCmdTest(executorService, command);
	}

}
 
然后在上面的CommandUtils的基础上再封装一层变成CommandHelper，具体实现如下：
 
package com.majing.learning.fileupload.common.process;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.majing.learning.fileupload.common.ConstValues;

public class CommandHelper {
	
	private static Logger logger = LoggerFactory.getLogger(CommandHelper.class);
	
	private static ExecutorService executorService=Executors.newFixedThreadPool(50);
	
	private static long default_timeout = 8000;
	
	public static ProcessResult process(String command){
		return process(command, default_timeout, TimeUnit.MILLISECONDS);
	}
	
	public static ProcessResult process(String command, long timeout, TimeUnit unit){
		CommandTask commandTask = new CommandTask(executorService, command);
		Future<ProcessResult> processResult = executorService.submit(commandTask);
		ProcessResult result = null;
		try{
			result = processResult.get(timeout, unit);
		}catch(Exception e){
			logger.error(ConstValues.EXCEPTION_OCCURED, e);
		}
		return result;
	}

}
 
至此，我们在需要调用系统命令时直接调用CommandHelper.process(command)就可以了，然后拿到返回结果ProcessResult。我也是自己做个记录，有需要的朋友可以直接拿去用。
 
顺便说一句，采用封装的这个类在完成上面相同的任务时，时间都在相同的机器上，耗时从原来的10s瞬间减少至200ms以内，由此可见，在适当的场景调用系统命令是多么重要啊。

         java中使用HttpClient实现服务端跨域HttpClient调用其他系统服务
 
 
 
一、 准备jar包
 
1、httpclient-4.5.3.jar
 
2、httpcore-4.4.8.jar
 
3、commons-logging-1.0.4.jar
 
 
 
 
 
二、HttpClient 执行 get 请求 后台代码    
 
    
 
/**
	 * @description: 使用httpClient对象执行get请求
	 * @param: uri  需要跨域请求的uri
	 * @author:wu
	 * @throws IOException 
	 * @throws ClientProtocolException 
	 * @createDate:2018年2月28日 下午2:19:00
	 */
	public static String  doGet(String uri) throws ClientProtocolException, IOException{
		if(StringUtils.isBlank(uri)){
			uri="http://192.168.1.253:999/paseJson/cityJson";
		}
		// 1、 创建 httpClient 对象
		CloseableHttpClient httpClient = HttpClients.createDefault();
		// 2、 创建 get 对象
		HttpGet get =new HttpGet(uri);
		// 3、 执行 get 请求
		CloseableHttpResponse response = httpClient.execute(get);
		// 4、 获取返回结果 HttpEntity  对象
		HttpEntity entity = response.getEntity();
		// 5、获取返回结果中的数据  
		String data = EntityUtils.toString(entity);
		// 6、 关闭 response、 关闭 httpClient
		response.close();
		httpClient.close();
		return data;
	}
 
 
 
三、 HttpClient 执行 post 请求 后台代码
 
 
 
/**
	 * @description:使用httpClient对象执行 post 请求
	 * @param: uri 需要跨域请求的uri , formDataMap  模拟表单需要提交数据 （name - value 形式）
	 * @author:wu
	 * @createDate:2018年2月28日 下午4:36:55
	 */
	public static String doPost(String uri,Map<String,Object> formDataMap) throws ClientProtocolException, IOException{
		if(StringUtils.isBlank(uri)){
			uri="http://192.168.1.253:999/paseJson/cityJson";
		}
		// 1、创建httpClient 对象
		CloseableHttpClient httpClient = HttpClients.createDefault();
		// 2、 创建post 对象
		HttpPost post =new HttpPost(uri);
		// 3、 创建一个list形式数据，模拟提交表单。 
		List<NameValuePair> formDataList=new ArrayList<>();
		// TODO: 这里可以遍历模拟表单传递过来的数据 formDataMap
		/*Iterator<Entry<String, Object>> iterator = formDataMap.entrySet().iterator();
		while(iterator.hasNext()){
			Entry<String, Object> next = iterator.next();
			String key = next.getKey();
			String value = next.getValue().toString();
			formDataList.add(new BasicNameValuePair(key, value));
		}*/
		formDataList.add(new BasicNameValuePair("ids", "110"));
		formDataList.add(new BasicNameValuePair("name", "httpClient 请求数据"));
		// 4、 把表单数据包装到entity 对象中 （StringEntity）
		StringEntity formData = new UrlEncodedFormEntity(formDataList, "UTF-8");
		post.setEntity(formData);
		// 5、 执行post请求
		CloseableHttpResponse response = httpClient.execute(post);
		// 6、 获取响应数据
		HttpEntity entity = response.getEntity();
		// 7、 响应数据转换为字符串
		String data = EntityUtils.toString(entity);
		// 8、 关闭 httpClient对象、关闭 response
		response.close();
		httpClient.close();
		return data;
	}
 
 
 
四、 测试代码
 
public static void main(String[] args) throws ClientProtocolException, IOException {
	String  data="";
	//data = doGet("http://192.168.1.253:999/paseJson/cityJson");
	data= doPost("https://www.baidu.com/", null);
	System.out.println(data);
}
 
 
 
 
 
五、源码附件
 
不知道怎么上传。。
 
 
 
（关于跨域的详细理解，请参考这篇文章： json和jsonp的区别和联系 springMVC实现jsonp跨域请求）
 
 
 
 

Java调用Tuxedo服务，有三种方式：
 
1.JNI
 
发布Tuxedo服务无需做额外限制，无需借助于任何J2EE容器。会影响系统移植和带来性能问题。
 
2.WTC
 
Weglogic为Tuxedo定制，存在一套和Tuxedo API相对应的Java API，发布Tuxedo服务无需做额外限制，双向调用。需要购买License，依赖于Weblogic容器，不能移植到其它J2EE容器。
 
3.Jolt
 
可用于但不依赖于J2EE容器，提供的API用WTC类似但不同。需要购买License，发布Tuxed服务有些额外的要求，不提供集成的Weblogic-server-tuxedo事务机制。
 
 
 
最后欢迎大家访问我的个人网站：1024s