java socket练习题，实现注册，登录和上传文件

做的比较粗糙，只是简单实现了这三个功能。创建项目的时候一定要记得导入MySql的jar包并且要将mysql服务启动

package socket;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class DBHelper {
    private static String Driver = "com.mysql.jdbc.Driver";
    private static String URL = "jdbc:mysql://localhost:3306/test";
    //用户名和密码填自己的
        private static String NAME = "";
    private static String PASSWORD = "";

    private static Connection conn = null;
    static {
        try {
            Class.forName(Driver);
            conn = DriverManager.getConnection(URL,NAME,PASSWORD);
            } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
                e.printStackTrace();
            }               
    }

    public static Connection getConnetion() {
        return conn;
    }
}

package socket;

import java.io.Serializable;

public class Users implements Serializable{
    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    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;
    }

    @Override
    public String toString() {
        return "Users [username=" + username + ", password=" + password + "]";
    }
}

package socket;

import java.io.Serializable;

public class FileUp implements Serializable{
    /**
     *需要实现序列化
     *文件内容以byte类型进行传递 
     */
    private static final long serialVersionUID = 1L;
    private int id;
    private String filename;
    private byte[] fileContent;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getFilename() {
        return filename;
    }

    public void setFilename(String filename) {
        this.filename = filename;
    }

    public byte[] getFileContent() {
        return fileContent;
    }

    public void setFileContent(byte[] fileContent) {
        this.fileContent = fileContent;
    }

}

package socket;

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

public class UserDAO {
    public boolean insert(Users user)  {
        Connection con = DBHelper.getConnetion();
        String sql = "INSERT INTO tusers(username,password) VALUES(?,?)";
        PreparedStatement ps;   
        try {
            ps = con.prepareStatement(sql);
            ps.setString(1, user.getUsername());
            ps.setString(2, user.getPassword());
            ps.execute();
        } catch (SQLException e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }
    public boolean checkUser(Users user) {
        Connection con = DBHelper.getConnetion();
        String sql = "SELECT * FROM tusers WHERE username=? AND password=?";
        PreparedStatement ps = null;
        ResultSet rs = null;
        boolean flag = false;
        try {
            ps = con.prepareStatement(sql);
            ps.setString(1, user.getUsername());
            ps.setString(2, user.getPassword());
            rs = ps.executeQuery();
            if(rs.next()) {
                flag = true;
            }
            else {
                flag = false;
            }
        } catch (SQLException e) {          
            e.printStackTrace();
        }finally {

        }
        return flag;

    }
}

package socket;

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

public class FileDAO {
    public boolean insert(FileUp file) {
        Connection con = DBHelper.getConnetion();

        String sql = "INSERT INTO tfiles(fname,fcontent) VALUES (?,?)";
        PreparedStatement ps;
        try {
            ps = con.prepareStatement(sql);
            ps.setString(1, file.getFilename());
            /**
             * 文件内容在数据库中保存格式为blob，保存文件内容时使用setBytes()方法
             */
            ps.setBytes(2, file.getFileContent());
            ps.execute();           
        } catch (SQLException e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }
}

package socket;
import java.io.Serializable;

public class CommandTransfer implements Serializable{
    /**
     * cmd为用户动作，如reg,login
     * obj为封装的内容，比如user和file类
     * flag为服务器返回的操作状态，true为成功，false为失败
     */
    private static final long serialVersionUID = 1L;
    private String cmd;
    private Object obj;
    private boolean flag;
    public String getCmd() {
        return cmd;
    }
    public void setCmd(String cmd) {
        this.cmd = cmd;
    }
    public Object getObj() {
        return obj;
    }
    public void setObj(Object obj) {
        this.obj = obj;
    }
    public boolean isFlag() {
        return flag;
    }
    public void setFlag(boolean flag) {
        this.flag = flag;
    }
    public static long getSerialversionuid() {
        return serialVersionUID;
    }   
}

package socket;

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

public class Server{

    public static void main(String[] args) {
        try {
            ServerSocket server = new ServerSocket(12345);
            System.out.println("server started...");            
            while(true) {
                System.out.println("waiting for client");
                Socket socket = server.accept();

                Runnable st  = new ServerThread(socket);
                Thread t = new Thread(st);
                t.start();
            }           
        } catch (IOException e) {
            e.printStackTrace();
        }       
    }
}

package socket;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.net.Socket;

public class ServerThread implements Runnable{
    private Socket socket ;
    private Users user;
    private FileUp file;
    ServerThread(Socket socket){
        this.socket = socket;
    }   
    @Override
    public void run() {
        try {
            InputStream is = socket.getInputStream();
            ObjectInputStream ois = new ObjectInputStream(is);
            //对传递过来的transfer对象执行反序列化操作
            CommandTransfer transfer = (CommandTransfer)ois.readObject();
            doCommand(transfer);
            toClient(transfer);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        finally {           
        }       
    }

    /**
     * 执行注册，登录，上传文件操作
     */
    public CommandTransfer doCommand(CommandTransfer transfer) {
        UserDAO udao = new UserDAO();
        FileDAO fdao = new FileDAO();       
        String cmd = transfer.getCmd();
        boolean flag = false;
        //判断用户当前操作是什么
        switch(cmd){
            case "reg":
                user = (Users)transfer.getObj();
                //先查询是否存在该用户，如果不存在再执行插入语句，否则返回false
                if(!udao.checkUser(user)) {
                    flag = udao.insert(user);
                }else {
                    flag = false;
                }
                break;
            case "login":
                user = (Users)transfer.getObj();
                flag = udao.checkUser(user);
                break;
            case "upload":
                //文件上传
                file = (FileUp)transfer.getObj();
                flag = fdao.insert(file);
                break;
        }
        transfer.setFlag(flag);
        return transfer;
    }

    /**
     * 向客户端发送执行结果
     * @param transfer
     */
    public void toClient(CommandTransfer transfer) {
        OutputStream os = null;
        ObjectOutputStream oos = null;
        try {
            os = socket.getOutputStream();
            oos = new ObjectOutputStream(os);
            oos.writeObject(transfer);
            oos.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
        finally {                   
        }
    }
}

package socket.action;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;

import socket.CommandTransfer;
import socket.FileUp;
import socket.Users;
/**
 * 客户端
 */
public class UserAction {
    private static Scanner scan= new Scanner(System.in);
    private static Users user;
    private Socket socket = null;   
    private static FileUp fileUp;   

    public static void main(String[] args) {

        UserAction action = new UserAction();
        action.showUI();

    }

    public void showUI() {
        System.out.println("你好，请选择：");
        System.out.println("1：注册");
        System.out.println("2：登录");
        System.out.println("3：退出");
        try {
            choice();
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }       
    public void choice() throws UnknownHostException, IOException {
        int choice = scan.nextInt();
        /**
         * 使用nextLine()方法解决在nextInt()后其它方法的nextLine()会接收"\n"的问题
         * 如果注释掉nextLine(),比如先输入1，那么reg()方法中if((username =scan.nextLine()).trim().isEmpty())这句就会自动被执行一次     
         */
        scan.nextLine();
        switch(choice) {
        case 1:         
            reg();
            break;
        case 2:         
            login();
            break;
        case 3:
            System.exit(0);
            break;
        default:
            System.out.println("输入无效，请重新输入");           
            choice();       
        }
    }
    public void reg() throws UnknownHostException, IOException {    
        CommandTransfer transfer = new CommandTransfer();
        //设置操作为注册reg
        transfer.setCmd("reg");
        System.out.println("请输入用户名");
        String username =null;
        String password =null;
        //判断输入是否为空，如果为空则回调reg()
        //使用trim()方法去掉空格
        if((username =scan.nextLine()).trim().isEmpty()) {          
                System.out.println("用户名不能为空，请重新输入");
                reg();          
        }else {
            System.out.println("请输入密码");
            if((password=scan.nextLine()).trim().isEmpty()) {
                System.out.println("密码不能为空，请重新输入");                 
                reg();
            }else {
                System.out.println("请确认密码");
                String password2;
                //判断确认密码是否为空以及两次输入是否相等
                if((password2 =scan.nextLine()).trim().isEmpty()||!password.equals(password2)) {
                    System.out.println("两次输入的密码不一样，请重新注册");
                    reg();
                }else {
                    //封装user对象
                    user = new Users();
                    user.setUsername(username);
                    user.setPassword(password);
                    transfer.setObj(user);
                    socket = new Socket("localhost",12345);
                    //向服务器发送transfer对象
                    outToServer(transfer);
                    //获取服务器执行结果
                    transfer = getFromServer();
                    if(transfer.isFlag()) {
                        System.out.println("注册成功，请登录");
                        login();
                    }
                    else {
                        System.out.println("注册失败，请重新注册");
                        reg();
                    }
                    System.out.println(user.getUsername()+user.getPassword());
                }
            }           
        }       
    }

    public void login() throws UnknownHostException, IOException {          
        CommandTransfer transfer = new CommandTransfer();
        //设置操作为登录login
        transfer.setCmd("login");
        System.out.println("请输入用户名");
        String username =null;
        String password =null;
        if((username =scan.nextLine()).trim().isEmpty()) {          
            System.out.println("用户名不能为空，请重新输入");
            login();            
        }else {
            System.out.println("请输入密码");
            if((password=scan.nextLine()).trim().isEmpty()) {
                System.out.println("密码不能为空，请重新输入");                 
                login();
            }
            else {
                user = new Users();
                user.setUsername(username);
                user.setPassword(password);
                transfer.setObj(user);
                socket = new Socket("localhost",12345);
                outToServer(transfer);
                transfer = getFromServer();
                if(transfer.isFlag()) {
                    //登录成功之后提示用户上传文件
                    System.out.println("登录成功,可以上传文件了");
                    upFile();
                }
                else {
                    System.out.println("登录失败，请检查用户名或密码");
                    login();
                }
            }
        }       
    }
    /**
     * 上传文件
     */
    public void upFile()  {
        fileUp = new FileUp();
        CommandTransfer transfer = new CommandTransfer();
        //设置操作为上传文件upload
        transfer.setCmd("upload");
        System.out.println("请输入上传文件的路径,格式如D:/123.txt");
        String path = scan.nextLine();
        File file = new File(path);
        //获取文件名
        String filename = file.getName();
        if(!file.exists()) {
            System.out.println("文件不存在，请重新输入");
            upFile();
        }
        if(!file.isFile()) {
            System.out.println("你所选择的不是文件，请重新输入");
            upFile();
        }

        try {
            FileInputStream fis = new FileInputStream(path);
            //使用fis.available()可以获取文件的大小
            byte[] content = new byte[fis.available()]; 
            //读取文件
            while(fis.read(content,0,content.length)!=-1) {
                fileUp.setFilename(filename);
                fileUp.setFileContent(content);
                transfer.setObj(fileUp);
            }
            socket = new Socket("localhost",12345);
            outToServer(transfer);
            transfer = getFromServer();
            fis.close();
            if(transfer.isFlag()) {
                //上传成功后客户端就停止运行了
                System.out.println("文件上传成功！");              
            }
            else {
                System.out.println("文件上传失败，请检查文件名");
                upFile();
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

        /**
         * 向服务器发送transfer对象
         * @param transfer
         * @throws IOException
         */
    public void outToServer(CommandTransfer transfer) throws IOException  {
        OutputStream os = socket.getOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(os);
        oos.writeObject(transfer);
        oos.flush();

    }

    /**
     * 获取服务器发送的信息，其实就一个flag
     */
    public CommandTransfer getFromServer() throws UnknownHostException, IOException {   
        InputStream is;
        ObjectInputStream ois;
        CommandTransfer transfer = null;
        try {           
            is = socket.getInputStream();
            ois = new ObjectInputStream(is);
            //需要强制类型转换
            transfer = (CommandTransfer)ois.readObject();

        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        //返回一个transfer对象,让其它方法调用里面的isFlag()方法来判断是否执行成功
        return transfer;        
    }
}