个人andriod实习小作品，个人联网笔记本

个人联网笔记本

个人信息：就读于燕大本科软件project专业 眼下大四;

本人博客：google搜索“cqs_2012”就可以;

个人爱好：酷爱数据结构和算法，希望将来从事算法工作为人民作出自己的贡献;

编程语言：java ;

编程坏境：Windows 7 专业版 x64;

编程工具：jdk，eclipse，AVD;

制图工具：office 2010 powerpoint;

硬件信息：7G-3 笔记本;

引言

个人第一部联网andriod作品诞生，andriod生涯里程碑的出现。

主要技术点

通信socket技术。使用多线程通信。

在socket使用中，使用一次打开一次，关闭一次，传输数据一去一回。

socket与应用程序主线程的切换;

对主线程进行枷锁。数据传送完后，在socket线程里对主线程的唤醒，防止主线程没有等待数据通信完成就開始运行。

对主线程设置锁；

// 线程锁（事实上就是定义一个全局变量，在myapplication（全局变量）中定义）
public static String loginThreadState = "off";

加锁操作

MyApplication.loginThreadState =“off”;

检查锁操作

// 推断当前线程是否唤醒

while(MyApplication.loginThreadState.equals("off"));

开锁以及唤醒操作

// 唤醒 login 进程
MyApplication.loginThreadState = "on";
MyApplication.loginThreadState.notify();

然后这样就能够实现通信了，而且能够等待通信返回来的数据，然后去处理。

个人笔记server端socket实现

import java.net.*;
import java.io.*;
import java.text.SimpleDateFormat;
import java.util.*;

import DBData.DataApplication;
import DBData.NoteBookClass;
import DBData.User;
import DBOperation.NoteDao;
import DBOperation.UserDao;
import DataChange.NoteChange;

public class MyAppNoteBookInfor extends Thread
{
	// 链接变量
	private static int port;
	private static ServerSocket serverSocket ;
	static Socket server;

	private DataInputStream input;
	private DataOutputStream output;

	static
	{
		try
		{
			// 设置服务器端口
			port = 8899;   
			serverSocket = new ServerSocket(port);
		}
		catch(Exception e)
		{
			e.printStackTrace();
		}
	}

	public MyAppNoteBookInfor()throws Exception
	{	  
		// 成功启动
		System.out.println("accept ready");
		server = serverSocket.accept(); 

		// 成功启动
		System.out.println("accept start");

		// 获取数据流
		input = new DataInputStream(server.getInputStream());
		output = new DataOutputStream(server.getOutputStream());	
	}


	// run 主函数
	public void run()  
	{
		try 
		{  	   	
			// 接收数据
			String commondData = getCommondData();

			// 处理数据,并发送数据
			if(commondData != null)
				selectCommond( commondData );

			server.close();
		} 
		catch (Exception e) 
		{
			// TODO: handle exception
			e.printStackTrace();
		}
	}




	// 选择函数 not over 数据处理
	public void selectCommond(String data)throws Exception
	{
		// 接收数据。处理
		String formatdata[] = data.split( DataApplication.commondGetDataStyle );

		// 选择操作命令
		switch( Integer.parseInt(formatdata[0]))
		{
			// check
			case DataApplication.commond_check_user:
			{
				// 数据转换	
				User user = new User();
				user.setId( formatdata[1] );
				user.setPwd( formatdata[2] );
	
				// 数据处理
				Boolean result = MyAppNoteBookServer.checkUser(user);
	
				// 转换格式
				String senddata = result.toString();
				// 发送数据
				sendData(senddata);
			} 		   		  
			break; 
	
			// select-all
			case DataApplication.commond_get_my_all_note:
			{
				// 数据处理
				String userid = formatdata[1]; 
				ArrayList<NoteBookClass> noteList = MyAppNoteBookServer.getUserNoteList(userid);

				String senddata = "null" ;
				if(noteList != null && noteList.size() > 0)
					// 数据转换
					senddata = NoteChange.noteListToStringWithSendForSelect(noteList); 
	
				// 发送数据
				sendData(senddata);
			}
			break;
	
			// new - note
			case DataApplication.commond_insert_note:
			{
				// 数据转换
				NoteBookClass noteBookClass = NoteChange.stringToNoteBookWithGetForInsert(formatdata[1]);
				// 数据处理
				Integer result = MyAppNoteBookServer.insertNote(noteBookClass);
				// 数据转换
				String senddata = result.toString();
				// 数据发送
				sendData(senddata);
			}
			break;
	
			// new user
			case DataApplication.commond_insert_user:
			{
				// 数据转换
				User user = new User();
				user.toUser(formatdata[1]);
				
				// 数据处理
				Integer result = MyAppNoteBookServer.insertUser(user);
				// 数据转换
				String senddata = result.toString();
				// 数据发送
				sendData(senddata);
			}
			break;
			
			
			case DataApplication.commond_search_note_by_key:
			{
				// 转换数据
				String[] keystStrings = NoteChange.dataToStringWithGetForSelectByKey(formatdata[1]);
				String useridString = keystStrings[0];
				String keywordString =keystStrings[1];
				
				// 数据处理
				ArrayList<NoteBookClass> noteList = MyAppNoteBookServer.getUserNoteListByKeywords(useridString,keywordString);
				
				// 数据转换
				String senddata = "null" ;
				if(noteList != null && noteList.size() > 0)
					senddata = NoteChange.noteListToStringWithSendForSelect(noteList); 
	
				// 发送数据
				sendData(senddata);						
			}
			break;
			
			case DataApplication.commond_alter_note:
			{
				// 转换数据
				NoteBookClass noteBookClass  = NoteChange.stringToNoteBookWithGetForAlter( formatdata[1] );
				
				// 数据处理
				MyAppNoteBookServer.AlterNoteBook(noteBookClass);
				ArrayList<NoteBookClass> noteList = MyAppNoteBookServer.getUserNoteList(noteBookClass.getUserId());

				String senddata = "null" ;
				if(noteList != null && noteList.size() > 0)
					// 数据转换
					senddata = NoteChange.noteListToStringWithSendForSelect(noteList); 
	
				// 发送数据
				sendData(senddata);				
			}
			break;
			
			case DataApplication.commond_delete_note:
			{
				// 获取并转换数据
				int id = Integer.parseInt(formatdata[1]);
				
				// 处理数据
				int result = MyAppNoteBookServer.DeleteNoteBookById(id);
				
				//  转换数据
				String senddata = String.valueOf(result);
				
				// 发送数据
				sendData(senddata);	
				
			}
			break;
		}

	}



	// 发送信息函数
	public void sendData(String data)
	{
		try 
		{
			// 发送消息
			output.writeUTF(data);
			output.flush();
		} 
		catch (Exception e) 
		{
			e.printStackTrace();
		}
	}

	// 接收命令函数
	public String getCommondData()
	{
		String data = null;
		try 
		{
			// 接收消息
			data = input.readUTF();

		} 
		catch (Exception e) 
		{
			// TODO: handle exception
		}
		return data;
	}

	// 主函数 main
	public static void main(String args[]) throws Exception
	{

		MyAppNoteBookInfor myAppNoteBookInfor; 
		while(true)
		{		
			myAppNoteBookInfor = new MyAppNoteBookInfor();
			myAppNoteBookInfor.start();
		}
	
	}

}

个人clientsocket实现

package Thread;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.net.Socket;

import com.icss.myappnotebook.MyApplication;

public class SocektThread extends Thread
{
	// 设置链接server
	private  String ip = "120.6.72.65" ;
	private  int port = 8899 ;	// 链接客户端程序 变量	
	private  Socket clientSocket ;

	// 设置数据流
	public  DataInputStream input ;
	public  DataOutputStream output ;



	// 线程主函数
	public void run()
	{	

		try
		{					
			// 链接server
			clientSocket = new Socket(ip,port);

			// 获取server输入流
			input = new DataInputStream(clientSocket.getInputStream());

			// 获取server输入流
			output = new DataOutputStream(clientSocket.getOutputStream());	


			switch (MyApplication.commond) 
			{

			// check-核对username和password
			case MyApplication.commond_check_user:

				// 发送数据 2点
				output.writeUTF(MyApplication.senddata);
				output.flush();

				// 发送成功
				System.out.println("send ok");

				// 接收数据
				MyApplication.getdata = input.readUTF();


				// 唤醒 login 进程
				MyApplication.loginThreadState = "on";
				MyApplication.loginThreadState.notify();

				break;

				// 获得全部notes			
			case MyApplication.commond_get_my_all_note:
				// 发送数据 2点
				output.writeUTF(MyApplication.senddata);
				output.flush();	

				// 接收数据
				MyApplication.getdata = input.readUTF();

				// 唤醒 menu 线程
				MyApplication.menuThreadState="on";
				MyApplication.menuThreadState.notify();	

				break;
				
			case MyApplication.commond_insert_note:
				// 发送数据
				output.writeUTF(MyApplication.senddata);
				output.flush();	
				
				// 接收数据
				MyApplication.getdata = input.readUTF();

				// 唤醒 new  线程
				MyApplication.newNoteBookThreadState = "on";
				MyApplication.newNoteBookThreadState.notify();	

				break;	
			case MyApplication.commond_insert_user:
				// 发送数据
				output.writeUTF(MyApplication.senddata);
				output.flush();	
				
				// 接收数据
				MyApplication.getdata = input.readUTF();

				// 唤醒 register 线程
				MyApplication.registerUserThreadState = "on";
				MyApplication.registerUserThreadState.notify();
				break;
			
			case MyApplication.commond_search_note_by_key:
				// 发送数据
				output.writeUTF(MyApplication.senddata);
				output.flush();	
				
				// 接收数据
				MyApplication.getdata = input.readUTF();
				
				// 唤醒 search 线程
				MyApplication.searchNoteBookThreadState = "on";
				MyApplication.searchNoteBookThreadState.notify();				
				break;
				
			case MyApplication.commond_alter_note:
				// 发送数据
				output.writeUTF(MyApplication.senddata);
				output.flush();	
				
				// 接收数据
				MyApplication.getdata = input.readUTF();
				
				// 唤醒 show one notebook 线程
				MyApplication.showOneNoteThreadState = "on";
				MyApplication.showOneNoteThreadState.notify();
				break;
			case MyApplication.commond_delete_note:
				// 发送数据
				output.writeUTF(MyApplication.senddata);
				output.flush();	
				
				// 接收数据
				MyApplication.getdata = input.readUTF();
				
				// 唤醒 show one notebook 线程
				MyApplication.openAllThreadState = "on";
				MyApplication.openAllThreadState.notify();				
				break;
			default:
				break;
			}

			clientSocket.close();


		}
		catch(Exception e)
		{
			e.printStackTrace();
		}




	}


}

希望对于想实现通信的好友有帮助，谢谢大家