程序博客网 > 常州科教城淘宝装修

Android 群聊天室

来源：互联网 发布：常州科教城淘宝装修 编辑：程序博客网 时间：2024/05/29 09:26
Top

THREAD_SORCKET DAY05

  1. 解析XML生成Point对象
  2. 实现群聊天室

1 解析XML生成Point对象

1.1 问题

要求解析如下xml文件，并且生成Point对象。

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans>
  3.   <bean name="point" class="day23.Point">
  4.       <param name="x" value="10"/>
  5.       <param name="y" value="20"/>
  6.   </bean>
  7. </beans>。

1.2 方案

利用dom4j解析xml首先要把dom4j-1.6.1.jar和jaxen-1.1-beta-6.jar这2个jar包拷贝到项目的lib目录下，并配置build path。把xml文件也拷贝到项目中，根据xml的格式创建相对应的Point实体类，然后编写BeanFactory类去解析xml文件。

1.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：编写Point实体类

创建一个java项目，创建包，包中创建一个类Point，根据xml的格式编写类的属性，并复写toString方法。代码如下所示：

  1. package tarena.gsd;
  2. //所有的类都一个类对象，其类型为Class类型
  3. public class Point {//Point.class
  5.     private int x;//也是对象,类型为Field类型
  6.     private int y;
  7.     
  8.     public double distance(Point point){
  9.        int a=x-point.x;
  10.        int b=y-point.y;
  11.        return Math.sqrt(a*a+b*b);
  12.     }
  14.     @Override
  15.     public String toString() {
  16.         return "Point [x=" + x + ", y=" + y + "]";
  17.     }
  18.     
  19. }

步骤二：编写BeanFactory类

编写BeanFactory类，用于解析xml文件，在类中定义2个静态的属性，类型是Map，用于存放解析元素的key和value值。代码如下：

  1. package tarena.gsd;
  2. import java.io.FileNotFoundException;
  3. import java.lang.reflect.Field;
  4. import java.util.HashMap;
  5. import java.util.Iterator;
  6. import java.util.List;
  7. import java.util.Map;
  8. import java.util.Map.Entry;
  9. import java.util.Set;
  11. import org.dom4j.Document;
  12. import org.dom4j.DocumentException;
  13. import org.dom4j.Element;
  14. import org.dom4j.Node;
  15. import org.dom4j.io.SAXReader;
  17. public class BeanFactory {// 工厂
  18.     /**
  19.      * 借助此类读取beans.xml文件（类加载时读取） 并将文件中的内容封装到Map集合中 要求： key:为name属性对应的值
  20.      * value:class属性对应的值
  21.      */
  22.     private static Map<String, String> beanMap = new HashMap<String, String>();
  23.     // key:bean的name属性值
  24.     // value:bean中的参数
  25.     private static Map<String, Map<String, String>> paramMap = new HashMap<String, Map<String, String>>();
  26.     // 当类中有多个静态属性(类变量)或静态代码块时
  27.     
  28. }

步骤三：编写newInstance方法

在BeanFactory类中编写一个newInstance方法，返回值类型是Object，参数是1个String型变量，方法中根据传入的值，用反射创建对象，并用map的值构建对象属性，最后把对象返回。代码如下：

  1. package tarena.gsd;
  2. import java.io.FileNotFoundException;
  3. import java.lang.reflect.Field;
  4. import java.util.HashMap;
  5. import java.util.Iterator;
  6. import java.util.List;
  7. import java.util.Map;
  8. import java.util.Map.Entry;
  9. import java.util.Set;
  11. import org.dom4j.Document;
  12. import org.dom4j.DocumentException;
  13. import org.dom4j.Element;
  14. import org.dom4j.Node;
  15. import org.dom4j.io.SAXReader;
  17. public class BeanFactory {// 工厂
  18.     /**
  19.      * 借助此类读取beans.xml文件（类加载时读取） 并将文件中的内容封装到Map集合中 要求： key:为name属性对应的值
  20.      * value:class属性对应的值
  21.      */
  22.     private static Map<String, String> beanMap = new HashMap<String, String>();
  23.     // key:bean的name属性值
  24.     // value:bean中的参数
  25.     private static Map<String, Map<String, String>> paramMap = new HashMap<String, Map<String, String>>();
  26.     
  28.     public static Object newInstance(String key) throws Exception {
  29.         // 通过反射构建类的对象
  30.         Class<?> c = Class.forName(beanMap.get(key));// 类对象
  31.         Object obj = c.newInstance();// 构建类的对象
  32.         // 通过反射给类的属性赋值
  33.         Map<String, String> params = paramMap.get(key);
  34.         // 遍历Map(首先应将map转换为set)
  35.         Set<Entry<String, String>> es = params.entrySet();
  36.         // 遍历set
  37.         for (Entry<String, String> e : es) {
  38.             // 通过类对象获得属性对象
  39.             Field f = c.getDeclaredField(e.getKey());
  40.             // 设置属性对象可访问
  41.             f.setAccessible(true);// 设置属性可访问
  42.             // 给obj对象的f属性赋值
  43.             f.set(obj, Integer.valueOf(e.getValue()));
  44.         }
  45.         return obj;
  46.     }
  48. }

步骤四：编写parse方法

在BeanFactory类中编写一个parse方法，返回值类型是Document，参数是1个String型变量，方法中根据传入的值，把传入的文件转换为Document对象并返回。代码如下：

  1. package tarena.gsd;
  2. import java.io.FileNotFoundException;
  3. import java.lang.reflect.Field;
  4. import java.util.HashMap;
  5. import java.util.Iterator;
  6. import java.util.List;
  7. import java.util.Map;
  8. import java.util.Map.Entry;
  9. import java.util.Set;
  11. import org.dom4j.Document;
  12. import org.dom4j.DocumentException;
  13. import org.dom4j.Element;
  14. import org.dom4j.Node;
  15. import org.dom4j.io.SAXReader;
  17. public class BeanFactory {// 工厂
  18.     /**
  19.      * 借助此类读取beans.xml文件（类加载时读取） 并将文件中的内容封装到Map集合中 要求： key:为name属性对应的值
  20.      * value:class属性对应的值
  21.      */
  22.     private static Map<String, String> beanMap = new HashMap<String, String>();
  23.     // key:bean的name属性值
  24.     // value:bean中的参数
  25.     private static Map<String, Map<String, String>> paramMap = new HashMap<String, Map<String, String>>();
  26.     // alt+shift+m (快速提取代码块为方法)
  27.     private static Document parse(String fileName) throws DocumentException,
  28.             FileNotFoundException {
  29.         // 1.构建解析器对象
  30.         SAXReader r = new SAXReader();
  31.         // 2.解析文件
  32.         // return r.read(
  33.         // new FileInputStream(fileName));
  34.         return r.read(BeanFactory.class.// 获得类对象
  35.                 getClassLoader(). // 类加载器对象(负责将类读到内存的对象)
  36.                 getResourceAsStream(fileName));// 从类路径读取
  37.     }
  39.     public static Object newInstance(String key) throws Exception {
  40.         // 通过反射构建类的对象
  41.         Class<?> c = Class.forName(beanMap.get(key));// 类对象
  42.         Object obj = c.newInstance();// 构建类的对象
  43.         // 通过反射给类的属性赋值
  44.         Map<String, String> params = paramMap.get(key);
  45.         // 遍历Map(首先应将map转换为set)
  46.         Set<Entry<String, String>> es = params.entrySet();
  47.         // 遍历set
  48.         for (Entry<String, String> e : es) {
  49.             // 通过类对象获得属性对象
  50.             Field f = c.getDeclaredField(e.getKey());
  51.             // 设置属性对象可访问
  52.             f.setAccessible(true);// 设置属性可访问
  53.             // 给obj对象的f属性赋值
  54.             f.set(obj, Integer.valueOf(e.getValue()));
  55.         }
  56.         return obj;
  57.     }
  58. }

步骤五：编写processParams方法

在BeanFactory类中编写一个processParams方法。该方法无返回值类型，参数是1个Node类型变量,1个是 String型变量，方法中把传入的Node节点解析出来，根据String值放入对象的map中。代码如下：

  1. package tarena.gsd;
  2. import java.io.FileNotFoundException;
  3. import java.lang.reflect.Field;
  4. import java.util.HashMap;
  5. import java.util.Iterator;
  6. import java.util.List;
  7. import java.util.Map;
  8. import java.util.Map.Entry;
  9. import java.util.Set;
  11. import org.dom4j.Document;
  12. import org.dom4j.DocumentException;
  13. import org.dom4j.Element;
  14. import org.dom4j.Node;
  15. import org.dom4j.io.SAXReader;
  17. public class BeanFactory {// 工厂
  18.     /**
  19.      * 借助此类读取beans.xml文件（类加载时读取） 并将文件中的内容封装到Map集合中 要求： key:为name属性对应的值
  20.      * value:class属性对应的值
  21.      */
  22.     private static Map<String, String> beanMap = new HashMap<String, String>();
  23.     // key:bean的name属性值
  24.     // value:bean中的参数
  25.     private static Map<String, Map<String, String>> paramMap = new HashMap<String, Map<String, String>>();
  27.     private static void processParams(Node n, String key) {
  28.         Element e = (Element) n;
  29.         @SuppressWarnings("unchecked")
  30.         Iterator<Element> it = e.elementIterator("param");
  31.         Map<String, String> map1 = new HashMap<String, String>();
  32.         while (it.hasNext()) {
  33.             Element e1 = it.next();
  34.             String k = e1.attributeValue("name");
  35.             String v = e1.attributeValue("value");
  36.             map1.put(k, v);
  37.         }
  38.         paramMap.put(key, map1);
  39.     }
  41.     // alt+shift+m (快速提取代码块为方法)
  42.     private static Document parse(String fileName) throws DocumentException,
  43.             FileNotFoundException {
  44.         // 1.构建解析器对象
  45.         SAXReader r = new SAXReader();
  46.         // 2.解析文件
  47.         // return r.read(
  48.         // new FileInputStream(fileName));
  49.         return r.read(BeanFactory.class.// 获得类对象
  50.                 getClassLoader(). // 类加载器对象(负责将类读到内存的对象)
  51.                 getResourceAsStream(fileName));// 从类路径读取
  52.     }
  54.     public static Object newInstance(String key) throws Exception {
  55.         // 通过反射构建类的对象
  56.         Class<?> c = Class.forName(beanMap.get(key));// 类对象
  57.         Object obj = c.newInstance();// 构建类的对象
  58.         // 通过反射给类的属性赋值
  59.         Map<String, String> params = paramMap.get(key);
  60.         // 遍历Map(首先应将map转换为set)
  61.         Set<Entry<String, String>> es = params.entrySet();
  62.         // 遍历set
  63.         for (Entry<String, String> e : es) {
  64.             // 通过类对象获得属性对象
  65.             Field f = c.getDeclaredField(e.getKey());
  66.             // 设置属性对象可访问
  67.             f.setAccessible(true);// 设置属性可访问
  68.             // 给obj对象的f属性赋值
  69.             f.set(obj, Integer.valueOf(e.getValue()));
  70.         }
  71.         return obj;
  72.     }
  73. }

步骤六：编写processData方法

在BeanFactory类中编写一个processData方法，方法无返回值类型，参数是1个Document类型变量，在方法中把传入的Document对象解析出来，放入相应的map中。代码如下：

  1. package tarena.gsd;
  2. import java.io.FileNotFoundException;
  3. import java.lang.reflect.Field;
  4. import java.util.HashMap;
  5. import java.util.Iterator;
  6. import java.util.List;
  7. import java.util.Map;
  8. import java.util.Map.Entry;
  9. import java.util.Set;
  11. import org.dom4j.Document;
  12. import org.dom4j.DocumentException;
  13. import org.dom4j.Element;
  14. import org.dom4j.Node;
  15. import org.dom4j.io.SAXReader;
  17. public class BeanFactory {// 工厂
  18.     /**
  19.      * 借助此类读取beans.xml文件（类加载时读取） 并将文件中的内容封装到Map集合中 要求： key:为name属性对应的值
  20.      * value:class属性对应的值
  21.      */
  22.     private static Map<String, String> beanMap = new HashMap<String, String>();
  23.     // key:bean的name属性值
  24.     // value:bean中的参数
  25.     private static Map<String, Map<String, String>> paramMap = new HashMap<String, Map<String, String>>();
  26.     // 当类中有多个静态属性(类变量)或静态代码块时
  27.     // 其执行顺序是从上到下
  29.     private static void processData(Document doc) {
  30.         // 3.处理数据
  31.         // 3.1获得所有的Bean节点
  32.         @SuppressWarnings("unchecked")
  33.         List<Node> nodes = doc.selectNodes("/beans/bean");// xpath
  34.         // 3.2遍历Bean节点，取出每个节点的内容封装到Map
  35.         for (Node n : nodes) {
  36.             String key = n.valueOf("@name");
  37.             String value = n.valueOf("@class");
  38.             beanMap.put(key, value);
  39.             processParams(n, key);
  40.         }
  41.     }
  43.     private static void processParams(Node n, String key) {
  44.         Element e = (Element) n;
  45.         @SuppressWarnings("unchecked")
  46.         Iterator<Element> it = e.elementIterator("param");
  47.         Map<String, String> map1 = new HashMap<String, String>();
  48.         while (it.hasNext()) {
  49.             Element e1 = it.next();
  50.             String k = e1.attributeValue("name");
  51.             String v = e1.attributeValue("value");
  52.             map1.put(k, v);
  53.         }
  54.         paramMap.put(key, map1);
  55.     }
  57.     // alt+shift+m (快速提取代码块为方法)
  58.     private static Document parse(String fileName) throws DocumentException,
  59.             FileNotFoundException {
  60.         // 1.构建解析器对象
  61.         SAXReader r = new SAXReader();
  62.         // 2.解析文件
  63.         // return r.read(
  64.         // new FileInputStream(fileName));
  65.         return r.read(BeanFactory.class.// 获得类对象
  66.                 getClassLoader(). // 类加载器对象(负责将类读到内存的对象)
  67.                 getResourceAsStream(fileName));// 从类路径读取
  68.     }
  70.     public static Object newInstance(String key) throws Exception {
  71.         // 通过反射构建类的对象
  72.         Class<?> c = Class.forName(beanMap.get(key));// 类对象
  73.         Object obj = c.newInstance();// 构建类的对象
  74.         // 通过反射给类的属性赋值
  75.         Map<String, String> params = paramMap.get(key);
  76.         // 遍历Map(首先应将map转换为set)
  77.         Set<Entry<String, String>> es = params.entrySet();
  78.         // 遍历set
  79.         for (Entry<String, String> e : es) {
  80.             // 通过类对象获得属性对象
  81.             Field f = c.getDeclaredField(e.getKey());
  82.             // 设置属性对象可访问
  83.             f.setAccessible(true);// 设置属性可访问
  84.             // 给obj对象的f属性赋值
  85.             f.set(obj, Integer.valueOf(e.getValue()));
  86.         }
  87.         return obj;
  88.     }
  90.     public static void main(String[] args) throws Exception {
  91.         // System.out.println(map);
  92.         // System.out.println(paramMap);
  93.         Point p = (Point) BeanFactory.newInstance("point");
  94.         System.out.println(p);
  95.     }
  96. }

步骤七：编写loadBeans方法

在BeanFactory类中编写一个loadBeans方法，方法无返回值类型，参数是1个String类型变量，在方法中调用parse方法把传入的String变量传入方法，获取Document对象，再调用processData把Document对象放入。代码如下：

  1. package tarena.gsd;
  2. import java.io.FileNotFoundException;
  3. import java.lang.reflect.Field;
  4. import java.util.HashMap;
  5. import java.util.Iterator;
  6. import java.util.List;
  7. import java.util.Map;
  8. import java.util.Map.Entry;
  9. import java.util.Set;
  11. import org.dom4j.Document;
  12. import org.dom4j.DocumentException;
  13. import org.dom4j.Element;
  14. import org.dom4j.Node;
  15. import org.dom4j.io.SAXReader;
  17. public class BeanFactory {// 工厂
  18.     /**
  19.      * 借助此类读取beans.xml文件（类加载时读取） 并将文件中的内容封装到Map集合中 要求： key:为name属性对应的值
  20.      * value:class属性对应的值
  21.      */
  22.     private static Map<String, String> beanMap = new HashMap<String, String>();
  23.     // key:bean的name属性值
  24.     // value:bean中的参数
  25.     private static Map<String, Map<String, String>> paramMap = new HashMap<String, Map<String, String>>();
  27.     // 此方法将读取的内容封装到map
  28.     private static void loadBeans(String fileName) throws Exception {
  29.         // 解析文件
  30.         Document doc = parse(fileName);
  31.         // 处理数据
  32.         processData(doc);
  33.     }
  35.     private static void processData(Document doc) {
  36.         // 3.处理数据
  37.         // 3.1获得所有的Bean节点
  38.         @SuppressWarnings("unchecked")
  39.         List<Node> nodes = doc.selectNodes("/beans/bean");// xpath
  40.         // 3.2遍历Bean节点，取出每个节点的内容封装到Map
  41.         for (Node n : nodes) {
  42.             String key = n.valueOf("@name");
  43.             String value = n.valueOf("@class");
  44.             beanMap.put(key, value);
  45.             processParams(n, key);
  46.         }
  47.     }
  49.     private static void processParams(Node n, String key) {
  50.         Element e = (Element) n;
  51.         @SuppressWarnings("unchecked")
  52.         Iterator<Element> it = e.elementIterator("param");
  53.         Map<String, String> map1 = new HashMap<String, String>();
  54.         while (it.hasNext()) {
  55.             Element e1 = it.next();
  56.             String k = e1.attributeValue("name");
  57.             String v = e1.attributeValue("value");
  58.             map1.put(k, v);
  59.         }
  60.         paramMap.put(key, map1);
  61.     }
  63.     // alt+shift+m (快速提取代码块为方法)
  64.     private static Document parse(String fileName) throws DocumentException,
  65.             FileNotFoundException {
  66.         // 1.构建解析器对象
  67.         SAXReader r = new SAXReader();
  68.         // 2.解析文件
  69.         // return r.read(
  70.         // new FileInputStream(fileName));
  71.         return r.read(BeanFactory.class.// 获得类对象
  72.                 getClassLoader(). // 类加载器对象(负责将类读到内存的对象)
  73.                 getResourceAsStream(fileName));// 从类路径读取
  74.     }
  76.     public static Object newInstance(String key) throws Exception {
  77.         // 通过反射构建类的对象
  78.         Class<?> c = Class.forName(beanMap.get(key));// 类对象
  79.         Object obj = c.newInstance();// 构建类的对象
  80.         // 通过反射给类的属性赋值
  81.         Map<String, String> params = paramMap.get(key);
  82.         // 遍历Map(首先应将map转换为set)
  83.         Set<Entry<String, String>> es = params.entrySet();
  84.         // 遍历set
  85.         for (Entry<String, String> e : es) {
  86.             // 通过类对象获得属性对象
  87.             Field f = c.getDeclaredField(e.getKey());
  88.             // 设置属性对象可访问
  89.             f.setAccessible(true);// 设置属性可访问
  90.             // 给obj对象的f属性赋值
  91.             f.set(obj, Integer.valueOf(e.getValue()));
  92.         }
  93.         return obj;
  94.     }
  96.     public static void main(String[] args) throws Exception {
  97.         // System.out.println(map);
  98.         // System.out.println(paramMap);
  99.         Point p = (Point) BeanFactory.newInstance("point");
  100.         System.out.println(p);
  101.     }
  102. }

步骤八：静态加载

在BeanFactory类中编写一个静态代码块，代码块中调用loadBeans方法，去加载xml文件。代码如下：

  1. package tarena.gsd;
  2. import java.io.FileNotFoundException;
  3. import java.lang.reflect.Field;
  4. import java.util.HashMap;
  5. import java.util.Iterator;
  6. import java.util.List;
  7. import java.util.Map;
  8. import java.util.Map.Entry;
  9. import java.util.Set;
  11. import org.dom4j.Document;
  12. import org.dom4j.DocumentException;
  13. import org.dom4j.Element;
  14. import org.dom4j.Node;
  15. import org.dom4j.io.SAXReader;
  17. public class BeanFactory {// 工厂
  18.     /**
  19.      * 借助此类读取beans.xml文件（类加载时读取） 并将文件中的内容封装到Map集合中 要求： key:为name属性对应的值
  20.      * value:class属性对应的值
  21.      */
  22.     private static Map<String, String> beanMap = new HashMap<String, String>();
  23.     // key:bean的name属性值
  24.     // value:bean中的参数
  25.     private static Map<String, Map<String, String>> paramMap = new HashMap<String, Map<String, String>>();
  26.     // 当类中有多个静态属性(类变量)或静态代码块时
  27.     // 其执行顺序是从上到下
  28.     static {
  29.         try {
  30.             loadBeans("beans.xml");
  31.         } catch (Exception e) {
  32.             e.printStackTrace();
  33.         }
  34.     }
  36.     // 此方法将读取的内容封装到map
  37.     private static void loadBeans(String fileName) throws Exception {
  38.         // 解析文件
  39.         Document doc = parse(fileName);
  40.         // 处理数据
  41.         processData(doc);
  42.     }
  44.     private static void processData(Document doc) {
  45.         // 3.处理数据
  46.         // 3.1获得所有的Bean节点
  47.         @SuppressWarnings("unchecked")
  48.         List<Node> nodes = doc.selectNodes("/beans/bean");// xpath
  49.         // 3.2遍历Bean节点，取出每个节点的内容封装到Map
  50.         for (Node n : nodes) {
  51.             String key = n.valueOf("@name");
  52.             String value = n.valueOf("@class");
  53.             beanMap.put(key, value);
  54.             processParams(n, key);
  55.         }
  56.     }
  58.     private static void processParams(Node n, String key) {
  59.         Element e = (Element) n;
  60.         @SuppressWarnings("unchecked")
  61.         Iterator<Element> it = e.elementIterator("param");
  62.         Map<String, String> map1 = new HashMap<String, String>();
  63.         while (it.hasNext()) {
  64.             Element e1 = it.next();
  65.             String k = e1.attributeValue("name");
  66.             String v = e1.attributeValue("value");
  67.             map1.put(k, v);
  68.         }
  69.         paramMap.put(key, map1);
  70.     }
  72.     // alt+shift+m (快速提取代码块为方法)
  73.     private static Document parse(String fileName) throws DocumentException,
  74.             FileNotFoundException {
  75.         // 1.构建解析器对象
  76.         SAXReader r = new SAXReader();
  77.         // 2.解析文件
  78.         // return r.read(
  79.         // new FileInputStream(fileName));
  80.         return r.read(BeanFactory.class.// 获得类对象
  81.                 getClassLoader(). // 类加载器对象(负责将类读到内存的对象)
  82.                 getResourceAsStream(fileName));// 从类路径读取
  83.     }
  85.     public static Object newInstance(String key) throws Exception {
  86.         // 通过反射构建类的对象
  87.         Class<?> c = Class.forName(beanMap.get(key));// 类对象
  88.         Object obj = c.newInstance();// 构建类的对象
  89.         // 通过反射给类的属性赋值
  90.         Map<String, String> params = paramMap.get(key);
  91.         // 遍历Map(首先应将map转换为set)
  92.         Set<Entry<String, String>> es = params.entrySet();
  93.         // 遍历set
  94.         for (Entry<String, String> e : es) {
  95.             // 通过类对象获得属性对象
  96.             Field f = c.getDeclaredField(e.getKey());
  97.             // 设置属性对象可访问
  98.             f.setAccessible(true);// 设置属性可访问
  99.             // 给obj对象的f属性赋值
  100.             f.set(obj, Integer.valueOf(e.getValue()));
  101.         }
  102.         return obj;
  103.     }
  105.     public static void main(String[] args) throws Exception {
  106.         // System.out.println(map);
  107.         // System.out.println(paramMap);
  108.         Point p = (Point) BeanFactory.newInstance("point");
  109.         System.out.println(p);
  110.     }
  111. }

1.4 完整代码

本案例Point类的完整代码如下所示：

代码

本案例客户端的完整代码如下所示：

代码

2 实现群聊天室

2.1 问题

要求编写一个Android程序，界面如图-1所示：

图-1

点击连接按钮后可以建立与服务器连接，连接后点击发送可以把发送的文本显示在所有连接客户端的ListView中，实现类似群聊的功能。

2.2 方案

先编写服务器程序，使用Vector 对象来存储所有连接上的客户端，使用ServerSocket来监听客户端连接，连接成功后存放入Vector中，在创建一个线程用于读取客户发送消息，并遍历Vector，把消息发送给所有客户端。

再编写Android客户端，按照界面要求编写界面，再编写Activity，在点击连接按钮后开启新线程，再使用Socket与服务端建立连接。在点击发送按钮后开启新线程，把输入框内容发送给服务端。在主程序中再开启一个新线程用于接收服务端发送过来的消息，并显示在ListView中。

2.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：编写布局文件

创建Android项目，相对布局编写布局文件，布局文件中放入2个EditText，2个按钮和1个ListView。代码如下所示：

  1. <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
  2.     xmlns:tools="http://schemas.android.com/tools"
  3.     android:layout_width="match_parent"
  4.     android:layout_height="match_parent"
  5.     tools:context=".MainActivity" >
  7.     <LinearLayout
  8.         android:id="@+id/linearLayout1"
  9.         android:layout_width="wrap_content"
  10.         android:layout_height="wrap_content"
  11.         android:layout_alignParentLeft="true"
  12.         android:layout_alignParentRight="true"
  13.         android:layout_alignParentTop="true" >
  15.         <EditText
  16.             android:id="@+id/nickname"
  17.             android:layout_width="0dp"
  18.             android:layout_height="wrap_content"
  19.             android:layout_weight="1"
  20.             android:ems="10"
  21.             android:enabled="false">
  23.             <requestFocus />
  24.         </EditText>
  26.         <Button
  27.             android:id="@+id/connect"
  28.             android:layout_width="wrap_content"
  29.             android:layout_height="wrap_content"
  30.             android:onClick="doClick"
  31.             android:text="建立连接" />
  32.     </LinearLayout>
  34.     <ListView
  35.         android:id="@+id/listView"
  36.         android:layout_width="match_parent"
  37.         android:layout_height="wrap_content"
  38.         android:layout_above="@+id/LinearLayout01"
  39.         android:layout_alignParentLeft="true"
  40.         android:layout_below="@+id/linearLayout1" >
  42.     </ListView>
  44.     <LinearLayout
  45.         android:id="@+id/LinearLayout01"
  46.         android:layout_width="wrap_content"
  47.         android:layout_height="wrap_content"
  48.         android:layout_alignParentBottom="true"
  49.         android:layout_alignParentLeft="true"
  50.         android:layout_alignParentRight="true" >
  52.         <EditText
  53.             android:id="@+id/text"
  54.             android:layout_width="0dp"
  55.             android:layout_height="wrap_content"
  56.             android:layout_weight="1"
  57.             android:ems="10"
  58.             android:hint="请输入发送文本" />
  60.         <Button
  61.             android:id="@+id/send"
  62.             android:layout_width="wrap_content"
  63.             android:onClick="doClick"
  64.             android:layout_height="wrap_content"
  65.             android:text="发送" />
  66.     </LinearLayout>
  68. </RelativeLayout>

步骤二：编写MainActivity类

编写MainActivity类，类中编写一个init方法，方法中获取界面的所有控件，并赋值给成员变量。在onCreate方法中调用init。在定义一个Handler类型的成员变量，实例化这个变量，并复写handleMessage方法，在方法中使用switch语句处理不同的消息。代码如下所示：

  1. package com.tarena.thread_socket_day05_cookbook_02_client;
  3. import java.io.DataInputStream;
  4. import java.io.DataOutputStream;
  5. import java.io.IOException;
  6. import java.net.InetSocketAddress;
  7. import java.net.Socket;
  8. import java.net.SocketAddress;
  9. import java.util.ArrayList;
  10. import java.util.List;
  12. import android.os.Bundle;
  13. import android.os.Handler;
  14. import android.app.Activity;
  15. import android.view.Menu;
  16. import android.view.View;
  17. import android.widget.ArrayAdapter;
  18. import android.widget.Button;
  19. import android.widget.EditText;
  20. import android.widget.ListView;
  21. import android.widget.Toast;
  23. public class MainActivity extends Activity {
  24.     private EditText etNickname;
  25.     private EditText etText;
  26.     private Button connect;
  27.     private boolean isConnected;
  28.     private ListView lv; 
  29.     private List<String> messages=new ArrayList<String>();
  30.     private ArrayAdapter<String> adapter;
  31.     private Socket socket;
  32.     private DataInputStream is;
  33.     private DataOutputStream os;
  34.     
  35.     private Handler handler=new Handler(){
  36.         public void handleMessage(android.os.Message msg) {
  37.             switch (msg.what) {
  38.             case HANDLER_CONNECT_SUCCESS:
  39.                 connect.setText("连接已建立");
  40.                 etNickname.setText(socket.getInetAddress().toString());
  41.                 etNickname.setEnabled(false);
  42.                 connect.setEnabled(false);
  43.                 isConnected = true;
  44.                 //把messages中的数据呈现在listView中
  45.                 adapter=new ArrayAdapter<String>(MainActivity.this, android.R.layout.simple_list_item_1, messages);
  46.                 lv.setAdapter(adapter);
  47.                 // 启动读取服务端返回聊天记录的线程
  48.                 new Reader().start();
  49.                 break;
  50.                 
  51.             case HANDLER_RECEIVE_MESSAGE:
  52.                 adapter.notifyDataSetChanged();
  53.                 break;
  54.             
  55.             case HANDLER_CONNECT_TIMEOUT:
  56.                 Toast.makeText(MainActivity.this, "连接超时", Toast.LENGTH_SHORT).show();
  57.                 break;
  58.             }
  59.         }
  60.     };
  61.     
  62.     public static final int HANDLER_CONNECT_SUCCESS = 0;
  63.     public static final int HANDLER_RECEIVE_MESSAGE = 1;
  64.     public static final int HANDLER_CONNECT_TIMEOUT = 2;
  65.     
  66.     
  67.     @Override
  68.     protected void onCreate(Bundle savedInstanceState) {
  69.         super.onCreate(savedInstanceState);
  70.         setContentView(R.layout.activity_main);
  71.         init();
  72.     }
  74.     private void init() {
  75.         etNickname = (EditText) findViewById(R.id.nickname);
  76.         etText = (EditText) findViewById(R.id.text);
  77.         connect = (Button) findViewById(R.id.connect);
  78.         lv = (ListView) findViewById(R.id.listView);
  79.     }
  81.     
  83. }

步骤三：编写客户端读取线程类

编写一个内部类Reader继承自Thread，复写run方法，在方法中使用无限循环，不断读取服务器发来的信息，接收后发消息通知界面去更新。代码如下所示：

  1. package com.tarena.thread_socket_day05_cookbook_02_client;
  3. import java.io.DataInputStream;
  4. import java.io.DataOutputStream;
  5. import java.io.IOException;
  6. import java.net.InetSocketAddress;
  7. import java.net.Socket;
  8. import java.net.SocketAddress;
  9. import java.util.ArrayList;
  10. import java.util.List;
  12. import android.os.Bundle;
  13. import android.os.Handler;
  14. import android.app.Activity;
  15. import android.view.Menu;
  16. import android.view.View;
  17. import android.widget.ArrayAdapter;
  18. import android.widget.Button;
  19. import android.widget.EditText;
  20. import android.widget.ListView;
  21. import android.widget.Toast;
  23. public class MainActivity extends Activity {
  24.     private EditText etNickname;
  25.     private EditText etText;
  26.     private Button connect;
  27.     private boolean isConnected;
  28.     private ListView lv; 
  29.     private List<String> messages=new ArrayList<String>();
  30.     private ArrayAdapter<String> adapter;
  31.     private Socket socket;
  32.     private DataInputStream is;
  33.     private DataOutputStream os;
  34.     
  35.     private Handler handler=new Handler(){
  36.         public void handleMessage(android.os.Message msg) {
  37.             switch (msg.what) {
  38.             case HANDLER_CONNECT_SUCCESS:
  39.                 connect.setText("连接已建立");
  40.                 etNickname.setText(socket.getInetAddress().toString());
  41.                 etNickname.setEnabled(false);
  42.                 connect.setEnabled(false);
  43.                 isConnected = true;
  44.                 //把messages中的数据呈现在listView中
  45.                 adapter=new ArrayAdapter<String>(MainActivity.this, android.R.layout.simple_list_item_1, messages);
  46.                 lv.setAdapter(adapter);
  47.                 // 启动读取服务端返回聊天记录的线程
  48.                 new Reader().start();
  49.                 break;
  50.                 
  51.             case HANDLER_RECEIVE_MESSAGE:
  52.                 adapter.notifyDataSetChanged();
  53.                 break;
  54.             
  55.             case HANDLER_CONNECT_TIMEOUT:
  56.                 Toast.makeText(MainActivity.this, "连接超时", Toast.LENGTH_SHORT).show();
  57.                 break;
  58.             }
  59.         }
  60.     };
  61.     
  62.     public static final int HANDLER_CONNECT_SUCCESS = 0;
  63.     public static final int HANDLER_RECEIVE_MESSAGE = 1;
  64.     public static final int HANDLER_CONNECT_TIMEOUT = 2;
  65.     
  66.     
  67.     @Override
  68.     protected void onCreate(Bundle savedInstanceState) {
  69.         super.onCreate(savedInstanceState);
  70.         setContentView(R.layout.activity_main);
  71.         init();
  72.     }
  74.     private void init() {
  75.         etNickname = (EditText) findViewById(R.id.nickname);
  76.         etText = (EditText) findViewById(R.id.text);
  77.         connect = (Button) findViewById(R.id.connect);
  78.         lv = (ListView) findViewById(R.id.listView);
  79.     }
  82.     class Reader extends Thread {
  83.         public Reader() {
  84.         }
  86.         // 接收服务端输入进客户端的信息 并且显示在ListView中
  87.         public void run() {
  88.             try {
  89.                 while (isConnected) {
  90.                     String data = is.readUTF();
  91.                     //更新listView的数据源
  92.                     messages.add(data);
  93.                     //发消息给Handler 更新listview
  94.                     handler.sendEmptyMessage(HANDLER_RECEIVE_MESSAGE);
  95.                 }
  97.                 is.close();
  98.             } catch (IOException e) {
  99.                 e.printStackTrace();
  100.             } 
  101.         }
  102.     }
  104. }

步骤四：编写send方法

编写MainActivity中编写send方法，在方法中获取输入框内容，开启新线程把内容发送给服务端。代码如下所示：

  1. package com.tarena.thread_socket_day05_cookbook_02_client;
  3. import java.io.DataInputStream;
  4. import java.io.DataOutputStream;
  5. import java.io.IOException;
  6. import java.net.InetSocketAddress;
  7. import java.net.Socket;
  8. import java.net.SocketAddress;
  9. import java.util.ArrayList;
  10. import java.util.List;
  12. import android.os.Bundle;
  13. import android.os.Handler;
  14. import android.app.Activity;
  15. import android.view.Menu;
  16. import android.view.View;
  17. import android.widget.ArrayAdapter;
  18. import android.widget.Button;
  19. import android.widget.EditText;
  20. import android.widget.ListView;
  21. import android.widget.Toast;
  23. public class MainActivity extends Activity {
  24.     private EditText etNickname;
  25.     private EditText etText;
  26.     private Button connect;
  27.     private boolean isConnected;
  28.     private ListView lv; 
  29.     private List<String> messages=new ArrayList<String>();
  30.     private ArrayAdapter<String> adapter;
  31.     private Socket socket;
  32.     private DataInputStream is;
  33.     private DataOutputStream os;
  34.     
  35.     private Handler handler=new Handler(){
  36.         public void handleMessage(android.os.Message msg) {
  37.             switch (msg.what) {
  38.             case HANDLER_CONNECT_SUCCESS:
  39.                 connect.setText("连接已建立");
  40.                 etNickname.setText(socket.getInetAddress().toString());
  41.                 etNickname.setEnabled(false);
  42.                 connect.setEnabled(false);
  43.                 isConnected = true;
  44.                 //把messages中的数据呈现在listView中
  45.                 adapter=new ArrayAdapter<String>(MainActivity.this, android.R.layout.simple_list_item_1, messages);
  46.                 lv.setAdapter(adapter);
  47.                 // 启动读取服务端返回聊天记录的线程
  48.                 new Reader().start();
  49.                 break;
  50.                 
  51.             case HANDLER_RECEIVE_MESSAGE:
  52.                 adapter.notifyDataSetChanged();
  53.                 break;
  54.             
  55.             case HANDLER_CONNECT_TIMEOUT:
  56.                 Toast.makeText(MainActivity.this, "连接超时", Toast.LENGTH_SHORT).show();
  57.                 break;
  58.             }
  59.         }
  60.     };
  61.     
  62.     public static final int HANDLER_CONNECT_SUCCESS = 0;
  63.     public static final int HANDLER_RECEIVE_MESSAGE = 1;
  64.     public static final int HANDLER_CONNECT_TIMEOUT = 2;
  65.     
  66.     
  67.     @Override
  68.     protected void onCreate(Bundle savedInstanceState) {
  69.         super.onCreate(savedInstanceState);
  70.         setContentView(R.layout.activity_main);
  71.         init();
  72.     }
  74.     private void init() {
  75.         etNickname = (EditText) findViewById(R.id.nickname);
  76.         etText = (EditText) findViewById(R.id.text);
  77.         connect = (Button) findViewById(R.id.connect);
  78.         lv = (ListView) findViewById(R.id.listView);
  79.     }
  81.     //发送消息
  82.     private void send() {
  83.         if(!isConnected){
  84.             Toast.makeText(this, "请先建立连接", Toast.LENGTH_SHORT).show();
  85.             return;
  86.         }
  87.         //发送消息
  88.         //获取输出流输出  网络访问需要在工作线程中完成
  89.         new Thread(){
  90.             public void run() {
  91.                 try {
  92.                     String text=etText.getText().toString();
  93.                     os.writeUTF(text);
  94.                     os.flush();
  95.                 } catch (IOException e) {
  96.                     e.printStackTrace();
  97.                 }
  98.             }
  99.         }.start();
  100.     }
  101.     class Reader extends Thread {
  102.         public Reader() {
  103.         }
  105.         // 接收服务端输入进客户端的信息 并且显示在ListView中
  106.         public void run() {
  107.             try {
  108.                 while (isConnected) {
  109.                     String data = is.readUTF();
  110.                     //更新listView的数据源
  111.                     messages.add(data);
  112.                     //发消息给Handler 更新listview
  113.                     handler.sendEmptyMessage(HANDLER_RECEIVE_MESSAGE);
  114.                 }
  116.                 is.close();
  117.             } catch (IOException e) {
  118.                 e.printStackTrace();
  119.             } 
  120.         }
  121.     }
  123. }

步骤五：编写connect方法

编写MainActivity中编写connect方法，在方法中开启新线程，使用Socket对象建立与服务端连接。代码如下所示：

  1. package com.tarena.thread_socket_day05_cookbook_02_client;
  3. import java.io.DataInputStream;
  4. import java.io.DataOutputStream;
  5. import java.io.IOException;
  6. import java.net.InetSocketAddress;
  7. import java.net.Socket;
  8. import java.net.SocketAddress;
  9. import java.util.ArrayList;
  10. import java.util.List;
  12. import android.os.Bundle;
  13. import android.os.Handler;
  14. import android.app.Activity;
  15. import android.view.Menu;
  16. import android.view.View;
  17. import android.widget.ArrayAdapter;
  18. import android.widget.Button;
  19. import android.widget.EditText;
  20. import android.widget.ListView;
  21. import android.widget.Toast;
  23. public class MainActivity extends Activity {
  24.     private EditText etNickname;
  25.     private EditText etText;
  26.     private Button connect;
  27.     private boolean isConnected;
  28.     private ListView lv; 
  29.     private List<String> messages=new ArrayList<String>();
  30.     private ArrayAdapter<String> adapter;
  31.     private Socket socket;
  32.     private DataInputStream is;
  33.     private DataOutputStream os;
  34.     
  35.     private Handler handler=new Handler(){
  36.         public void handleMessage(android.os.Message msg) {
  37.             switch (msg.what) {
  38.             case HANDLER_CONNECT_SUCCESS:
  39.                 connect.setText("连接已建立");
  40.                 etNickname.setText(socket.getInetAddress().toString());
  41.                 etNickname.setEnabled(false);
  42.                 connect.setEnabled(false);
  43.                 isConnected = true;
  44.                 //把messages中的数据呈现在listView中
  45.                 adapter=new ArrayAdapter<String>(MainActivity.this, android.R.layout.simple_list_item_1, messages);
  46.                 lv.setAdapter(adapter);
  47.                 // 启动读取服务端返回聊天记录的线程
  48.                 new Reader().start();
  49.                 break;
  50.                 
  51.             case HANDLER_RECEIVE_MESSAGE:
  52.                 adapter.notifyDataSetChanged();
  53.                 break;
  54.             
  55.             case HANDLER_CONNECT_TIMEOUT:
  56.                 Toast.makeText(MainActivity.this, "连接超时", Toast.LENGTH_SHORT).show();
  57.                 break;
  58.             }
  59.         }
  60.     };
  61.     
  62.     public static final int HANDLER_CONNECT_SUCCESS = 0;
  63.     public static final int HANDLER_RECEIVE_MESSAGE = 1;
  64.     public static final int HANDLER_CONNECT_TIMEOUT = 2;
  65.     
  66.     
  67.     @Override
  68.     protected void onCreate(Bundle savedInstanceState) {
  69.         super.onCreate(savedInstanceState);
  70.         setContentView(R.layout.activity_main);
  71.         init();
  72.     }
  74.     private void init() {
  75.         etNickname = (EditText) findViewById(R.id.nickname);
  76.         etText = (EditText) findViewById(R.id.text);
  77.         connect = (Button) findViewById(R.id.connect);
  78.         lv = (ListView) findViewById(R.id.listView);
  79.     }
  80.     //发送消息
  81.     private void send() {
  82.         if(!isConnected){
  83.             Toast.makeText(this, "请先建立连接", Toast.LENGTH_SHORT).show();
  84.             return;
  85.         }
  86.         //发送消息
  87.         //获取输出流输出  网络访问需要在工作线程中完成
  88.         new Thread(){
  89.             public void run() {
  90.                 try {
  91.                     String text=etText.getText().toString();
  92.                     os.writeUTF(text);
  93.                     os.flush();
  94.                 } catch (IOException e) {
  95.                     e.printStackTrace();
  96.                 }
  97.             }
  98.         }.start();
  99.     }
  101.     // 建立连接
  102.     private void connect(){
  103.         //访问网络 须在工作线程
  104.         new Thread(){
  105.             public void run() {
  106.                 try {
  107.                     socket = new Socket();
  108.                     SocketAddress address=new InetSocketAddress("192.168.1.107", 9999);
  109.                     //3秒没有连接  将会抛出TimeOut异常
  110.                     socket.connect(address, 3000);
  111.                     is=new DataInputStream(socket.getInputStream());
  112.                     os=new DataOutputStream(socket.getOutputStream());
  113.                     //不出异常  连接建立成功发消息给handler
  114.                     handler.sendEmptyMessage(HANDLER_CONNECT_SUCCESS);
  115.                 } catch (IOException e) {
  116.                     e.printStackTrace();
  117.                     handler.sendEmptyMessage(HANDLER_CONNECT_TIMEOUT);
  118.                 }
  119.             }
  120.         }.start();
  121.     }
  122.     class Reader extends Thread {
  123.         public Reader() {
  124.         }
  126.         // 接收服务端输入进客户端的信息 并且显示在ListView中
  127.         public void run() {
  128.             try {
  129.                 while (isConnected) {
  130.                     String data = is.readUTF();
  131.                     //更新listView的数据源
  132.                     messages.add(data);
  133.                     //发消息给Handler 更新listview
  134.                     handler.sendEmptyMessage(HANDLER_RECEIVE_MESSAGE);
  135.                 }
  137.                 is.close();
  138.             } catch (IOException e) {
  139.                 e.printStackTrace();
  140.             } 
  141.         }
  142.     }
  144. }

步骤六：编写doClick方法

编写MainActivity中编写doClick方法，方法为按钮的点击处理方法，根据不同的按钮控件id，分别调用connect方法和send方法。代码如下所示：

  1. package com.tarena.thread_socket_day05_cookbook_02_client;
  3. import java.io.DataInputStream;
  4. import java.io.DataOutputStream;
  5. import java.io.IOException;
  6. import java.net.InetSocketAddress;
  7. import java.net.Socket;
  8. import java.net.SocketAddress;
  9. import java.util.ArrayList;
  10. import java.util.List;
  12. import android.os.Bundle;
  13. import android.os.Handler;
  14. import android.app.Activity;
  15. import android.view.Menu;
  16. import android.view.View;
  17. import android.widget.ArrayAdapter;
  18. import android.widget.Button;
  19. import android.widget.EditText;
  20. import android.widget.ListView;
  21. import android.widget.Toast;
  23. public class MainActivity extends Activity {
  24.     private EditText etNickname;
  25.     private EditText etText;
  26.     private Button connect;
  27.     private boolean isConnected;
  28.     private ListView lv; 
  29.     private List<String> messages=new ArrayList<String>();
  30.     private ArrayAdapter<String> adapter;
  31.     private Socket socket;
  32.     private DataInputStream is;
  33.     private DataOutputStream os;
  34.     
  35.     private Handler handler=new Handler(){
  36.         public void handleMessage(android.os.Message msg) {
  37.             switch (msg.what) {
  38.             case HANDLER_CONNECT_SUCCESS:
  39.                 connect.setText("连接已建立");
  40.                 etNickname.setText(socket.getInetAddress().toString());
  41.                 etNickname.setEnabled(false);
  42.                 connect.setEnabled(false);
  43.                 isConnected = true;
  44.                 //把messages中的数据呈现在listView中
  45.                 adapter=new ArrayAdapter<String>(MainActivity.this, android.R.layout.simple_list_item_1, messages);
  46.                 lv.setAdapter(adapter);
  47.                 // 启动读取服务端返回聊天记录的线程
  48.                 new Reader().start();
  49.                 break;
  50.                 
  51.             case HANDLER_RECEIVE_MESSAGE:
  52.                 adapter.notifyDataSetChanged();
  53.                 break;
  54.             
  55.             case HANDLER_CONNECT_TIMEOUT:
  56.                 Toast.makeText(MainActivity.this, "连接超时", Toast.LENGTH_SHORT).show();
  57.                 break;
  58.             }
  59.         }
  60.     };
  61.     
  62.     public static final int HANDLER_CONNECT_SUCCESS = 0;
  63.     public static final int HANDLER_RECEIVE_MESSAGE = 1;
  64.     public static final int HANDLER_CONNECT_TIMEOUT = 2;
  65.     
  66.     
  67.     @Override
  68.     protected void onCreate(Bundle savedInstanceState) {
  69.         super.onCreate(savedInstanceState);
  70.         setContentView(R.layout.activity_main);
  71.         init();
  72.     }
  74.     private void init() {
  75.         etNickname = (EditText) findViewById(R.id.nickname);
  76.         etText = (EditText) findViewById(R.id.text);
  77.         connect = (Button) findViewById(R.id.connect);
  78.         lv = (ListView) findViewById(R.id.listView);
  79.     }
  81.     public void doClick(View view) {
  82.         switch (view.getId()) {
  83.         case R.id.connect:
  84.             connect();
  85.             break;
  86.         
  87.         case R.id.send:
  88.             send();
  89.             break;
  90.         }
  91.     }
  92.     //发送消息
  93.     private void send() {
  94.         if(!isConnected){
  95.             Toast.makeText(this, "请先建立连接", Toast.LENGTH_SHORT).show();
  96.             return;
  97.         }
  98.         //发送消息
  99.         //获取输出流输出  网络访问需要在工作线程中完成
  100.         new Thread(){
  101.             public void run() {
  102.                 try {
  103.                     String text=etText.getText().toString();
  104.                     os.writeUTF(text);
  105.                     os.flush();
  106.                 } catch (IOException e) {
  107.                     e.printStackTrace();
  108.                 }
  109.             }
  110.         }.start();
  111.     }
  113.     // 建立连接
  114.     private void connect(){
  115.         //访问网络 须在工作线程
  116.         new Thread(){
  117.             public void run() {
  118.                 try {
  119.                     socket = new Socket();
  120.                     SocketAddress address=new InetSocketAddress("192.168.1.107", 9999);
  121.                     //3秒没有连接  将会抛出TimeOut异常
  122.                     socket.connect(address, 3000);
  123.                     is=new DataInputStream(socket.getInputStream());
  124.                     os=new DataOutputStream(socket.getOutputStream());
  125.                     //不出异常  连接建立成功发消息给handler
  126.                     handler.sendEmptyMessage(HANDLER_CONNECT_SUCCESS);
  127.                 } catch (IOException e) {
  128.                     e.printStackTrace();
  129.                     handler.sendEmptyMessage(HANDLER_CONNECT_TIMEOUT);
  130.                 }
  131.             }
  132.         }.start();
  133.     }
  135.     class Reader extends Thread {
  136.         public Reader() {
  137.         }
  139.         // 接收服务端输入进客户端的信息 并且显示在ListView中
  140.         public void run() {
  141.             try {
  142.                 while (isConnected) {
  143.                     String data = is.readUTF();
  144.                     //更新listView的数据源
  145.                     messages.add(data);
  146.                     //发消息给Handler 更新listview
  147.                     handler.sendEmptyMessage(HANDLER_RECEIVE_MESSAGE);
  148.                 }
  150.                 is.close();
  151.             } catch (IOException e) {
  152.                 e.printStackTrace();
  153.             } 
  154.         }
  155.     }
  157. }

步骤七：服务端程序

创建一个java项目作为服务端程序，创建包，包中创建类Server，类中使用定义一个Vector 对象来存储所有连接上的客户端，再使用ServerSocket来监听客户端连接，连接成功后存放入Vector中。再编写一个线程内部类，用于读取客户发送消息，并遍历Vector，把消息发送给所有客户端。再main方法中开始连接监听。代码如下所示：

  1. package tarena.gsd;
  3. import java.io.DataInputStream;
  4. import java.io.DataOutputStream;
  5. import java.io.IOException;
  6. import java.net.ServerSocket;
  7. import java.net.Socket;
  8. import java.util.Vector;
  10. public class Server {
  11.     //使用Vector保存客户端的所有连接   使用方式同ArrayList  优点：线程安全
  12.     private Vector<Client> clients=new Vector<Client>();
  13.     
  14.     public void startServer() throws IOException {
  15.         ServerSocket ss=new ServerSocket(9999);
  16.         //接收客户端请求
  17.         while(true){
  18.             Socket socket=ss.accept();
  19.             Client c=new Client(socket);
  20.             clients.add(c);
  21.             c.start();
  22.         }
  23.     }
  24.     
  25.     
  26.     public static void main(String[] args) throws IOException {
  27.         Server server=new Server();
  28.         server.startServer();
  29.     }
  30.     
  31.     class Client extends Thread{
  32.         Socket socket;
  33.         DataInputStream is;
  34.         DataOutputStream os;
  35.         
  36.         public Client(Socket socket) {
  37.             this.socket=socket;
  38.             try {
  39.                 this.is=new DataInputStream(socket.getInputStream());
  40.                 this.os=new DataOutputStream(socket.getOutputStream());
  41.             } catch (IOException e) {
  42.                 e.printStackTrace();
  43.             }
  44.         }
  46.         //start后    接收客户端传进的数据   并且把这些数据输出给每一个客户端
  47.         public void run() {
  48.             boolean isLoop=true;
  49.             while(isLoop){
  50.                 //接收客户端传来的数据
  51.                 try {
  52.                     String msg=is.readUTF();
  53.                     System.out.println(msg);
  54.                     //若用户输入的exit 则退出
  55.                     if(msg.equals("exit")){
  56.                         isLoop=false; //退出循环
  57.                         socket.close();
  58.                         clients.remove(this);
  59.                         return;
  60.                     }else{
  61.                         for(int i=0; i<clients.size(); i++){
  62.                             clients.get(i).os.writeUTF(socket.getInetAddress()+"\n"+msg);
  63.                         }
  64.                     }
  65.                 } catch (IOException e) {
  66.                     e.printStackTrace();
  67.                     break;
  68.                 }
  69.             }
  70.         }
  71.     }
  72. }

2.4 完整代码

本案例布局文件的完整代码如下所示：

代码

本案例MainActivity的完整代码如下所示：

代码

本案例服务端Server类的完整代码如下所示：

代码
0 0
常州科教城淘宝装修 常州科教城淘宝装修
原创粉丝点击
热门IT博客
centos 拷贝文件夹centos 拷贝文件夹
免费文件修复软件免费文件修复软件
登录知乎论坛
linux判断文件是否存在
微信小程取数组里的数
知行英语综合教程
linux中查看文件格式
新浪微博怎么去丢域名
男人至死都是少年 知乎
linux查看java进程命令
剑灵朱丽叶数据
vue.js react.js 对比
电视直播哪个软件最好
淘宝推广公司
jsp java代码
云南seo建站
mac vmware 文件共享
nba球队数据
淘宝账户被冻结怎么办
spss数据分析软件下载
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 太阳眼镜有划痕怎么办 眼镜腿胶套掉了怎么办 近视眼想当兵怎么办 这辈子完了怎么办 小孩子不想学习怎么办 小孩子想日人怎么办 小孩子想赚钱怎么办 义务兵不想当怎么办 中途不想当兵怎么办 当兵想媳妇怎么办 不想服兵役怎么办 2018不想当兵怎么办 想报效祖国怎么办 2018农村危房怎么办 坐月子很无聊怎么办 痛经总想拉大便怎么办 痛经特别严重怎么办 边防改革新兵怎么办 危险来临时怎么办 情绪很低落怎么办 找微信群找不到怎么办 婴儿裹手怎么办 孩子裹手怎么办 宝宝裹手怎么办 手机微手没有了怎么办 长期泡脚脚变黑怎么办 脚黑怎么办 当兵受不了怎么办 孩子上课调皮怎么办 挨打没有还手怎么办 有人故意找茬怎么办 消防改革新兵怎么办 驾驶证列入嫌疑怎么办 怎么办二手车营业执照 当兵后近视怎么办 师生发生冲突怎么办 部队复检不合格怎么办 轻度肾结石怎么办 双肾小结石怎么办 肝结石怎么办 肾结石支架血尿怎么办

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里