网络---中断套接字Socket

  1 package socketpack_2;
  2 import java.awt.BorderLayout;
  3 import java.awt.EventQueue;
  4 import java.awt.event.ActionEvent;
  5 import java.awt.event.ActionListener;
  6 import java.io.IOException;
  7 import java.io.OutputStream;
  8 import java.io.PrintWriter;
  9 import java.net.InetSocketAddress;
 10 import java.net.ServerSocket;
 11 import java.net.Socket;
 12 import java.nio.channels.SocketChannel;
 13 import java.util.Scanner;
 14 import javax.swing.JButton;
 15 import javax.swing.JFrame;
 16 import javax.swing.JPanel;
 17 import javax.swing.JScrollPane;
 18 import javax.swing.JTextArea;
 19 /**
 20  * 网络 -可中断套接字
 21  * @author Visec·Dana
 22  */
 23 public class InterruptibleSocketTest {
 24     public static void main(String[] args) {
 25         EventQueue.invokeLater(new Thread()
 26         {
 27             public void run(){
 28                 JFrame frame=new InterruptibleSocketFrame();
 29                 frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 30                 frame.setVisible(true);
 31 
 32             }
 33         }
 34                 );
 35     }
 36 }
 37 class InterruptibleSocketFrame extends JFrame{
 38     private static final long serialVersionUID = 1L;
 39     public InterruptibleSocketFrame(){
 40         setSize(WIDTH,HEIGHT);
 41         setTitle("InterruptibleSocketTest");
 42 
 43         JPanel northpJPanel =new JPanel();
 44         add(northpJPanel,BorderLayout.NORTH);
 45 
 46         messages=new JTextArea();
 47         add(new JScrollPane(messages)); 
 48         interruptilButton=new JButton("Interruptilbel");
 49         blockingButton=new JButton("Blocking");
 50 
 51         northpJPanel.add(interruptilButton);
 52         northpJPanel.add(blockingButton);
 53         interruptilButton.addActionListener(new ActionListener() {
 54             @Override
 55             public void actionPerformed(ActionEvent event){
 56                 interruptilButton.setEnabled(false);
 57                 blockingButton.setEnabled(false);
 58                 canncelButton.setEnabled(false);
 59                 connectThread=new Thread(new Runnable(){
 60                     @Override
 61                     public void run() {
 62                         try{
 63                             connectInterruptibly();
 64                         } catch (Exception e) {
 65                             messages.append("\nInterruptibleSocketTest.connectInterruptibly:\n"+e);
 66                         }
 67                     }
 68                 });
 69                 connectThread.start();
 70             }
 71         });
 72         blockingButton.addActionListener(new ActionListener() {
 73             @Override
 74             public void actionPerformed(ActionEvent e) {
 75                 interruptilButton.setEnabled(false);
 76                 blockingButton.setEnabled(false);
 77                 canncelButton.setEnabled(false);
 78                 connectThread=new Thread(new Runnable(){
 79                     @Override
 80                     public void run() {
 81                         try {
 82                             connectBlocking();
 83                         } catch (IOException e) {
 84                             messages.append("InterruptibleSocketTest.connectblocking"+e);
 85                         }
 86                     }
 87                 });
 88                 connectThread.start();
 89             }
 90         });
 91         
 92         canncelButton =new JButton("Cancel");
 93         canncelButton.setEnabled(false);
 94         northpJPanel.add(canncelButton);
 95         canncelButton.addActionListener(new ActionListener() {
 96             @Override
 97             public void actionPerformed(ActionEvent e) {
 98                 connectThread.interrupt();
 99                 canncelButton.setEnabled(false);
100                 
101             }
102         });
103         server =new TestServer();
104         new Thread(server).start();
105         
106     }
107     /**
108      * 连接到服务器  终端I/O流  Interruptible
109      * @throws IOException
110      */
111     public void connectInterruptibly()throws IOException{
112         messages.append("Interruptible:\n");
113         SocketChannel channel=SocketChannel.open(new InetSocketAddress("192.168.0.141", 514));
114         try {
115             in=new Scanner(channel);
116             while(!Thread.currentThread().isInterrupted()){
117                 messages.append("Reading");
118                 if(in.hasNextLine()){
119                     String line=in.nextLine();
120                     messages.append(line);
121                     messages.append("\n");
122                 }
123             }
124         }finally{
125             channel.close();
126             EventQueue.invokeLater(new Runnable() {
127                 @Override
128                 public void run() {
129                     messages.append("Channel closed\n");
130                     interruptilButton.setEnabled(true);
131                     blockingButton.setEnabled(true);
132                 }
133             });
134         }
135     }
136     /**
137      * 连接到服务器  终端I/O流  Blocking
138      * @throws IOException
139      */
140     public void connectBlocking()throws IOException{
141         messages.append("Blocking:\n\n");
142         Socket socket=new Socket("localhost",8189);
143         try {
144             in=new Scanner(socket.getInputStream());
145             while (!Thread.currentThread().isInterrupted()){
146                 if(in.hasNextLine()){
147                     String line=in.nextLine();
148                     messages.append(line);
149                     messages.append("\n");
150                 }
151             }
152         }finally{
153             socket.close();
154             EventQueue.invokeLater(new Runnable() {
155                 @Override
156                 public void run() {
157                     messages.append("Socket closed\n");
158                     interruptilButton.setEnabled(false);
159                 }
160             });
161         }
162     }
163     /**
164      * 测试服务器监听8189端口 并返回标示给客户端
165      */
166     class TestServer implements Runnable{
167         @Override
168         public void run() {
169             try {
170                 ServerSocket s=new ServerSocket(8189);
171                 while(true){
172                     Socket incoming=s.accept();
173                     Runnable r=new TestServerHandler(incoming);
174                     Thread t=new Thread(r);
175                     t.start();
176                 }
177             } catch (Exception e) {
178                 messages.append("\nTestServer.run:\n"+e);
179             }
180         }
181 
182     }
183     class TestServerHandler implements Runnable{
184         public TestServerHandler(Socket i){
185             incoming=i;
186         }
187         @Override
188         public void run() {
189             try {
190                 OutputStream outputStream=incoming.getOutputStream();
191                 PrintWriter out=new PrintWriter(outputStream,true/*autoFulsh*/);
192                 while(counter<=100){
193                     counter++;
194                     if(counter<=10) out.print(counter);
195                     Thread.sleep(100);
196                 }
197                 incoming.close();
198                 messages.append("Closing Server\n");
199             } catch (Exception e) {
200                 messages.append("\nTestServerHandler.run:\n"+e);
201             }
202 
203         }
204         private Socket incoming;
205         private int counter;
206     }
207 
208     private     Scanner in;
209     private  JTextArea messages=null; 
210     private  JButton interruptilButton,blockingButton,canncelButton;
211     private     Thread connectThread;
212     private TestServer server;
213 
214     public static final int WIDTH=550;
215     public static final int HEIGHT=400;
216 }