Java的系统调用

Java提供了系统调用的功能，

如果，一套程序要部署在不同操作系统上运行，这就要求我们，针对不同操作系统完成不同的系统调用。

下面，针对命令行模式的系统调用，编写了一些代码。

注意，并发调用的时候，不要太多，最好不要超过是个并发，否则系统运行缓慢。

并且实现的Ping命令在三个不同操作系统上面的系统调用。

 

首先，介绍两个依赖的接口，一个用于处理程序抛出的异常，一个用于记录程序日志。

package houlei.util; /** * 异常处理器，可以处理“异常”和“错误”。 */ public interface ExceptionHandler { /** * 该方法完成异常处理的过程 * @param t 程序抛出的“异常”和“错误” */ void handle(Throwable t); }

package houlei.util; /** * 日志处理器，用于处理程序中需要记录的日志。 */ public interface LogHandler { void debug(String msg); void debug(String msg,Throwable t); void error(String msg); void error(String msg,Throwable t); void info(String msg); void info(String msg,Throwable t); }

由于个人习惯，编程时，很少将异常抛出，而是在不影响程序正常功能的情况，记录日志。

上述两个接口的实现类，如下：（为节省空间，已经折叠）

package houlei.util; public class DefaultExceptionHandler implements ExceptionHandler { public void handle(Throwable t) { t.printStackTrace(); } }

package houlei.util; import java.text.SimpleDateFormat; import java.util.Date; public class DefaultLogHandler implements LogHandler { private static final SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss.S"); public DefaultLogHandler(Class<? extends Object> clazz){ } private void log(String msg){ System.out.println(sdf.format(new Date())+msg); } private void log(String msg, Throwable t){ synchronized (System.out) { System.out.println(sdf.format(new Date())+msg); t.printStackTrace(System.out); } } public void debug(String msg) { log(msg); } public void debug(String msg, Throwable t) { log(msg,t); } public void error(String msg) { System.err.println(sdf.format(new Date())+msg); } public void error(String msg, Throwable t) { synchronized (System.err) { System.err.println(sdf.format(new Date())+msg); t.printStackTrace(System.err); } } public void info(String msg) { log(msg); } public void info(String msg, Throwable t) { log(msg,t); } }

 

其次，介绍大体的设计思路。

命令行形式的系统调用，应该可以分成三个部分：

1.针对不同系统，产生不同格式的命令。

2.针对不同格式命令，产生不同的结果处理流程。

3.要有一个统一的处理过程。

根据上述思路，产生三个接口：

package houlei.util.syscall; /** * 系统调用命令对象的工厂接口类。该接口实现针对不同的操作系统产生不同的命令对象。 */ public interface CommandFactory { /**获得命令对象 * @param osName 操作系统的名称 * @return 返回针对操作系统的命令对象 * @throws CommandException 无法产生命令对象时，抛出该异常 */ public Command getCommand(String osName) throws CommandException; }

package houlei.util.syscall; /** * 针对不同的命令，产生不同的行处理类。 */ public interface LineFilterFactory { /** * 获得 系统调用结果的行过滤器对象 * @param command 命令对象 * @return 过滤器对象 */ public LineFilter getLineFilter(Command command); }

package houlei.util.syscall; import houlei.util.ExceptionHandler; /** * 命令处理器。该接口可以处理命令行形式的系统调用。 */ public interface CommandExecutor { /** * 处理命令行。 * @param command 等待调用的命令行 * @param filter 处理调用结果的每一行，直到成功为止。 * @param handler 异常处理器，处理调用过程中抛出的异常。 * @return 当调用结果的某一行被<code>filter</code>处理成功时，返回<code>true</code>。 */ public boolean execute(Command command,LineFilter filter,ExceptionHandler handler); }

命令行形式的系统调用，一般，都会有结果显示给用户，基于这种情况，我们可以分析结果的每一行，来判断命令是否执行成功。

由于整体的处理过程是相同的，所以，编写了一个默认的CommandExecutor实现类。

package houlei.util.syscall; import houlei.util.ExceptionHandler; import java.util.Scanner; public class DefaultCommandExecutor implements CommandExecutor { public boolean execute(Command command, LineFilter filter, ExceptionHandler handler) { try{ Process pro = Runtime.getRuntime().exec(command.toCommandLine()); Scanner sc = new Scanner(pro.getInputStream()); while(sc.hasNextLine()){ String line = sc.nextLine(); if(filter.doFilter(line)){ sc.close(); pro.destroy(); return true; } } }catch (Exception e) { handler.handle(e); } return false; } }

当然，还要介绍几个与上述代码有依赖关系的类。

package houlei.util.syscall; /** * 系统调用的命令。通过该接口，可以得到所要调用的命令。 */ public interface Command { /** * 返回命令行的信息 * @return 返回命令行的信息 */ public abstract String toCommandLine(); }

package houlei.util.syscall; /** * 命令执行结果的过滤器。通过分析系统调用结果的每一行信息，来处理调用结果。 */ public interface LineFilter { /** * 根据命令的执行结果，每一行调用该方法，进行处理。 * @param line 执行命令后，结果的行内容。 * @return 当处理的行满足条件时返回true，从而终止处理过程。 */ public boolean doFilter(String line); }

package houlei.util.syscall; public class CommandException extends Exception { private static final long serialVersionUID = 1899369274928610152L; public CommandException() { super(); } public CommandException(String message, Throwable cause) { super(message, cause); } public CommandException(String message) { super(message); } public CommandException(Throwable cause) { super(cause); } }

第三，介绍Ping命令的编程实现。

由于前面介绍的三个部分当中，第三个部分已经有默认的实现。

所以，只需要完成其他两个部分的编码即可。

1.针对不同操作系统，产生不同格式的系统调用命令。

package houlei.util.syscall.ping; import java.util.Collections; import java.util.HashMap; import java.util.Map; import houlei.util.syscall.Command; import houlei.util.syscall.CommandException; import houlei.util.syscall.CommandFactory; import houlei.util.syscall.ping.ext.AixPingCommand; import houlei.util.syscall.ping.ext.LinuxPingCommand; import houlei.util.syscall.ping.ext.WindowsPingCommand; public class PingCommandFactory implements CommandFactory { /** * 用于精确匹配的处理类映射。现无数据，可根据实际情况添加。 */ private final Map<String,Class<? extends PingCommand>> commands = Collections.synchronizedMap(new HashMap<String,Class<? extends PingCommand>>()); /** * 用于模糊匹配的处理类映射。现只有三个映射，分别实现AIX、Linux、Windows三个系统与处理类的映射。 */ private final Map<String,Class<? extends PingCommand>> matchedCommands = Collections.synchronizedMap(new HashMap<String,Class<? extends PingCommand>>()); public PingCommandFactory(){ init(); } private void init() { /** 初始化映射关系 */ registMatchedCommand("AIX", AixPingCommand.class); registMatchedCommand("LINUX", LinuxPingCommand.class); registMatchedCommand("WIN", WindowsPingCommand.class); } /**注册精确匹配的命令实现类 * @param osName 系统名称 * @param clazz 命令实现类 */ public void registCommand(String osName,Class<? extends PingCommand> clazz){ commands.put(osName, clazz); } /**删除精确匹配的命令实现类 * @param osName 系统名称 * @return 已删除的对象 */ public Class<? extends PingCommand> removeCommand(String osName){ return commands.remove(osName); } /**注册模糊匹配的命令实现类 * @param osName 系统名称 * @param clazz 命令实现类 */ public void registMatchedCommand(String osName,Class<? extends PingCommand> clazz){ matchedCommands.put(osName, clazz); } /**删除模糊匹配的命令实现类 * @param osName 系统名称 * @return 已删除的对象 */ public Class<? extends PingCommand> removeMatchedCommand(String osName){ return matchedCommands.remove(osName); } /* (non-Javadoc) * @see houlei.util.syscall.CommandFactory#getCommand(java.lang.String) */ public Command getCommand(String osName) throws CommandException { Class<? extends PingCommand> cmd = commands.get(osName); if(null==null){ synchronized (matchedCommands) { for(String os : matchedCommands.keySet()){ if(osName.toUpperCase().contains(os)){ cmd = matchedCommands.get(os); break; } } } } if(null==cmd){ throw new CommandException("Not support system : "+osName); } try { return cmd.newInstance(); } catch (Exception e) { throw new CommandException("Can not create instance of "+cmd.getName()+" and system is "+osName); } } }

2.针对不同格式的命令，产生不同的处理过程。

根据实际情况，针对三个操作系统，ping命令成功的结果中都有“ TTL= ”字符串，

所以，工厂类产生一种Filter即可。

package houlei.util.syscall.ping; import houlei.util.syscall.Command; import houlei.util.syscall.LineFilter; import houlei.util.syscall.LineFilterFactory; public class PingLineFilterFactory implements LineFilterFactory { public LineFilter getLineFilter(Command command) { return new PingLineFilter(); } }

如果没看懂上面的解释，请看工厂类产生的产品代码。

package houlei.util.syscall.ping; import houlei.util.DefaultLogHandler; import houlei.util.LogHandler; import houlei.util.syscall.LineFilter; public class PingLineFilter implements LineFilter { private static final LogHandler DefaultLogger = new DefaultLogHandler(PingLineFilter.class); private LogHandler logger = DefaultLogger; public PingLineFilter() { super(); } public PingLineFilter(LogHandler logger) { super(); this.logger = logger; } public boolean doFilter(String line) { if(line.length()<=0)return false; logger.debug("PingResultLine:/t"+line); if(line.toUpperCase().contains("TTL=")){ return true; } return false; } public LogHandler getLogger() { return logger; } public void setLogger(LogHandler logger) { this.logger = logger; } }

之后是关于Ping命令的一些代码。

package houlei.util.syscall.ping; import houlei.util.syscall.Command; /** * Ping命令的接口类，用于设置Ping命令的参数，和，形成命令行信息。 */ public interface PingCommand extends Command{ /** * 命令字 */ public final String CommandWord = "ping"; /** * 获得命令字 * @return 返回命令字 */ public String getCommandWord(); /** * 发送数据包的个数 * @return 发送数据包的个数 */ public int getPackageCount(); /** * 设置发送探测数据包的个数 * @param packageCount 发送探测数据包的个数 * @return */ public PingCommand setPackageCount(int packageCount); /** * 探测数据包的大小 * @return 探测数据包的大小 */ public int getPackageSize(); /** * 设置探测数据包的大小 * @param packageSize 探测数据包的大小 * @return */ public PingCommand setPackageSize(int packageSize); /** * 等待超时（单位：秒） * @return 等待超时（单位：秒） */ public int getTimeOut(); /** * 设置等待超时（单位：秒） * @param timeOut 等待超时（单位：秒） * @return */ public PingCommand setTimeOut(int timeOut); /** * 待探测的主机 * @return 待探测的主机 */ public String getHost(); /** * 设置待探测的主机 * @param host 待探测的主机 * @return */ public PingCommand setHost(String host); }

package houlei.util.syscall.ping; public abstract class AbstractPingCommand implements PingCommand{ protected int packageCount=-1; protected int packageSize=-1; protected int timeOut=-1; protected String host=null; public String getCommandWord() { return CommandWord; } public int getPackageCount() { return packageCount; } public PingCommand setPackageCount(int packageCount) { this.packageCount = packageCount; return this; } public int getPackageSize() { return packageSize; } public PingCommand setPackageSize(int packageSize) { this.packageSize = packageSize; return this; } public int getTimeOut() { return timeOut; } public PingCommand setTimeOut(int timeOut) { this.timeOut = timeOut; return this; } public String getHost() { return host; } public PingCommand setHost(String host) { this.host = host; return this; } }

下面是三个系统的系统命令（折叠了两个，展开了一个）

package houlei.util.syscall.ping.ext; import houlei.util.syscall.ping.AbstractPingCommand; public class AixPingCommand extends AbstractPingCommand{ public String toCommandLine() { StringBuilder buff = new StringBuilder(); buff.append(CommandWord); if(packageCount>0){ buff.append(" -c ").append(packageCount); } if(packageSize>0){ buff.append(" -l ").append(packageSize); } if(timeOut>0){ buff.append(" -w ").append(timeOut); } if(null==host){ throw new IllegalArgumentException("The args named host must be not null."); } buff.append(' ').append(host); return buff.toString(); } }

package houlei.util.syscall.ping.ext; import houlei.util.syscall.ping.AbstractPingCommand; public class LinuxPingCommand extends AbstractPingCommand { public String toCommandLine() { StringBuilder buff = new StringBuilder(); buff.append(CommandWord); if(packageCount>0){ buff.append(" -c ").append(packageCount); } if(packageSize>0){ buff.append(" -s ").append(packageSize); } if(timeOut>0){ buff.append(" -W ").append(timeOut); } if(null==host){ throw new IllegalArgumentException("The args named host must be not null."); } buff.append(' ').append(host); return buff.toString(); } }

package houlei.util.syscall.ping.ext; import houlei.util.syscall.ping.AbstractPingCommand; public class WindowsPingCommand extends AbstractPingCommand { public String toCommandLine() { StringBuilder buff = new StringBuilder(); buff.append(CommandWord); if(packageCount>0){ buff.append(" -n ").append(packageCount); } if(packageSize>0){ buff.append(" -l ").append(packageSize); } if(timeOut>0){ buff.append(" -w ").append(timeOut*1000); } if(null==host){ throw new IllegalArgumentException("The args named host must be not null."); } buff.append(' ').append(host); return buff.toString(); } }

最后，为代码的使用者，提供一个门面类，方便使用。

package houlei.util.syscall.ping; import houlei.util.DefaultLogHandler; import houlei.util.ExceptionHandler; import houlei.util.LogHandler; import houlei.util.syscall.CommandException; import houlei.util.syscall.CommandExecutor; import houlei.util.syscall.CommandFactory; import houlei.util.syscall.DefaultCommandExecutor; import houlei.util.syscall.LineFilter; import houlei.util.syscall.LineFilterFactory; /** * 关于Ping命令的工具类。采用调用系统ping命令的方式实现网络路径探测。 */ public class PingFacade { /** * 操作系统的名称 */ public static final String OSName = System.getProperty("os.name"); private static final LineFilterFactory DefaultLineFilterFactory = new PingLineFilterFactory(); private static final CommandFactory DefaultCommandFactory = new PingCommandFactory(); private static final CommandExecutor DefaultCMDExecutor = new DefaultCommandExecutor(); private static final ExceptionHandler DefaultExceptionHandler = new houlei.util.DefaultExceptionHandler(); private static final LogHandler DefaultLoggerHandler = new DefaultLogHandler(PingFacade.class); private static final PingFacade instance = new PingFacade(); private CommandFactory commandFactory = DefaultCommandFactory; private LineFilterFactory lineFilterFactory = DefaultLineFilterFactory; private CommandExecutor commandExecutor = DefaultCMDExecutor; private ExceptionHandler exceptionHandler = DefaultExceptionHandler; private LogHandler logHandler = DefaultLoggerHandler; public static PingFacade getInstance(){ return instance; } /** * 根据系统类型调用ping，查看网络是否连通 * * @param host 待探测的主机 * @param packSize 数据包的大小 * @param timeOut 等待超时（单位：秒） * @param packCount 数据包的数量 * @return 探测是否成功 */ public boolean ping(String host,int packageSize,int timeOut, int packageCount){ try { PingCommand command = (PingCommand)commandFactory.getCommand(OSName); command.setHost(host).setPackageSize(packageSize).setTimeOut(timeOut).setPackageCount(packageCount); logHandler.debug("os.name = "+OSName+"/tcmd = "+command.toCommandLine()); LineFilter filter = lineFilterFactory.getLineFilter(command); logHandler.debug("LineFilter.class = "+filter.getClass().getName()); return commandExecutor.execute(command, filter, exceptionHandler); } catch (CommandException e) { exceptionHandler.handle(e); } return false; } public CommandFactory getCommandFactory() { return commandFactory; } public void setCommandFactory(CommandFactory commandFactory) { this.commandFactory = commandFactory; } public LineFilterFactory getLineFilterFactory() { return lineFilterFactory; } public void setLineFilterFactory(LineFilterFactory lineFilterFactory) { this.lineFilterFactory = lineFilterFactory; } public CommandExecutor getCommandExecutor() { return commandExecutor; } public void setCommandExecutor(CommandExecutor commandExecutor) { this.commandExecutor = commandExecutor; } public ExceptionHandler getExceptionHandler() { return exceptionHandler; } public void setExceptionHandler(ExceptionHandler exceptionHandler) { this.exceptionHandler = exceptionHandler; } public LogHandler getLogHandler() { return logHandler; } public void setLogHandler(LogHandler logHandler) { this.logHandler = logHandler; } }