android检查连接的wifi强度

基于TCP协议的网络通信

使用URL访问网络资源

使用HTTP访问网络

使用WebView视图显示网页

 

 

 

基于TCP协议的网络通信

TCP/IP通信协议是一种可靠的网络协议，它在通信的两端各建立一个Socket，通信的两端之间形成网络虚拟链路。Java对基于TCP协议的网络通信提供了良好的封装，Java使用Socket对象来代表两端的通信接口，并通过Socket产生IO流来进行网络通信。

1.1 使用ServerSocket创建TCP服务器端

Java中能接收其他通信实体连接请求的类是ServerSocket， ServerSocket对象用于监听来自客户端的Socket连接，如果没有连接，它将一直处于等待状态。 ServerSocket包含一个监听来自客户端连接请求的方法。

Socket accept()：如果接收到一个客户端Socket的连接请求，该方法将返回一个与客户端Socket对应的Socket；否则该方法将一直处于等待状态，线程也被阻塞。

 

为了创建ServerSocket对象，ServerSocket类提供了如下几个构造器：

ServerSocket(int port)：用指定的端口port来创建一个ServerSocket。该端口应该是有一个有效的端口整数值：0～65535。

ServerSocket(int port,int backlog)：增加一个用来改变连接队列长度的参数backlog。

ServerSocket(int port,int backlog,InetAddress localAddr)：在机器存在多个 IP地址的情况下，允许通过localAddr这个参数来指定将ServerSocket绑定到指定的IP地址。

 

当ServerSocket使用完毕，应使用ServerSocket的close()方法来关闭该ServerSocket。

 

通常情况下，服务器不应该只接受一个客户端请求，而应该不断地接受来自客户端的所有请求，所以Java程序通常会通过循环，不断地调用ServerSocket的accept()方法。如下代码片段所示:

 

1.2 使用Socket进行通信

客户端通常可使用Socket的构造器来连接到指定服务器，Socket通常可使用如下两个构造器：

Socket(InetAddress/String remoteAddress, int port)：创建连接到指定远程主机、远程端口的Socket。

Socket(InetAddress/String remoteAddress, int port, InetAddress localAddr, int localPort)：创建连接到指定远程主机、远程端口的Socket，并指定本地IP地址和本地端口号。

上面两个构造器中指定远程主机时既可使用InetAddress来指定，也可直接使用String对象来指定，但程序通常使用String对象（如127.0.0.1）来指定远程IP。

 

以上代码将会连接到指定服务器，让服务器端的ServerSocket的accept()方法向下执行。

当客户端、服务器端产生了对应的Socket之后,程序无须再区分服务器、客户端，而是通过各自的Socket进行通信，Socket提供如下两个方法来获取输入流和输出流：

InputStream getInputStream()：返回该Socket对象对应的输入流，让程序通过该输入流从Socket中取出数据。

OutputStream getOutputStream()：返回该Socket对象对应的输出流，让程序通过该输出流向Socket中输出数据。

例：简单网络通信：

服务器端程序代码：

SimpleServer.java

public class SimpleServer
{
	public static void main(String[] args) 
		throws IOException
	{
		//创建一个ServerSocket，用于监听客户端Socket的连接请求
		ServerSocket ss = new ServerSocket(30000);
		//采用循环不断接受来自客户端的请求
		while (true)
		{
			//每当接受到客户端Socket的请求，服务器端也对应产生一个Socket
			Socket s = ss.accept();
			OutputStream os = s.getOutputStream();
			os.write(您好，您收到了服务器的新年祝福！

				.getBytes(utf-8));
			//关闭输出流，关闭Socket
			os.close();
			s.close();
		}
	}
}

 

客户端程序：

SimpleClient.java

public class SimpleClient extends Activity
{
	EditText show;
	@Override
	public void onCreate(Bundle savedInstanceState)
	{
		super.onCreate(savedInstanceState);
		setContentView(R.layout.main);
		show = (EditText) findViewById(R.id.show);
		//关闭输入流、socket
		try
		{
			Socket socket = new Socket(127.0.0.1 , 30000);
			//将Socket对应的输入流包装成BufferedReader
			BufferedReader br = new BufferedReader(
				new InputStreamReader(socket.getInputStream()));
			//进行普通IO操作
			String line = br.readLine();
			show.setText(来自服务器的数据： + line);			
			br.close();
			socket.close();	
		}
		catch (IOException e)
		{
			e.printStackTrace();
		}
	}
}

 

 

总结Socket通信，创建服务器步骤：

指定端口实例化一个ServerSocket

调用ServerSocket的accept()等待连接

获取位于该底层Socket的流以进行读写操作

对数据封装成流

对Socket进行读写

关闭打开的流

总结Socket通信，创建客户端的步骤：

通过IP地址和端口实例化Socket，请求连接服务器

获取Socket上的流以进行读写

把流包装进BufferedReader/PrintWriter的实例

对Socket进行读写

关闭打开的流

 

1.3 多线程

实际应用中的客户端则可能需要和服务器端保持长时间通信，即服务器需要不断地读取客户端数据，并向客户端写入数据；客户端也需要不断地读取服务器数据，并向服务器写入数据。

服务器应该为每个Socket单独启动一条线程，每条线程负责与一个客户端进行通信。

客户端读取服务器数据的线程同样会被阻塞，所以系统应该单独启动一条线程，该线程专门负责读取服务器数据。

例：C/S聊天室程序：

服务端程序：

MyServer.java

public class MyServer
{
	//定义保存所有Socket的ArrayList
	public static ArrayList socketList 
		= new ArrayList();
    public static void main(String[] args) 
		throws IOException
    {
        ServerSocket ss = new ServerSocket(30000);
		while(true)
		{
			//此行代码会阻塞，将一直等待别人的连接
			Socket s = ss.accept();
			socketList.add(s);
			//每当客户端连接后启动一条ServerThread线程为该客户端服务
			new Thread(new ServerThread(s)).start();
		}
    }
}

 

ServerThread.java

//负责处理每个线程通信的线程类
public class ServerThread implements Runnable 
{
	//定义当前线程所处理的Socket
	Socket s = null;
	//该线程所处理的Socket所对应的输入流
	BufferedReader br = null;
	public ServerThread(Socket s)
		throws IOException
	{
		this.s = s;
		//初始化该Socket对应的输入流
		br = new BufferedReader(new InputStreamReader(
			s.getInputStream() , utf-8));   //②
	}
	public void run()
	{
		try
		{
			String content = null;
			//采用循环不断从Socket中读取客户端发送过来的数据
			while ((content = readFromClient()) != null)
			{
				//遍历socketList中的每个Socket，
				//将读到的内容向每个Socket发送一次
				for (Socket s : MyServer.socketList)
				{
					OutputStream os = s.getOutputStream();
					os.write((content + 
).getBytes(utf-8));
				}
			}
		}
		catch (IOException e)
		{
			e.printStackTrace();
		}
	}
	//定义读取客户端数据的方法
	private String readFromClient()
	{
		try
		{
			return br.readLine();	
		}
		//如果捕捉到异常，表明该Socket对应的客户端已经关闭
		catch (IOException e)
		{
			//删除该Socket。
			MyServer.socketList.remove(s);    //①
		}
		return null;
	}
}

 

客户端程序：

MultiThreadClient.java

public class MultiThreadClient extends Activity
{
	// 定义界面上的两个文本框
	EditText input, show;
	// 定义界面上的一个按钮
	Button send;
	OutputStream os;
	Handler handler;

	@Override
	public void onCreate(Bundle savedInstanceState)
	{
		super.onCreate(savedInstanceState);
		setContentView(R.layout.main);
		input = (EditText) findViewById(R.id.input);
		send = (Button) findViewById(R.id.send);
		show = (EditText) findViewById(R.id.show);
		Socket s;
		handler = new Handler()
		{
			@Override
			public void handleMessage(Message msg)
			{
				// 如果消息来自于子线程
				if (msg.what == 0x123)
				{
					// 将读取的内容追加显示在文本框中
					show.append(
 + msg.obj.toString());
				}
			}
		};
		try
		{
			s = new Socket(127.0.0.1, 30000);
			// 客户端启动ClientThread线程不断读取来自服务器的数据
			new Thread(new ClientThread(s, handler)).start(); // ①
			os = s.getOutputStream();
		}
		catch (Exception e)
		{
			e.printStackTrace();
		}
		send.setOnClickListener(new OnClickListener()
		{
			@Override
			public void onClick(View v)
			{
				try
				{
					// 将用户在文本框内输入的内容写入网络
					os.write((input.getText().toString() + 
)
						.getBytes(utf-8));
					// 清空input文本框
					input.setText();
				}
				catch (Exception e)
				{
					e.printStackTrace();
				}
			}
		});
	}
}

 

客户端线程：

ClientThread.java

public class ClientThread implements Runnable
{
	//该线程负责处理的Socket
	private Socket s;
	private Handler handler;
	//该线程所处理的Socket所对应的输入流
	BufferedReader br = null;
	public ClientThread(Socket s , Handler handler)
		throws IOException
	{
		this.s = s;
		this.handler = handler;
		br = new BufferedReader(
			new InputStreamReader(s.getInputStream()));
	}
	public void run()
	{
		try
		{
			String content = null;
			//不断读取Socket输入流中的内容。
			while ((content = br.readLine()) != null)
			{
				// 每当读到来自服务器的数据之后，发送消息通知程序界面显示该数据
				Message msg = new Message();
				msg.what = 0x123;
				msg.obj = content;
				handler.sendMessage(msg);
			}
		}
		catch (Exception e)
		{
			e.printStackTrace();
		}
	}
}

 

使用URL访问网络资源

URL对象代表统一资源定位器，它是指向互联网”资源”的指针，资源可以是简单的文件或目录，也可以是对更复杂的对象的引用，URL可由协议名、主机、端口和资源组成 。

URL类提供了多个构造器用于创建URL对象，一旦获得了URL对象之后，可以调用如下常用方法来访问该URL对应的资源。
String getFile():获取此URL的资源名
String getHost()：获取此URL的主机名
String getPath()：获取些URL的路径部分
int getPort()：获取此URL的端口号
String getProtocol()：获取此URL的协议名称
String getQuery()：获取此URL的查询字符串部分
URLConnection openConnection()：URL所引用远程对象连接
InputStream openStream()：打开与些URL的连接，并返回一个用于读取该URL资源的InputStream。

例：使用URL读取网络资源：

URLTest.java

public class URLTest extends Activity
{
	ImageView show;
	@Override
	public void onCreate(Bundle savedInstanceState)
	{
		super.onCreate(savedInstanceState);
		setContentView(R.layout.main);
		show = (ImageView) findViewById(R.id.show);
		// 定义一个URL对象
		try
		{
			URL url = new URL(http://www.xxx.com/photo.png);
			// 打开该URL对应的资源的输入流
			InputStream is = url.openStream();
			// 从InputStream中解析出图片
			Bitmap bitmap = BitmapFactory.decodeStream(is);
			// 使用ImageView显示该图片
			show.setImageBitmap(bitmap);
			is.close();
			// 再次打开URL对应的资源的输入流
			is = url.openStream();
			// 打开手机文件对应的输出流
			OutputStream os = openFileOutput(crazyit.png
				, MODE_WORLD_READABLE);
			byte[] buff = new byte[1024];
			int hasRead = 0;
			// 将URL对应的资源下载到本地
			while((hasRead = is.read(buff)) > 0)
			{
				os.write(buff, 0 , hasRead);
			}
			is.close();
			os.close();
		}
		catch (Exception e)
		{
			e.printStackTrace();
		}
	}
}

 

2.1 使用URLConnection提交请求

通常创建一个和URL的连接，并发送请求。读取此URL引用的资源需要如下几个步骤 ：

通过调用Url对象openConnection()方法创建URLConnection对象。

设置URLConnection的参数和普通请求属性。

如果只是发送get方式请求，使用Connect方法建立和远程资源之间的实际连接即可；如果需要发送post方式的请求需要获取URlConnection实例对应的输出流来发送请求参数。

远程资源变为可用，程序可以访问远程资源的头字段或通过输入流读取远程资源的数据。

在建立和远程资源的实际连接之前，可以通过如下方法来设置请求头字段。

setAllowUserInteraction:设置该URLConnection的allowUserInteraction请求头字段的值。

setDoInput:设置该URLConnection的doInput请求头字段的值。

setDoOutput:设置该URLConnection的doOutput请求头字段的值。

setIfModifiedSince:设置该URLConnection的ifModifiedSince请求头字段的值。

setUseCaches:设置该URLConnection的useCaches请求头字段的值

还可以使用如下方法来设置或增加通用头字段。

setRequestProperty(String key,String value)：设置该URLConnection的key请求头字段的值为value。

addRequestProperty(String key,String value)：为该URLConnection的key请求头字段增加value值。

当远程资源可用时，程序可以使用以下方法用于访问头字段和内容。

Object getContent():获取该URLConnection的内容

String getHeaderField(String name):获取指定响应头字段的值

getInputStream():返回该URLConnection对应的输入流，用于获取URLConnection响应的内容。

getOutputStream():返回该URLConnection对应的输出流，用于向URLConnection发送请求参数。

例：向Web站点发送GET、POST请求：

GetPostMain.java

public class GetPostMain extends Activity
{
	Button get , post;
	EditText show;
	@Override
	public void onCreate(Bundle savedInstanceState)
	{
		super.onCreate(savedInstanceState);
		setContentView(R.layout.main);
		get = (Button) findViewById(R.id.get);
		post = (Button) findViewById(R.id.post);
		show = (EditText)findViewById(R.id.show);
		get.setOnClickListener(new OnClickListener()
		{
			@Override
			public void onClick(View v)
			{
				String response = GetPostUtil
					.sendGet(http://127.0.0.1:8080/abc/a.jsp , null);
				show.setText(response);
				
			}			
		});
		post.setOnClickListener(new OnClickListener()
		{
			@Override
			public void onClick(View v)
			{
				String response = GetPostUtil
					.sendPost(http://127.0.0.1:8080/abc/login.jsp
					, name=xxx&pass=123);
				show.setText(response);
				
			}			
		});	
	}
}

 

GetPostUtil.java

public class GetPostUtil
{
	/**
	 * 向指定URL发送GET方法的请求
	 * 
	 * @param url
	 *            发送请求的URL
	 * @param params
	 *            请求参数，请求参数应该是name1=value1&name2=value2的形式。
	 * @return URL所代表远程资源的响应
	 */
	public static String sendGet(String url, String params)
	{
		String result = ;
		BufferedReader in = null;
		try
		{
			String urlName = url + ? + params;
			URL realUrl = new URL(urlName);
			// 打开和URL之间的连接
			URLConnection conn = realUrl.openConnection();
			// 设置通用的请求属性
			conn.setRequestProperty(accept, */*);
			conn.setRequestProperty(connection, Keep-Alive);
			conn.setRequestProperty(user-agent,
				Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1));
			// 建立实际的连接
			conn.connect();
			// 获取所有响应头字段
			Map> map = conn.getHeaderFields();
			// 遍历所有的响应头字段
			for (String key : map.keySet())
			{
				System.out.println(key + ---> + map.get(key));
			}
			// 定义BufferedReader输入流来读取URL的响应
			in = new BufferedReader(
				new InputStreamReader(conn.getInputStream()));
			String line;
			while ((line = in.readLine()) != null)
			{
				result += 
 + line;
			}
		}
		catch (Exception e)
		{
			System.out.println(发送GET请求出现异常！ + e);
			e.printStackTrace();
		}
		// 使用finally块来关闭输入流
		finally
		{
			try
			{
				if (in != null)
				{
					in.close();
				}
			}
			catch (IOException ex)
			{
				ex.printStackTrace();
			}
		}
		return result;
	}

	/**
	 * 向指定URL发送POST方法的请求
	 * 
	 * @param url
	 *            发送请求的URL
	 * @param params
	 *            请求参数，请求参数应该是name1=value1&name2=value2的形式。
	 * @return URL所代表远程资源的响应
	 */
	public static String sendPost(String url, String params)
	{
		PrintWriter out = null;
		BufferedReader in = null;
		String result = ;
		try
		{
			URL realUrl = new URL(url);
			// 打开和URL之间的连接
			URLConnection conn = realUrl.openConnection();
			// 设置通用的请求属性
			conn.setRequestProperty(accept, */*);
			conn.setRequestProperty(connection, Keep-Alive);
			conn.setRequestProperty(user-agent,
				Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1));
			// 发送POST请求必须设置如下两行
			conn.setDoOutput(true);
			conn.setDoInput(true);
			// 获取URLConnection对象对应的输出流
			out = new PrintWriter(conn.getOutputStream());
			// 发送请求参数
			out.print(params);
			// flush输出流的缓冲
			out.flush();
			// 定义BufferedReader输入流来读取URL的响应
			in = new BufferedReader(
				new InputStreamReader(conn.getInputStream()));
			String line;
			while ((line = in.readLine()) != null)
			{
				result += 
 + line;
			}
		}
		catch (Exception e)
		{
			System.out.println(发送POST请求出现异常！ + e);
			e.printStackTrace();
		}
		// 使用finally块来关闭输出流、输入流
		finally
		{
			try
			{
				if (out != null)
				{
					out.close();
				}
				if (in != null)
				{
					in.close();
				}
			}
			catch (IOException ex)
			{
				ex.printStackTrace();
			}
		}
		return result;
	}
}

 

使用HTTP访问网络

3.1 使用HttpURLConnection

URLConnection还有一个子类：HttpURLConnection，可以用于向指定网站发送GET请求、POST请求。它在URLConnection的基础上提供了如下方法：

int getResponseCode():获取服务器的响应代码

String getResponseMessage():获取服务器的响应信息

String getRequestMethod():获取发送请求的方法

Void setRequestMethod(String method):设置发送请求的方法

例：多线程下载：

为了实现多线程，程序可按如下步骤进行：

创建URL对象

获取指定URL对象所指象的资源大小（由getContentLength()方法实现），此处用到了HttpURLConnection类。

在本地磁盘上创建一个与网络资源相同大小的空文件

计算每条线程应该下载网络资源的哪个部分

依次创建、启动多条线程来下载网络资源的指定部分。

 

3.2 使用Apache HttpClient

HttpClient是一个增强版的HttpURLConnection，它是一个简单的客户端(并不是浏览器)，可以发送HTTP请求，接收HTTP响应，以及管理HTTP连接。但不会缓存服务器的响应，不能执行HTML页面中嵌入的JavaScript代码，也不会对页面内容进行任何解析、处理。

Android已经成功地集成了HttpClient，可以直接在Android应用中使用HttpClient来访问提交请求、接收响应。使用HttpClient的步骤如下：

创建HttpClient对象

如果需要发送GET请求，创建HttpGet对象，如果需要发送POST请求，创建HttpPost对象。

如果需要发送请求参数，可调用HttpGet、HttpPost共同的setParams(HttpParams params)方法来添加请求参数。

调用HttpClient对象的execute(HttpUriRequest request)发送请求，该方法返回一个HttpResponse。

调用HttpResponse的getAllHeader()、getHeaders(String name)等方法可获取服务器的响应头；调用HttpResponse的getEntity()方法可获取HttpEntity对象，该对象包含了服务器的响应内容。程序可通过该对象获取服务器的响应内容。

例：HttpClient访问被保护的资源：

HttpClientTest.java

public class HttpClientTest extends Activity
{
	Button get;
	Button login;
	EditText response;
	HttpClient httpClient;

	@Override
	public void onCreate(Bundle savedInstanceState)
	{
		super.onCreate(savedInstanceState);
		setContentView(R.layout.main);
		// 创建DefaultHttpClient对象
		httpClient = new DefaultHttpClient();
		get = (Button) findViewById(R.id.get);
		login = (Button) findViewById(R.id.login);
		response = (EditText) findViewById(R.id.response);
		get.setOnClickListener(new OnClickListener()
		{
			@Override
			public void onClick(View v)
			{
				// 创建一个HttpGet对象
				HttpGet get = new HttpGet(
					http://127.0.0.1:8080/foo/secret.jsp);
				try
				{
					// 发送GET请求
					HttpResponse httpResponse = httpClient.execute(get);
					HttpEntity entity = httpResponse.getEntity();
					if (entity != null)
					{
						// 读取服务器响应
						BufferedReader br = new BufferedReader(
							new InputStreamReader(entity.getContent()));
						String line = null;
						response.setText();
						while ((line = br.readLine()) != null)
						{
							// 使用response文本框显示服务器响应
							response.append(line + 
);
						}
					}
				}
				catch (Exception e)
				{
					e.printStackTrace();
				}
			}
		});
		login.setOnClickListener(new OnClickListener()
		{
			@Override
			public void onClick(View v)
			{
				final View loginDialog = getLayoutInflater().inflate(
					R.layout.login, null);
				new AlertDialog.Builder(HttpClientTest.this)
					.setTitle(登录系统)
					.setView(loginDialog)
					.setPositiveButton(登录,
						new DialogInterface.OnClickListener()
						{
							@Override
							public void onClick(DialogInterface dialog,
								int which)
							{
								String name = ((EditText) loginDialog
									.findViewById(R.id.name)).getText()
									.toString();
								String pass = ((EditText) loginDialog
									.findViewById(R.id.pass)).getText()
									.toString();
								HttpPost post = new HttpPost(
									http://127.0.0.1:8080/foo/login.jsp);
								// 如果传递参数个数比较多的话可以对传递的参数进行封装
								List params = new ArrayList();
								params
									.add(new BasicNameValuePair(name, name));
								params
									.add(new BasicNameValuePair(pass, pass));
								try
								{
									// 设置请求参数
									post.setEntity(new UrlEncodedFormEntity(
										params, HTTP.UTF_8));
									// 发送POST请求
									HttpResponse response = httpClient
										.execute(post);
									// 如果服务器成功地返回响应
									if (response.getStatusLine()
										.getStatusCode() == 200)
									{
										String msg = EntityUtils
											.toString(response.getEntity());
										// 提示登录成功
										Toast.makeText(HttpClientTest.this,
											msg, 5000).show();
									}
								}
								catch (Exception e)
								{
									e.printStackTrace();
								}
							}
						}).setNegativeButton(取消, null).show();
			}
		});
	}
}

 

使用WebView视图显示网页

4.1 使用WebView浏览网页

WebView的用法与普通的ImageView组件的用法基本相似，它提供了大量方法来执行浏览器操作，例如如下常用方法。

void goBack():后退

void goForward()：前进

void loadUrl(String url)：加载指定的URL对应的网页

boolean zoomIn()：放大网页

boolean zoomOut():缩小网页

例：迷你浏览器：

MiniBrowser.java

public class MiniBrowser extends Activity
{
	EditText url;
	WebView show;
	@Override
	public void onCreate(Bundle savedInstanceState)
	{
		super.onCreate(savedInstanceState);
		setContentView(R.layout.main);
		// 获取页面中文本框、WebView组件
		url = (EditText) findViewById(R.id.url);
		show = (WebView) findViewById(R.id.show);
	}
	@Override
	public boolean onKeyDown(int keyCode, KeyEvent event)
	{
		if (keyCode == KeyEvent.KEYCODE_SEARCH)
		{
			String urlStr = url.getText().toString();
			// 加载、并显示urlStr对应的网页
			show.loadUrl(urlStr);
			return true;
		}
		return false;
	}
}

 

Main.xml

4.2 使用WebView加载HTML代码

利用WebView可以对HTML字符串进行解析、当成HTML页面来显示。 WebView提供了一个loadDataWithBaseURL(String baseUrl,String data,String mimeType,String encoding,String historyUrl)方法，该方法是对loadData(String data, data,String mimeType,String encoding)方法的增强，它不会产生乱码。

 

例：使用WebView加载HTML：

在配置文件中加上访问网络的权限

 

ViewHtml.java

public class ViewHtml extends Activity
{
	WebView show;
	@Override
	public void onCreate(Bundle savedInstanceState)
	{
		super.onCreate(savedInstanceState);
		setContentView(R.layout.main);
		// 获取程序中的WebView组件
		show = (WebView) findViewById(R.id.show);
		StringBuilder sb = new StringBuilder();
		// 拼接一段HTML代码
		sb.append(

); sb.append(); sb.append(); sb.append(); sb.append(); sb.append( 
 ); sb.append(); sb.append(); // 使用简单的loadData方法会导致乱码，可能是Android API的Bug //show.loadData(sb.toString() , text/ 
html , utf-8); // 加载、并显示HTML代码 show.loadDataWithBaseURL(null, sb.toString() , text/html , utf-8, null); } }