网络---中断套接字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 }