Android 14保存图片到手机 安卓保存

项目背景： Android的sqlite数据库，需要上传服务器，进行更新保存；

项目技术： 

1. socket通信

1.1 服务器与客户端均采用多线程（必须的，因Android UI里面进行网络数据请求的时候，socket不能在主线程）；

参考：

1.2 socket可以保持多客户端同时在线，易于维护。 http需轮询。 参考两者的差别：

java.lang.ClassNotFoundException 原因是 客户端和服务端传递的对象所在包的路径不一致

2.Android客户端

2.1 定义Handler， 用于socket子线程回传数据，UI刷新；

putExtra (String name, Serializable value)，务必注意数据要序列化； --》参考：，注意在AndroidManifest文件里面，注册activity。

2.3 利用Arraylist<Object>，对数据表的每一行数据，进行存储;

2.4 数据库的显示技术，用到了listView技术；

2.5 数据库查询，直接sqlite包里面的query方法，得到cursor，可进行遍历；

3. 服务器端

3.1 服务端的sqlite，采用的下载包：org.sqlite.JDBC ，可参考

synchronized是为了给该对象上锁，加static目的是变成静态方法， 同一时间，只能接受一个对象访问该方法，且是静态访问，其他对象也被上锁。

//当前时间 Date day=new Date();  SimpleDateFormat df = new SimpleDateFormat("yyyy_MM_dd_HHmmss");

3.4  JDBC数据库的更新时，默认是autoCommit， 为保证安全，可以先禁止掉，用prepareStatement代替createStatement。如：

//1. Obtain connection and set `false` to autoCommit
c = DriverManager.getConnection("jdbc:sqlite:"+dbFileName);
   c.setAutoCommit(false);        
   //2. Prepare and execute statements
         statement1=c.prepareStatement(sql);
//3. Execute the statements
statement1.executeUpdate();
         //4. Commit the changes
 c.commit();

以下为示例转载：Socket传输List<Object>数据

在进行Android程序开发时，有需求将服务器（PC）的数据库数据在android客户端显示，通过网络或Socket进行数据的传输，一般的SOCKET数据传输都是以流媒体进行传输，一把从服务器查询的数据类型经过面向对象的封装成Object，所以，一般都将数据转换成JSON或者XML进行传输，android程序进行解析显示，但也可以通过ObjectInputStream，ObjectOutputStream通过Socket传输，下面为代码：

数据的封装类：Student.java

1. package Test;  
2.   
3. import java.io.Serializable;  
4.   
5. public class Student implements Serializable {//实现序列化接口...必须  
6. private int id;  
7. private String name;  
8.   
9. public int getId() {  
10. return id;  
11.     }  
12.   
13. public void setId(int id) {  
14. this.id = id;  
15.     }  
16.   
17. public String getName() {  
18. return name;  
19.     }  
20.   
21. public void setName(String name) {  
22. this.name = name;  
23.     }  
24.   
25. @Override  
26. public String toString() {  
27. // TODO Auto-generated method stub  
28. return id + "=" + name;  
29.     }  
30. }

 

还有一个集合类的封装：ListTest.java

1. package Test;  
2.   
3. import java.io.Serializable;  
4. import java.util.List;  
5.   
6. public class ListTest implements Serializable {//实现序列化接口...必须  
7.   
8. private List<Student> list;  
9.   
10. public List<Student> getList() {  
11. return list;  
12.     }  
13.   
14. public void setList(List<Student> list) {  
15. this.list = list;  
16.     }  
17.       
18. }

下面是简单的Socket传输测试：

服务端：

1. package Test;  
2.   
3. import java.io.IOException;  
4. import java.io.ObjectInputStream;  
5. import java.io.ObjectOutputStream;  
6. import java.net.ServerSocket;  
7. import java.net.Socket;  
8. import java.util.ArrayList;  
9. import java.util.List;  
10.   
11. public class Server extends Thread {  
12. private ServerSocket server;  
13. private Socket socket;  
14.       
15. public Server(){  
16. try {  
17. new ServerSocket(9000);  
18.             socket = server.accept();  
19. catch (Exception e) {  
20. "start error");  
21.         }  
22.     }  
23. @Override  
24. public void run() {  
25. try {  
26. new Student();  
27. 1);  
28. "name1");  
29. new Student();  
30. 1);  
31. "name2");  
32. new ArrayList<Student>();  
33.             list.add(stu);  
34.             list.add(stu1);  
35.               
36. new ListTest();  
37.             test.setList(list);  
38.               
39.               
40. new ObjectOutputStream(socket.getOutputStream());  
41.             out.writeObject(test);  
42.             out.flush();  
43.             out.close();  
44.             socket.close();  
45. catch (Exception e) {  
46.             e.printStackTrace();  
47.         }  
48.     }  
49.       
50. public static void main(String[] args) {  
51. new Server().start();  
52.     }  
53. }

客户端：

1. package Test;  
2.   
3. import java.io.ObjectInputStream;  
4. import java.net.Socket;  
5. import java.util.List;  
6.   
7. public class Client {  
8. public static void main(String[] args) {  
9. try {  
10. new Socket("127.0.0.1",9000);  
11. new ObjectInputStream(socket.getInputStream());  
12. //进行Object传输可以使用ObjectInputStream  
13.             ListTest test = (ListTest) in.readObject();  
14.             List<Student> list = test.getList();  
15. for (Student student : list) {  
16.                 System.out.println(student.getName());  
17.             }  
18. catch (Exception e) {  
19.             e.printStackTrace();  
20.         }  
21.     }  
22. }

其中的两个封装类必须实现序列化接口！！！