20170403总结

20170319 - 20170403学习内容：

       1.Android网络应用：

           （1） 基于TCP协议的网络通信：

                 　IP协议负责将消息从一个主机传送到另一个主机，消息在传送过程中被分割成一个个小包。

 　　　　　　  TCP协议负责收集这些信息包，并将其按适当的次序放好传送，在接收端收到后再将其正确的还原；

 　　　  (2)使用ServerSocket创建TCP服务器端

 　　　　　　在两个通信实体没有建立虚拟链路之前，必须有一个通信实体先做出“主动姿态”，主动接受来自其他通信实体的连接请求。

 　　　　　　Java中能接收其他通信实体连接请求的类是ServerSocket。

/**
*服务器端
*/
1 //创建一个ServerSocket，用于监听客户端Socket的连接请求
ServerSocket ss = new ServerSocket(30000);
//采用循环不断接收来自客户端的请求
while(true){
    //每当接收到客户端Socket的请求时，服务器端也对应产生一个Socket
    Socket s = ss.accept();
    //下面就可以使用Socket进行通信了
     ......
}

　　　　　使用Socket进行通信

           

//创建连接到服务器ip地址（例如：118.89.228.123、端口30000的Socket）
Socket s = new Socket("118.89.228.123",30000);
//使用Socket进行通信

....

     使用Socket建立聊天室：

          服务器端：

         

import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.security.Provider.Service;
import java.util.ArrayList;


public class MySever {
    //定义保存所有Socket的ArrayList
    public static ArrayList<Socket> socketList = new ArrayList<Socket>();

    public static void main(String[] args) throws IOException {
        ServerSocket ss = new ServerSocket(40000);
        while(true){    
            //此行代码会阻塞，将一直等待别人的连接
            Socket s = ss.accept();
            socketList.add(s);
            //每当客户端连接后启动一条ServerThread线程为该客户端服务
            new Thread(new ServerThread(s)).start();
        }
    }
}

 

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.net.Socket;
import java.net.SocketException;
import java.util.Iterator;

/**
 * 作用：负责处理每条线程通信的线程类
 * @author lenovo
 *
 */

public class ServerThread implements Runnable{
    //定义当前线程所处理的Socket
    Socket s = null;
    //该线程所处理的Socket所对应的输入流
    BufferedReader br = null;
    public ServerThread(Socket s) throws IOException{
        this.s = s;
        //初始化该Socket对应的输入流
        br = new BufferedReader(new InputStreamReader(s.getInputStream(),"utf-8"));
    }

    public void run() {
        try{
            // TODO Auto-generated method stub
            String content = null;
            //采用循环不断从Socket中读取客户端发送过来的数据
            while((content = readFromClient()) != null){
                //遍历socketList中的每个Socket
                //将读到的内容向每个Socket发送一次
                for(Iterator<Socket> it = MySever.socketList.iterator();it.hasNext();){
                    Socket s = it.next();
                    OutputStream os;
                    try {
                        os = s.getOutputStream();
                        os.write((content + "
").getBytes("utf-8"));
                    } catch (SocketException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                        it.remove();
                        System.out.println(MySever.socketList);
                    }
                }
            }    
        }catch(IOException e){
            e.printStackTrace();
        }        
    }
    
    //定义读取客户端数据的方法
    private String readFromClient(){
        try {
            return br.readLine();
        } catch (IOException e) {  //如果捕捉到异常，表明该Socket对应的客户端已经关闭
            // TODO Auto-generated catch block
            e.printStackTrace();
            //删除该Socket
            MySever.socketList.remove(s);
        }
        return null;
    }

}

 

      客户端：

package com.crazyit.test;

import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;

public class MainActivity extends Activity {
    private EditText input;
    private TextView show;
    private Button send;
    private Handler handler;

    //定义与服务器通信的子线程
    private ClientThread clientThread;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        input = (EditText) findViewById(R.id.input);
        send = (Button) findViewById(R.id.send);
        show = (TextView) findViewById(R.id.show);

        handler = new Handler(){
            @Override
            public void handleMessage(Message msg) {
                //如果消息来自于子线程
                if (msg.what == 0x123){
                    //将读取的内容追加显示在文本框中
                    show.append("
" + msg.obj.toString());
                }
            }
        };
        clientThread = new ClientThread(handler);
        //客户端启动ClientThread线程创建网络连接，读取来自服务器的数据
        new Thread(clientThread).start();
        send.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                //当用户点击发送按钮后，将用户输入的数据封装成Message，然后发送给子线程的Handler
                Message msg = new Message();
                msg.what = 0x345;
                msg.obj = input.getText().toString();
                clientThread.revHandler.sendMessage(msg);
                //清空input文本框
                input.setText("");
            }
        });
    }
}

package com.crazyit.test;

import android.os.Handler;
import android.os.Looper;
import android.os.Message;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.Socket;
import java.net.SocketTimeoutException;

/**
 * Created by Zeng on 2017/3/27.
 */
public class ClientThread implements Runnable{
    private Socket s;
    //定义向UI线程发送消息的Handler对象
    private Handler handler;
    //定义接收UI线程的消息的Handler对象
    public Handler revHandler;
    //该线程所处理的Socket所对应的输入流
    BufferedReader br = null;
    OutputStream os = null;

    public ClientThread(Handler handler){
        this.handler = handler;
    }

    @Override
    public void run() {
        try {
            s = new Socket("118.89.228.123",30000);//服务器
//            s = new Socket("172.16.69.122",40000);//本地运行
            br = new BufferedReader(new InputStreamReader(s.getInputStream()));
            os = s.getOutputStream();
            new Thread(){
                @Override
                public void run() {
                    String content = null;
                    try{
                        while ((content = br.readLine()) != null){
                            Message message = new Message();
                            message.what = 0x123;
                            message.obj = content;
                            handler.sendMessage(message);
                        }
                    }catch (IOException e){
                        e.printStackTrace();
                    }
                }
            }.start();
            //为当前线程初始化Looper
            Looper.prepare();
            //创建revHandler对象
            revHandler = new Handler(){
                @Override
                public void handleMessage(Message msg) {
                    //接收UI线程中用户输入的数据
                    if (msg.what == 0x345){
                        //将用户在文本框输入的内容写入网络
                        try {
                            os.write((msg.obj.toString() + "
").getBytes("utf-8"));
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }
            };
            //启动Looper
            Looper.loop();
        }catch (SocketTimeoutException e1){
            System.out.println("网络连接超时！！！");
        }
        catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2.学习OKHttp使用方法及其部分源码，接下来继续学习其实现机制。

3.学习Java部分设计模式：

    （四）工厂模式： (1)静态工厂模式：TextUtil.isEmpty()

　　　　　　　　　  (2)简单工厂模式：卖肉夹馍

　　　　　　　　　  (3)工厂方法模式：把类的实例化过程推迟到子类

 　　　　　　　　　 (4)抽象工厂模式：提供一个接口，用于创建相关的或者依赖对象的家族，而不需要明确指定具体类

 　(五)单例模式：(1)饿汉模式

public class Singleton  
{  
    private static Singleton instance = new Singleton();  
      
    public static Singleton getInstance()  
    {  
        return instance ;  
    }  
} 

　　　　　　　　 (2)赖汉  

public class Singleton02  
{  
    private static Singleton02 instance;  
  
    public static Singleton02 getInstance()  
    {  
        if (instance == null)  
        {  
            synchronized (Singleton02.class)  
            {  
                if (instance == null)  
                {  
                    instance = new Singleton02();  
                }  
            }  
        }  
        return instance;  
    }  
}

　　　　　　(3)枚举：

public enum Singleton03  
{  
    INSTANCE;  
}  

　　　　　　(4)使用一个持有类

public class Singleton04  
{  
    private static final class InstanceHolder  
    {  
        private static Singleton04 INSTANCE = new Singleton04();  
    }  
  
    public static Singleton04 getInstance()  
    {  
        return InstanceHolder.INSTANCE;  
    }  
}  

 3、学习了Git的基本使用，下阶段将继续学习更多操作；

上述许多代码来自张鸿洋大神的博客:特此注明：http://blog.csdn.net/lmj623565791/article/category/2206597

总结：

     这两星期来总体学习效率不高，在学习开源开源项目时经常遇到很多问题，很多问题解决不了就很难以进行下一步的学习，这两周来看了两个关于使用百度推送的即时通信软件，一直困扰在其推送机制上，弄明白是如何实现推送的；另外一方面可能是毕业论文方向的问题，看了好多论文关于分级保护的论文非常有限，遇到一些问题只能自己慢慢琢磨，问老师甩给我的第一句就是自己想，自己网上找！！！！

下一阶段将继续学习上述存在的问题，并把Android一些章节学完，漏了好多章节没看，现在写代码困难重重！！！！！