客户端与服务器端的通信：client（android）—server—database实现

浅浅的花香味﹌ 2024-04-17 06:05 11阅读 0赞

今天给大家带来的是客户端与服务器端的通信，话不多说，直接上例子：

界面

今天我们实现一个注册的功能，客户端的界面编写神马的咱就不在这浪费时间了，我这也直接写好了，一个最简单的注册和登录界面：

界面写好之后，接下来咱们就去弄接口了。

数据库

这里使用的mysql，搭建数据库这一步自己去搞定 ，新建一个test\_sql数据库，在里面创建一个user表

里面的字段就三个user\_id，user\_name,userpwd;

接下来我们开发WebService 服务工程

接下来我们打开eclipse j2ee，新建一个web工程

接下来我们需要准备三个jar包：gson.jar---mysql-connector-java-8.0.11.jar--servlet-api.jar

这里我们采用jdbc连接，

没有jdbc包的请看这边：https://pan.baidu.com/s/1AwY1rUV4uR1MflFsg2bqAQ

因为我们要将结果以json的形式传给客户端，所以我们还需要一个gson的包，

没有gson包的请看这边：https://pan.baidu.com/s/1ay-vFvQ3WKPedQuRNQ2t6g

编写servlet要用到HttpServletRequest和HttpServletResponse等对象，这些对象都是要靠servlet-api.jar包才能使用的。

如果你安装了Tomcat,这个jar包一般在tomcat安装目录\\lib 文件夹下面有，当你把web项目部署到tomcat，会自动加载这个jar包来识别Serlvet一些对象。

如果没有servlet-api包的请看过来：https://pan.baidu.com/s/11idZbGYjMWIOztesG-4xRA

这些准备好之后我们在Java Resources-->src下创建三个包，一个放Servlet，一个放mysql的工具类，一个放对象;

然后我们开始写数据库的工具类：DBUtils .java

package com.hxb.db;

import java.sql.Connection;  
import java.sql.DriverManager;  
import java.sql.ResultSet;  
import java.sql.SQLException;  
import java.sql.Statement;

public class DBUtils \{  
private Connection conn;  
private String url = "jdbc:mysql://127.0.0.1:3306/test\_sql?serverTimezone=UTC"; // 指定连接数据库的URL  
private String user = "root"; // 指定连接数据库的用户名  
private String password = ""; // 指定连接数据库的密码  
private Statement sta;  
private ResultSet rs; // 打开数据库连接

public void openConnect() \{  
try \{  
// 加载数据库驱动  
Class.forName("com.mysql.jdbc.Driver");  
conn = DriverManager.getConnection(url, user, password);// 创建数据库连接  
if (conn != null) \{  
System.out.println("数据库连接成功"); // 连接成功的提示信息  
\}  
\} catch (Exception e) \{  
System.out.println("ERROR: " + e.getMessage());  
\}  
\}

// 获得查询user表后的数据集  
public ResultSet getUser() \{  
// 创建 statement对象  
try \{  
sta = conn.createStatement(); // 执行SQL查询语句  
rs = sta.executeQuery("select \* from user");  
\} catch (SQLException e) \{  
e.printStackTrace();  
\}  
return rs;  
\}

// 判断数据库中是否存在某个用户名及其密码,注册和登录的时候判断  
public boolean isExistInDB(String username, String password) \{  
boolean isFlag = false; // 创建 statement对象  
try \{  
System.out.println("判断用户名密码");  
sta = conn.createStatement(); // 执行SQL查询语句  
rs = sta.executeQuery("select \* from user");// 获得结果集  
if (rs != null) \{  
while (rs.next()) \{ // 遍历结果集  
if (rs.getString("user\_name").equals(username)) \{  
if (rs.getString("user\_pwd").equals(password)) \{  
isFlag = true;  
break;  
\}  
\}  
\}  
\}  
\} catch (SQLException e) \{  
e.printStackTrace();  
isFlag = false;  
\}  
return isFlag;

// 注册 将用户名和密码插入到数据库(id设置的是自增长的，因此不需要插入)  
public boolean insertDataToDB(String username, String password) \{  
String sql = " insert into user ( user\_name , user\_pwd ) values ( " + "'" + username + "', " + "'" + password  
\+ "' )";  
try \{  
sta = conn.createStatement();  
// 执行SQL查询语句  
return sta.execute(sql);  
\} catch (SQLException e) \{  
e.printStackTrace();  
\}  
return false;  
\}

// 关闭数据库连接  
public void closeConnect() \{  
try \{  
if (rs != null) \{  
rs.close();  
\}  
if (sta != null) \{  
sta.close();  
\}  
if (conn != null) \{  
conn.close();  
\}  
System.out.println("关闭数据库连接成功");  
\} catch (SQLException e) \{  
System.out.println("Error: " + e.getMessage());  
\}  
\}

在domain 下面创建 BaseBean和UserBean

package com.hxb.domain;  
/\*\*  
\* 返回给用户的对象  
\* @author 贺兴波  
\*  
\*/  
public class BaseBean \{  
private int code;  
private String msg;  
private Object data;

public int getCode() \{  
return code;  
\}

public void setCode(int code) \{  
this.code = code;  
\}

public String getMsg() \{  
return msg;  
\}

public void setMsg(String msg) \{  
this.msg = msg;  
\}

public Object getData() \{  
return data;  
\}

public void setData(Object data) \{  
this.data = data;  
\}

package com.hxb.domain;

import java.io.Serializable;  
/\*\*  
\* 数据库查询封装对象  
\* @author 贺兴波  
\*  
\*/  
public class UserBean implements Serializable\{  
  
private int id;  
private String username;  
private String password;  
public int getId() \{  
return id;  
\}  
public void setId(int id) \{  
this.id = id;  
\}  
public String getUsername() \{  
return username;  
\}  
public void setUsername(String username) \{  
this.username = username;  
\}  
public String getPassword() \{  
return password;  
\}  
public void setPassword(String password) \{  
this.password = password;  
\}

再在servlet包下面创建LoginDateServlet 服务

package com.hxb.servlet;

import java.io.IOException;  
import java.sql.ResultSet;  
import java.sql.SQLException;

import javax.servlet.ServletException;  
import javax.servlet.http.HttpServlet;  
import javax.servlet.http.HttpServletRequest;  
import javax.servlet.http.HttpServletResponse;

import com.google.gson.Gson;  
import com.hxb.db.DBUtils;  
import com.hxb.domain.BaseBean;  
import com.hxb.domain.UserBean;

public class LoginDateServlet extends HttpServlet \{

@Override  
protected void doGet(HttpServletRequest request, HttpServletResponse response)  
throws ServletException, IOException \{  
doPost(request, response);  
\}  
  
@Override  
protected void doPost(HttpServletRequest request, HttpServletResponse response)  
throws ServletException, IOException \{  
System.out.println("request--->"+request.getRequestURL()+"===="+request.getParameterMap().toString());  
String username = request.getParameter("username"); // 获取客户端传过来的参数  
String password = request.getParameter("password");  
response.setContentType("text/html;charset=utf-8");  
if (username == null || username.equals("") || password == null || password.equals("")) \{  
System.out.println("用户名或密码为空");  
return;  
\} // 请求数据库  
DBUtils dbUtils = new DBUtils();  
dbUtils.openConnect();  
// 打开数据库连接  
BaseBean data = new BaseBean(); // 基类对象，回传给客户端的json对象  
UserBean userBean = new UserBean(); // user的对象  
if (dbUtils.isExistInDB(username, password)) \{  
// 判断账号是否存在  
data.setCode(-1);  
data.setData(userBean);  
data.setMsg("该账号已存在");  
\} else if (!dbUtils.insertDataToDB(username, password)) \{  
// 注册成功  
data.setCode(0);  
data.setMsg("注册成功!!");  
ResultSet rs = dbUtils.getUser();  
int id = -1;  
if (rs != null) \{  
try \{  
while (rs.next()) \{  
if (rs.getString("user\_name").equals(username)  
&& rs.getString("user\_pwd").equals(password)) \{  
id = rs.getInt("user\_id");  
\}  
\}  
userBean.setId(id);  
\} catch (SQLException e) \{  
e.printStackTrace();  
\}  
\}  
userBean.setUsername(username);  
userBean.setPassword(password);  
data.setData(userBean);  
\} else \{  
// 注册不成功，这里错误没有细分，都归为数据库错误  
data.setCode(500);  
data.setData(userBean);  
data.setMsg("数据库错误");  
\}  
Gson gson = new Gson();  
String json = gson.toJson(data);  
// 将对象转化成json字符串  
try \{  
response.getWriter().println(json);  
// 将json数据传给客户端  
\} catch (Exception e) \{  
e.printStackTrace();  
\} finally \{  
response.getWriter().close(); // 关闭这个流，不然会发生错误的  
\}  
dbUtils.closeConnect(); // 关闭数据库连接\}  
\}

打开WebContent--->WEB-INF--->web.xml

进行编辑

<?xml version="1.0" encoding="UTF-8"?>  
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
xmlns="http://java.sun.com/xml/ns/javaee"  
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app\_3\_0.xsd"  
id="WebApp\_ID" version="3.0">  
<display-name>TestServices</display-name>  
<welcome-file-list>  
<welcome-file>index.html</welcome-file>  
<welcome-file>index.htm</welcome-file>  
<welcome-file>index.jsp</welcome-file>  
<welcome-file>default.html</welcome-file>  
<welcome-file>default.htm</welcome-file>  
<welcome-file>default.jsp</welcome-file>  
</welcome-file-list>  
  
<servlet>  
<description>This is the description of my J2EE component</description>  
<display-name>This is the display name of my J2EE component</display-name>  
<servlet-name>LoginDateServlet</servlet-name>  
<servlet-class>com.hxb.servlet.LoginDateServlet</servlet-class>  
</servlet>

<servlet-mapping>  
<servlet-name>LoginDateServlet</servlet-name>  
<url-pattern>/servlet/LoginDateServlet</url-pattern>  
</servlet-mapping>  
  
</web-app>

目前这些东西都准备好了；；；；我们就可以启动LoginDateServlet 服务了

在这里启动的访问方式是get 所以会出现以下“用户名或密码为空”

需要在链接后面加上----?username=aa&password=123

回到数据库中查询下我们的请求是否操作成功

到现在我们的服务以及创建好了，接下来我们开发客户端；

打开我们的Android Studio 新建一个工程 TestNet 这里我就不做多的介绍

直接编写layout-->activity\_main

<?xml version="1.0" encoding="utf-8"?>  
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
xmlns:tools="http://schemas.android.com/tools"  
android:id="@+id/activity\_main"  
android:layout\_width="match\_parent"  
android:layout\_height="match\_parent"  
android:orientation="vertical"  
android:paddingBottom="@dimen/activity\_vertical\_margin"  
android:paddingLeft="@dimen/activity\_horizontal\_margin"  
android:paddingRight="@dimen/activity\_horizontal\_margin"  
android:paddingTop="@dimen/activity\_vertical\_margin"  
tools:context="net.pay.hxb.com.testnet.MainActivity">

<Button  
android:layout\_width="match\_parent"  
android:layout\_height="wrap\_content"  
android:onClick="loginPOST"  
android:text="登录（POST）" />  
</LinearLayout>  
编写MainActivity

package net.pay.hxb.com.testnet;

import android.os.Bundle;  
import android.support.v7.app.AppCompatActivity;  
import android.util.Log;  
import android.view.View;  
import android.widget.EditText;

import java.io.ByteArrayOutputStream;  
import java.io.DataInputStream;  
import java.io.DataOutputStream;  
import java.io.File;  
import java.io.FileInputStream;  
import java.io.FileOutputStream;  
import java.io.IOException;  
import java.io.InputStream;  
import java.io.PrintWriter;  
import java.net.HttpURLConnection;  
import java.net.URL;  
import java.net.URLEncoder;  
import java.util.HashMap;

public class MainActivity extends AppCompatActivity \{

String TAG = MainActivity.class.getCanonicalName();  
private EditText et\_data\_uname;  
private EditText et\_data\_upass;  
private HashMap<String, String> stringHashMap;

@Override  
protected void onCreate(Bundle savedInstanceState) \{  
super.onCreate(savedInstanceState);  
setContentView(R.layout.activity\_main);  
et\_data\_uname = (EditText) findViewById(R.id.et\_data\_uname);  
et\_data\_upass = (EditText) findViewById(R.id.et\_data\_upass);  
stringHashMap = new HashMap<>();  
\}

public void loginGET(View view) \{  
stringHashMap.put("username", et\_data\_uname.getText().toString());  
stringHashMap.put("password", et\_data\_upass.getText().toString());  
new Thread(getRun).start();

public void loginPOST(View view) \{  
stringHashMap.put("username", et\_data\_uname.getText().toString());  
stringHashMap.put("password", et\_data\_upass.getText().toString());

new Thread(postRun).start();  
\}

/\*\*  
\* get请求线程  
\*/  
Runnable getRun = new Runnable() \{

@Override  
public void run() \{  
// TODO Auto-generated method stub  
requestGet(stringHashMap);  
\}  
\};  
/\*\*  
\* post请求线程  
\*/  
Runnable postRun = new Runnable() \{

@Override  
public void run() \{  
// TODO Auto-generated method stub  
requestPost(stringHashMap);  
\}  
\};

/\*\*  
\* get提交数据  
\*  
\* @param paramsMap  
\*/  
private void requestGet(HashMap<String, String> paramsMap) \{  
try \{  
String baseUrl = "http://10.0.2.2:8080/TestServices/servlet/LoginDateServlet?";  
StringBuilder tempParams = new StringBuilder();  
int pos = 0;  
for (String key : paramsMap.keySet()) \{  
if (pos > 0) \{  
tempParams.append("&");  
\}  
tempParams.append(String.format("%s=%s", key, URLEncoder.encode(paramsMap.get(key), "utf-8")));  
pos++;  
\}

Log.e(TAG,"params--get-->>"+tempParams.toString());  
String requestUrl = baseUrl + tempParams.toString();  
// 新建一个URL对象  
URL url = new URL(requestUrl);  
// 打开一个HttpURLConnection连接  
HttpURLConnection urlConn = (HttpURLConnection) url.openConnection();  
// 设置连接主机超时时间  
urlConn.setConnectTimeout(5 \* 1000);  
//设置从主机读取数据超时  
urlConn.setReadTimeout(5 \* 1000);  
// 设置是否使用缓存 默认是true  
urlConn.setUseCaches(true);  
// 设置为Post请求  
urlConn.setRequestMethod("GET");  
//urlConn设置请求头信息  
//设置请求中的媒体类型信息。  
urlConn.setRequestProperty("Content-Type", "application/json");  
//设置客户端与服务连接类型  
urlConn.addRequestProperty("Connection", "Keep-Alive");  
// 开始连接  
urlConn.connect();  
// 判断请求是否成功  
if (urlConn.getResponseCode() == 200) \{  
// 获取返回的数据  
String result = streamToString(urlConn.getInputStream());  
Log.e(TAG, "Get方式请求成功，result--->" + result);  
\} else \{  
Log.e(TAG, "Get方式请求失败");  
\}  
// 关闭连接  
urlConn.disconnect();  
\} catch (Exception e) \{  
Log.e(TAG, e.toString());  
\}  
\}

/\*\*  
\* post提交数据  
\*  
\* @param paramsMap  
\*/  
private void requestPost(HashMap<String, String> paramsMap) \{  
try \{  
String baseUrl = "http://10.0.2.2:8080/TestServices/servlet/LoginDateServlet";  
//合成参数  
StringBuilder tempParams = new StringBuilder();  
int pos = 0;  
for (String key : paramsMap.keySet()) \{  
if (pos >0) \{  
tempParams.append("&");  
\}  
tempParams.append(String.format("%s=%s", key, URLEncoder.encode(paramsMap.get(key), "utf-8")));  
pos++;  
\}  
String params = tempParams.toString();  
Log.e(TAG,"params--post-->>"+params);  
// 请求的参数转换为byte数组  
// byte\[\] postData = params.getBytes();  
// 新建一个URL对象  
URL url = new URL(baseUrl);  
// 打开一个HttpURLConnection连接  
HttpURLConnection urlConn = (HttpURLConnection) url.openConnection();  
// 设置连接超时时间  
urlConn.setConnectTimeout(5 \* 1000);  
//设置从主机读取数据超时  
urlConn.setReadTimeout(5 \* 1000);  
// Post请求必须设置允许输出 默认false  
urlConn.setDoOutput(true);  
//设置请求允许输入 默认是true  
urlConn.setDoInput(true);  
// Post请求不能使用缓存  
urlConn.setUseCaches(false);  
// 设置为Post请求  
urlConn.setRequestMethod("POST");  
//设置本次连接是否自动处理重定向  
urlConn.setInstanceFollowRedirects(true);  
//配置请求Content-Type  
// urlConn.setRequestProperty("Content-Type", "application/json");//post请求不能设置这个  
// 开始连接  
urlConn.connect();

// 发送请求参数  
PrintWriter dos = new PrintWriter(urlConn.getOutputStream());  
dos.write(params);  
dos.flush();  
dos.close();  
// 判断请求是否成功  
if (urlConn.getResponseCode() == 200) \{  
// 获取返回的数据  
String result = streamToString(urlConn.getInputStream());  
Log.e(TAG, "Post方式请求成功，result--->" + result);  
\} else \{  
Log.e(TAG, "Post方式请求失败");  
\}  
// 关闭连接  
urlConn.disconnect();  
\} catch (Exception e) \{  
Log.e(TAG, e.toString());  
\}  
\}

/\*\*  
\* 将输入流转换成字符串  
\*  
\* @param is 从网络获取的输入流  
\* @return  
\*/  
public String streamToString(InputStream is) \{  
try \{  
ByteArrayOutputStream baos = new ByteArrayOutputStream();  
byte\[\] buffer = new byte\[1024\];  
int len = 0;  
while ((len = is.read(buffer)) != -1) \{  
baos.write(buffer, 0, len);  
\}  
baos.close();  
is.close();  
byte\[\] byteArray = baos.toByteArray();  
return new String(byteArray);  
\} catch (Exception e) \{  
Log.e(TAG, e.toString());  
return null;  
\}  
\}

/\*\*  
\* 文件下载  
\*  
\* @param fileUrl  
\*/  
private void downloadFile(String fileUrl) \{  
try \{  
// 新建一个URL对象  
URL url = new URL(fileUrl);  
// 打开一个HttpURLConnection连接  
HttpURLConnection urlConn = (HttpURLConnection) url.openConnection();  
// 设置连接主机超时时间  
urlConn.setConnectTimeout(5 \* 1000);  
//设置从主机读取数据超时  
urlConn.setReadTimeout(5 \* 1000);  
// 设置是否使用缓存 默认是true  
urlConn.setUseCaches(true);  
// 设置为Post请求  
urlConn.setRequestMethod("GET");  
//urlConn设置请求头信息  
//设置请求中的媒体类型信息。  
urlConn.setRequestProperty("Content-Type", "application/json");  
//设置客户端与服务连接类型  
urlConn.addRequestProperty("Connection", "Keep-Alive");  
// 开始连接  
urlConn.connect();  
// 判断请求是否成功  
if (urlConn.getResponseCode() == 200) \{  
String filePath = "";//下载文件保存在本地的地址  
File descFile = new File(filePath);  
FileOutputStream fos = new FileOutputStream(descFile);  
;  
byte\[\] buffer = new byte\[1024\];  
int len;  
InputStream inputStream = urlConn.getInputStream();  
while ((len = inputStream.read(buffer)) != -1) \{  
// 写到本地  
fos.write(buffer, 0, len);  
\}  
\} else \{  
Log.e(TAG, "文件下载失败");  
\}  
// 关闭连接  
urlConn.disconnect();  
\} catch (Exception e) \{  
Log.e(TAG, e.toString());  
\}  
\}

/\*\*  
\* 文件上传  
\*  
\* @param filePath  
\* @param paramsMap  
\*/  
private void upLoadFile(String filePath, HashMap<String, String> paramsMap) \{  
try \{  
String baseUrl = "https://xxx.com/uploadFile";  
File file = new File(filePath);  
//新建url对象  
URL url = new URL(baseUrl);  
//通过HttpURLConnection对象,向网络地址发送请求  
HttpURLConnection urlConn = (HttpURLConnection) url.openConnection();  
//设置该连接允许读取  
urlConn.setDoOutput(true);  
//设置该连接允许写入  
urlConn.setDoInput(true);  
//设置不能适用缓存  
urlConn.setUseCaches(false);  
//设置连接超时时间  
urlConn.setConnectTimeout(5 \* 1000); //设置连接超时时间  
//设置读取超时时间  
urlConn.setReadTimeout(5 \* 1000); //读取超时  
//设置连接方法post  
urlConn.setRequestMethod("POST");  
//设置维持长连接  
urlConn.setRequestProperty("connection", "Keep-Alive");  
//设置文件字符集  
urlConn.setRequestProperty("Accept-Charset", "UTF-8");  
//设置文件类型  
urlConn.setRequestProperty("Content-Type", "multipart/form-data; boundary=" + "\*\*\*\*\*");  
String name = file.getName();  
DataOutputStream requestStream = new DataOutputStream(urlConn.getOutputStream());  
requestStream.writeBytes("--" + "\*\*\*\*\*" + "\\r\\n");  
//发送文件参数信息  
StringBuilder tempParams = new StringBuilder();  
tempParams.append("Content-Disposition: form-data; name=\\"" + name + "\\"; filename=\\"" + name + "\\"; ");  
int pos = 0;  
int size = paramsMap.size();  
for (String key : paramsMap.keySet()) \{  
tempParams.append(String.format("%s=\\"%s\\"", key, paramsMap.get(key), "utf-8"));  
if (pos < size - 1) \{  
tempParams.append("; ");  
\}  
pos++;  
\}  
tempParams.append("\\r\\n");  
tempParams.append("Content-Type: application/octet-stream\\r\\n");  
tempParams.append("\\r\\n");  
String params = tempParams.toString();  
requestStream.writeBytes(params);  
//发送文件数据  
FileInputStream fileInput = new FileInputStream(file);  
int bytesRead;  
byte\[\] buffer = new byte\[1024\];  
DataInputStream in = new DataInputStream(new FileInputStream(file));  
while ((bytesRead = in.read(buffer)) != -1) \{  
requestStream.write(buffer, 0, bytesRead);  
\}  
requestStream.writeBytes("\\r\\n");  
requestStream.flush();  
requestStream.writeBytes("--" + "\*\*\*\*\*" + "--" + "\\r\\n");  
requestStream.flush();  
fileInput.close();  
int statusCode = urlConn.getResponseCode();  
if (statusCode == 200) \{  
// 获取返回的数据  
String result = streamToString(urlConn.getInputStream());  
Log.e(TAG, "上传成功，result--->" + result);  
\} else \{  
Log.e(TAG, "上传失败");  
\}  
\} catch (IOException e) \{  
Log.e(TAG, e.toString());  
\}  
\}

\}  
需要的网络权限：

<uses-permission android:name="android.permission.INTERNET" />编译App 运行  
编译运行APP,输入数据请求结果：