Let's Go!

发布新日志

  • java socket 实现服务端与客户端——最简练的实例

    2009-04-28 16:18:38

    //一对一的服务端和客户机:一个服务端只能同时服务一个客户端
    //服务端:

    import java.io.*;
    import java.net.*;

    public class MyServer {
     public static void main(String[] args) throws IOException{
         
         ServerSocket server=new ServerSocket(5678);
         Socket client=server.accept();
           
            BufferedReader in=new BufferedReader(new InputStreamReader(client.getInputStream()));
            PrintWriter ut=new PrintWriter(client.getOutputStream());
           
            while(true){
                     String str=in.readLine();
                    System.out.println(str);
                    out.println("has receive....");
                     out.flush();
                     if(str.equals("end"))
                             break;
                    }
                    client.close();
            }
    }

     

     

    //客户端
    import java.net.*;
    import java.io.*;

    public class Client{
     static Socket client;
     
     public static void main(String[] args)throws Exception{
      client=new Socket(InetAddress.getLocalHost(),5678);
             BufferedReader in=new BufferedReader(new InputStreamReader(client.getInputStream()));
             PrintWriter ut=new PrintWriter(client.getOutputStream());
             //标准输入
      BufferedReader wt=new BufferedReader(new InputStreamReader(System.in));
     
      while(true){
               String str=wt.readLine();
               //String str = "jonathan";
               out.println(str);
               out.flush();
               if(str.equals("end")){
                        break;
              }
               System.out.println(in.readLine());
      }
      client.close();
     }
    }

    可以参考PrintWriter的用法  方法:println(?)

    java.io
    类 PrintWriter

    java.lang.Object
      继承者 java.io.Writer
          继承者 java.io.PrintWriter
    
  • mldn的socket基础

    2009-04-28 00:27:23

    服务端

    import java.io.* ;
    import java.net.* ;
    import java.lang.*;

    public class TCPServer
    {
     public static void main(String args[]) throws Exception
     {
      try
      { 
       // 使用ServerSocket
       ServerSocket server = null ;
       // 每一个用户在程序中就是一个Socket
       Socket client = null ;
       server = new ServerSocket(8888) ;
       System.out.println("Server listen on :"+server.getLocalPort());
       
        boolean flag = true;
       
       
       while(flag)
         {
       
       // 等待客户端连接
       client = server.accept() ;
       // 向客户端打印信息:HELLO MLDN
       PrintWriter ut = null ;
       // 准备向客户端打印信息
       out = new PrintWriter(client.getOutputStream()) ;
       out.println("HELLO MLDN") ;
       
      
       
       
       out.close() ;
       client.close() ;
         } 
         server.close() ;
        
      }
      catch(Exception e)
          {
            System.out.println("Exception :"+e.getMessage());
           }
        
        
     }
    };

    客户端

    import java.io.* ;
    import java.net.* ;
    public class TCPClient
    {
     public static void main(String args[]) throws Exception
     {
      try
      {
       // 表示一个客户端的Socket
       Socket client = null ;
       // 表示一个客户端的输入信息
       BufferedReader buf = null ;
       client = new Socket("192.168.1.102",8888) ;
       
       
       buf = new BufferedReader(new InputStreamReader(client.getInputStream())) ;
       System.out.println(buf.readLine()) ;
       
       
       buf.close() ;
       client.close() ;
      }
      catch(Exception e)
      {
           System.out.println("错误信息;"+e.getMessage());
      } 
     }
    };

     

  • java基础复习笔记8,9,10

    2009-04-27 22:46:09

     

     

    Net包,对于网络连接

    Awt包

    swing包

     

    几种网络:E,D为保留网络

    V4

    W,x,y,z

    A:w从0~126 W代表网络,剩余代表本机

    B:128~191 w,x代表网络,剩余代表本机

    C:192~223 w,x,y代表网络,z代表本机

     

    应用程序需要一个或多个端口和外接连通

     

    80http协议端口

    8080tomcat

    1521oracle

    3306mysql

    1433sqlserver

     

    4000~5000安全

     

    Net包支持tcp和udp协议

     

    Tcp套接字

    serverSocket

    Sockect

     

    传出内容

    字符 文本文件 支持中文

    字节 传文件

     

    服务器端

    1.         开放端口ServerSocket s = new ServerSocket(要开放的端口号)//一个端口可同时用于收发

    如果端口号已用,报异常

    2.         Socket so = s.accept();监控端口,等待访问,创建一个Socket对象,用来收发操作

    3.         接受信息BufferedReader b = new BufferedReader(new InputStreamReader(so.getInputStream));

    建立管道

    4.b.realine();读取

    5.发送建立管道反馈。PrintStream p = new PrintStream(so.getOutPutStream());

    P.println();不要用print,另一端要读取

    6.关闭端口及流

    客户端

    1.         不用建ServerSocket,建Socket。

    Socket so = (服务器IP字符串,服务器端口号);默认用与服务器相同端口号。

    如果访问正常,继续。否则报异常。

    2. 发送建立管道PrintStream p = new PrintStream(so.getOutPutStream());

    P.println();不要用print

    3. 接受信息BufferedReader b = new BufferedReader(new InputStreamReader(so.getInputStream));建立管道。

    b.realine();读取

    4.关闭端口及流

     

    Netstat –a –n查看端口

     

    传送文件(现在这种方式不流行了)

    用Socket

    一个服务器,一个客户端

     

    建立连接

     

    1.       读取文件内容

    2.       FileInputStream f = new FileInputStream(“”);

    3.       DataInputStream df;

    4.       发送,每次2k

    5.       BufferedOutputStream bf = new

    6.       DataOutputStream do

    7.       while(i!=-1){

    do.write(b,0,i);

    I = df.read(b);

    }

    8.       接收文件,读取传来的内容

    9.       BufferedInputStream bi

    10.   DataInputStream di

    11.   写入文件,每次2k

    12.   FileOutputStream f = new FileInputStream(“”);

    13.   DataOutputStream df;

    14.    

    15.   while(i!=-1){

    df.write(b,0,i);

    I = di.read(b);

    }

     

    对各种流的总结:

     

    字符流

    输入根类reader

    输出根类writer

     

    输入

    低级流IntputStreamReader

    高级流BufferedReader

     

    文件

           输入

    低级流    FileReader

    高级流    BufferedReader

    输出

    低级流    FileWriter

    高级流    PrintWriter

     

    网络

    输出

    PrintStream p = new PrintStream(so.getOutputStream());

           输入

    BufferedReader b = new BufferedReader(new InputStreamReader(so.getInputStream()));

     

    控制台

    输入

    BufferedReader b = new BufferedReader(new InputStreamReader(System.in));

    输出

    System.out.println("服务器端说: " + value);

     

    字节流

    输入根类InputStream

    输出根类OutputStream

     

    文件

           输入

                  低级 FileInputStream;

                  高级

    二进制 DataInputStream

                         对象 ObjectInputStream

    输出

                  低级 fileOutputStream;

                  高级

    二进制 DataOutputStream

                         对象 ObjectOutputStream

     

    网络

    输出

    低级流

    BufferedOutputStream bo = new BufferedOutputStream(so.getOutputStream());

    高级流

    DataOutputStream dd = new DataOutputStream(bo);

    输入

    低级流

    BufferedInputStream b = new BufferedInputStream(so.getInputStream());

    高级流

    DataInputStream d = new DataInputStream(b);

     

    线程 每个线程完成应用程序的一个功能

     

    Thread t = Thread.currentThread();//该方法用来获取系统的当前线程。Thread类是线程的父类

     

    Thread [main,5,main]

    1.       所在线程组

    2.       默认优先级

    3.       当前线程名

     

    两种方法创建子线程

    1.  继承Thread 类,覆盖run()方法,功能都写进去

    2.  实现runable接口,实现run()方法

     

    T.start();

    Start()方法自动调用run()方法,run方法结束后死亡,run不允许向上抛异常

     

    创建 就绪 启动 运行

     

    Sleep(毫秒);//捕获异常

     

    线程

     

    创建 就绪启动(调用start方法,start自动调用run方法) 运行结束

     

    运行的四种情况

    1.  Sleep();

    2.  Yield();线程让出执行权;后面的都给让出,该线程排到最后

    3.  阻塞。因为IO和CPU引起

    4.  挂起。Wait();//挂

    Notify();//解

    这两种方法必须是同步的。

     

    同步,线程安全。

    同步:当一个对象调用同步方法时,第一个方法没执行完,第二个方法不会启动。

    同步方法:被关键字synchronized修饰

     

    Synchronized(对象){}同步块。里面的对象调用的方法全部同步。

    Wait();谁调用就挂谁

    Notify();挂过谁就解谁

     

    不要把线程类和实体类并在一起。

    public class one extends Thread {

           Ligong l = null;

    。。。}

    每个实体类需要多个run方法。

     

    Java线程优先级。

    有10级

    10~1

    10最高,1最低

    垃圾回收线程为1;

    默认为5.

     

    操作系统的优先级有6级。1和6是不给java用的。

    Java的优先级映射到操作系统

     

    1,2一级,3,4一级,5单个一级,6,7,8,9,10一级。这是对应的xp系统。

     

    Thread t1 = new One();//自定义类one继承自Thread,父类声明子类实例化

    One类覆盖了Thread类的run方法

     

    T1.GetPriority();获取优先级

     

    SetPriority(int);设置优先级

     

    优先级设高了报异常

     

    精灵线程(守护线程)

    主线程结束后,精灵线程还会运行

    垃圾回收就是精灵线程

     

    T1.isDaemon()判断是否精灵线程

    T1.setDaemon(true)设置为精灵线程

     

    实现runnable的类,而不是继承Thread的类,的启动方法

    Class One implements Runnable{

           Run(){}

    }

    One o = new One();

    Thread t1 = new Thread(o);//不能像之前那样实例化了

    Ti。Start();

     

    GUI图形界面

     

    AWT重量级

    包含窗体frame

    控件

    布局管理器

    事件

     

    Swing轻量级,扩展包

    窗体

    控件

     

    用swing的窗体和控件

    用awt的布局和事件

     

    AWT的窗口

    Frame. f = new Frame();

    F.setVisible(true);//显示

     

    SetSize(宽,高(单位像素));设置大小

     

    SetLocation(x,y);初始位置

     

    SetTitle(String);设置标题

     

    SetResizable(true);设置是否可以改变

     

    自己建一个窗体类

    Class MyFrame. extends Frame

    控件设为属性

    窗体设置放在构造方法中

     

    控件有:

    按钮Button

    This。Add(b);

    文本框 文本域 下拉菜单 单选 多选 标签

     

    布局

    默认为覆盖

     

    先设置布局,后添加控件

     

    FlowLayout f = new FlowLayout();

    This.setLayout(f);

     

    或者This.setLayout(new FlowLayout());

     

    三种常用布局

    1.       流式FlowLayout

    默认以居中对齐添加,控件大小以字符为标准

    2.       东南西北中

    BorderLayout

    可以指定添加的位置

    Add(bn,BorderLayout.NORTH);

    Add(bc,BorderLayout.CENTRE);

     

    3.       网格

    GridLayout

    分为表格

    如果建的多于表格数,行保持不变,列增加

    Button b[] = new Button[12];只是声明了,并没有实例

    4.       空布局

     

    Panel p = new Panel();看不见的容器

    P.setLayout(new GridLayout());

     

    文本框

    TestField t = new TestField();

    TestField t = new TestField(显示的字符数);

    T.setColumns(显示的字符数);

    SetEchoChar(‘*’)设置显示的字符,此处为输密码时使用

     

    setEditable(false)是否可编辑

     

    setTest(“”)

    getTest()

     

    GUI

     

    AWT

    窗体

    控件

           按钮Button

           文本框TextField

           标签Label

           下拉列表Choice

           单选CheckboxGroup

           多选Checkbox

           文本域TextArea

    布局

           流式FlowLayout

           东西南北中BorderLayout

    网格GridLayout

    事件

           单击

           鼠标

           窗体

           焦点

           键盘

           文本框改变

           下拉列表框

     

    TextField

    Button

    Label

    CheckBox//多选

     

    CheckBoxGroup//单选按钮组

    CheckBox(“”,g,true)//添加单选按钮(名称,所属按钮组,是否被选中)

     

    CheckboxGroup g = new CheckboxGroup();/

    Checkbox r1 = new Checkbox("男",g,true);

    Checkbox r2 = new Checkbox("女",g,true);

    如果有多个设置被选中,则后面的替换前面的,此例中r2被选中

     

    Choice

    c.add(“辽宁”);//第一个默认

    一般第一个都是“请选择”,防止懒人不选

     

    TextArea(行数,列数)

     

    事件类implements接口{

           方法(){

           事件源的功能

    }

    }

    1.  创建事件类对象

    2.  把该对象注册入事件源

     

    做成一个private修饰的内部类,因为他可以使用原类的属性

    或者原类直接implements接口,以后将自己添加进去就可以。

     

    可以为一个控件添加多个事件

     

    单击事件ActionListener

    Button b = new Button("ok");

    b.addActionListener(d);

     

    ActionPerformed(ActionEvent a)

     

    有两个以上控件同时使用该事件,触发不同的方法

    第一种方法:使用参数a处理,其中也有两种方法。

    1.         a.getActionCommand();//返回被点击按钮的字符,只适用于按钮

    比较字符确定点了那个按钮,只适用于按钮

    2.         a.getSourse();返回对象

    比较对象是否相等

     

    鼠标事件(5个方法)MouseListener

    Button bg = new Button("绿色");

    bg.addMouseListener(sg);

     

           mouseClicked单击事件

           mousePressed按下事件

           mouseReleased抬起事件

           mouseEntered移入

           mouseExited移出

     

    有两个以上控件同时使用该事件,触发不同的方法

    第二种方法:为每个控件添加不同的事件对象

    sbsj sg = new sbsj(Color.GREEN);

    sbsj sr = new sbsj(Color.RED);

     

    bg.addMouseListener(sg);

    br.addMouseListener(sr);

     

    窗体事件(七个方法)WindowListener

    this.addWindowListener(c);

     

           WindowOpened()//最先打开时

    WindowClosing()//点关闭按钮时调用

           windowClosed()//窗体使用dispose()关闭时会调用//dispose()就是关闭

           WindowIconfied()//最小化时

           WindowDeiconfied()//从最小化还原时

           WindowActivated()//活动时

    WindowDeactivated()//不活动时

     

    关闭窗体程序不退setVisibale()

    关闭则system。Exit(0);

     

    键盘事件KeyListener

    TextField t = new TextField(20);

    t.addKeyListener(j);

     

           keyPressed按下

                         char c = a.getKeyChar();

                         if(Character.isDigit(c)){

                                t.setText(t.getText()+c);

                         }//输入数字则显示,其它不显示

     

           keyReleased抬起

           keyTyped(KeyEvent a)从键盘输入一个字符

     

    下拉列表事件ItemListener

    Choice c = new Choice();

    c.addItemListener(x);

     

           itemStateChanged//选择时

     

    文本框改变事件TextListener

    TextField t  = new TextField(20);

    t.addTextListener(w);

     

    textValueChanged//内容改变时

           可以用在搜索技术上

     

    焦点事件FocusListener

    TextField tu = new TextField(26);

    tu.addFocusListener(j);

     

           focusGained获得焦点时

           focusLost失去焦点时

                  可以用来判断是否用户名重复,更加人性化

                  JOptionPane.showMessageDialog(this,v,"标题",i);

    //弹出对话框(从本对象弹出,提示内容,提示框标题,符号—比如3是问号)

                  tu.requestFocus();//该方法是用来获取焦点

                  tu.selectAll();//该方法用来全选内容

    http://blog.sina.com.cn/s/blog_46d5810901009pm0.html

  • java的io类,基础操作

    2009-04-27 22:29:01


    //字符流

    //从控制台输入字符,并打印出来

    import java.lang.*;
    import java.io.*;

    public class Datain
    {
     public static void main(String args[]) throws Exception
        {

          BufferedReader b = new BufferedReader(new InputStreamReader(System.in));
          String s  = b.readLine();
          System.out.println(s);
         }
    };

    // 字节流

     

  • java写的Socket客户端和服务端通信,经验证可以执行的代码,并添加了很多注释

    2009-04-27 18:19:44

        复杂的不是Socket本身,他的结构不复杂,主要是输入、输出流的加入,由于io类练习的少,所以理解上费了些事,这就是java基础薄弱的表现哦,缺乏java基础类的练习

    服务端:

     //package com.socket;

    import java.net.*;
    import java.io.*;
    import java.lang.*;

    public class TestSocketServer{
     
      public static void main(String args[])
      {
        try
        {
         boolean flag = true;
        
         Socket clientSocket = null;   
          //定义客户端套接字
         //JavaAPI 包java.net,找到Socket类,查看其包含的方法
         //Socket()
         //通过系统默认类型的 SocketImpl 创建未连接套接字
       
         String inputLine;
         int c;
        
         ServerSocket sSocket = new ServerSocket(8018);   
         // 创建绑定端口的服务端socket
         //JavaAPI 包java.net,找到ServerSocket类,查看其包含的方法
         //ServerSocket(int port)
         // 创建绑定到特定端口的服务器套接字。
            
         System.out.println("Server listen on :"+sSocket.getLocalPort());
           // int getLocalPort()  返回此套接字在其上侦听的端口。
       
       
       
        
         while(flag)
         {
          clientSocket = sSocket.accept();
          //Socket accept()
                // 侦听并接受到此套接字的连接。
         
          DataInputStream dataIn = new DataInputStream(new BufferedInputStream(clientSocket.getInputStream()));
          //InputStream getInputStream()
                 //返回此套接字的输入流。
         
          OutputStream dataOut = clientSocket.getOutputStream();

          //OutputStream getOutputStream()
                //返回此套接字的输出流。
              
                while((inputLine = dataIn.readLine())!= null)
                {
                 //当客户端输入stop的时候,服务器停止运行
                 if(inputLine.equals("stop"))
                    { flag = false;
                      break;
                    
                     }
                  else
                     {
                      System.out.println(inputLine);
                     
                       while((c = System.in.read())!=-1)       //System.in.read()   当返回   -1   时,表示流的结束
                    
                     //java.lang 类 System
                     //     in
                     //    public static final InputStream in“标准”输入流。
                     //    此流已打开并准备提供输入数据。
                     //    通常,此流对应于键盘输入或者由主机环境或用户指定的另一个输入源。
                    
                    
                      // java.io 类 InputStream                      
                      // abstract  int read()
                       // 从输入流读取下一个数据字节。
                      
                       {
                          dataOut.write((byte)c);     
                         
                         
                         
                          if(c=='\n')       ////   如果读到的c是换行符    这里 '\n' 是字符,转换成整型数值后与c进行比较
                          {
                           dataOut.flush();  ////将c转成字节型写入输出流,将信息发送到客户端
                           break;
                           //类 OutputStream
                           //方法  flush
                           //public void flush()
                          //throws IOException刷新此输出流并强制写出所有缓冲的输出字节。flush 的常规协定是:如果此输出流的实现已经缓冲了以前写入的任何字节,则调用此方法指示应将这些字节立即写入它们预期的目标。
                         //如果此流的预期目标是由基础操作系统提供的一个抽象(如一个文件),则刷新此流只能保证将以前写入到流的字节传递给操作系统进行写入,但不保证能将这些字节实际写入到物理设备(如磁盘驱动器)。
                         //OutputStream 的 flush 方法不执行任何操作。

                           }
                        }
                      }
                 }
                
                 dataIn.close();
                 dataOut.close();
                 clientSocket.close();
         
         }
        
         sSocket.close();
        
        
        }
       
        catch(Exception e)
        {
         System.out.println("Exception :"+e.getMessage());
         }
        
       }
     
     
     
     
    }

     

     

     

    客户端:

     

    //package com.socket;
    import java.lang.*;
    import java.net.*;
    import java.io.*;


    public class TestSocketClient{
     
     public static void main(String args[])
     {
        try
        {
             //创建通讯并且和服务端主机连接
             Socket cSocket = new Socket("192.168.1.102",8018);
             //JavaAPI 包java.net,找到Socket类,查看其包含的方法
             // Socket(InetAddress address, int port)  构造方法
                // 创建一个流套接字并将其连接到指定 IP 地址的指定端口号。
           
             //打开这个Socket的输入/输出流
             OutputStream dataOut = cSocket.getOutputStream();
             DataInputStream dataIn = new DataInputStream(cSocket.getInputStream());
           
             int c;
             boolean flag = true;
           
             String responseline;
             responseline = null;
           
             while(flag)
             {
              //从标准输入输出接收字符并且写入系统
                while((c=System.in.read())!=-1)
                {
                 dataOut.write((byte)c);
                 if(c=='\n')
                   {
                    dataOut.flush();
                    //将程序阻塞,直到回答信息被接收到后将他们显示在标准输出上
                   
                    responseline = dataIn.readLine();
                    System.out.println("Message is:"+responseline);
                   
                    }
                
                 }
             
              }
              dataOut.close();
              dataIn.close();
              cSocket.close();
         }
         catch(Exception e)
         {
             System.out.println("Exception :"+e.getMessage());
          }
      
      }
    }

     

     

     

    --------------------------------------------------------------

    服务端的关键代码

      ServerSocket sSocket = new ServerSocket(8018);  

          while(flag)
         { 
           Socket clientSocket = sSocket.accept();
           DataInputStream dataIn = new DataInputStream(new BufferedInputStream(clientSocket.getInputStream()));
           OutputStream dataOut = clientSocket.getOutputStream();
           String inputLine = dataIn.readLine();
        
        
        
            while(inputLine != null)
                {
                 if(inputLine.equals("stop"))
                    { flag = false;
                      break;
                    
                     }
                  else
                     {
                      System.out.println(inputLine);
                     
                       while((c = System.in.read())!=-1)                
                       {
                          dataOut.write((byte)c);     
                          if(c=='\n')      
                          {
                           dataOut.flush();  
                           break;
                           }
                        }
                      }
                 }
                 dataIn.close();
                 dataOut.close();
                 clientSocket.close();  
           }
           sSocket.close();
          

     

    帖子参考;

    http://topic.csdn.net/u/20070518/09/5bfb2de8-8ab1-4c26-abfd-5d28fc410761.html?1410589227

     

     

    上午又写了一遍,需要注意的地方还很多哦

    客户端与服务端,需要交替输入数据来进行交互

    服务端:

    import java.net.*;
    import java.lang.*;
    import java.io.*;

    public class MySocketServer
      {
     
        public static void main(String args[])     //throws IOException
         {
            try{
             ServerSocket myServer = new ServerSocket(8018);
             System.out.println("正在监听端口:"+myServer.getLocalPort());
             Socket myClient = null;
            
             boolean flag = true;
             String InputMessage = null;
             int c;
          
         
             while(flag)
             {
               myClient = myServer.accept();
               //接收客户端的信息,如果不是Stop就继续监听,加个if判断
               DataInputStream dataIn = new DataInputStream(myClient.getInputStream());
               //DataInputStream dataIn = new DataInputStream(new BufferedInputStream(myClient.getInputStream()));       
               OutputStream dataOut = myClient.getOutputStream();
              
              while( (InputMessage = dataIn.readLine()) != null )
                {
                 if( InputMessage.equals("stop"))
                 {
                     flag = false;
                     break;
                  }
                 else
                 {               
                      System.out.println("从客户端接收到的信息是:"+InputMessage);
                      //输入:读取至 末尾-1结束,遇到回车'\n'结束:
                      while((c=System.in.read())!= -1)
                        {
                          dataOut.write((byte)c);
                           if(  c== '\n')
                           {
                             dataOut.flush();
                             break;
                           }
                         
                         }
      
                  }
              }
              dataIn.close();    
               dataOut.close();
               myClient.close();
              }
             myServer.close(); 
             }
           catch(Exception e)
              {
                 System.out.println(e.getMessage());
               } 
         
         } 
     
     }

     

    客户端:

    import java.io.*;
    import java.lang.*;
    import java.net.*;

    public class MySocketClient
    {
     public static void main(String args[])
     {
       try{   
         
           Socket myClient = new Socket("192.168.1.25",8018);
                              
           DataInputStream dataIn = new DataInputStream(myClient.getInputStream());
           OutputStream dataOut = myClient.getOutputStream();
          
           boolean flag = true;
           int c;
           String serverResponse = null ;
          
           while(flag)
           {
              while( (c=System.in.read())!= -1 )
                {
                  dataOut.write((byte)c);
                  if(c=='\n')
                     {
                        dataOut.flush();
                        serverResponse = dataIn.readLine();
                        System.out.println("服务器的返回信息是:"+serverResponse);
                      
                      }
                 }
            
            }
           dataIn.close();
           dataOut.close();
           myClient.close(); 
          }
        
       catch(Exception e)
       {
         System.out.println("Exception :"+e.getMessage());
        } 
     }  
    }

     

     

     

     

  • Java socket 入门编程实例----- 两个例子都有问题,仅作参考

    2009-04-27 15:48:17

     

     

    例子是学习编程的法宝。你在学习java Socket 吗?看看下

    面的这个例子吧!
    实现Client端功能的ClientApp.java原文件:

    import java.net.*;
    import java.io.*;
    import java.lang.*;

    public class ClientApp
    {
    public static void main(String args[])
    {
    try
    {
    //创建通讯并且和主机Rock连接
    Socket cSocket=new Socket("192.168.100.188",8018);
    //打开这个Socket的输入/输出流
    OutputStream s=cSocket.getOutputStream();
    DataInputStream is=new DataInputStream

    (cSocket.getInputStream());

    int c;
    boolean flag=true;

    String responseline;

    while(flag)
    {
    //从标准输入输出接受字符并且写如系统
    while((c=System.in.read())!=-1)
    {
    os.write((byte)c);
    if(c==''\n'')
    {
    os.flush();
    //将程序阻塞,直到回答信息被收到后将他们在标准输出上

    显示出来
    responseline=is.readLine();
    System.out.println("Message is:"+responseline);
    }
    }
    }
    os.close();
    is.close();
    cSocket.close();

    }
    catch(Exception e)
    {
    System.out.println("Exception :"+ e.getMessage());
    }
    }
    }  


       实现Server端功能的ServerApp.java原文件:

    import java.net.*;
    import java.io.*;

    public class ServerApp
    {
    public static void main(String args[])
    {
    try
    {
    boolean flag=true;
    Socket clientSocket=null;
    String inputLine;
    int c;

    ServerSocket sSocket=new ServerSocket(8018);
    System.out.println("Server listen

    on:"+sSocket.getLocalPort());

    while(flag)
    {
    clientSocket=sSocket.accept();
    DataInputStream is= new DataInputStream(new

    BufferedInputStream(clientSocket.getInputStream()));
    OutputStream s=clientSocket.getOutputStream();

    while((inputLine=is.readLine())!=null)
    {
    //当客户端输入stop的时候服务器程序运行终止!
    if(inputLine.equals("stop"))
    {
    flag=false;
    break;
    }
    else
    {
    System.out.println(inputLine);

    while((c=System.in.read())!=-1)
    {
    os.write((byte)c);
    if(c==''\n'')
    {
    os.flush(); //将信息发送到客户端
    break;
    }
    }
    }


    }
    is.close();
    os.close();
    clientSocket.close();

    }
    sSocket.close();
    }
    catch(Exception e)
    {
    System.out.println("Exception :"+ e.getMessage());
    }
    }
    }    

     

     

     

     

    ===========================================================

    Java socket编程实例
    2006-12-13 01:59

    这是一个C/S之间通信的例子,在JDK1.4下测试通过.
    //服务器端源程序tcpserver.java

    import java.io.*;
    import java.net.*;
    public class tcpserver
    {
    public static void main(String[] args) throws IOException
    {
    ServerSocket svrsoc=null;
    Socket soc=null;
    DataInputStream in=null;
    PrintStream ut=null;
    InetAddress clientIP=null;
    String str=null;
    try
    {
    svrsoc=new ServerSocket(8000);
    System.out.println("Server start....");
    soc=svrsoc.accept();

    in=new DataInputStream(soc.getInputStream());
    out=new PrintStream(soc.getOutputStream());
    clientIP=soc.getInetAddress();
    System.out.println("Client's IP address:"+clientIP);
    out.println("welcome.....");
    str=in.readLine();
    while (!str.equals("quit"))
    {
    System.out.println("Client said:"+str);
    str=in.readLine();
    }
    System.out.println("Client want to leave");
    }
    catch(Exception e)
    {
    System.out.println("error:"+e);
    }
    finally
    {
    in.close();
    out.close();
    soc.close();
    svrsoc.close();
    System.exit(0);
    }
    }
    }

    //客户端源程序tcpclient.java

    import java.io.*;
    import java.net.*;
    public class tcpclient
    {
    public static void main(String[] args) throws IOException
    {
    Socket soc=null;
    DataInputStream in=null;
    PrintStream ut=null;
    DataInputStream sysin=null;
    String strin=null;
    String strout=null;
    try
    {
    soc=new Socket(args[0],8000);
    System.out.println("Connecting to the Server");
    in=new DataInputStream(soc.getInputStream());
    out=new PrintStream(soc.getOutputStream());
    strin=in.readLine();
    System.out.println("Server said:"+strin);
    sysin=new DataInputStream(System.in);
    strout=sysin.readLine();
    while (!strout.equals("quit"))
    {
    out.println(strout);
    strout=sysin.readLine();
    }
    out.println(strout);
    }
    catch(Exception e)
    {
    System.out.println("error:"+e);
    }
    finally
    {
    in.close();
    out.close();
    soc.close();
    sysin.close();
    System.exit(0);
    }
    }
    }

  • MyEclipse Enterprise Workbench 5.0.1GA + 注册机 + Eclipse 3.2全套下载

    2009-04-23 23:39:14

    http://www.inspiresky.com/bbs/dispbbs.asp?boardid=13&id=10017

    一个MyEclipse5.0 注册码

    License Name:     Hoocoral
    License Key:       ULR8ZC-444-55-4467865796016010

    Eclipse里:

    Window---->Preferences--->Subscription ----->Enter Subscription

     

     

    myeclipse5.0GA

    注册码  :  Subscriber: www.1cn.biz
              Subscriber Code: jLR8ZC-655355-5450765457039125
        

    安装方法: 解压eclipse
              >安装 myeclpse到eclipse下 
               > 启动eclipse 注册完成就可以用了

     

    ----------------------------------------------------------

    eclipse myeclipse 下载地址
    2008-03-12 11:45

    eclipse 3.2.2 官方 下载地址 download :http://archive.eclipse.org/eclipse/downloads/drops/R-3.2.2-200702121330/download.php?dropFile=eclipse-SDK-3.2.2-win32.zip

    MyEclipse Enterprise Workbench 5.5.1 GA for Windows 98/2000/NT/XP/Vista (05/21/2007)   官方 下载地址 download :http://www.myeclipseide.com/Downloads-index-req-getit-lid-83.html

     

  • web.xml配置servlet

    2009-03-12 17:17:31

    <!-- 1 JSPC servlet mappings start -->

      <servlet>
     
     <!-- servlet name -->
     <servlet-name>mldn</servlet-name>
     <!--servlet file path -->
     <jsp-file>/WEB-INF/sdemo.jsp</jsp-file>
     
     <!--servlet param and init_value -->
     <init-param>
      <param-name>uname</param-name>
      <param-value>mldn</param-value>
     </init-param>
     
     <init-param>
      <param-name>upass</param-name>
      <param-value>LiXingHua</param-value>
     </init-param>

      </servlet>

    <!-- 2 JSPC servlet mappings start -->

      <servlet-mapping>
      <!-- servlet name --> 
     <servlet-name>mldn</servlet-name>
     <!-- servlet connect path -->
     <url-pattern>/lxh</url-pattern>
      </servlet-mapping>
     

    <!--  3 set default welcom page          -->

     <!-- 
      <welcome-file-list>
            <welcome-file>index.html</welcome-file>
            <welcome-file>index.htm</welcome-file>
            <welcome-file>index.jsp</welcome-file>
       </welcome-file-list>
    -->

     <!-- 
      <welcome-file-list>
            <welcome-file>default.html</welcome-file>
            <welcome-file>default.htm</welcome-file>
            <welcome-file>default.jsp</welcome-file>
       </welcome-file-list>
    -->

    <!-- 4 JSPC servlet mappings end -->

885/5<12345
Open Toolbar