Java 如何使用thred让服务器与客户端通信

我们使用rfid阅读器和mysql数据库创建了一个系统，可以让我使用mifare卡通过门锁系统，因为我们已经构建了一个UI，我们需要让服务器将消息发送回客户端

例如，“你通过了门”之类的事情，我们试图使用多线程来实现我们的目标，但它继续停止

这是密码

public class DoorServer4 {
static{
    try{

        Class.forName("com.mysql.jdbc.Driver");
        System.out.println("connect ti MySQLToJava");
    }
    catch (Exception e){
        System.out.println("Error loading MySQL Driver");
        e.printStackTrace();
    }
}
public class EchoThread extends Thread {
    PrintWriter out;
    String wel;
    public EchoThread(Socket ss, String wel) throws IOException{
        this.wel = wel;
        out = new PrintWriter(new OutputStreamWriter(ss.getOutputStream()));
    }
    public void printText() throws IOException{
        out.println(wel);
        out.flush();
    }
    public void run(){
        try {
            printText();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }


}

public static void main(String[] args) throws IOException {
    // TODO Auto-generated method stub
    new DoorServer4().go();

    }        

    public void go() throws IOException{        
    String wel = null;
    ArrayList<String> list=new ArrayList<String>();

    ServerSocket ss = new ServerSocket(25566);
    System.out.println("start listening...");

    while(true){
    Socket socket = ss.accept();
    System.out.println("client connected...");

    InputStream rawIn = socket.getInputStream();

    BufferedReader in = new BufferedReader(new InputStreamReader(rawIn));
      String line=null;
      while ((line=in.readLine()) != null) {
          list.add(line);
          //System.out.println(line);
          }
     System.out.println(list.get(0));
     System.out.println(list.get(1));

    try{

        DBConnection DBCon = new
                DBConnection("jdbc:mysql://localhost/lanyang?useUnicode=true&characterEncoding=big5","root","1234");
        Connection conn = DBCon.makeConnection();

        Statement stmt = conn.createStatement();
        ResultSet rs = stmt.executeQuery("SELECT `m_name`,`card_num` FROM memberdata WHERE `card_num` LIKE '"+list.get(0)+"%'") ;  
        if(rs.next()){
        String card = rs.getString("card_num");
        if(card !="")
          wel = "welcome"+rs.getString("m_name");
            System.out.println("welcome"+rs.getString("m_name"));

            Statement st = conn.createStatement();
            String qry1 = "INSERT INTO door VALUES ('" +list.get(0)+"','" +list.get(1)+"')";
            st.executeUpdate(qry1);
        }
        else{

            wel = "member not found";
            System.out.println("member not found");
        }
    }
    catch(Exception e){
        e.printStackTrace();
    }
     EchoThread echo = new EchoThread(socket, wel);
        echo.start();
        list.clear();
    }

}

    }

公共类门服务器4{
静止的{
试一试{
Class.forName（“com.mysql.jdbc.Driver”）；
System.out.println（“connectti MySQLToJava”）；
}
捕获（例外e）{
System.out.println（“加载MySQL驱动程序时出错”）；
e、 printStackTrace（）；
}
}
公共类EchoThread扩展线程{
打印输出；
弦乐；
公共EchoThread（套接字ss、字符串wel）引发IOException{
this.wel=wel；
out=新的PrintWriter（新的OutputStreamWriter（ss.getOutputStream（））；
}
public void printText（）引发IOException{
out.println（wel）；
out.flush（）；
}
公开募捐{
试一试{
printText（）；
}捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
}
}
公共静态void main（字符串[]args）引发IOException{
//TODO自动生成的方法存根
新的门服务器4（）.go（）；
}        
public void go（）引发IOException{
字符串wel=null；
ArrayList=新建ArrayList（）；
ServerSocket ss=新的ServerSocket（25566）；
System.out.println（“开始侦听…”）；
while（true）{
套接字=ss.accept（）；
System.out.println（“客户端连接…”）；
InputStream rawIn=socket.getInputStream（）；
BufferedReader in=新的BufferedReader（新的InputStreamReader（rawIn））；
字符串行=null；
而（（line=in.readLine（））！=null）{
列表。添加（行）；
//系统输出打印项次（行）；
}
System.out.println（list.get（0））；
System.out.println（list.get（1））；
试一试{
DBCon=new
数据库连接（“jdbc:mysql://localhost/lanyang?useUnicode=true&characterEncoding=big5“，”根“，”1234”）；
连接conn=DBCon.makeConnection（）；
语句stmt=conn.createStatement（）；
ResultSet rs=stmt.executeQuery（“从memberdata中选择'm_name'，'card_num'，其中'card_num'LIKE'”+“列表。获取（0）+“%”；
如果（rs.next（））{
String card=rs.getString（“card_num”）；
如果（卡片！=“”）
well=“welcome”+rs.getString（“m_name”）；
System.out.println（“欢迎”+rs.getString（“m_name”）；
语句st=conn.createStatement（）；
String qry1=“插入到门值中（“+list.get（0）+”，“+list.get（1）+”）；
st.executeUpdate（qry1）；
}
否则{
wel=“未找到成员”；
System.out.println（“未找到成员”）；
}
}
捕获（例外e）{
e、 printStackTrace（）；
}
EchoThread echo=新EchoThread（插座，wel）；
echo.start（）；
list.clear（）；
}
}
}

党卫军

公共类门客户端3{
打印流编写器；
缓冲读取器；
插座；
公共静态void main（字符串[]args）引发CardException{
//TODO自动生成的方法存根
DoorClient3客户端=新的DoorClient3（）；
client.go（）；
}
public void go（）引发CardException{
设置网络（）；
SimpleDataFormat sdFormat=新的SimpleDataFormat（“yyyy/MM/dd hh:MM:ss”）；
String nowDate=sdFormat.format（new Date（））；
//显示终端列表
TerminalFactory=TerminalFactory.getDefault（）；
列表端子=工厂.terminals（）.List（）；
System.out.println（“终端：+终端”）；
//使用第一个终端
CardTerminal=terminals.get（0）；
//连接卡
卡=终端。连接（“*”）；
System.out.println（“卡：+卡”）；
CardChannel=card.getBasicChannel（）；
//发送选择小程序命令
responseADU answer=channel.transmit（新命令ADDU（新字节[]{（字节）0xFF，（字节）0xCA，（字节）0x00，（字节）0x00，（字节）0x00}）；
System.out.println（“答案：+answer.toString（））；
//发送测试命令
应答=通道.传输（新命令ADDU（新字节[]{（字节）0xFF，（字节）0xCA，（字节）0x00，（字节）0x00，（字节）0x00}）；
System.out.println（“答案：+answer.toString（））；
//字节r[]=answer.getData（）；
字符串hex=DatatypeConverter.printHexBinary（answer.getBytes（））；
writer.println（（字符串）十六进制）；
writer.print（（字符串）nowDate）；
writer.flush（）；
writer.close（）；
//断开卡的连接
卡。断开连接（错误）；
试一试{
睡眠（10000）；
}捕捉（中断异常e）{
e、 printStackTrace（）；
}
线程读取器线程=新线程（new IncomingReader（））；
readerThread.start（）；
}
专用网络（）{
试一试{
套接字=新套接字（“本地主机”，25566）；
InputStreamReader rawIn=新的InputStreamReader（socket.getInputStream（））；
in=新的缓冲读取器（rawIn）；
writer=newprintstream（socket.getOutputStream（））；
}捕获（IOEX异常）{
例如printStackTrace（）；
}
}
公共类IncomingReader实现Runnable{
@凌驾
公开募捐{
//TODO自动生成的方法存根
字符串消息；
试一试{
而（（message=in.readLine（））！=null）{
System.out.println（“读取”+消息）；
} 
}捕获（例外情况除外）{
例如printStackTrace（）；
}
}
}
}

在

DoorClient3#go（）

中使用

writer.close（）

。这将关闭整个套接字。见： 意味着：您无法将更多数据写入套接字的

OutputStream

。 仅在

输入结束时关闭写入程序（和套接字）
    public class DoorClient3 {

PrintStream writer;
BufferedReader in;
Socket socket;

public static void main(String[] args) throws CardException {
    // TODO Auto-generated method stub
    DoorClient3 client = new DoorClient3();
    client.go();
}
public void go() throws CardException {
    setUpNetworking();
    SimpleDateFormat sdFormat = new SimpleDateFormat("yyyy/MM/dd hh:mm:ss");
       String nowDate = sdFormat.format(new Date());
       // Display the list of terminals
       TerminalFactory factory = TerminalFactory.getDefault();
       List<CardTerminal> terminals = factory.terminals().list();
       System.out.println("Terminals: " + terminals);

       // Use the first terminal
       CardTerminal terminal = terminals.get(0);
       // Connect wit hthe card
       Card card = terminal.connect("*");
       System.out.println("card: " + card);
       CardChannel channel = card.getBasicChannel();
       // Send Select Applet command
       ResponseAPDU answer = channel.transmit(new CommandAPDU(new byte[] { (byte)0xFF, (byte)0xCA, (byte)0x00, (byte)0x00, (byte)0x00 } ));
       System.out.println("answer: " + answer.toString());

       // Send test command
       answer = channel.transmit(new CommandAPDU(new byte[] { (byte)0xFF, (byte)0xCA, (byte)0x00, (byte)0x00, (byte)0x00 } ));
       System.out.println("answer: " + answer.toString());
       //byte r[] = answer.getData();
       String hex = DatatypeConverter.printHexBinary(answer.getBytes());
       writer.println((String)hex);
       writer.print((String)nowDate);
       writer.flush();
       writer.close();
       // Disconnect the card
       card.disconnect(false);

       try{
           Thread.sleep(10000);
       }catch (InterruptedException e){
           e.printStackTrace();
       }

       Thread readerThread = new Thread(new IncomingReader());
       readerThread.start();

}
private void setUpNetworking() {
    try {
        socket = new Socket("localhost", 25566);
        InputStreamReader rawIn = new InputStreamReader(socket.getInputStream());
        in = new BufferedReader(rawIn);
        writer = new PrintStream(socket.getOutputStream());
    }catch(IOException ex) {
        ex.printStackTrace();
    }
}
public class IncomingReader implements Runnable {

    @Override
    public void run() {
        // TODO Auto-generated method stub
        String message;
        try {
            while ((message = in.readLine()) != null) {
                System.out.println("read" + message);
            } 
            }catch(Exception ex){
                ex.printStackTrace();
        }
    }

}

}