java.net.InetAddress
获得本机地址对象，InetAddress.getLocalHost();
获得表示远程地址的对象，InetAddress.getByName(ip或主机名);
getHostAddress(); ip getHostName(); 主机名
java.net.ServersSocket
ServerSocket ss = new ServerSocket(端口号);
Socket s = ss.accept(); //阻塞方法
java.net.Socket
Socket s = new Socket( ip , 端口号);
获得双向通行的流：s.getInputStream(); s.getOutputStream();
设置接收数据超时：s.setSoTimeout(毫秒);
关闭：1）关闭Socket，2）关闭ServerSocket
简单的Client/Server程序
1. 客户端程序
import java.io.*;
import java.net.*;
public class TalkClient {
public static void main(String args[]) {
try{
Socket socket=new Socket("127.0.0.1",4700);
//向本机的4700端口发出客户请求
BufferedReader sin=new BufferedReader(new InputStreamReader(System.in));
//由系统标准输入设备构造BufferedReader对象
PrintWriter os=new PrintWriter(socket.getOutputStream());
//由Socket对象得到输出流，并构造PrintWriter对象
BufferedReader is=new BufferedReader(new InputStreamReader(socket.getInputStream()));
//由Socket对象得到输入流，并构造相应的BufferedReader对象
String readline;
readline=sin.readLine(); //从系统标准输入读入一字符串
while(!readline.equals("bye")){
//若从标准输入读入的字符串为 "bye"则停止循环
os.println(readline);
//将从系统标准输入读入的字符串输出到Server
os.flush();
//刷新输出流，使Server马上收到该字符串
System.out.println("Client:"+readline);
//在系统标准输出上打印读入的字符串
System.out.println("Server:"+is.readLine());
//从Server读入一字符串，并打印到标准输出上
readline=sin.readLine(); //从系统标准输入读入一字符串
} //继续循环
os.close(); //关闭Socket输出流
is.close(); //关闭Socket输入流
socket.close(); //关闭Socket
}catch(Exception e) {
System.out.println("Error"+e); //出错，则打印出错信息
}
}
}
2. 服务器端程序
import java.io.*;
import java.net.*;
import java.applet.Applet;
public class TalkServer{
public static void main(String args[]) {
try{
ServerSocket server=null;
try{
server=new ServerSocket(4700);
//创建一个ServerSocket在端口4700监听客户请求
}catch(Exception e) {
System.out.println("can not listen to:"+e);
//出错，打印出错信息
}
Socket socket=null;
try{
socket=server.accept();
//使用accept()阻塞等待客户请求，有客户
//请求到来则产生一个Socket对象，并继续执行
}catch(Exception e) {
System.out.println("Error."+e);
//出错，打印出错信息
}
String line;
BufferedReader is=new BufferedReader(new InputStreamReader(socket.getInputStream()));
//由Socket对象得到输入流，并构造相应的BufferedReader对象
PrintWriter os=newPrintWriter(socket.getOutputStream());
//由Socket对象得到输出流，并构造PrintWriter对象
BufferedReader sin=new BufferedReader(new InputStreamReader(System.in));
//由系统标准输入设备构造BufferedReader对象
System.out.println("Client:"+is.readLine());
//在标准输出上打印从客户端读入的字符串
line=sin.readLine();
//从标准输入读入一字符串
while(!line.equals("bye")){
//如果该字符串为 "bye"，则停止循环
os.println(line);
//向客户端输出该字符串
os.flush();
//刷新输出流，使Client马上收到该字符串
System.out.println("Server:"+line);
//在系统标准输出上打印读入的字符串
System.out.println("Client:"+is.readLine());
//从Client读入一字符串，并打印到标准输出上
line=sin.readLine();
//从系统标准输入读入一字符串
} //继续循环
os.close(); //关闭Socket输出流
is.close(); //关闭Socket输入流
socket.close(); //关闭Socket
server.close(); //关闭ServerSocket
}catch(Exception e){
System.out.println("Error:"+e);
//出错，打印出错信息
}
}
}
package com.mdream.shenmo_alpha.utils;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.List;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.client.CookieStore;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.cookie.Cookie;
import org.apache.http.impl.client.AbstractHttpClient;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.params.HttpConnectionParams;
import org.apache.http.protocol.HTTP;
import org.apache.http.util.EncodingUtils;
import org.apache.http.util.EntityUtils;
import android.content.Context;
import android.content.res.AssetManager;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
public class HttpUtils {
public static boolean HTTP_RESULT;
private static String result;
public static List<Cookie> mCookies = new ArrayList<Cookie>();
static final String digits = "0123456789ABCDEF";
public static String encode(String s, String enc)
throws UnsupportedEncodingException {
if (s == null || enc == null) {
throw new NullPointerException();
}
"".getBytes(enc);
StringBuilder buf = new StringBuilder(s.length() + 16);
int start = -1;
for (int i = 0; i < s.length(); i++) {
char ch = s.charAt(i);
if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')
|| (ch >= '0' && ch <= '9')
|| " .-*_/:?=&".indexOf(ch) > -1) {
if (start >= 0) {
convert(s.substring(start, i), buf, enc);
start = -1;
}
if (ch != ' ') {
buf.append(ch);
} else {
buf.append('+');
}
} else {
if (start < 0) {
start = i;
}
}
}
if (start >= 0) {
convert(s.substring(start, s.length()), buf, enc);
}
return buf.toString();
}
private static void convert(String s, StringBuilder buf, String enc)
throws UnsupportedEncodingException {
byte[] bytes = s.getBytes(enc);
for (int j = 0; j < bytes.length; j++) {
buf.append('%');
buf.append(digits.charAt((bytes[j] & 0xf0) >> 4));
buf.append(digits.charAt(bytes[j] & 0xf));
}
}
public static String httpGet(String url) {
HttpClient httpClient = new DefaultHttpClient();
httpClient.getParams().setIntParameter(HttpConnectionParams.SO_TIMEOUT,
10000);
httpClient.getParams().setIntParameter(
HttpConnectionParams.CONNECTION_TIMEOUT, 10000);
try {
String urlEncode = encode(url, "UTF-8");
HttpGet request = new HttpGet(urlEncode);
HttpResponse response;
if (mCookies != null) {
for (int i = 0; i < mCookies.size(); i++) {
request.addHeader("Cookie", mCookies.get(i).getName() + "="
+ mCookies.get(i).getValue());
}
}
response = httpClient.execute(request);
if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
HTTP_RESULT = true;
HttpEntity entity = response.getEntity();
result = EntityUtils.toString(entity, HTTP.UTF_8);
CookieStore mCookieStore = ((AbstractHttpClient) httpClient)
.getCookieStore();
List<Cookie> cookies = mCookieStore.getCookies();
List<Integer> mCookieIndex = new ArrayList<Integer>();
if (mCookies != null) {
for (int i = 0; i < mCookies.size(); i++) {
for (int j = 0; j < cookies.size(); j++) {
boolean cookieEq = mCookies.get(i).getName()
.equals(cookies.get(j).getName());
if (cookieEq) {
mCookieIndex.add(i);
}
}
}
for (int i = 0; i < mCookieIndex.size(); i++) {
int index = mCookieIndex.get(i);
mCookies.remove(index);
}
}
mCookies.addAll(cookies);
} else {
HTTP_RESULT = false;
}
} catch (Exception e) {
HTTP_RESULT = false;
mCookies.clear();
System.out.println("网络连接失败 HttpUtils！");
e.printStackTrace();
}
return result;
}
public static String readFromSDcard(String fileName) {
String fileContent = "";
try {
File f = new File("/mnt/sdcard/" + fileName);
if (f.isFile() && f.exists()) {
InputStreamReader read = new InputStreamReader(
new FileInputStream(f), "gbk");
BufferedReader reader = new BufferedReader(read);
String line;
while ((line = reader.readLine()) != null) {
fileContent += line;
}
read.close();
}
} catch (Exception e) {
e.printStackTrace();
}
return fileContent;
}
public static String getFromRaw(Context context, String filename) {
String result = "";
try {
AssetManager am = context.getAssets();
InputStream in = am.open(filename);
int lenght = in.available();
byte[] buffer = new byte[lenght];
in.read(buffer);
result = EncodingUtils.getString(buffer, "gbk");
in.close();
} catch (Exception e) {
}
return result;
}
/**
* 从Assets中读取图片
*
* @throws IOException
*/
public static Bitmap getImageFromAssetsFile(Context context, String fileName)
throws IOException {
AssetManager am = context.getResources().getAssets();
BitmapFactory.Options opt = new BitmapFactory.Options();
opt.inPreferredConfig = Bitmap.Config.RGB_565;
opt.inPurgeable = true;
opt.inInputShareable = true;
// 获取资源图片
InputStream is = am.open(fileName);
Bitmap bitmap = Bitmap
.createBitmap(BitmapFactory.decodeStream(is, null, opt),
GConstant.NPCPOS_X, GConstant.NPCPOS_Y,
GConstant.NPC_WIDTH_, GConstant.NPC_HEIGHT_);
is.close();
return bitmap;
}
}
public String textPost(String urlPath, String params) {
StringBuffer sb = new StringBuffer();
BufferedReader br = null;
try {
URL url = new URL(urlPath);
//打开连接
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
//设置提交方式
conn.setDoOutput(true);
conn.setDoInput(true);
conn.setRequestMethod("POST");
//post方式不能使用缓存
conn.setUseCaches(false);
conn.setInstanceFollowRedirects(true);
//设置连接超时时间
conn.setConnectTimeout(6 * 1000);
//配置本次连接的Content-Type，配置为application/x-www-form-urlencoded
conn.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
//维持长连接
conn.setRequestProperty("Connection", "Keep-Alive");
//设置浏览器编码
conn.setRequestProperty("Charset", "UTF-8");
DataOutputStream dos = new DataOutputStream(conn.getOutputStream());
//将请求参数数据向服务器端发送
dos.writeBytes(params);
dos.flush();
dos.close();
if (conn.getResponseCode() == 200) {
//获得服务器端输出流
br = new BufferedReader(new InputStreamReader(conn.getInputStream(), "UTF-8"));
int c = 0;
while ((c = br.read()) != -1) {
sb.append((char) c);
}
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (br != null)
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
return sb.toString();
}