javadoc的生成和java应用程序的打包和部署

最新推荐文章于 2023-08-28 22:49:28 发布

梦醒-已千年

最新推荐文章于 2023-08-28 22:49:28 发布

阅读量1.2k

点赞数

分类专栏： java 文章标签： java RMI

本文链接：https://blog.csdn.net/u010102951/article/details/42966711

版权

java 专栏收录该内容

25 篇文章 0 订阅

订阅专栏

javadoc命令

如果要将一个类生成文档，该类必须是public访问权限。例如我们要将以下的类生成javadoc文档可以使用下面的命令：

/**
 * 这是一个可以对数组进行操作的工具类，该类中提供了，获取最值，排序等功能。
 * 
 * @author 张三
 * @version V1.1
 */

public class ArrayTool {
	/**
	 * 无参构造
	 */
	public ArrayTool() {
	}

	/**
	 * 获取一个整形数组中的最大值。 
	 * @param arr 接收一个int类型的数组。
	 * @return 会返回一个该数组中最大值。
	 */
	public static int getMax(int[] arr) {
		int max = 0;
		for (int x = 1; x < arr.length; x++) {
			if (arr[x] > arr[max])
				max = x;
		}
		return arr[max];
	}

	/**
	 * 给int数组进行选择排序。
	 * @param arr 接收一个int类型的数组。
	 */
	public static void selectSort(int[] arr) {
		for (int x = 0; x < arr.length - 1; x++) {
			for (int y = x + 1; y < arr.length; y++) {
				if (arr[x] > arr[y]) {
					swap(arr, x, y);
				}
			}
		}
	}

	/**
	 * 给int数组进行冒泡排序。
	 * @param arr 接收一个int类型的数组。
	 */
	public static void bubbleSort(int[] arr) {
		for (int x = 0; x < arr.length - 1; x++) {
			for (int y = 0; y < arr.length - x - 1; y++) {
				if (arr[y] > arr[y + 1]) {
					swap(arr, y, y + 1);
				}
			}
		}
	}

	/**
	 * 给数组中元素进行位置的置换。
	 * @param arr 接收一个int类型的数组。
	 * @param a 要置换的位置
	 * @param b 要置换的位置
	 */
	private static void swap(int[] arr, int a, int b) {
		int temp = arr[a];
		arr[a] = arr[b];
		arr[b] = temp;
	}

	/**
	 * 用于打印数组中的元素。打印形式是：[elemet1, element2, ...]
	 * @param arr 接收一个int类型的数组。
	 */
	public static void printArray(int[] arr) {
		System.out.print("[");
		for (int x = 0; x < arr.length; x++) {
			if (x != arr.length - 1)
				System.out.print(arr[x] + ", ");
			else
				System.out.println(arr[x] + "]");
		}
	}
}

将类文件存放到指定目录：

javac -d 需要存放的目录 *.java

把程序包进jar

jar就是Java ARchive。这种文件是pkzip格式的文件，它能够让你把一组类文件包装起来，所以交付的时候只需要一个JAR文件。可执行的JAR代表用户不需要把文件抽出来就能够运行。程序可以在类文件保存在JAR的情况下执行。秘诀在于创建manifest文件，它会带有jar的信息，告诉JVM哪个类含有main（）方法！

①指定所有的类文件都在classFile目录下；

②创建manifest.txt文件用来描述哪个类含有main（）方法，该文件的格式如下：

③使用jar工具来创建带有所有类以及manifest的JAR文件

大部分完全在本机的java应用程序都是以可执行的jar来部署的。

JVM能够从JAR中载入类，并调用该类的main（）方法。事实上整个应用程序都可以包在JAR中。一旦main（）方法开始执行，JVM就不会在乎类从哪里来，只要能够找到就行。其中一个来源就是classpath指定位置的所有jar文件。如果看到某个JAR，则JVM就会在需要类的时候查询此JAR。

RMI（Remote Method Invocation）

一般来说方法的调用都是发生在相同的堆上的两个对象之间的，也就是说调用方和被调用方都在同一个堆上。

但是，如果要调用不同机器上的对象的方法怎么办？

远程过程调用需要4种东西：服务器、客户端、服务器辅助设施和客户端辅助设施。

辅助设施的任务：

辅助设施是实际上执行通信的对象。他们会让客户端感觉上就好像是在调用本机的对象。客户端是真正服务的代理（proxy）。也就是说：客户端以为它调用的是远程的服务，因为辅助设置假装成服务对象。

但是客户端辅助设施并不是真正的远程服务，虽然辅助设施的举止跟它很像（因为它提供的方法和服务和所声明的一样），却没有任何真正客户端需要的方法的方法和逻辑。相反，辅助设施会去连接服务器，将调用的信息传递过去（像是方法名称或者参数内容），然后等待server响应。

在Server端，服务器的辅助设施会通过Socket连接来自Client设施的要求，解析打包送来的信息，然后调用真正的服务。因此对服务对象来说调用来自本地。

服务的辅助设施取得返回值之后就把它包装后送出去（通过Socket的输出串流）给客户端的辅助设施。客户端的辅助设施会解开这些信息传送给客户端的对象。

客户端对象看起来像是在调用远程的方法。但是实际上它只是在调用本地处理Socket的串流细节的“代理”。

java RMI提供客户端和服务器端的辅助设施对象。

在RMI中，客户端的辅助设施称为stub，而服务端的辅助设施称为skeleton。

创建远程服务的5个步骤：

一、创建Remote接口：远程的接口定义了客户端可以远程调用的方法。它是个作为服务的多态化类。stub的服务都会实现此接口。

二、实现Remote接口：这是真正执行的类。它实现出定义在该接口上的方法。它是客户端会调用的对象。

三、用RMIC产生stub和skeleton：客户端和服务器都有helper。你无需创建这些类或者产生这些类的源代码。这都会在你执行JDK所附的rmic工具时自动地处理掉。

四、启动RMI registry：RMI registry就像是电话薄。用户会从此处取得代理（客户端的stub/helper对象）。

五、启动远程服务：你必须让服务对象开始执行。实现服务的类会起始服务的实例并向RMI registry注册。要有注册后才能够对用户提供服务。

以下是一个简单的范例：

一、创建远程接口

import java.rmi.Remote;
import java.rmi.RemoteException;

/**
 * Remote是一个标记接口
 */
public interface MyRemote extends Remote {
    /*
     * 远程接口定义了客户端可以远程调用的方法，是一个作为服务的多态化类。也就是说：
     * 客户端会调用有实现此接口的stub，而此stub因为会执行网络的输入输出工作，
     * 所以可能产生各种问题，客户端必须处理或者声明异常（每一个远程调用都会被认为是有风险的，这样声明会强迫客户端注意到这件事）。
     * 
     * 远程方法的参数和返回值都应该是primitive主数据类型或Serializable， 因为参数和返回值都会被打包通过网络传送，而这依靠序列化
     */
    public String sayHello() throws RemoteException;
}

二、实现远程接口

import java.net.MalformedURLException;
import java.rmi.Naming;
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;

/**
 * 为了要称为远程服务对象，你的对象必须要有与远程有关的功能。其中最简单的方式就是继承UnicastRemoteObject
 *
 */
public class MyRemoteImpl extends UnicastRemoteObject implements MyRemote {
    /* UnicastRemoteObject的构造方法会抛出RemoteException。处理它的唯一方式是对它的声明实现一个构造方法 */
    protected MyRemoteImpl() throws RemoteException {
	super();
    }

    @Override
    public String sayHello() throws RemoteException {
	return "Server says：“Hey！”";
    }

    public static void main(String[] args) {
	try {
	    MyRemote service = new MyRemoteImpl();
	    /* 向RMI registry注册服务 */
	    Naming.rebind("RemoteHello", service);
	} catch (RemoteException e) {
	    e.printStackTrace();
	} catch (MalformedURLException e) {
	    e.printStackTrace();
	}
    }

}

三、产生stub和skeleton

四、执行rmiregistry

五、启动服务（从另一个命令行）

客户端如何取得stub对象？

客户端必须取得stub对象，因为客户端必须要调用它的方法。这就得靠RMI registry了。客户端会像查电话簿一样进行搜索，找出上面有相符合的名称的服务。

import java.net.MalformedURLException;
import java.rmi.Naming;
import java.rmi.NotBoundException;
import java.rmi.RemoteException;

public class MyRemoteClient {
    public static void main(String[] args) {
	new MyRemoteClient().go();
    }

    private void go() {
	MyRemote service;
	try {
	    service = (MyRemote) Naming.lookup("rmi://127.0.0.1/RemoteHello");
	    String s = service.sayHello();	//就像是调用本机的方法，但是是有风险的
	    System.out.println(s);
	} catch (MalformedURLException e) {
	    e.printStackTrace();
	} catch (RemoteException e) {
	    e.printStackTrace();
	} catch (NotBoundException e) {
	    e.printStackTrace();
	}

    }
}

下面是远程调用的综合实例：

import java.rmi.Remote;
import java.rmi.RemoteException;

public interface ServiceServer extends Remote {
    Object[]getServiceList()throws RemoteException;
    Service getService(Object serviceKey)throws RemoteException;
}

import java.io.Serializable;

import javax.swing.JPanel;

public interface Service extends Serializable{
    public JPanel getGuiPanel();
}

import java.net.MalformedURLException;
import java.rmi.Naming;
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
import java.util.HashMap;

public class ServiceServerImpl extends UnicastRemoteObject implements ServiceServer {
    HashMap serviceList;	//服务会存储在HashMap中
    protected ServiceServerImpl() throws RemoteException {
	setUpServices();
    }

    private void setUpServices() {
	serviceList = new HashMap();
	serviceList.put("Dice Rolling Service", new DiceService());
	serviceList.put("Day of Week Service", new DayOfWeekService());
    }

    @Override
    public Object[] getServiceList() throws RemoteException {
	System.out.println("in remote");
	return serviceList.keySet().toArray();
    }

    @Override
    public Service getService(Object serviceKey) throws RemoteException {
	Service thesService = (Service) serviceList.get(serviceKey);
	return thesService;
    }

    public static void main(String[] args) {
	try {
	    Naming.rebind("ServiceServer", new ServiceServerImpl());
	} catch (RemoteException e) {
	    e.printStackTrace();
	} catch (MalformedURLException e) {
	    e.printStackTrace();
	}
	System.out.println("Remote service is running");
    }
}

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.JLabel;
import javax.swing.JPanel;

public class DiceService implements Service {
    JLabel label;
    JComboBox numOfDice;
    @Override
    public JPanel getGuiPanel() {
	JPanel panel = new JPanel();
	JButton button = new JButton("Roll `em!");
	String[]choices = {"1","2","3","4","5"};
	numOfDice = new JComboBox(choices);
	label = new JLabel("Dice values here");
	button.addActionListener(new ActionListener() {
	    
	    @Override
	    public void actionPerformed(ActionEvent paramActionEvent) {
		String diceOutput = "";
		String selection = (String) numOfDice.getSelectedItem();
		int numOfDiceToRoll = Integer.parseInt(selection);
		for (int i = 0; i < numOfDiceToRoll; i++) {
		    int r = (int) (Math.random()*99+1);
		    diceOutput += (" "+r);
		}
		label.setText(diceOutput);
	    }
	});
	panel.add(numOfDice);
	panel.add(button);
	panel.add(label);
	return panel;
    }

}

import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.text.DateFormatSymbols;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;

public class DayOfWeekService implements Service {
    JLabel outputLabel;
    JComboBox month;
    JTextField day;
    JTextField year;

    @Override
    public JPanel getGuiPanel() {
	JPanel panel = new JPanel();
	JButton button = new JButton("Do it");
	button.addActionListener(new ActionListener() {

	    @Override
	    public void actionPerformed(ActionEvent paramActionEvent) {
		int monthNum = month.getSelectedIndex();
		int dayNum = Integer.parseInt(day.getText());
		int yearNum = Integer.parseInt(year.getText());
		Calendar c = Calendar.getInstance();
		c.set(Calendar.MONTH, monthNum);
		c.set(Calendar.DAY_OF_MONTH, dayNum);
		c.set(Calendar.YEAR, yearNum);
		Date date = c.getTime();
		String dayOfWeek = new SimpleDateFormat("EEEE").format(date);
		outputLabel.setText(dayOfWeek);
	    }
	});
	outputLabel = new JLabel("Date appears here");
	DateFormatSymbols dateStuff = new DateFormatSymbols();
	month = new JComboBox(dateStuff.getMonths());
	day = new JTextField(8);
	year = new JTextField(8);
	JPanel inputPanel = new JPanel(new GridLayout(3, 2));
	inputPanel.add(new JLabel("月"));
	inputPanel.add(month);
	inputPanel.add(new JLabel("日"));
	inputPanel.add(day);
	inputPanel.add(new JLabel("年"));
	inputPanel.add(year);
	panel.add(inputPanel);
	panel.add(button);
	panel.add(outputLabel);
	return panel;
    }
}

import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.net.MalformedURLException;
import java.rmi.Naming;
import java.rmi.NotBoundException;
import java.rmi.RemoteException;

import javax.swing.JComboBox;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class ServiceBrowser {
    JPanel mainPanel;
    JComboBox serviceList;
    ServiceServer server;

    public void buildGUI() {
	JFrame frame = new JFrame("RMI Browser");
	mainPanel = new JPanel();
	frame.getContentPane().add(BorderLayout.CENTER, mainPanel);

	Object[] services = getServicesList();
	serviceList = new JComboBox(services);

	frame.getContentPane().add(BorderLayout.NORTH, serviceList);
	serviceList.addActionListener(new ActionListener() {

	    @Override
	    public void actionPerformed(ActionEvent paramActionEvent) {
		Object selection = serviceList.getSelectedItem();
		loadService(selection);
	    }
	});
	frame.setSize(500, 100);
	frame.setVisible(true);
	frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }

    private Object[] getServicesList() {
	Object obj = null;
	Object[] services = null;

	try {
	    obj = Naming.lookup("rmi://127.0.0.1/ServiceServer");
	    server = (ServiceServer) obj;
	    services = server.getServiceList();
	} catch (MalformedURLException e) {
	    e.printStackTrace();
	} catch (RemoteException e) {
	    e.printStackTrace();
	} catch (NotBoundException e) {
	    e.printStackTrace();
	}
	return services;
    }

    private void loadService(Object serviceSelection) {
	try {
	    Service svc = server.getService(serviceSelection);
	    mainPanel.removeAll();
	    mainPanel.add(svc.getGuiPanel());
	    mainPanel.validate();
	    mainPanel.repaint();
	} catch (RemoteException e) {
	    e.printStackTrace();
	}
    }

    public static void main(String[] args) {
	new ServiceBrowser().buildGUI();
    }

}

运行结果：