Socket通信综合示例

1用户注册
客户单选择‘用户注册’，提示要输入用户名，密码，确认密码，校验成功后将用户
信息保存到数据库，并提示数据库注册成功，请登录
2用户登录
客户端选择‘登录以后’后，提示输入用户名和密码，验证成功则提示上传文件
，验证失败则给出提示信息，并可以重新登录
3文件上传
客户端输入上传文件的路径，并读取文件数据，通过输出流发送到服务端，服务端接受
后将上传文件保持在数据库

package com.slp.entity;

import java.io.Serializable;

public class File implements  Serializable {

    /**
     *
     */
    private static final long serialVersionUID = 1254554707571682105L;
    private int fid;
    private String fname;
    private byte[] focntent;
    public int getFid() {
        return fid;
    }
    public void setFid(int fid) {
        this.fid = fid;
    }
    public String getFname() {
        return fname;
    }
    public void setFname(String fname) {
        this.fname = fname;
    }
    public byte[] getFocntent() {
        return focntent;
    }
    public void setFocntent(byte[] focntent) {
        this.focntent = focntent;
    }
    public File(int fid, String fname, byte[] focntent) {
        this.fid = fid;
        this.fname = fname;
        this.focntent = focntent;
    }
    public File(String fname,byte[] focntent){
        this.fname=fname;
        this.focntent=focntent;
    }

}
package com.slp.entity;

import java.io.Serializable;

public class Users implements  Serializable{

    /**
     *
     */
    private static final long serialVersionUID = -7751437846681691870L;
    private int id;
    private String username;
    private String password;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    public Users(int id, String username, String password) {
        super();
        this.id = id;
        this.username = username;
        this.password = password;
    }
    public Users(){

    }

}
package com.slp.service;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

import com.imooc.entity.File;
import com.imooc.util.Util;

public class FileService {
    private Connection conn = null;
    private PreparedStatement ptmt = null;
    private ResultSet rs = null;

    public void savefile(File file) {
        String sql = (" insert into tb_file(fname,focntent) values(?,?)");
        try
        {   conn=Util.getConnection();
            ptmt = conn.prepareStatement(sql);
            ptmt.setString(1, file.getFname());
            ptmt.setBytes(2, file.getFocntent());
            ptmt.executeUpdate();
        } catch (

        SQLException e)
        {
            e.printStackTrace();
        } finally{
            Util.closeAll(conn, ptmt, rs);
        }
    }

}
package com.slp.service;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

import com.imooc.entity.Users;
import com.imooc.util.Util;

public class UsersService {
    private PreparedStatement ptmt = null;
    private ResultSet rs = null;
    private Connection conn=null;
    public void zhuce(Users users) {
        String sql = "insert into tb_user(username,password) values(?,?)";
        try {
            conn=Util.getConnection();
            ptmt = conn.prepareStatement(sql);
            ptmt.setString(1, users.getUsername());
            ptmt.setString(2, users.getPassword());
            ptmt.execute();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            Util.closeAll(conn, ptmt, rs);
        }
    }

    public Boolean Denglu(Users users){
        String sql = "Select  username,password from tb_user where username=? and password=? ";
        try {

            conn = Util.getConnection();
            ptmt = conn.prepareStatement(sql);
            ptmt.setString(1, users.getUsername());
            ptmt.setString(2, users.getPassword());
            rs = ptmt.executeQuery();
            if (rs.next()) {
                return true;
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            Util.closeAll(conn, ptmt, rs);
        }
        return false;
    }

}
package com.slp.socket;

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;

import com.imooc.entity.File;
import com.imooc.entity.Users;
import com.imooc.service.FileService;
import com.imooc.service.UsersService;
import com.imooc.util.CommendTranser;

public class SocketClient {
    Scanner scan = new Scanner(System.in);
    private Socket socket = null;
    // Socket ss = new Socket("localhost", 1346);
    // Scanner scan = new Scanner(System.in);
    // String in = scan.next();
    // InputStream is = ss.getInputStream();
    // InputStreamReader isr = new InputStreamReader(is);
    // BufferedReader bfr=new BufferedReader(isr);
    // String info;
    // while((info=bfr.readLine())!=null){
    // System.out.println("我是客户端 "+"\t"+"服务器说"+info);
    // }
    //
    //
    // OutputStream os = ss.getOutputStream();
    // PrintWriter pw = new PrintWriter(os);
    // pw.write(in);

    public void showMainMenu() {
        System.out.println("******欢迎使用imooc上传器*******");
        System.out.println("1 用户登录  ，2 用户注册 ，3 退出");
        System.out.println("***************************");
        System.out.println("请选择：》》》》》》》》");
        int choose = scan.nextInt();
        switch (choose) {
        case 1:
            showlogin();
            break;
        case 2:
            showzhuce();
            break;
        case 3:
            System.out.println("再见了，你炸了");
            System.exit(0);
        default:
            System.out.println(" 输入有误");
            System.exit(0);
        }
    }

    public void showlogin() {
        Users users = new Users();
        System.out.println("欢迎使用登录");
        CommendTranser transer = new CommendTranser();
        int count = 0;
        while (true) {
            if (count >= 3) {
                System.out.println("您已经三次输入失败，再见");
                System.exit(0);
            }
            System.out.println("请输入用户名");
            users.setUsername(scan.next());
            System.out.println("请输入密码");
            users.setPassword(scan.next());
            transer.setCmd("login");
            transer.setData(users);
            count++;
            try {
                socket = new Socket("localhost", 1346);
                sendData(transer);
                transer=getDate();
                System.out.println("   " + transer.getResult());
                System.out.println("***********************");
                if (transer.isFlag()) {
                    break;
                }
            } catch (UnknownHostException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                clossAll();
            }

        }
        showUploadFile();

    }

    public void showzhuce() {
        Users users = new Users();
        System.out.println("欢迎使用注册");
        CommendTranser transer = new CommendTranser();
        while (true) {
            System.out.println("请输入用户名");
            users.setUsername(scan.next());
            System.out.println(" 请输入密码");
            users.setPassword(scan.next());
            System.out.println("请再次输入密码");
            String rePassword = scan.next();
            if (!users.getPassword().equals(rePassword)) {
                System.out.println("俩次输入不一致");
                System.out.println("**************");
                continue;
            }
            transer.setCmd("zhuce");
            transer.setData(users);
            try {
                socket = new Socket("localhost", 1346);
                sendData(transer);
                transer=getDate();
                System.out.println("  " + transer.getResult());
                System.out.println("***********************");
                if (transer.isFlag()) {
                    break;
                }
            } catch (UnknownHostException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                clossAll();
            }
        }
        showUploadFile();
    }

    public void showUploadFile() {
        System.out.println("请输入上传的绝对路径 如： (e://imooc//dog.jpg)");
        String path = scan.next();

        File file = null;
        FileInputStream fis = null;
        BufferedInputStream bis = null;
        String fname = path.substring(path.lastIndexOf("/") + 1);
        try {
            fis = new FileInputStream(path);
            byte[] focntent = new byte[fis.available()];
            bis = new BufferedInputStream(fis);
            bis.read(focntent);
            file = new File(fname, focntent);

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                bis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        CommendTranser transer = new CommendTranser();
        transer.setCmd("uploadFile");
        transer.setData(file);
        try {
            socket = new Socket("localhost", 1346);
            sendData(transer);
            transer=getDate();
            System.out.println(transer.getResult());
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            clossAll();
        }
    }

    public CommendTranser sendData(CommendTranser transer) {
        ObjectOutputStream oos=null;//对象输出流
            try {
             oos=new ObjectOutputStream(socket.getOutputStream());
             oos.writeObject(transer);
              return transer;
            } catch (IOException e) {
                e.printStackTrace();
            }
    return null;
    }

    public CommendTranser  getDate(){
        ObjectInputStream ois =null;//对象输入流
        CommendTranser transer = null;
         try {
            ois=new ObjectInputStream(socket.getInputStream());
            transer= (CommendTranser) ois.readObject();
        } catch (IOException e) {
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return transer;
    }

    public void clossAll() {
        try {
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
package com.slp.socket;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;

public class SocketServer {

    public static void main(String[] args) {
    try {
        ServerSocket serversocket=new ServerSocket(1346);
        Socket socket=null;
        System.out.println("");
        while(true){
             socket=serversocket.accept();
            System.out.println("欢迎您..");
            SocketThread thread=new SocketThread(socket);
            thread.start();

        }

    } catch (IOException e) {
        e.printStackTrace();
    }

}
}
package com.slp.socket;

public class SocketStart {

    public static void main(String[] args) {

        SocketClient client=new SocketClient();
        client.showMainMenu();
}
}
package com.slp.socket;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;

import com.imooc.entity.File;
import com.imooc.entity.Users;
import com.imooc.service.FileService;
import com.imooc.service.UsersService;
import com.imooc.util.CommendTranser;

public class SocketThread  extends Thread{

    private Socket socket=null;
    private ObjectInputStream ois =null;//对象输入流
    private ObjectOutputStream oos=null;//对象输出流
    private UsersService us=new UsersService();//用户业务对象
    private FileService fs=new FileService();//文件业务对象
    //通过构造方法,初始化socket
    public SocketThread (Socket socket){
        this.socket=socket;
    }
    @Override
    public void run() {
        try {
            ois=new ObjectInputStream(socket.getInputStream());
            oos=new ObjectOutputStream(socket.getOutputStream());
            CommendTranser transer=(CommendTranser)ois.readObject();
            transer=execute(transer);
            oos.writeObject(transer);

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
         public CommendTranser execute(CommendTranser transer){
             String cmd =transer.getCmd();
             if(cmd.equals("login")){
                 Users users=(Users)transer.getData();
                 boolean flag=us.Denglu(users);
                   transer.setFlag(flag);
                   if(flag){
                       transer.setResult("登录成功");
                   }else{
                       transer.setResult("用户名或密码不正确");
                   }
             }else if(cmd.equals("zhuce")){
                 Users users=(Users)transer.getData();
                 us.zhuce(users);
                 boolean flag= us.Denglu(users);
                 transer.setFlag(flag);
                 if(flag){
                     transer.setResult("注册成功");
                 }else{
                     transer.setResult("注册失败，未知原因");

                 }
                 }else if(cmd.equals("uploadFile")){
                 File file=(File)transer.getData();
                 fs.savefile(file);
                 transer.setResult(" 上传成功");
                 }
             return transer;
         }

}
package com.slp.util;

import java.io.Serializable;

public class CommendTranser implements  Serializable {
    private static final long serialVersionUID = 1L;
    private String cmd;//当前操作的命令
    private Object data;//发送的数据
    private boolean flag;//操作是否成功
    private String result;//返回的结果
    public String getCmd() {
        return cmd;
    }
    public void setCmd(String cmd) {
        this.cmd = cmd;
    }
    public Object getData() {
        return data;
    }
    public void setData(Object data) {
        this.data = data;
    }
    public boolean isFlag() {
        return flag;
    }
    public void setFlag(boolean flag) {
        this.flag = flag;
    }
    public String getResult() {
        return result;
    }
    public void setResult(String result) {
        this.result = result;
    }

}
package com.slp.util;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
//注：我是将原来的引用Util util=new Util();

public class Util {
//    private static final String URL = "jdbc:mysql://127.0.0.1:3306/imooc";
//    private static final String NAME = "root";
//    private static final String PASSWORD = "199666";
//
//    public static Connection conn=null;
//
//    static{
//    // 获得数据库的连接
//    try {
//        Class.forName("com.mysql.jdbc.Driver");
//        conn = DriverManager.getConnection(URL, NAME, PASSWORD);
//    } catch (SQLException e) {
//        e.printStackTrace();
//    } catch (ClassNotFoundException e) {
//        e.printStackTrace();
//    }
//    }

//    public  Connection getConnection(){
//
//
//    return conn;
//}

    public static  Connection getConnection(){
         String driverClassName="com.mysql.jdbc.Driver";
        String URL = "jdbc:mysql://127.0.0.1:3306/imooc";
       String username = "root";
        String password = "199666";
        Connection conn=null;
        try {
            Class.forName(driverClassName);
            conn=DriverManager.getConnection(URL, username, password);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return conn;
    }

//    关闭资源的操作
    public static  void closeAll( Connection conn,Statement stmt,ResultSet rs){

        try {
            if(conn!=null){
                conn.close();
            }
            if(stmt!=null){
                stmt.close();
            }if(rs!=null){
                rs.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }

    }

}
时间： 2025-01-15 17:32:51

Socket通信综合示例的相关文章

C# 如何实现简单的Socket通信(附示例)

上周由于有个项目需要用到网络通信这块,然后就花了点时间研究了一下,本来想上周就写出来的,但是突然要忙,所以等到现在. 话说对于网络通信,以前写C++的时候,天天面对着线程和Socket,所以换成C#也就没那么怕了,虽然C++下也没有掌握的多好,但毕竟只是一个小Demo,只作为了解一下过程. 自己写了一个服务端和一个客户端,刚开始比较简单,只是能达到连通,收发信息的目的,但是很粗糙.而后稍加改进呢~加上了多线程,所以能感觉更科学一些,不过自己真的很菜,代码写的不是很好看,下面分两个版本给大家表出来

【Java】Java Socket 通信示例

用socket(套接字)实现客户端与服务端的通信. 这里举两个例子: 第一种是每次客户端发送一个数据,服务端就做一个应答.(也就是要轮流发) 第二种是客户端可以连续的向服务端发数据,服务端也可以连续向客户端发数据.(多线程) 为了方便起见,客户端服务端都放在一个主机上,分别开两个进程[哈哈,进程间通信lol~] PS: 一个聊天程序雏形 代码也放在GitHub上了:https://github.com/MummyDing/socketChatDemo Demo 1: 简单的Socket通信,一人

python的socket通信实例

一.socket简介 1. 套接字 套接字是为特定网络协议(例如TCP/IP,ICMP/IP,UDP/IP等)套件对上的网络应用程序提供者提供当前可移植标准的对象. 它们允许程序接受并进行连接,如发送和接受数据.为了建立通信通道,网络通信的每个端点拥有一个套接字对象极为重要. 套接字为BSD UNIX系统核心的一部分,而且他们也被许多其他类似UNIX的操作系统包括Linux所采纳. 许多非BSD UNIX系统(如ms-dos,windows,os/2,mac os及大部分主机环境)都以库形式提供

使用Socket通信实现Silverlight客户端实时数据的获取(模拟GPS数据，地图实时位置)

原文:使用Socket通信实现Silverlight客户端实时数据的获取(模拟GPS数据,地图实时位置) 在上一篇中说到了Silverlight下的Socket通信,在最后的时候说到本篇将会结合地图.下面就来看看本文实现的功能: Silverlight 与服务器利用Socket通讯,实时从服务器获取数据(本文中的数据是地理坐标),由于没有GPS,所以本文在服务器写了一个构造新坐标的函数(本文是一个三角函数),然后利用Timer组件,实时调用,得到新的坐标,并将新的坐标发送给客户端,客户端接收到发

android中非阻塞socket通信

1.什么是同步与异步,阻塞与非阻塞 首先我们要明白搞明白:同步就等于阻塞?异步就等于非阻塞?这是不对的,同步不等于阻 塞,而异步也不等于非阻塞. 1)那什么是同步编程? 什么是同步,就是在发出一个功能调用时,在没有得到结果之前,该调用就不返回.根据这个定义,android中绝大多数函数都是同步调用.但是一般而言,我们在谈论同步.异步的时候,特指那些需要其他部件协作或者需要一定时间完成的任务.在android中,由于主线程(UI线程的不安全性),我们经常会用到handler的SendMessage

.NET开源高性能Socket通信中间件Helios介绍及演示

一:Helios是什么 Helios是一套高性能的Socket通信中间件,使用C#编写.Helios的开发受到Netty的启发,使用非阻塞的事件驱动模型架构来实现高并发高吞吐量.Helios为我们大大的简化了Socket编程,它已经为我们处理好了高并发情况下的解包,粘包,buffer管理等等. GitHub:https://github.com/helios-io/helios/ 二:Helios的特点 1.Powerful APIs Takes the complexity out of so

.net平台下C#socket通信（中）

本文主要讲述: 1.正常通信中握手建立 2.一对多的通信 3.发送接收数据格式转换 4.资源释放 5.开启并保持服务监听 1.握手建立正常的通信通道 项目需要通信的双方(假设是一个上位机.一个下位机)之间需要建立一个稳定的通道,以便进行通信.本项目中具体操作是:上位机作为服务器,下位机作为客户端,同时制定通信协议.上位机首先打开监听等待建立通道,下位机主动连接上位机后发送连接成功的信息到上位机,上位机根据通信协议发送数据到下位机,此时通道已经建立.但为了保险起见(同时遵循三次握手),客户端再次发

iOS开发之Socket通信实战--Request请求模块

实际上在iOS很多应用开发中,大部分用的网络通信都是http/https协议,除非有特殊的需求会用到Socket网络协议进行网络数据传输,这时候在iOS客户端就需要很好的第三方CocoaAsyncSocket来进行长连接连接和传输数据,该第三方地址:https://github.com/robbiehanson/CocoaAsyncSocket,读者可以自行google或者baidu搜索这个库的用法,网上有很多资料,而且用法不难. 在一些对Socket通信使用需求不是很高的应用中,比如需要多个i

Flash Socket通信的安全策略问题 843端口

1.问题描述       将flash发布为html格式后,加载页面后,swf无法与服务器进行socket通信.Flash端显示的错误为:securityErrorHandler信息: [SecurityErrorEvent type="securityError" bubbles=false cancelable=false eventPhase=2 text="Error #2048"] 在服务器端显示的信息是由客户端尝试进行连接,但是无法接受数据.接受的数据显