Java exception invalid type



How to Fix java.io.StreamCorruptedException: invalid type code in Java?

There are several problems been faced which are as follows:

  1. When you write an object in a file using serialization in java for the first time, no problem arises in reading the file afterward, even when you write multiple objects in one go.
  2. Now, when next time you try to append new objects (of the same type) to that file using serialization, writing the file will be done successfully without any error.
  3. But, reading the file will create a problem and an exception named as StreamCorruptedException will be thrown.

The root cause behind these problems or we can say the reasons are as follows:

  1. Whenever we open a file & try to append a serializable object to the end of the file using ObjectOutputStream & FileOutputStream, ObjectOutputStream will write the header to the end of the file to write the object data. Each time when the file gets open and the first object is written, ObjectOutputStream will write the header to the end of the file prior to the writing of object data.
  2. So, in this way header gets written multiple times whenever the file is opened in append mode to write the object using FileOutputStream & ObjectOutputStream.

In order to fix these issues, several measures are needed to be implemented as follows:

  1. Create your own Object Output Stream class, say MyObjectOutputStream class, by extending ObjectOutputStream (Inheritance) & Override the method : “protected void writeStreamHeader() throws IOException.” In your new class, this method should do nothing.
  2. Now when you write Object for the first time, i.e, when file length is 0, use object of Predefined class ObjectOutputStream, to write the object using writeObject().
  3. This will write the header to the file in the beginning.

Next time whenever you write the object, i.e, when file length is > 0, use the object of Your defined class MyObjectOutputStream, to write the object using writeObject(). As you have overridden the writeStreamHeader() method & it does nothing, the header will not be written again in the file.

Implementation:

Here in order to optimize the program, to get understanding in one go, we will be having 3 different java class files corresponding to their executable java classes

Источник

Java exception invalid type

Table of Contents

When a program violates the semantic constraints of the Java programming language, the Java Virtual Machine signals this error to the program as an exception .

An example of such a violation is an attempt to index outside the bounds of an array. Some programming languages and their implementations react to such errors by peremptorily terminating the program; other programming languages allow an implementation to react in an arbitrary or unpredictable way. Neither of these approaches is compatible with the design goals of the Java SE platform: to provide portability and robustness.

Instead, the Java programming language specifies that an exception will be thrown when semantic constraints are violated and will cause a non-local transfer of control from the point where the exception occurred to a point that can be specified by the programmer.

An exception is said to be thrown from the point where it occurred and is said to be caught at the point to which control is transferred.

Programs can also throw exceptions explicitly, using throw statements (§14.18).

Explicit use of throw statements provides an alternative to the old-fashioned style of handling error conditions by returning funny values, such as the integer value -1 where a negative value would not normally be expected. Experience shows that too often such funny values are ignored or not checked for by callers, leading to programs that are not robust, exhibit undesirable behavior, or both.

Every exception is represented by an instance of the class Throwable or one of its subclasses (§11.1). Such an object can be used to carry information from the point at which an exception occurs to the handler that catches it. Handlers are established by catch clauses of try statements (§14.20).

During the process of throwing an exception, the Java Virtual Machine abruptly completes, one by one, any expressions, statements, method and constructor invocations, initializers, and field initialization expressions that have begun but not completed execution in the current thread. This process continues until a handler is found that indicates that it handles that particular exception by naming the class of the exception or a superclass of the class of the exception (§11.2). If no such handler is found, then the exception may be handled by one of a hierarchy of uncaught exception handlers (§11.3) — thus every effort is made to avoid letting an exception go unhandled.

Читайте также:  Chrome crashes no error message

The exception mechanism of the Java SE platform is integrated with its synchronization model (§17.1), so that monitors are unlocked as synchronized statements (§14.19) and invocations of synchronized methods (§8.4.3.6, §15.12) complete abruptly.

11.1. The Kinds and Causes of Exceptions

11.1.1. The Kinds of Exceptions

An exception is represented by an instance of the class Throwable (a direct subclass of Object ) or one of its subclasses.

Throwable and all its subclasses are, collectively, the exception classes .

The classes Exception and Error are direct subclasses of Throwable :

Exception is the superclass of all the exceptions from which ordinary programs may wish to recover.

The class RuntimeException is a direct subclass of Exception . RuntimeException is the superclass of all the exceptions which may be thrown for many reasons during expression evaluation, but from which recovery may still be possible.

RuntimeException and all its subclasses are, collectively, the run-time exception classes .

Error is the superclass of all the exceptions from which ordinary programs are not ordinarily expected to recover.

Error and all its subclasses are, collectively, the error classes .

The unchecked exception classes are the run-time exception classes and the error classes.

The checked exception classes are all exception classes other than the unchecked exception classes. That is, the checked exception classes are Throwable and all its subclasses other than RuntimeException and its subclasses and Error and its subclasses.

Programs can use the pre-existing exception classes of the Java SE platform API in throw statements, or define additional exception classes as subclasses of Throwable or of any of its subclasses, as appropriate. To take advantage of compile-time checking for exception handlers (§11.2), it is typical to define most new exception classes as checked exception classes, that is, as subclasses of Exception that are not subclasses of RuntimeException .

The class Error is a separate subclass of Throwable , distinct from Exception in the class hierarchy, to allow programs to use the idiom » > catch (Exception e) < " (§11.2.3) to catch all exceptions from which recovery may be possible without catching errors from which recovery is typically not possible.

Note that a subclass of Throwable cannot be generic (§8.1.2).

11.1.2. The Causes of Exceptions

An exception is thrown for one of three reasons:

A throw statement (§14.18) was executed.

An abnormal execution condition was synchronously detected by the Java Virtual Machine, namely:

evaluation of an expression violates the normal semantics of the Java programming language (§15.6), such as an integer divide by zero.

an error occurs while loading, linking, or initializing part of the program (§12.2, §12.3, §12.4); in this case, an instance of a subclass of LinkageError is thrown.

an internal error or resource limitation prevents the Java Virtual Machine from implementing the semantics of the Java programming language; in this case, an instance of a subclass of VirtualMachineError is thrown.

These exceptions are not thrown at an arbitrary point in the program, but rather at a point where they are specified as a possible result of an expression evaluation or statement execution.

An asynchronous exception occurred (§11.1.3).

11.1.3. Asynchronous Exceptions

Most exceptions occur synchronously as a result of an action by the thread in which they occur, and at a point in the program that is specified to possibly result in such an exception. An asynchronous exception is, by contrast, an exception that can potentially occur at any point in the execution of a program.

Asynchronous exceptions occur only as a result of:

An invocation of the (deprecated) stop method of class Thread or ThreadGroup .

The (deprecated) stop methods may be invoked by one thread to affect another thread or all the threads in a specified thread group. They are asynchronous because they may occur at any point in the execution of the other thread or threads.

Читайте также:  Localization error что это

An internal error or resource limitation in the Java Virtual Machine that prevents it from implementing the semantics of the Java programming language. In this case, the asynchronous exception that is thrown is an instance of a subclass of VirtualMachineError .

Note that StackOverflowError , a subclass of VirtualMachineError , may be thrown synchronously by method invocation (§15.12.4.5) as well as asynchronously due to native method execution or Java Virtual Machine resource limitations. Similarly, OutOfMemoryError , another subclass of VirtualMachineError , may be thrown synchronously during class instance creation (§15.9.4, §12.5), array creation (§15.10.2, §10.6), class initialization (§12.4.2), and boxing conversion (§5.1.7), as well as asynchronously.

The Java SE platform permits a small but bounded amount of execution to occur before an asynchronous exception is thrown.

Asynchronous exceptions are rare, but proper understanding of their semantics is necessary if high-quality machine code is to be generated.

The delay noted above is permitted to allow optimized code to detect and throw these exceptions at points where it is practical to handle them while obeying the semantics of the Java programming language. A simple implementation might poll for asynchronous exceptions at the point of each control transfer instruction. Since a program has a finite size, this provides a bound on the total delay in detecting an asynchronous exception. Since no asynchronous exception will occur between control transfers, the code generator has some flexibility to reorder computation between control transfers for greater performance. The paper Polling Efficiently on Stock Hardware by Marc Feeley, Proc. 1993 Conference on Functional Programming and Computer Architecture, Copenhagen, Denmark, pp. 179-187, is recommended as further reading.

11.2. Compile-Time Checking of Exceptions

The Java programming language requires that a program contains handlers for checked exceptions which can result from execution of a method or constructor (§8.4.6, §8.8.5). This compile-time checking for the presence of exception handlers is designed to reduce the number of exceptions which are not properly handled. For each checked exception which is a possible result, the throws clause for the method or constructor must mention the class of that exception or one of the superclasses of the class of that exception (§11.2.3).

The checked exception classes (§11.1.1) named in the throws clause are part of the contract between the implementor and user of the method or constructor. The throws clause of an overriding method may not specify that this method will result in throwing any checked exception which the overridden method is not permitted, by its throws clause, to throw (§8.4.8.3). When interfaces are involved, more than one method declaration may be overridden by a single overriding declaration. In this case, the overriding declaration must have a throws clause that is compatible with all the overridden declarations (§9.4.1).

The unchecked exception classes (§11.1.1) are exempted from compile-time checking.

Error classes are exempted because they can occur at many points in the program and recovery from them is difficult or impossible. A program declaring such exceptions would be cluttered, pointlessly. Sophisticated programs may yet wish to catch and attempt to recover from some of these conditions.

Run-time exception classes are exempted because, in the judgment of the designers of the Java programming language, having to declare such exceptions would not aid significantly in establishing the correctness of programs. Many of the operations and constructs of the Java programming language can result in exceptions at run time. The information available to a Java compiler, and the level of analysis a compiler performs, are usually not sufficient to establish that such run-time exceptions cannot occur, even though this may be obvious to the programmer. Requiring such exception classes to be declared would simply be an irritation to programmers.

For example, certain code might implement a circular data structure that, by construction, can never involve null references; the programmer can then be certain that a NullPointerException cannot occur, but it would be difficult for a Java compiler to prove it. The theorem-proving technology that is needed to establish such global properties of data structures is beyond the scope of this specification.

Читайте также:  Resource id error php

We say that a statement or expression can throw an exception class E if, according to the rules in §11.2.1 and §11.2.2, the execution of the statement or expression can result in an exception of class E being thrown.

We say that a catch clause can catch its catchable exception class(es):

The catchable exception class of a uni- catch clause is the declared type of its exception parameter (§14.20).

The catchable exception classes of a multi- catch clause are the alternatives in the union that denotes the type of its exception parameter.

Источник

StreamCorruptedException: invalid type code: AC

I’m just writing a small application which is supposed to send serialized objects via network. The first object a client sends to the server is correctly answered by the server (sends an answer object). However, every further object the client sends causes a StreamCorruptionError on the server side. This problem occurs always when server and client are on localhost. If they are on two different machines it seems to work. Any ideas why is that?
I guess there is some conceptual mistake in my code. How to handle the ObjectOutputStreams and ObjectInputStreams correctly.

Here is the main client code: This is the server: This is the ServerThread (for listening): Thanks for your help in advance.
Yours,
Peter

Comments

You must create the ObjectInputStream and the ObjectOutputStream for the life of the socket at both ends, or anew for each ob ject at both ends. Not a mixture of the two.

Also you should always close the output stream of a socket before closing its input stream or the socket itself, which in fact are redundant once you’ve closed the output stream.

Ok, I have a little bit difrent problem, but maybe you can help me.
I have two sides, which want to comunicate each other. Both of them ae listening for connection from the other one, and one connection arrived, the connection is establish. The problem is, when I would like to disconnect (for example by Disconet button on on of the sides).
Both sides implementes class comunicator, which handles serverThread (for listening for arriving connection) and clientThread (to create when connecting, or when connection arvied). Clases for communicator, ServerThread, and Client thread looks like this:
public class Communicator <
private Socket socket;
private ServerSocket serverSocket;
private UserInputDataThread thread;
private UserServerThread serverthread;
private int port;

public Communicator(int port) <
try <
serverSocket = new ServerSocket(port);
>
catch(Exception e) <
System.out.println(«Tworzymy comunicator:»+e);
>
this.port=port;
serverthread=new UserServerThread(serverSocket);
serverthread.start();

//for connecting with other side
public Socket connect(String host, int port) <
try <
socket = new Socket(host,port);
thread = new UserInputDataThread(socket, user ,userWindow);
thread.start();
System.out.println(«Watek startuje. «);
>
catch(Exception e) <
System.out.println(«W metodzie Connect: «+e);
>
return socket;
>

//for disconnecting with other side
public void disconnect() <
System.out.println(«Disconnect»);
thread.sendMessage(new Disconnect());
thread.Stop();
userWindow.getConnectionWindow().DisplayMessage(«Connection closed.\n»);
userWindow.DisplayBottomMassage(«Disconnected»);
System.out.println(«Rozlaczenie»);
>

public void setThread( UserInputDataThread thread) <
this.thread = thread;
>
>
//Server Thread for listining for conections
public class UserServerThread extends Thread <
ServerSocket serverSocket;
UserInputDataThread thread;
Socket socket;

public UserServerThread(ServerSocket serverSocket) <
this.serverSocket=serverSocket;
>

public void run() <
while(true) <
try <
socket = serverSocket.accept();

thread= new UserInputDataThread(socket);
thread.start();
user.getCommunicator().setThread(thread);
>
catch(IOException e) <
//System.out.println(«W watku servera: «+e);
>
>
>

public class UserInputDataThread extends Thread <
protected Socket socket;
protected boolean state=true;
ObjectInputStream Objectin;
ObjectOutputStream Objectout;

//Client thread
public UserInputDataThread(Socket socket, <
this.socket = socket;
state=true;

>
public void run() <
Message message;
try <
Objectout = new ObjectOutputStream(socket.getOutputStream());
Objectin = new ObjectInputStream(socket.getInputStream());

while(state) <
try <
message = (Message)Objectin.readObject();
user.receivedMessage(message, new CommunicatorAddress(socket));
if(message.getClass().getName()==»Disconnect») <
System.out.println(«Dostalismy wiadomosc Disconnect»);
userWindow.getConnectionWindow().setConnectButtons();
userWindow.DisplayBottomMassage(«Disconnected»);

Stop();
return;
>
//user.receivedMessage(message, new CommunicatorAddress(socket));

>
catch (Exception ex) <
System.out.println(«1. W watku: «+ex);
Stop();
return;
>
>
>
catch(Exception e) <
System.out.println(«Przy tworzeniu strumieni»+e);
>

public void sendMessage(Message message) <
try <
Objectout.writeObject(message);
Objectout.flush();
>
catch(Exception e)
<
System.out.println(«Przy wysylaniu: «+e);
>

public void Stop() <

state=false;
try <
Objectout.close();
Objectout=null;
>
catch(Exception e)
<
System.out.println(«Przy stop: «+e);
>

Everything works fine untill I do disconnect(). I send to the other side Message («Disconnect) (class message is Serializable) and the other side close the output stream and socket.
But the side, which run disconected() in the thread UserInputThread give me exception java socket closed.
I thought, maybe because later I’m closing outputstream, so i commented this,and later i got the exception EOF Exception.
Could you tell me what I’m doing wrong, or how should look disconnecting with 2 sides?
Thanks for help
Lazik

Источник

Оцените статью
toolgir.ru
Adblock
detector