java网络编程是java非常重要的一个部分， 现在没啥程序是不联网的， 极少数程序是单机的外， 大部分都要连接网络， java的网络功能已经很强大， 同时由于java有非常庞大的开源社区，里面各种资源都有， 基本常见需要的网络等程序， 网络开发框架非常齐全， 通过java开发的网络程序也比较简单， 性能也不差。 能满足各种不同需求的。

另外网络编程也涉及很多java的基础知识， 对java流的读取方式， java的线程等等都要有很好的理解才能做好。

学习java的网络编程一方面可以学习网络知识，同时可以巩固前面学习的java等知识。

还是从网络上找个 网络编程的知识来， 可以简单看看， 能看明白多少都可以总之看来， 在今后工作中慢慢 加固就好！！

这里有两份 java网络编程的 视频， 都是比较好的！  前面一个 比较简洁， 快速的讲解了网络编程的 相关总体内容， 后面比较详细。

http://pan.baidu.com/s/1c08PIIc  eemv       马士兵的  网络编程， 比较好， 快速入门。

http://pan.baidu.com/s/1gdncWfh vp7f 传智播客毕向东Java基础视频教程- 网络基础知识， 这个讲的比较全面， 还是很值得一看的。

另外， 下面是从网络查找的java相关资料，也可以参考阅读。

Java网络编程菜鸟进阶：TCP和套接字入门

JDK 提供了对 TCP（Transmission Control Protocol，传输控制协议）和 UDP（User Datagram Protocol，用户数据报协议）这两个数据传输协议的支持。本文开始探讨 TCP。

TCP 基础知识

在“服务器-客户端”这种架构中，服务器和客户端各自维护一个端点，两个端点需要通过网络进行数据交换。TCP 为这种需求提供了一种可靠的流式连接，流式的意思是传出和收到的数据都是连续的字节，没有对数据量进行大小限制。一个端点由 IP 地址和端口构成（专业术语为“元组 {IP 地址, 端口}”）。这样，一个连接就可以由元组 {本地地址, 本地端口, 远程地址, 远程端口} 来表示。

连接过程

在 TCP 编程接口中，端点体现为 TCP 套接字。共有两种 TCP 套接字：主动和被动，“被动”状态也常被称为“侦听”状态。服务器和客户端利用套接字进行连接的过程如下：

1、服务器创建一个被动套接字，开始循环侦听客户端的连接。

2、客户端创建一个主动套接字，连接服务器。

3、服务器接受客户端的连接，并创建一个代表该连接的主动套接字。

4、服务器和客户端通过步骤 2 和 3 中创建的两个主动套接字进行数据传输。

下面是连接过程的图解：

一个简单的 TCP 服务器

JDK 提供了 ServerSocket 类来代表 TCP 服务器的被动套接字。下面的代码演示了一个简单的 TCP 服务器（多线程阻塞模式），它不断侦听并接受客户端的连接，然后将客户端发送过来的文本按行读取，全文转换为大写后返回给客户端，直到客户端发送文本行 bye：

public class TcpServer implements Runnable {
private ServerSocket serverSocket;

public TcpServer(int port) throws IOException {
// 创建绑定到某个端口的 TCP 服务器被动套接字。
serverSocket = new ServerSocket(port);
}

@Override
public void run() {
while (true) {
try {
// 以阻塞的方式接受一个客户端连接，返回代表该连接的主动套接字。
Socket socket = serverSocket.accept();
// 在新线程中处理客户端连接。
new Thread(new ClientHandler(socket)).start();
} catch (IOException ex) {
ex.printStackTrace();
}
}
}
}

public class ClientHandler implements Runnable {
private Socket socket;

public ClientHandler(Socket socket) {
this.socket = Objects.requireNonNull(socket);
}

@Override
public void run() {
try (Socket s = socket) { // 减少代码量的花招……
// 包装套接字的输入流以读取客户端发送的文本行。
BufferedReader in = new BufferedReader(new InputStreamReader(
s.getInputStream(), StandardCharsets.UTF_8));
// 包装套接字的输出流以向客户端发送转换结果。
PrintWriter out = new PrintWriter(new OutputStreamWriter(
s.getOutputStream(), StandardCharsets.UTF_8), true);

String line = null;
while ((line = in.readLine()) != null) {
if (line.equals("bye")) {
break;
}

// 将转换结果输出给客户端。
out.println(line.toUpperCase(Locale.ENGLISH));
}
} catch (IOException ex) {
ex.printStackTrace();
}
}
}

阻塞模式的编程方式简单，但存在性能问题，因为服务器线程会卡死在接受客户端的 accept() 方法上，不能有效利用资源。套接字支持非阻塞模式，现在暂时略过。

一个简单的 TCP 客户端

JDK 提供了 Socket 类来代表 TCP 客户端的主动套接字。下面的代码演示了上述服务器的客户端：

public class TcpClient implements Runnable {
private Socket socket;

public TcpClient(String host, int port) throws IOException {
// 创建连接到服务器的套接字。
socket = new Socket(host, port);
}

@Override
public void run() {
try (Socket s = socket) { // 再次减少代码量……
// 包装套接字的输出流以向服务器发送文本行。
PrintWriter out = new PrintWriter(new OutputStreamWriter(
s.getOutputStream(), StandardCharsets.UTF_8), true);
// 包装套接字的输入流以读取服务器返回的文本行。
BufferedReader in = new BufferedReader(new InputStreamReader(
s.getInputStream(), StandardCharsets.UTF_8));

Console console = System.console();
String line = null;
while ((line = console.readLine()) != null) {
if (line.equals("bye")) {
break;
}

// 将文本行发送给服务器。
out.println(line);
// 打印服务器返回的文本行。
console.writer().println(in.readLine());
}

// 通知服务器关闭连接。
out.println("bye");
} catch (IOException ex) {
ex.printStackTrace();
}
}
}

从 JDK 文档可以看到，ServerSocket 和 Socket 在初始化的时候，可以设定一些参数，还支持延迟绑定。这些东西对性能和行为都有所影响。后续两篇文章将分别详解这两个类的初始化。

另外推荐有时间可以查找一下netty的资料。

Netty是由JBOSS提供的一个java开源框架是做java网络开发的框架。Netty提供异步的、事件驱动的网络应用程序框架和工具，用以快速开发高性能、高可靠性的网络服务器和客户端程序。
也就是说，Netty 是一个基于NIO的客户，服务器端编程框架，使用Netty 可以确保你快速和简单的开发出一个网络应用，例如实现了某种协议的客户，服务端应用。Netty相当简化和流线化了网络应用的编程开发过程，例如，TCP和UDP的socket服务开发。
“快速”和“简单”并不意味着会让你的最终应用产生维护性或性能上的问题。Netty 是一个吸收了多种协议的实现经验，这些协议包括FTP,SMTP,HTTP，各种二进制，文本协议，并经过相当精心设计的项目，最终，Netty 成功的找到了一种方式，在保证易于开发的同时还保证了其应用的性能，稳定性和伸缩性。

推荐看：《Netty权威指南》这个本书， 前面一部分对java的io，网络模型有很好的介绍， 大家可以 到csdn的下载频道搜索， 下载。

下面的资料都是将来网络编程要涉及到的， 现在看看了解了解

Java NIO与IO的区别和比较

在Java7中NIO.2异步执行

Java NIO类库Selector机制解析

相关文章

从0开始学编程(22)-android开发环境搭建与入门教程

从0开始学编程(21)-Java网络编程入门

从0开始学编程(20)-Java线程入门

从0开始学编程(19)–java流概念入门

从0开始学编程(18)–java快速入门

从0开始学编程(17)–面向对象思想了解

从0开始学编程(16)–数据库加强

从0开始学编程(15)–总结篇-php编程强化巩固

从0开始学编程(14) – Php数据相关操作

从0开始学编程(13) Php获取form表单数据

从0开始学编程(12) 使用 eclipse的 php插件单步调试php程序

从0开始学编程(11) 使用 eclipse的 php插件 调试php程序

从0开始学编程(10) 用例子学习bootstrap的布局

从0开始学编程(9) – css、html和js简便工具

从0开始学编程(8) – 数据库简介

从0开始学编程(7) – 常用网站介绍

从0开始学编程(6)–在多了解一下php都涉及些啥东西

从0开始学编程(5)–方便的php编辑工具notepad++

从0开始学编程(4)–html基础入门

从0开始学编程(3)–学习必备的基础技能

从0开始学编程(2)–学习的方法和目标

从0开始学编程(1)–xampp配置php学习环境

线程是个非常重要的 概念， 在现在手机都是多核的系统了， 程序不支持多线程， 是不可现象的， 什么是多线程， 线程同进程是什么关系？

下面一个文章简单介绍了，线程和进程的基本概念， 比较有意思， 推荐大家看看！

进程与线程的一个简单解释

另外， 线程也是比较难懂的， 涉及到了很多东西， 但是从入门的角度将， 推荐一个马士兵的 教程， 大家可以通过这进行入门。
http://pan.baidu.com/s/1bn8jBTP j2ke 多线程基础入门

同时也可以参考下面的 一些从网络上找的资料来了解一下线程， 特别是主线程和工作者线程的概念。 常见的线程创建等等。

主线程

首先每个 Java 程序都是从主线程开始运行的，主线程就是执行 main() 方法的那个线程。在 main() 方法中获取当前线程很简单：

// 示例1
public static void main(String[] args) {
    Thread mainThread = Thread.currentThread();
    System.out.println("当前线程: " + mainThread.getName());
}

Thread 对象的文档在这里。Thread 对象包含很多方法和属性，除了上面例子当中的 name 属性外，还有状态、优先级等等。现在我们只需要知道 main() 方法是在主线程中运行就可以了。

线程是可以暂停的

我们通常使用 sleep() 方法来使线程在指定的时间内暂停执行。下面是一个在主线程中执行循环和暂停的例子：

// 示例2
public static void main(String[] args) {
    for (int i = 0; i < 10; i++) {
        System.out.println(i);

        try {
            Thread.sleep(500);    // 暂停线程
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

注意：首先，sleep() 方法是静态的，因为它永远只能用在当前的线程上；其次，sleep() 方法会抛出异常，该异常通常发生在暂停状态被打断时。所以这里用 try-catch 代码块包围起来。

sleep() 方法接受一个 long 类型的参数，指明需要暂停多少毫秒。这个例子当中，我们循环输出 i 变量，共循环 10 次，每输出一次就暂停 500 毫秒。

你可能觉得整个程序的运行时间会是精确的 5000 毫秒，但请千万不要这么认为，首先 sleep() 方法并非十分精确，CPU 在各个线程之间切换会要花掉很微量的一点时间，如果这个例子循环次数不是 10 次而是十万次百万次，那么积累的误差就会比较大了；其次，代码中的 System.out.println() 方法和 for 循环本身也要花掉一点时间，所以每次循环不会是绝对精确的 500 毫秒。

创建新的线程

除了主线程外，我们还可以创建和执行另外的线程。执行新线程的方式是调用该线程对象的 start() 方法。

// 示例3
public static void main(String[] args) {
    Thread thread1 = new Thread();
    thread1.start();    // 启动线程
}

从这个例子中我们可以看到，thread1 是一个通过 new Thread() 创建出来的对象。把线程看作是对象这点十分重要，这意味着我们可以创建 Thread 的子类，而子类的对象仍然是线程对象。执行这段代码什么输出都没有，因为我们没有为 thread1 定义要执行什么操作。下面的例子中，我们让 thread1 来做循环输出。

// 示例4
public static void main(String[] args) {

    Thread thread1 = new Thread() {

        @Override
        public void run() {               // 指定线程要做的事
            for (int i = 0; i < 10; i++) {
                System.out.println(i);

                try {
                    Thread.sleep(500);    // 暂停线程
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    };

    thread1.start();    // 启动线程
}

这里我们创建了一个 Thread 类的匿名子类，并覆写了 run() 方法。通过覆写 run() 方法，我们可以指定线程要做哪些事情。

线程之间没有父子关系
线程与线程之间是平等的，并没有父子关系。不过 Java 为了方便管理线程，定义了一个叫线程组（ThreadGroup）的类，线程组之间可以存在父子关系。不过这个概念平常用的很少，所以这里只是顺带提下，不作详细介绍。

线程是并行执行的

在示例4中，thread1 其实是与主线程并行执行的。为了演示这点，我们首先将这个循环提取成一个方法：

private static void printNumbers(int start, int end) {
    for (int i = start; i < end; i++) {
        System.out.println(i);

        try {
            Thread.sleep(500);    // 暂停线程
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

然后示例4就变成了：

public static void main(String[] args) {

    Thread thread1 = new Thread() {

        @Override
        public void run() {
            printNumbers(0, 10);  // 提取出来的方法
        }
    };

    thread1.start();    // 启动线程
}

我们在最后面添加一行，让主线程在启动 thread1 之后也做一个循环输出：

// 示例5
public static void main(String[] args) {

    Thread thread1 = new Thread() {

        @Override
        public void run() {
            printNumbers(0, 10);  // 循环输出
        }
    };

    thread1.start();        // 启动线程
    printNumbers(100, 110); // 主线程也循环输出
}

执行 main() 方法，在输出中你可以看到 0~9 与 100~109 交替出现，这说明主线程和 thread1 在同时执行。

将线程中的逻辑独立出来

为了使线程中的逻辑能够被重用，我们通常将其声明为一个独立的类。在前面的代码示例中，我们都是以匿名类的方式来创建线程的。独立声明一个线程类的方式是这样的：

// 示例6
public class MyThread extends Thread {

    private int start;
    private int end;

    // 构造方法
    public MyThread(int start, int end) {
        this.start = start;
        this.end = end;
    }

    @Override
    public void run() {
        printNumbers();
    }

    private void printNumbers() {
        for (int i = this.start; i < this.end; i++) {
            System.out.println(i);

            try {
                Thread.sleep(500);    // 暂停线程
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

在示例 6 中我们可以看到，执行这个线程所需的两个参数现在变成了 MyThread 的两个成员。这是我们向线程传递执行参数的一般方式。提取成独立的类之后，线程使用起来就非常简单了：

public static void main(String[] args) {
    new MyThread(0,10).start();
    new MyThread(100,110).start();
    new MyThread(1000,1010).start();
}

线程的返回值

我们有时候希望当线程执行完毕时，我们能得到一个结果。在示例 6 中我们了解了向线程传递参数的方式，类似的我们也可以为线程类定义一个成员用来保存线程的执行结果。下面是一个例子：

// 示例7
public class ThreadWithReturnValue extends Thread {

    public String result;

    @Override
    public void run() {
        try {
            Thread.sleep(3000);
            this.result = "result";  // 假设产生结果需要比较长的时间
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws Exception {
        ThreadWithReturnValue thread = new ThreadWithReturnValue();
        thread.start();
        Thread.sleep(3100);
        System.out.println(thread.result);  // 获得结果
    }
}

在这个例子当中，ThreadWithReturnValue 线程产生结果需要 3 秒钟，那么主线程就需要等待 3 秒以上才能得到 "result"，否则就只能得到 null。在实际情况中，我们并不知道线程产生结果需要多长时间，而我们也不想无限制的等下去。

出于这样的目的，Thread 对象为我们提供了 join() 方法，用于等待指定的线程直到执行完毕。示例 7 当中的 main() 方法可以改造成这样子：

public static void main(String[] args) throws Exception {
    ThreadWithReturnValue thread = new ThreadWithReturnValue();
    thread.start();
    thread.join();      // 等待直到 thread 执行完毕
    System.out.println(thread.result);
}

这样我们就能在线程执行完毕时立刻得到结果了。我们可以运行多个线程，然后依次调用它们的 join() 方法，这样等待的时间就是它们当中运行最久的那个线程的运行时间。当它运行完毕时，我们就得到所有线程的执行结果了。线程的入门概念就介绍到这里，本文只是介绍非常基本的概念，Java 在处理多线程和并发方面还有很多很复杂的东西等待你去了解和尝试。

相关文章

从0开始学编程(22)-android开发环境搭建与入门教程

从0开始学编程(21)-Java网络编程入门

从0开始学编程(20)-Java线程入门

从0开始学编程(19)–java流概念入门

从0开始学编程(18)–java快速入门

从0开始学编程(17)–面向对象思想了解

从0开始学编程(16)–数据库加强

从0开始学编程(15)–总结篇-php编程强化巩固

从0开始学编程(14) – Php数据相关操作

从0开始学编程(13) Php获取form表单数据

从0开始学编程(12) 使用 eclipse的 php插件单步调试php程序

从0开始学编程(11) 使用 eclipse的 php插件 调试php程序

从0开始学编程(10) 用例子学习bootstrap的布局

从0开始学编程(9) – css、html和js简便工具

从0开始学编程(8) – 数据库简介

从0开始学编程(7) – 常用网站介绍

从0开始学编程(6)–在多了解一下php都涉及些啥东西

从0开始学编程(5)–方便的php编辑工具notepad++

从0开始学编程(4)–html基础入门

从0开始学编程(3)–学习必备的基础技能

从0开始学编程(2)–学习的方法和目标

从0开始学编程(1)–xampp配置php学习环境