加入数据库mysql实现android注册登陆功能的客户端服务器源码与解析

From:http://blog.csdn.net/grape875499765/article/details/49981951

我11月21日发表了“实现android注册登陆功能的客户端服务器源码与解析”的博客，刚刚加入了数据库，把我自己加入数据库的过程和又完善了服务器的代码分享一下

一、阅读要求

同11月21日发表博文，如果没有阅读的话建议先阅读后再阅读本博文

对数据库有基本的了解和掌握

二、实现情况

1、解决了在注册时忽然退出再次注册这种情况下，服务器端的bug

2、解决了在注册时忽然退出直接登陆这种情况下，服务器端的bug

3、加入了数据库，可以进行大量用户名和密码存储

三、操作步骤

1、同上篇博文一样的操作环境

2、搭建mysql数据库，如果不会的请自行百度，我使用的是mysql workbench 6.3CE

3、在数据库中建表，建表语句在MyServer->mysql文件夹里面

4、运行MyServer，要注意是运行MyServer而不是运行整个工程

5、安装好app，打开MyClient，然后开始进行注册登陆等操作，可以检测一下是否还存在我在第二条实现情况里面提到的bug，图片界面和上一篇博文相同

四、代码讲解

1、首先客户端和上一篇博文代码是相同的，在这里就不粘贴了，如果想看的朋友请到上一篇博文观看

2、服务器代码

话不多说，解释都在注释中

MyServer.java

[java]  view plain  copy

1. package com.test;  
2.   
3. import java.io.DataInputStream;  
4. import java.io.DataOutputStream;  
5. import java.io.IOException;  
6. import java.io.InputStream;  
7. import java.io.OutputStream;  
8. import java.net.ServerSocket;  
9. import java.net.Socket;  
10. import java.sql.ResultSet;  
11.   
12.   
13. public class MyServer {  
14.     public static void main(String[] args){  
15.         try{  
16.             ServerSocket server=new ServerSocket(6666);  
17.             while(true){  
18.                 System.out.println("服务器回归原点");//调试信息  
19.                 Socket s1 = server.accept();  
20.                 System.out.println("接到客户端socket请求");//调试信息  
21.                 InputStream is1 = s1.getInputStream();  
22.                 DataInputStream dis1=new DataInputStream(is1);  
23.                 String []getStr = dis1.readUTF().split(" ");;//用空格把账号和密码分开存储  
24.                 System.out.println(getStr[0]+" "+getStr[1]+" "+getStr[2]);//调试信息  
25.                   
26.                 //如果发来注册的信息就做如下操作  
27.                 if(getStr[2].equals("Register")){  
28.                     System.out.println("等待下一步指令");  
29.                     Socket s2 = server.accept();  
30.                     InputStream is2 = s2.getInputStream();  
31.                     DataInputStream dis2 = new DataInputStream(is2);  
32.                     String []getStrSecond = dis2.readUTF().split(" ");//用空格把账号和密码分开存储  
33.                     //这个处理是针对有人注册没注册完就退出了程序然后另外有人开始登陆或者重新注册  
34.                     System.out.println(getStrSecond[0] + " " + getStrSecond[1]  
35.                             + " " + getStrSecond[2]);// 调试信息  
36.                     if(getStrSecond[2].equals("Login")){  
37.                         /判断是否可以登录//  
38.                         login(s2,getStrSecond);  
39.                     }  
40.                     else if(getStrSecond[2].equals("Register")){  
41.                         //不需要处理  
42.                     }  
43.                     else if(getStrSecond[2].equals("Registered")){  
44.                         ///数据库插入操作  
45.                         insertMasterDB(getStrSecond);  
46.                         ///数据库插入操作  
47.                     }  
48.                     is2.close();  
49.                     s2.close();  
50.                     dis2.close();  
51.                 }  
52.                 //如果发来登录账号+密码+login做如下操作  
53.                 else if(getStr[2].equals("Login")){  
54.                     System.out.println("进入登陆判断");//调试信息  
55.                     /判断是否可以登录//  
56.                     login(s1,getStr);  
57.                     //System.out.println(getStr[0]+" "+getStr[1]+" "+getStr[2]);//调试信息  
58.                 }  
59.                 //这里是针对进入注册界面但是没有完成注册就退出且再次进入注册界面情况的处理  
60.                 else if(getStr[2].equals("Registered")){  
61.                     ///数据库插入操作  
62.                     insertMasterDB(getStr);  
63.                     ///数据库插入操作  
64.                 }  
65.                 dis1.close();  
66.                 s1.close();  
67.             }  
68.         }catch(IOException e){  
69.             e.printStackTrace();  
70.         }     
71.     }  
72.       
73.     /** 
74.      * 该函数为是否允许用户登录函数 
75.      * @param s1 建立连接的socket变量 
76.      * @param getStr 要查找的_id和password都在里面 
77.      */  
78.     public static void login(Socket s1,String []getStr){  
79.         //如果账号和密码都对的话则返回允许登录命令  
80.         /查找用户名和密码是否一致//  
81.         ServerDatabase masterDB = new ServerDatabase();  
82.         masterDB.connSQL();  
83.         String select = "select * from userdata where _id = '" + getStr[0]  
84.                 + "' and password = '" + getStr[1] + "';";  
85.         ResultSet resultSet = masterDB.selectSQL(select);  
86.         // ///查找用户名和密码是否一致//  
87.         try {  
88.             // 用户名和密码不一致  
89.             if (resultSet.next() == false) {  
90.                 // 禁止登录命令  
91.                 OutputStream os=s1.getOutputStream();  
92.                 DataOutputStream dos=new DataOutputStream(os);  
93.                 dos.writeUTF("NO");  
94.                 dos.close();  
95.                 System.out.println("用户密码错误");//调试信息  
96.             }  
97.             // 用户名和密码一致  
98.             else {  
99.                 // 允许登录命令  
100.                 OutputStream os=s1.getOutputStream();  
101.                 DataOutputStream dos=new DataOutputStream(os);  
102.                 dos.writeUTF("YES");  
103.                 dos.close();  
104.                 System.out.println("用户密码正确");//调试信息  
105.             }  
106.         } catch (Exception e) {  
107.             System.out.println("显示出错。");  
108.             e.printStackTrace();  
109.         }  
110.         masterDB.deconnSQL();// 关闭连接  
111.     }  
112.       
113.     /** 
114.      * 该函数为插入master数据库命令 
115.      * @param getStr 插入数据库的_id password都在里面 
116.      */  
117.     public static void insertMasterDB(String []getStr){  
118.         ServerDatabase masterDB = new ServerDatabase();  
119.         masterDB.connSQL();  
120.         String s = "select * from userdata";//调试信息  
121.         String insert = "insert into userdata(_id,password) " +  
122.                 "values('"+getStr[0]+"','"+getStr[1]+"')";  
123.         if (masterDB.insertSQL(insert) == true) {  
124.             System.out.println("insert successfully");  
125.             ResultSet resultSet = masterDB.selectSQL(s);//调试信息  
126.             masterDB.layoutStyle2(resultSet);//调试信息  
127.         }  
128.         masterDB.deconnSQL();//关闭连接  
129.     }  
130. }  

ServerDatabase.java

[java]  view plain  copy

1. package com.test;  
2.   
3. import java.sql.Connection;  
4. import java.sql.DriverManager;  
5. import java.sql.PreparedStatement;  
6. import java.sql.ResultSet;  
7. import java.sql.SQLException;  
8.   
9. public class ServerDatabase {  
10.     private Connection conn = null;  
11.     private PreparedStatement statement = null;  
12.     // connect to MySQL  
13.     public void connSQL() {  
14.         String urle = "jdbc:mysql://localhost:3306/masterdatabase";//port：3306 database:masterdatabase  
15.         String username = "root";//user  
16.         String password = "102938475610";//password  
17.         try {   
18.             Class.forName("com.mysql.jdbc.Driver" );//加载驱动，连接数据库  
19.             conn = DriverManager.getConnection(urle,username, password );   
20.             }  
21.         //捕获加载驱动程序异常  
22.          catch ( ClassNotFoundException cnfex ) {  
23.              System.err.println(  
24.              "装载 JDBC/ODBC 驱动程序失败。" );  
25.              cnfex.printStackTrace();   
26.          }   
27.          //捕获连接数据库异常  
28.          catch ( SQLException sqlex ) {  
29.              System.err.println( "无法连接数据库" );  
30.              sqlex.printStackTrace();  
31.          }  
32.     }  
33.   
34.     // disconnect to MySQL  
35.     public void deconnSQL() {  
36.         try {  
37.             if (conn != null)  
38.                 conn.close();  
39.         } catch (Exception e) {  
40.             System.out.println("关闭数据库问题 ：");  
41.             e.printStackTrace();  
42.         }  
43.     }  
44.   
45.     // execute selection language  
46.     public ResultSet selectSQL(String sql) {  
47.         ResultSet rs = null;  
48.         try {  
49.             statement = conn.prepareStatement(sql);  
50.             rs = statement.executeQuery(sql);  
51.         } catch (SQLException e) {  
52.             e.printStackTrace();  
53.         }  
54.         return rs;  
55.     }  
56.   
57.     // execute insertion language  
58.     public boolean insertSQL(String sql) {  
59.         try {  
60.             statement = conn.prepareStatement(sql);  
61.             statement.executeUpdate();  
62.             return true;  
63.         } catch (SQLException e) {  
64.             System.out.println("插入数据库时出错：");  
65.             e.printStackTrace();  
66.         } catch (Exception e) {  
67.             System.out.println("插入时出错：");  
68.             e.printStackTrace();  
69.         }  
70.         return false;  
71.     }  
72.     //execute delete language  
73.     public boolean deleteSQL(String sql) {  
74.         try {  
75.             statement = conn.prepareStatement(sql);  
76.             statement.executeUpdate();  
77.             return true;  
78.         } catch (SQLException e) {  
79.             System.out.println("插入数据库时出错：");  
80.             e.printStackTrace();  
81.         } catch (Exception e) {  
82.             System.out.println("插入时出错：");  
83.             e.printStackTrace();  
84.         }  
85.         return false;  
86.     }  
87.     //execute update language  
88.     public boolean updateSQL(String sql) {  
89.         try {  
90.             statement = conn.prepareStatement(sql);  
91.             statement.executeUpdate();  
92.             return true;  
93.         } catch (SQLException e) {  
94.             System.out.println("插入数据库时出错：");  
95.             e.printStackTrace();  
96.         } catch (Exception e) {  
97.             System.out.println("插入时出错：");  
98.             e.printStackTrace();  
99.         }  
100.         return false;  
101.     }  
102.       
103.     // show data in ju_users  
104.     public void layoutStyle2(ResultSet rs) {  
105.         System.out.println("-----------------");  
106.         System.out.println("_id" + "\t" + "password");  
107.         System.out.println("-----------------");  
108.         try {  
109.             while (rs.next()) {  
110.                 System.out.println(rs.getString("_id") + "\t"  
111.                         + rs.getString("password") + "\n");  
112.                 //"\t" + rs.getInt("age") + "\t"+ rs.getString("work") + "\t" + rs.getString("others") +"\n");  
113.             }  
114.         } catch (SQLException e) {  
115.             System.out.println("显示时数据库出错。");  
116.             e.printStackTrace();  
117.         } catch (Exception e) {  
118.             System.out.println("显示出错。");  
119.             e.printStackTrace();  
120.         }  
121.     }  
122.   
123.     /*public static void main(String args[]) { 
124.  
125.         ServerDatabase h = new ServerDatabase(); 
126.         h.connSQL(); 
127.         String select = "select * from userdata where _id=" 
128.                 + "'w'" + " and password=" 
129.                 + "'w'" + ";"; 
130.         ResultSet resultSet = h.selectSQL(select); 
131.         h.layoutStyle2(resultSet);//调试信息 
132.         String s = "select * from userdata"; 
133.  
134.         String insert = "insert into userdata(_id,password) " + 
135.                 "values('aaron','102938475610')"; 
136.         String update = "update userdata set password ='123456789' where _id= 'aaron'"; 
137.         String delete = "delete from userdata where _id= 'aaron'"; 
138.  
139.         if (h.insertSQL(insert) == true) { 
140.             System.out.println("insert successfully"); 
141.             ResultSet resultSet = h.selectSQL(s); 
142.             h.layoutStyle2(resultSet); 
143.         } 
144.         if (h.updateSQL(update) == true) { 
145.             System.out.println("update successfully"); 
146.             ResultSet resultSet = h.selectSQL(s);    
147.             h.layoutStyle2(resultSet); 
148.         } 
149.         if (h.insertSQL(delete) == true) { 
150.             System.out.println("delete successfully"); 
151.             ResultSet resultSet = h.selectSQL(s); 
152.             h.layoutStyle2(resultSet); 
153.         } 
154.         h.deconnSQL(); 
155.     }*/  
156. }  

五、注意

1、在java中使用mysql前，要加入相应的jar包，在我的工程中有，但是有可能需要再次添加

mysql-connector-java-5.0.5-bin.jar我使用的jar包，如果工程中没有的话，请自行查找如何添加

2、由于本人在做一个android项目，名字叫做Master，所以在服务器端会提到相关的变量，请读者不要过于在意

3、在使用前，客户端要改掉LogIn.java和Register.java的ip地址，在命令行中用ipconfig查询，服务器端请改掉username password，这两个是你在mysql中设置的用户名和密码

4、在ServerDatabase.java中有一段注释掉的main函数，这个是给读者提供update和delete函数的用法，因为在MyServer.java中并没有调用

源码链接

http://download.csdn.net/detail/grape875499765/9291427