StreamCorruptedException

[smek]

Hallo allemaal,

Ik ben bezig met een client/server project waarbij ik graag na het verwijderen van een item uit de database op de server een bericht naar de clients sturen om deze te refreshen.
De server is multithreaded ik houd de clients Threads bij in een arraylist. Zodra er een client iets verwijderd dan wordt er met een broadcast method een bericht naar elke client gestuurd.

Aan de client kant moet ik dit bericht opvangen en dan gaat het fout en krijg ik een StreamCorruptedException. Kan iemand mij uit de brand helpen? Ik heb geen idee hoe ik dit goed voor elkaar krijg.

Hieronder de belangrijkste code.

server.java

package marktplaats;

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

import javax.swing.*;

public class Server extends JFrame{
	private ArrayList<HandleAClient> list = new ArrayList<HandleAClient>();
	
	public static void main(String[] args) {
		new Server();
	}

	public Server() {
		setTitle("Administrator");
		setBounds(600,250,300,300);
		setVisible(true);
		
		try {
			// Create a server socket
			ServerSocket serverSocket = new ServerSocket(8000);

			// Number a client
			int clientNo = 1;

			while (true) {
				// Listen for a new connection request
				Socket socket = serverSocket.accept();
				Log log = new Log();
				
				// Find the client's host name, and IP address
				InetAddress inetAddress = socket.getInetAddress();
				
				log.writeToLog("Clientnumber = " + clientNo + "\ndate = "
						+ new Date() + " clients IP = "
						+ inetAddress.getHostAddress());
				
				// Create a new thread for the connection
				HandleAClient task = new HandleAClient(socket, this);
				list.add(task);
				// Start the new thread
				task.start();

				// Increment clientNo
				clientNo++;
			}
		} catch (IOException ex) {
			System.err.println(ex);
		}
	}
	
	public synchronized void broadcast(){
		for(HandleAClient client : list){
			client.sendRefresh();
		}
	}
}

HandleAClient.java

package marktplaats;

import java.io.*;
import java.net.*;
import java.util.ArrayList;

import marktplaats.models.*;

class HandleAClient extends Thread {
	private Socket socket; // A connected socket
	private ObjectInputStream inputFromClient;
	private ObjectOutputStream outputToClient;
	private Log log = new Log();
	private PrintWriter outStream;
	private Server server;
	
	/** Construct a thread */
	public HandleAClient(Socket socket, Server server) {
		this.socket = socket;
		this.server = server;
	}

	/** Run a thread */
	public void run() {
		try {
			inputFromClient = new ObjectInputStream(socket.getInputStream());
			outputToClient = new ObjectOutputStream(socket.getOutputStream());
			outStream = new PrintWriter(socket.getOutputStream(), true);
			
			boolean clientActive = true;
			while (clientActive) {
				Message message = (Message) inputFromClient.readObject();
				if (message.getMethod().equals("login")) {
					User user = (User) message.getObj();
					outputToClient.writeObject(login(user));
				}
				if(message.getMethod().equals("addUser")){
					User user =(User) message.getObj();
					user = addUser(user);
					outputToClient.writeObject(user);
				}
				
				if (message.getMethod().equals("addPrikbordItem")) {
					PrikbordItem item = (PrikbordItem) message.getObj();
					addPrikbordItem(item);
					//server.broadcast();
				}
				if (message.getMethod().equals("getPrikbordItem")) {
					PrikbordItem item = getPrikbordItem((PrikbordItem) message
							.getObj());
					outputToClient.writeObject(item);
				}
				if (message.getMethod().equals("getLog")) {
					String logText = log.readFromLog();
					outputToClient.writeObject(logText);
				}
				if (message.getMethod().equals("getPrikbordItems")) {
					outputToClient.writeObject(getPrikbordItems());
				}
				if (message.getMethod().equals("updatePrikbordItem")) {
					PrikbordItem item = (PrikbordItem) message.getObj();
					updatePrikbordItem(item);
					//server.broadcast();
				}
				if (message.getMethod().equals("deletePrikbordItem")) {
					PrikbordItem item = (PrikbordItem) message.getObj();
					deletePrikbordItem(item);
					//server.broadcast();
				}
				if (message.getMethod().equals("getPrikbordItemsTotal")) {
					outputToClient.writeObject(getPrikbordItemsTotal());
				}
				if (message.getMethod().equals("bye")) {
					clientActive = false;
				}
			}
			socket.close();
		} catch (IOException e) {
			log.writeToLog(e.getMessage());
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			log.writeToLog(e.getMessage());
		}
		
		
	}

	private User addUser(User user) {
		UserModel model = new UserModel();
		user = (User) model.save(user);
		return user;
	}

	private User login(User user) {
		UserModel model = new UserModel();
		user = model.login(user);
		return user;
	}

	private void addPrikbordItem(PrikbordItem prikborditem) {
		PrikbordItemModel model = new PrikbordItemModel();
		model.save(prikborditem);
	}

	private PrikbordItem getPrikbordItem(PrikbordItem prikbordItem) {
		PrikbordItemModel model = new PrikbordItemModel();
		return model.findById(prikbordItem.getId());
	}

	private ArrayList<PrikbordItem> getPrikbordItems() {
		PrikbordItemModel model = new PrikbordItemModel();
		return model.findAll();
	}

	private void updatePrikbordItem(PrikbordItem prikborditem) {
		PrikbordItemModel model = new PrikbordItemModel();
		if (model.update(prikborditem)) {
			System.out.println("Opgeslagen");
		}
	}
	//findAllWithAds
	private void deletePrikbordItem(PrikbordItem item) {
		PrikbordItemModel model = new PrikbordItemModel();
		if(model.delete(item.getId())){
			System.out.println("Verwijderd");
		}
	}
	private ArrayList<User> getPrikbordItemsTotal(){
		UserModel model = new UserModel();
		return model.findAllWithAds();
	}

	public void sendRefresh() {
		try {
			Message message = new Message();
			message.setMethod("refresh");
			outputToClient.writeObject(message);
			outputToClient.flush();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

client kant

Marktplaats.java

package marktplaats;

import java.awt.*;
import java.awt.event.*;
import java.io.*;

import javax.swing.*;

import marktplaats.models.*;

public class Marktplaats extends JFrame implements ActionListener {
	
	private JMenuBar menuBar = new JMenuBar();
	private JMenu bestand;
	private JMenuItem nieuw, lijst, showlog, showstats;
	private ServerInterface server = new ServerInterface();
	private UpdatePanel updatePanel;
	private LijstPanel lijstPanel;
	private LogPanel logPanel;
	private StatsPanel statsPanel;
	private JTable table;
	private User user;
	private CheckDialog dialog = new CheckDialog(this);
	private JFrame frame;
	private ListenToServer listen;
	private ObjectInputStream sInput;
	public static void main(String[] args) {
		new Marktplaats();
	}
	
	/**
	 * Constructor Martkplaats
	 * Shows an login dialog if user is logged in it shows various JPanels
	 */
	public Marktplaats() {
		sInput = server.getInputStream();
		//Eerst inloggen
		LoginDialog dialoog = new LoginDialog(this, server);
		dialoog.setVisible(true);
		
		//Is de gebruiker ingelogd?
		if(dialoog.getUser() != null){
			
			this.user = dialoog.getUser();
			setTitle("Welkom " + this.user.getName());
			frame = this;
			setSize(700, 500);
			
			//Maak een eigen CloseOperation
			setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
			addWindowListener(new WindowAdapter()
			{
			    public void windowClosing(WindowEvent e)
			    {
			        JFrame frame = (JFrame)e.getSource();
			        //Sluit de verbinding met de server
			        server.bye();
		            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
			    }
			});
			
			this.initializeMenu();
	
			setLayout(new BorderLayout());
			addLijstPanel();
			setVisible(true);
			listen = new ListenToServer();
			listen.start();
		} else {//Gebruiker is niet ingelogd
			//Sluit de verbinding met de server en sluit de applicatie
			server.bye();
			System.exit(0);
		}
	}
	/**
	 * initializeMenu
	 * Initializes the main menu
	 */
	public void initializeMenu() {
		// Stel menu balk in
		setJMenuBar(menuBar);

		bestand = new JMenu("Bestand");
		
		lijst = new JMenuItem("Lijst");
		lijst.addActionListener(this);
		bestand.add(lijst);
		
		showlog = new JMenuItem("Open log");
		showlog.addActionListener(this);
		bestand.add(showlog);
		
		showstats = new JMenuItem("Open Statistieken");
		showstats.addActionListener(this);
		bestand.add(showstats);
		
		menuBar.add(bestand);
	}
	/**
	 * Method addUpdatePanel
	 * Adds the JPanel to update a PrikbordItem
	 * @param id identifier of PrikbordItem
	 */
	public void addUpdatePanel(int id) {
		getContentPane().removeAll();
		updatePanel = new UpdatePanel(this, server, id);
		add(updatePanel, BorderLayout.CENTER);
		updatePanel.revalidate();
	}
	/**
	 * Method addLijstPanel
	 * Adds the JPanel that shows a list of PrikbordItems
	 * and implements a MouseListener to listen to clicks
	 */
	public void addLijstPanel() {
		lijstPanel = new LijstPanel();
		table = lijstPanel.initTable(server);
		add(lijstPanel, BorderLayout.CENTER);
		
		table.addMouseListener(new MouseAdapter() {
			public void mouseClicked(MouseEvent e) {
				int row = table.rowAtPoint(e.getPoint());
				int column = table.columnAtPoint(e.getPoint());
				int cellvalue =  Integer.parseInt((String) table.getModel().getValueAt(row, 0));
				if(column == 5){
					addUpdatePanel(cellvalue);
				}
				if(column == 6){
					dialog.setVisible(true);
					if(dialog.getOk()){
						server.deletePrikbordItem(cellvalue);
						getContentPane().removeAll();
						addLijstPanel();
					}
				}
			}
		});
		lijstPanel.revalidate();
	}
	
	public void addLogPanel() {
		logPanel = new LogPanel(server);
		add(logPanel, BorderLayout.CENTER);
		logPanel.revalidate();
	}
	/**
	 * Method addNieuwPanel
	 * Adds the JPanel to add a new PrikbordItem
	 */
	public void addStatsPanel() {
		statsPanel = new StatsPanel(server);
		add(statsPanel, BorderLayout.CENTER);
		statsPanel.revalidate();
	}
	
	@Override
	public void actionPerformed(ActionEvent e) {
		//Verwijder alle JPanels
		getContentPane().removeAll();
		if (e.getSource() == lijst) {
			addLijstPanel();
		}
		if (e.getSource() == showlog) {
			addLogPanel();
		}
		if (e.getSource() == showstats) {
			addStatsPanel();
		}
		repaint();
	}
	
	private class ListenToServer extends Thread{
		
		public void run(){
			System.out.println("Listen Started");
			while(true) {
				try {
					Message msg = (Message) sInput.readObject();
					if(msg.getMethod().equals("refresh")){
						System.out.println("refresh");
						getContentPane().revalidate();
					}
				}
				catch(IOException e) {
					System.out.println(e.toString());
				}
				catch (ClassNotFoundException e) {
					System.out.println(e.toString());
				}
			}
			
		}
	}
}

 

[Westerland]

Het lijkt mij dat die vastloopt op:


msg = (Message) sInput.readObject();


de sInput vraag je op via server.getInputStream();

had je hier een eige classe voor gemaakt ? ( de class/interface ServerInterface, of is dit onderdeel van een reeds bestaand framework )

Waarom doe je het overigens niet gewoon met Sockets zoals de serverside doet ?

je kan het namelijk op exact dezelfde manier afhandelen met in/output stream.

 

[smek]

De client werkt ook met sockets ik was alleen vergeten deze klasse erbij te posten. De klasse Marktplaats kent deze klasse en gebruikt deze om verbinding met de server te maken en objecten van en naar de server te sturen.
Met de method getInputStream haal ik de ObjectInputStream op en zo zou ik dus readObject moeten kunnen gebruiken.

package marktplaats.models;

import java.io.*;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.ArrayList;
import marktplaats.Message;

/**
 * Class ServerInterface
 * This class is the interface to communicate with te server.
 * @author Sander Groen
 * @version 1.0
 */
public class ServerInterface {
	private Socket socket;
	private ObjectOutputStream toServer;
	private ObjectInputStream fromServer;
	
	public ServerInterface(){
		try {
			socket = new Socket("localhost", 8000);
			toServer = new ObjectOutputStream(socket.getOutputStream());
			fromServer = new ObjectInputStream(socket.getInputStream());
		} catch (UnknownHostException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
	public ObjectInputStream getInputStream(){
		return this.fromServer;
	}
	/**
	 * getPrikbordItem
	 * @param id identifier of PrikbordItem
	 * @return an PrikbordItem object
	 */
	public PrikbordItem getPrikbordItem(int id){
		PrikbordItem item = new PrikbordItem();
		try {
			PrikbordItem p = new PrikbordItem();
			p.setId(id);
			
			Message msg = new Message();
			msg.setObj(p);
			// Vraag de methode naam op van deze methode
			msg.setMethod(Thread.currentThread().getStackTrace()[1].getMethodName());
			
			toServer.writeObject(msg);
			toServer.flush();
			
			item = (PrikbordItem) fromServer.readObject();
			return item;
		} 
		catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		catch (IOException e) {
			System.err.println(e.getMessage());
		}
		return null;
	}
	/**
	 * getPrikbordItems
	 * @return all PrikbordItems in an arraylist
	 */
	public ArrayList<PrikbordItem> getPrikbordItems(){
		try {
			PrikbordItem p = new PrikbordItem();
			p.setId(1);
			
			Message msg = new Message();
			// Vraag de methode naam op van deze methode
			msg.setMethod(Thread.currentThread().getStackTrace()[1].getMethodName());
			msg.setObj(p);
			toServer.writeObject(msg);
			
			ArrayList<PrikbordItem> prikborditems = 
				(ArrayList<PrikbordItem>) fromServer.readObject();
			return prikborditems;
		} catch (IOException ex) {
			System.err.println(ex);
		}
		catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		return null;
	}
	/**
	 * addPrikbordItem
	 * @param prikborditem object of PrikbordItem to send to server
	 */
	public void addPrikbordItem(PrikbordItem prikborditem){
		try {
			Message msg = new Message();
			// Vraag de methode naam op van deze methode
			msg.setMethod(Thread.currentThread().getStackTrace()[1].getMethodName());
			msg.setObj(prikborditem);
			toServer.writeObject(msg);
		} catch (IOException ex) {
			System.err.println(ex);
		}
	}
	/**
	 * updatePrikbordItem
	 * @param prikborditem object of PrikbordItem to update on server
	 */
	public void updatePrikbordItem(PrikbordItem prikborditem){
		try {
			Message msg = new Message();
			// Vraag de methode naam op van deze methode
			msg.setMethod(Thread.currentThread().getStackTrace()[1].getMethodName());
			msg.setObj(prikborditem);
			toServer.writeObject(msg);
		} catch (IOException ex) {
			System.err.println(ex);
		}
	}
	/**
	 * Method bye closes connection with server
	 */
	public void bye(){
		try {
			Message msg = new Message();
			// Vraag de methode naam op van deze methode
			msg.setMethod(Thread.currentThread().getStackTrace()[1].getMethodName());
			PrikbordItem prikborditem = new PrikbordItem();
			msg.setObj(prikborditem);
		toServer.writeObject(msg);
		} catch (IOException ex) {
			System.err.println(ex);
		}
	}
	
	public User login(User user) {
		try {
			Message msg = new Message();
			// Vraag de methode naam op van deze methode
			msg.setMethod(Thread.currentThread().getStackTrace()[1].getMethodName());
			msg.setObj(user);
			toServer.writeObject(msg);
			user = (User) fromServer.readObject();
		} catch (IOException ex) {
			System.err.println(ex);
		}
		catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		return user;
	}
	
	public void deletePrikbordItem(int cellvalue) {
		PrikbordItem prikborditem = new PrikbordItem();
		prikborditem.setId(cellvalue);
		try {
			Message msg = new Message();
			// Vraag de methode naam op van deze methode
			msg.setMethod(Thread.currentThread().getStackTrace()[1].getMethodName());
			msg.setObj(prikborditem);
			toServer.writeObject(msg);
		} catch (IOException ex) {
			System.err.println(ex);
		}
	}
	public User addUser(User user) {
		try {
			Message msg = new Message();
			// Vraag de methode naam op van deze methode
			msg.setMethod(Thread.currentThread().getStackTrace()[1].getMethodName());
			msg.setObj(user);
			toServer.writeObject(msg);
			user = (User) fromServer.readObject();
		} catch (IOException ex) {
			System.err.println(ex);
		}
		catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		return user;
	}
	
	public String getLog(){
		String log = "";
		try {
			Message msg = new Message();
			msg.setMethod(Thread.currentThread().getStackTrace()[1].getMethodName());
			toServer.writeObject(msg);
			log = (String) fromServer.readObject();
		} catch (IOException ex) {
			System.err.println(ex);
		} catch (ClassNotFoundException e) {
			System.err.println(e);
		}
		return log;
	}
	
	public ArrayList<User> getPrikbordItemsTotal() {
		try {
			Message msg = new Message();
			msg.setMethod(Thread.currentThread().getStackTrace()[1].getMethodName());
			toServer.writeObject(msg);
			ArrayList<User> prikbordItemsTotal = 
				(ArrayList<User>) fromServer.readObject();
			return prikbordItemsTotal;
		} catch (IOException ex) {
			System.err.println(ex);
		} catch (ClassNotFoundException e) {
			System.err.println(e);
		}
		return null;
	}
}

 

[Westerland]

Het lijkt mij niet in de socket verbinding te zitten. Heb je al getest of de sockets uberhaupt een goede verbinding maken ? zo niet misschien moet je ipv "localhost" "127.0.0.1" gebruiken.
Wat verder een probleem kan zijn is de message die je over de sockets stuurd ? implements de class (en alle subclasses die die class gebruikt) de interface Serializeable wel ?

mocht dit niet het geval zijn zou je dan het project willen rarren ? dan zal ik morgenavond kijken of ik er uit kom (als het nog niet opgelost is)