分布式计算的第一次课,法师给了几份代码,要求仔细阅读后理解代码,为接下来的进一步学习做准备。代码涉及到的应该都是分布式计算的基础,相信接下来的开发会用到,这里先做一下总结。代码总共涉及到以下五个方面:
- java语言的异常捕获和处理机制
- 基于socket API开发的基本原理
- 多线程机制
- java序列化与反序列化机制
- java语言的反射机制
这方面的内容相信写过java代码的人都知道了,Java采用将出错处理和正常代码分开的方法来实现异常处理。每当Java程序运行过程中发生一个可识别的运行错误时,即该错误有一个异常类与之相对应时,系统都会产生一个相应的该异常类的对象,即产生一个异常。一旦一个异常对象产生了,系统中就一定有相应的机制来处理它,确保不会产生死机、死循环或其他对操作系统的损害,从而保证了整个程序运行的安全性。
- // 捕获与处理异常例程
- class Account {
- private double balance = 1000;
- public void transfer(double amount)throws OutOfMoney {
- // 在方法中声明抛出异常
- if (balance < amount)
- // 直接抛出异常
- throw new OutOfMoney("[Balance:" + balance + " < Amount:" + amount + "]");
- balance = balance - amount;
- }
- public double getBalance() {
- return balance;
- }
- }
- class OutOfMoney extends Exception {
- public OutOfMoney() {
- // 给出该异常的一个缺省的字符串描述
- super("Your account have not enough money!");
- }
- public OutOfMoney(String msg) {
- // 允许使用者自行给出对异常的一个字符串描述
- super(msg);
- }
- }
- public class AccountException {
- public static void main(String[]args) {
- Account obj = new Account();
- double amount = 800;
- for (int count = 0; count < 3; count++) {
- try {
- obj.transfer(amount);
- System.out.println("Transfer amount: " + amount + ", and then balance: " + obj.getBalance());
- } catch (OutOfMoney exc) {
- exc.printStackTrace();
- } finally {
- System.out.println("finally语句块中的语句总是会执行!");
- }
- amount = amount - 300;
- }
- }
- }
// 捕获与处理异常例程
class Account {
private double balance = 1000;
public void transfer(double amount)throws OutOfMoney {
// 在方法中声明抛出异常
if (balance < amount)
// 直接抛出异常
throw new OutOfMoney("[Balance:" + balance + " < Amount:" + amount + "]");
balance = balance - amount;
}
public double getBalance() {
return balance;
}
}
class OutOfMoney extends Exception {
public OutOfMoney() {
// 给出该异常的一个缺省的字符串描述
super("Your account have not enough money!");
}
public OutOfMoney(String msg) {
// 允许使用者自行给出对异常的一个字符串描述
super(msg);
}
}
public class AccountException {
public static void main(String[]args) {
Account obj = new Account();
double amount = 800;
for (int count = 0; count < 3; count++) {
try {
obj.transfer(amount);
System.out.println("Transfer amount: " + amount + ", and then balance: " + obj.getBalance());
} catch (OutOfMoney exc) {
exc.printStackTrace();
} finally {
System.out.println("finally语句块中的语句总是会执行!");
}
amount = amount - 300;
}
}
}
基于socket API开发的基本原理:
- // 简单的利用流套接字实现通信的服务端程序
- import java.io.*;
- import java.net.*;
- public class MyServer {
- public static void main(String[] args)throws IOException {
- if (args.length != 1) {
- System.out.println("用法:EchoServer <端口号>");
- return ;
- }
- // 创建 ServerSocket 实例,建立连接
- ServerSocket server = new ServerSocket(Integer.parseInt(args[0]));
- System.out.println("服务程序正在监听端口" + args[0]);
- // 监听客户程序的连接请求
- Socket client = server.accept();
- BufferedReader in = new BufferedReader(new InputStreamReader(client.getInputStream()));
- PrintWriter out = new PrintWriter(client.getOutputStream());
- // 从客户端读取数据,并打印在屏幕上,如果接收到”End”,则退出程序。
- String str;
- System.out.println("客户端已经建立连接");
- while ((str = in.readLine()) != null) {
- System.out.println(str);
- System.out.println("收到请求:" + str);
- out.println("服务端已经收到请求:" + str);
- out.flush();
- if (str.equals("end")) {
- System.out.println("通信已经终止");
- break;
- }
- }
- // 关闭连接
- out.close();
- in.close();
- client.close();
- }
- }
// 简单的利用流套接字实现通信的服务端程序
import java.io.*;
import java.net.*;
public class MyServer {
public static void main(String[] args)throws IOException {
if (args.length != 1) {
System.out.println("用法:EchoServer <端口号>");
return ;
}
// 创建 ServerSocket 实例,建立连接
ServerSocket server = new ServerSocket(Integer.parseInt(args[0]));
System.out.println("服务程序正在监听端口" + args[0]);
// 监听客户程序的连接请求
Socket client = server.accept();
BufferedReader in = new BufferedReader(new InputStreamReader(client.getInputStream()));
PrintWriter out = new PrintWriter(client.getOutputStream());
// 从客户端读取数据,并打印在屏幕上,如果接收到”End”,则退出程序。
String str;
System.out.println("客户端已经建立连接");
while ((str = in.readLine()) != null) {
System.out.println(str);
System.out.println("收到请求:" + str);
out.println("服务端已经收到请求:" + str);
out.flush();
if (str.equals("end")) {
System.out.println("通信已经终止");
break;
}
}
// 关闭连接
out.close();
in.close();
client.close();
}
}
- // 简单的利用流套接字实现通信的客户端程序
- import java.net.*;
- import java.io.*;
- public class MyClient {
- static Socket server;
- public static void main(String[] args)throws Exception {
- if (args.length != 2) {
- System.out.println("用法:MyClient <主机名> <端口号>");
- return ;
- }
- // 获取本地ip地址,访问在本地的服务程序,缺省端口是:1234
- Socket server = new Socket(args[0], Integer.parseInt(args[1]));
- // 建立连接并打开相关联的输入流和输出流
- BufferedReader in = new BufferedReader(new InputStreamReader (server.getInputStream()));
- PrintWriter out = new PrintWriter(server.getOutputStream());
- BufferedReader wt = new BufferedReader(new InputStreamReader(System.in));
- // 将控制台输入的字符串发送给服务端,如果接收到"end",则退出程序。
- while (true) {
- String str = wt.readLine();
- out.println(str);
- out.flush();
- if (str.equals("end")) {
- System.out.println("通信已经终止");
- break;
- }
- System.out.println(in.readLine());
- }
- // 关闭连接
- wt.close();
- out.close();
- in.close();
- server.close();
- }
- }
// 简单的利用流套接字实现通信的客户端程序
import java.net.*;
import java.io.*;
public class MyClient {
static Socket server;
public static void main(String[] args)throws Exception {
if (args.length != 2) {
System.out.println("用法:MyClient <主机名> <端口号>");
return ;
}
// 获取本地ip地址,访问在本地的服务程序,缺省端口是:1234
Socket server = new Socket(args[0], Integer.parseInt(args[1]));
// 建立连接并打开相关联的输入流和输出流
BufferedReader in = new BufferedReader(new InputStreamReader (server.getInputStream()));
PrintWriter out = new PrintWriter(server.getOutputStream());
BufferedReader wt = new BufferedReader(new InputStreamReader(System.in));
// 将控制台输入的字符串发送给服务端,如果接收到"end",则退出程序。
while (true) {
String str = wt.readLine();
out.println(str);
out.flush();
if (str.equals("end")) {
System.out.println("通信已经终止");
break;
}
System.out.println(in.readLine());
}
// 关闭连接
wt.close();
out.close();
in.close();
server.close();
}
}
多线程机制:
两个小例子,代码很简单,分别是通过实现Runnable接口定义新线程以及通过继承thread类定义新线程。
- // 通过实现Runnable接口定义新线程
- class Counter implements Runnable {
- public void run() {
- for (int i = 0; i < 100; i++)
- System.out.println("计数器= " + i);
- }
- }
- public class RunnableThread {
- public static void main(String[] args) {
- Counter counter = new Counter();
- Thread thread = new Thread(counter);
- thread.start();
- System.out.println("主程序结束");
- }
- }
// 通过实现Runnable接口定义新线程
class Counter implements Runnable {
public void run() {
for (int i = 0; i < 100; i++)
System.out.println("计数器= " + i);
}
}
public class RunnableThread {
public static void main(String[] args) {
Counter counter = new Counter();
Thread thread = new Thread(counter);
thread.start();
System.out.println("主程序结束");
}
}
- // 通过继承Thread类定义新线程
- public class SubclassThread extends Thread {
- public void run() {
- while (true) {
- // 执行线程自身的任务
- try {
- sleep(5 * 1000);
- break;
- } catch (InterruptedException exc) {
- // 睡眠被中断
- }
- }
- }
- public static void main(String[] args) {
- Thread thread = new SubclassThread();
- thread.start();
- System.out.println("主程序结束");
- }
- }
// 通过继承Thread类定义新线程
public class SubclassThread extends Thread {
public void run() {
while (true) {
// 执行线程自身的任务
try {
sleep(5 * 1000);
break;
} catch (InterruptedException exc) {
// 睡眠被中断
}
}
}
public static void main(String[] args) {
Thread thread = new SubclassThread();
thread.start();
System.out.println("主程序结束");
}
}
java序列化与反序列化机制:
无论是何种类型的数据,都是以二进制序列的形式在网络上传送,所以需要发送进程将对象转换为字节序列,才能在网络上传送;接收进程则需要把字节序列再恢复为对象。在进程间消息通信过程中,把Java对象转换为字节序列的过程称为对象的序列化。把字节序列恢复为Java对象的过程称为对象的反序列化。因此,对象的序列化主要有两种用途:将对象的字节序列持久化,保存在文件系统中;在网络上传送对象的字节序列。
- // 测试对象的序列化和反序列化
- import java.io.*;
- public class AccountSerializable {
- public static void main(String[] args)throws Exception {
- // 创建本地文件输入流
- File f = new File("objectFile.obj");
- ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(f));
- // 序列化对象
- Account Account1 = new Account("Zhang3", 1000);
- Account Account2 = new Account("Li4", 2000);
- out.writeObject(Account1);
- out.writeObject(Account2);
- out.close();
- // 反序列化对象
- ObjectInputStream in = new ObjectInputStream(new FileInputStream(f));
- Account obj1 = (Account)in.readObject();
- System.out.println("Account1=" + obj1);
- Account obj2 = (Account)in.readObject();
- System.out.println("Account2=" + obj2);
- in.close();
- }
- }
- // Account类实现java.io.Serializable接口
- class Account implements Serializable {
- private String name;
- private double balance;
- public Account(String name, double balance) {
- this.name = name;
- this.balance = balance;
- }
- public String toString() {
- return "name=" + name + ", balance=" + balance;
- }
- }
// 测试对象的序列化和反序列化
import java.io.*;
public class AccountSerializable {
public static void main(String[] args)throws Exception {
// 创建本地文件输入流
File f = new File("objectFile.obj");
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(f));
// 序列化对象
Account Account1 = new Account("Zhang3", 1000);
Account Account2 = new Account("Li4", 2000);
out.writeObject(Account1);
out.writeObject(Account2);
out.close();
// 反序列化对象
ObjectInputStream in = new ObjectInputStream(new FileInputStream(f));
Account obj1 = (Account)in.readObject();
System.out.println("Account1=" + obj1);
Account obj2 = (Account)in.readObject();
System.out.println("Account2=" + obj2);
in.close();
}
}
// Account类实现java.io.Serializable接口
class Account implements Serializable {
private String name;
private double balance;
public Account(String name, double balance) {
this.name = name;
this.balance = balance;
}
public String toString() {
return "name=" + name + ", balance=" + balance;
}
}
java语言的反射机制:
Java语言的反射(Reflection)机制可以在程序运行时判断任意一个对象所属的类,构造任意一个类的对象,判断任意一个类所具有的成员变量和方法,调用任意一个对象的方法,或者生成动态代理。
- // 演示Reflection的基本使用方法
- import java.lang.reflect.*;
- public class AccountReflect {
- public Object copy(Object object)throws Exception {
- // 获得对象的类型
- Class classType = object.getClass();
- System.out.println("Class:" + classType.getName());
- // 通过默认构造方法创建一个新的对象
- Object objectCopy = classType.getConstructor(new Class[]{}).newInstance(new Object[]{});
- // 获得对象的所有属性
- Field fields[] = classType.getDeclaredFields();
- for (int i = 0; i < fields.length; i++) {
- Field field = fields[i];
- String fieldName = field.getName();
- String firstLetter = fieldName.substring(0,1).toUpperCase();
- // 获得和属性对应的getXXX()方法的名字
- String getMethodName = "get" + firstLetter + fieldName.substring(1);
- // 获得和属性对应的setXXX()方法的名字
- String setMethodName = "set" + firstLetter + fieldName.substring(1);
- // 获得和属性对应的getXXX()方法
- Method getMethod = classType.getMethod(getMethodName, new Class[]{});
- // 获得和属性对应的setXXX()方法
- Method setMethod = classType.getMethod(setMethodName, new Class[] {field.getType()});
- // 调用原对象的getXXX()方法
- Object value = getMethod.invoke(object, new Object[]{});
- System.out.println(fieldName + ":" + value);
- // 调用复制对象的setXXX()方法
- setMethod.invoke(objectCopy, new Object[]{value});
- }
- return objectCopy;
- }
- public static void main(String[] args)throws Exception {
- Account Account = new Account("Zhang3", 1000);
- Account AccountCopy = (Account)new AccountReflect().copy(Account);
- System.out.println("Copy information:" + AccountCopy.getName() + " " + AccountCopy.getBalance());
- }
- }
- // Account类
- class Account {
- private String name;
- private int balance;
- public Account(){}
- public Account(String name, int balance) {
- this.name = name;
- this.balance = balance;
- }
- public String getName() {
- return name;
- }
- public void setName(String name) {
- this.name = name;
- }
- public int getBalance() {
- return balance;
- }
- public void setBalance(int balance) {
- this.balance = balance;
- }
- }
// 演示Reflection的基本使用方法
import java.lang.reflect.*;
public class AccountReflect {
public Object copy(Object object)throws Exception {
// 获得对象的类型
Class classType = object.getClass();
System.out.println("Class:" + classType.getName());
// 通过默认构造方法创建一个新的对象
Object objectCopy = classType.getConstructor(new Class[]{}).newInstance(new Object[]{});
// 获得对象的所有属性
Field fields[] = classType.getDeclaredFields();
for (int i = 0; i < fields.length; i++) {
Field field = fields[i];
String fieldName = field.getName();
String firstLetter = fieldName.substring(0,1).toUpperCase();
// 获得和属性对应的getXXX()方法的名字
String getMethodName = "get" + firstLetter + fieldName.substring(1);
// 获得和属性对应的setXXX()方法的名字
String setMethodName = "set" + firstLetter + fieldName.substring(1);
// 获得和属性对应的getXXX()方法
Method getMethod = classType.getMethod(getMethodName, new Class[]{});
// 获得和属性对应的setXXX()方法
Method setMethod = classType.getMethod(setMethodName, new Class[] {field.getType()});
// 调用原对象的getXXX()方法
Object value = getMethod.invoke(object, new Object[]{});
System.out.println(fieldName + ":" + value);
// 调用复制对象的setXXX()方法
setMethod.invoke(objectCopy, new Object[]{value});
}
return objectCopy;
}
public static void main(String[] args)throws Exception {
Account Account = new Account("Zhang3", 1000);
Account AccountCopy = (Account)new AccountReflect().copy(Account);
System.out.println("Copy information:" + AccountCopy.getName() + " " + AccountCopy.getBalance());
}
}
// Account类
class Account {
private String name;
private int balance;
public Account(){}
public Account(String name, int balance) {
this.name = name;
this.balance = balance;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getBalance() {
return balance;
}
public void setBalance(int balance) {
this.balance = balance;
}
}
总结以上内容,通过反射机制,客户端可以将向服务端发出的请求对象进行封装,客户端只需要知道远程对象名及其提供服务的方法名,就可以与服务端实现通信。示例代码如下:
- //远程对象接口
- public interface AccountService {
- public String getAccount(String Name);
- }
//远程对象接口
public interface AccountService {
public String getAccount(String Name);
}
- //远程对象接口的实现类
- public class AccountServiceImpl implements AccountService {
- public String getAccount(String Name) {
- return "Account id: " + Name;
- }
- }
//远程对象接口的实现类
public class AccountServiceImpl implements AccountService {
public String getAccount(String Name) {
return "Account id: " + Name;
}
}
- //远程调用对象
- import java.io.*;
- public class RemoteCall implements Serializable {
- private String className; //表示类名或接口名
- private String methodName; //表示方法名
- private Class[] paramTypes; //表示方法参数类型
- private Object[] params; //表示方法参数值
- //表示方法的执行结果
- //如果方法正常执行,则result为方法返回值,如果方法抛出异常,那么result为该异常。
- private Object result;
- public RemoteCall(){}
- public RemoteCall(String className, String methodName, Class[] paramTypes,
- Object[] params) {
- this.className = className;
- this.methodName = methodName;
- this.paramTypes = paramTypes;
- this.params = params;
- }
- public String getClassName() {
- return className;
- }
- public void setClassName(String className) {
- this.className = className;
- }
- public String getMethodName() {
- return methodName;
- }
- public void setMethodName(String methodName) {
- this.methodName = methodName;
- }
- public Class[] getParamTypes() {
- return paramTypes;
- }
- public void setParamTypes(Class[] paramTypes) {
- this.paramTypes = paramTypes;
- }
- public Object[] getParams() {
- return params;
- }
- public void setParams(Object[] params) {
- this.params = params;
- }
- public Object getResult() {
- return result;
- }
- public void setResult(Object result) {
- this.result = result;
- }
- public String toString() {
- return "className=" + className + " methodName=" + methodName;
- }
- }
//远程调用对象
import java.io.*;
public class RemoteCall implements Serializable {
private String className; //表示类名或接口名
private String methodName; //表示方法名
private Class[] paramTypes; //表示方法参数类型
private Object[] params; //表示方法参数值
//表示方法的执行结果
//如果方法正常执行,则result为方法返回值,如果方法抛出异常,那么result为该异常。
private Object result;
public RemoteCall(){}
public RemoteCall(String className, String methodName, Class[] paramTypes,
Object[] params) {
this.className = className;
this.methodName = methodName;
this.paramTypes = paramTypes;
this.params = params;
}
public String getClassName() {
return className;
}
public void setClassName(String className) {
this.className = className;
}
public String getMethodName() {
return methodName;
}
public void setMethodName(String methodName) {
this.methodName = methodName;
}
public Class[] getParamTypes() {
return paramTypes;
}
public void setParamTypes(Class[] paramTypes) {
this.paramTypes = paramTypes;
}
public Object[] getParams() {
return params;
}
public void setParams(Object[] params) {
this.params = params;
}
public Object getResult() {
return result;
}
public void setResult(Object result) {
this.result = result;
}
public String toString() {
return "className=" + className + " methodName=" + methodName;
}
}
- // 客户端程序
- import java.io.*;
- import java.net.*;
- import java.util.*;
- public class RemoteClient {
- public void invoke()throws Exception {
- Socket socket = new Socket("localhost", 8000);
- OutputStream out = socket.getOutputStream();
- ObjectOutputStream oos = new ObjectOutputStream(out);
- InputStream in = socket.getInputStream();
- ObjectInputStream ois = new ObjectInputStream(in);
- RemoteCall call = new RemoteCall("AccountService", "getAccount", new Class[] { String.class }, new Object[] {"Zhang3"});
- // 向服务器发送Call 对象
- oos.writeObject(call);
- // 接收包含了方法执行结果的Call 对象
- call = (RemoteCall)ois.readObject();
- System.out.println(call.getResult());
- ois.close();
- oos.close();
- socket.close();
- }
- public static void main(String args[])throws Exception {
- new RemoteClient().invoke();
- }
- }
// 客户端程序
import java.io.*;
import java.net.*;
import java.util.*;
public class RemoteClient {
public void invoke()throws Exception {
Socket socket = new Socket("localhost", 8000);
OutputStream out = socket.getOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(out);
InputStream in = socket.getInputStream();
ObjectInputStream ois = new ObjectInputStream(in);
RemoteCall call = new RemoteCall("AccountService", "getAccount", new Class[] { String.class }, new Object[] {"Zhang3"});
// 向服务器发送Call 对象
oos.writeObject(call);
// 接收包含了方法执行结果的Call 对象
call = (RemoteCall)ois.readObject();
System.out.println(call.getResult());
ois.close();
oos.close();
socket.close();
}
public static void main(String args[])throws Exception {
new RemoteClient().invoke();
}
}
- //服务端程序
- import java.io.*;
- import java.net.*;
- import java.util.*;
- import java.lang.reflect.*;
- public class Server {
- // 存放远程对象的缓存
- private Map remoteObjects = new HashMap();
- // 把一个远程对象放到缓存中
- public void register(String className, Object remoteObject) {
- remoteObjects.put(className, remoteObject);
- }
- public void service()throws Exception {
- // 创建基于流的Socket,并在8000端口监听
- ServerSocket serverSocket = new ServerSocket(8000);
- System.out.println("服务器启动......");
- while (true) {
- Socket socket = serverSocket.accept();
- InputStream in = socket.getInputStream();
- ObjectInputStream ois = new ObjectInputStream(in);
- OutputStream out = socket.getOutputStream();
- ObjectOutputStream oos = new ObjectOutputStream(out);
- RemoteCall remotecallobj = (RemoteCall)ois.readObject();
- //接收客户发送的Call对象
- System.out.println(remotecallobj);
- remotecallobj = invoke(remotecallobj); //调用相关对象的方法
- oos.writeObject(remotecallobj);
- //向客户发送包含了执行结果的remotecallobj对象
- ois.close();
- oos.close();
- socket.close();
- }
- }
- public RemoteCall invoke(RemoteCall call) {
- Object result = null;
- try {
- String className = call.getClassName();
- String methodName = call.getMethodName();
- Object[] params = call.getParams();
- Class classType = Class.forName(className);
- Class[] paramTypes = call.getParamTypes();
- Method method = classType.getMethod(methodName, paramTypes);
- Object remoteObject = remoteObjects.get(className);
- //从缓存中取出相关的远程对象
- if (remoteObject == null) {
- throw new Exception(className + "的远程对象不存在");
- } else {
- result = method.invoke(remoteObject, params);
- }
- } catch (Exception e) {
- result = e;
- }
- call.setResult(result); //设置方法执行结果
- return call;
- }
- public static void main(String args[])throws Exception {
- Server server = new Server();
- //把事先创建的RemoteServiceImpl 对象加入到服务器的缓存中
- server.register("AccountService", new AccountServiceImpl());
- server.service();
- }
- }