Introduction à cette section :
La leçon conceptuelle de la section précédente était sèche et ennuyeuse, n'est-ce pas ? Mais vous en avez quand même tiré quelque chose, non ? À partir de cette section, nous allons étudier la communication Socket basée sur le protocole TCP. D'abord, comprenons le concept de Socket, le modèle de communication Socket, les étapes de mise en œuvre de Socket, et ce que le serveur et le client Socket doivent chacun faire ! Très bien, creusons dans ce Socket étape par étape, du plus simple au plus profond !
1. Qu'est-ce qu'un Socket ?

2. Modèle de communication Socket :

Analyse des étapes de mise en œuvre de la communication Socket:
Étape 1: Créer ServerSocket et Socket
Étape 2: Ouvrir les flux d'entrée/sortie du Socket connecté
Étape 3: Effectuer des opérations de lecture/écriture sur le Socket conformément au protocole
Étape 4: Fermer les flux d'entrée/sortie et le Socket
Très bien, écrivons un exemple simple. Après avoir démarré le serveur, le client clique sur un bouton pour se connecter au serveur, et envoie une chaîne au serveur, indiquant qu'il s'est connecté au serveur via Socket~
3. Écrire le serveur Socket :
Les choses que le serveur doit faire sont les suivantes:
Étape 1: Créer un objet ServerSocket et lier le port d'écoute
Étape 2: Appeler la méthode accept() pour écouter les requêtes des clients
Étape 3: Une fois la connexion établie, lire les informations de requête envoyées par le client via le flux d'entrée
Étape 4: Envoyer les informations de réponse au client via le flux de sortie
Étape 5: Fermer les ressources associées
Implémentation du code:
Créez simplement un projet Java dans Eclipse et collez-y le code Java !
public class SocketServer {
public static void main(String[] args) throws IOException {
//1.创建一个服务器端Socket,即ServerSocket,指定绑定的端口,并监听此端口
ServerSocket serverSocket = new ServerSocket(12345);
InetAddress address = InetAddress.getLocalHost();
String ip = address.getHostAddress();
Socket socket = null;
//2.调用accept()等待客户端连接
System.out.println("~~~服务端已就绪,等待客户端接入~,服务端ip地址: " + ip);
socket = serverSocket.accept();
//3.连接后获取输入流,读取客户端信息
InputStream is=null;
InputStreamReader isr=null;
BufferedReader br=null;
OutputStream os=null;
PrintWriter pw=null;
is = socket.getInputStream(); //获取输入流
isr = new InputStreamReader(is,"UTF-8");
br = new BufferedReader(isr);
String info = null;
while((info=br.readLine())!=null){//循环读取客户端的信息
System.out.println("客户端发送过来的信息" + info);
}
socket.shutdownInput();//关闭输入流
socket.close();
}
}
Ensuite, nous exécutons le code, et la console affichera :

Bien, passons maintenant au client Android !
4. Écriture du client Socket :
Les choses que le client doit faire sont les suivantes:
Étape 1: Créer un objet Socket, en spécifiant l'adresse et le numéro de port du serveur auquel se connecter
Étape 2: Une fois la connexion établie, envoyer les informations de requête au serveur via le flux de sortie
Étape 3: Obtenir les informations de réponse du serveur via le flux d'entrée
Étape 4: Fermer les ressources associées
Implémentation du code:
MainActivity.java:
public class MainActivity extends AppCompatActivity implements View.OnClickListener {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Button btn_accept = (Button) findViewById(R.id.btn_accept);
btn_accept.setOnClickListener(this);
}
@Override
public void onClick(View v) {
new Thread() {
@Override
public void run() {
try {
acceptServer();
} catch (IOException e) {
e.printStackTrace();
}
}
}.start();
}
private void acceptServer() throws IOException {
//1.创建客户端Socket,指定服务器地址和端口
Socket socket = new Socket("172.16.2.54", 12345);
//2.获取输出流,向服务器端发送信息
OutputStream os = socket.getOutputStream();//字节输出流
PrintWriter pw = new PrintWriter(os);//将输出流包装为打印流
//获取客户端的IP地址
InetAddress address = InetAddress.getLocalHost();
String ip = address.getHostAddress();
pw.write("客户端:~" + ip + "~ 接入服务器!!");
pw.flush();
socket.shutdownOutput();//关闭输出流
socket.close();
}
}
Comme Android n'autorise pas les opérations réseau sur le thread principal (thread UI), nous devons ici démarrer nous-mêmes un autre thread pour connecter le Socket !
Résultat de l'exécution:
Après avoir cliqué sur le bouton, la console du serveur affiche :
5. Exemple amélioré : Piggy Simple Chat Room
Le simple fait de cliquer sur un bouton puis que le serveur renvoie une information est vraiment ennuyeux, non ? Ensuite, construisons une salle de chat très simple. Nous devons utiliser un pool de threads, une collection pour stocker les connexions Socket, et nous devons aussi écrire nous-mêmes un thread. Nous découvrirons les détails dans le code !
Le simple fait de cliquer sur un bouton puis que le serveur renvoie une information est vraiment ennuyeux, non ? Ensuite, construisons une salle de chat très simple. Nous devons utiliser un pool de threads, une collection pour stocker les connexions Socket, et nous devons aussi écrire nous-mêmes un thread. Nous découvrirons les détails dans le code !
Schéma de l'effet d'implémentation :
D'abord, exécutons notre serveur :
Ensuite, exécutons notre programme sur deux émulateurs respectivement :
Ensuite, écrivons le code :
Tout d'abord, le serveur. Il place les opérations de lecture/écriture du socket dans un thread personnalisé. Après avoir créé ServerSocket, il appelle la méthode accept dans une boucle. Lorsqu'un nouveau client se connecte, il ajoute le socket à la collection et crée un nouveau thread dans le pool de threads !
De plus, dans la méthode de lecture des informations, la chaîne d'entrée est vérifiée. S'il s'agit de la chaîne "bye", le socket est retiré de la collection puis fermé !
Server.java:
public class Server {
//定义相关的参数,端口,存储Socket连接的集合,ServerSocket对象
//以及线程池
private static final int PORT = 12345;
private List<Socket> mList = new ArrayList<Socket>();
private ServerSocket server = null;
private ExecutorService myExecutorService = null;
public static void main(String[] args) {
new Server();
}
public Server()
{
try
{
server = new ServerSocket(PORT);
//创建线程池
myExecutorService = Executors.newCachedThreadPool();
System.out.println("服务端运行中...\n");
Socket client = null;
while(true)
{
client = server.accept();
mList.add(client);
myExecutorService.execute(new Service(client));
}
}catch(Exception e){e.printStackTrace();}
}
class Service implements Runnable
{
private Socket socket;
private BufferedReader in = null;
private String msg = "";
public Service(Socket socket) {
this.socket = socket;
try
{
in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
msg = "用户:" +this.socket.getInetAddress() + "~加入了聊天室"
+"当前在线人数:" +mList.size();
this.sendmsg();
}catch(IOException e){e.printStackTrace();}
}
@Override
public void run() {
try{
while(true)
{
if((msg = in.readLine()) != null)
{
if(msg.equals("bye"))
{
System.out.println("~~~~~~~~~~~~~");
mList.remove(socket);
in.close();
msg = "用户:" + socket.getInetAddress()
+ "退出:" +"当前在线人数:"+mList.size();
socket.close();
this.sendmsg();
break;
}else{
msg = socket.getInetAddress() + " 说: " + msg;
this.sendmsg();
}
}
}
}catch(Exception e){e.printStackTrace();}
}
//为连接上服务端的每个客户端发送信息
public void sendmsg()
{
System.out.println(msg);
int num = mList.size();
for(int index = 0;index < num;index++)
{
Socket mSocket = mList.get(index);
PrintWriter pout = null;
try {
pout = new PrintWriter(new BufferedWriter(
new OutputStreamWriter(mSocket.getOutputStream(),"UTF-8")),true);
pout.println(msg);
}catch (IOException e) {e.printStackTrace();}
}
}
}
}
Vient ensuite le client. La difficulté du client réside dans la nécessité d'ouvrir un autre thread, car Android n'autorise pas les opérations réseau directement sur le thread principal, et n'autorise pas les opérations sur l'UI dans des threads autres que le thread principal. L'approche ici consiste à créer soi-même un nouveau thread et à utiliser un Handler pour mettre à jour l'UI. En développement réel, faire cela directement n'est pas recommandé !!!
Fichier de mise en page :activity_main.xml:
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical" >
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="小猪简易聊天室" />
<TextView
android:id="@+id/txtshow"
android:layout_width="match_parent"
android:layout_height="wrap_content"
/>
<EditText
android:id="@+id/editsend"
android:layout_width="match_parent"
android:layout_height="wrap_content"
/>
<Button
android:id="@+id/btnsend"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:text="发送"
/>
</LinearLayout>
MainActivity.java :
public class MainActivity extends AppCompatActivity implements Runnable {
//定义相关变量,完成初始化
private TextView txtshow;
private EditText editsend;
private Button btnsend;
private static final String HOST = "172.16.2.54";
private static final int PORT = 12345;
private Socket socket = null;
private BufferedReader in = null;
private PrintWriter out = null;
private String content = "";
private StringBuilder sb = null;
//定义一个handler对象,用来刷新界面
public Handler handler = new Handler() {
public void handleMessage(Message msg) {
if (msg.what == 0x123) {
sb.append(content);
txtshow.setText(sb.toString());
}
}
;
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
sb = new StringBuilder();
txtshow = (TextView) findViewById(R.id.txtshow);
editsend = (EditText) findViewById(R.id.editsend);
btnsend = (Button) findViewById(R.id.btnsend);
//当程序一开始运行的时候就实例化Socket对象,与服务端进行连接,获取输入输出流
//因为4.0以后不能再主线程中进行网络操作,所以需要另外开辟一个线程
new Thread() {
public void run() {
try {
socket = new Socket(HOST, PORT);
in = new BufferedReader(new InputStreamReader(socket.getInputStream(), "UTF-8"));
out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(
socket.getOutputStream())), true);
} catch (IOException e) {
e.printStackTrace();
}
}
}.start();
//为发送按钮设置点击事件
btnsend.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
String msg = editsend.getText().toString();
if (socket.isConnected()) {
if (!socket.isOutputShutdown()) {
out.println(msg);
}
}
}
});
new Thread(MainActivity.this).start();
}
//重写run方法,在该方法中输入流的读取
@Override
public void run() {
try {
while (true) {
if (socket.isConnected()) {
if (!socket.isInputShutdown()) {
if ((content = in.readLine()) != null) {
content += "\n";
handler.sendEmptyMessage(0x123);
}
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
Résumé de cette section :
Bien, cette section a expliqué la communication Socket basée sur TCP. L'article a présenté le modèle de communication Socket, implémenté un exemple simple de communication Socket et écrit un exemple amélioré : Salon de discussion Piggy. Je crois que cela apportera de la commodité à ceux qui débutent en programmation Socket~ Merci~