Get error code java - Исправление ошибок и поиск оптимальных решений проблем

In real life there are two audiences:

the log handler with a configurable log level (ERROR) and logging (in English) with much info;
the end user with an localized translated message, also with parameters.

The first property is that you probably want a message as format String with Object... parameters. Probably should use MessageFormat.

Sensible would be to support typed parameters.

/** Type-checkable Message Definition. */
public record MessageDef(String format, Class<?>... parameterTypes) {
    public void checkFormat() {
        ... check actual parameters with parameterTypes.length
    }
    public void checkUsage(Object[] args) {
        ... check parameter types
    }
}

One could make an enum for the error categories. However enums are more suitable for closed domains with a fixed set of values. Extending values in future means that you have created a needless common bottleneck for source version control and so on.
An error is more like an open domain. However if you number them with error codes, an enum gives a nice overview.

The only advantage of error codes is the internationalisation. An Hungarian error message can be easily retrieved.

Then, if you rethrow check exceptions as RuntimeException, like IllegalArgumentException or you own custom ones, you might not want parallel classes: run-time exceptions and categories.

All-in-all I would advise an enum:

public enum MessageType {
    INVALID_TEMPLATE(400, Level.ERROR,
        new MessageDef("You have got the error in {0}.", String.class)),
    ...
    REQUEST_REJECTED(200, Level.INFO,
        new MessageDef("Done."));

    public final int code;
    public final Level level;
    public final MessageDef def;

    MessageType(int code, Level level, MessageDef def) {
        this.code = code;
        this.level = level;
        this.def = def;
    }
}

One small remark: such little discussion points in the beginning of a project sometimes might be better postponed to a fast refactoring after having written sufficient code. Here an enum might not fit, you might have much re-throwing of exceptions. A premature decision is not needed. And might hamper fast productivity.
Especially as you probably need not mark the code places, you most likely call the same show-error dialog.

Источник

In Java, there are three methods to print exception information. All of them are present in the Throwable class. Since Throwable is the base class for all exceptions and errors, we can use these three methods on any exception object.

Methods to Print Exceptions in Java

There are three methods to print exception messages in Java. These are:

1. java.lang.Throwable.printStackTrace() method:

By using this method, we will get the name(e.g., java.lang.ArithmeticException) and description(e.g., / by zero) of an exception separated by a colon, and the stack trace (wherein the code, that exception has occurred) in the next line.

Syntax:

public void printStackTrace()

Java

public class Test {

public static void main(String[] args)

{

try {

int a = 20 / 0;

}

catch (Exception e) {

e.printStackTrace();

System.out.println(e);

}

Runtime Exception:

java.lang.ArithmeticException: / by zero
    at Test.main(Test.java:9)

Output:

java.lang.ArithmeticException: / by zero

2. toString() method:

Using this method will only get the name and description of an exception. Note that this method is overridden in the Throwable class.

Java

public class Test {

public static void main(String[] args)

{

try {

int a = 20 / 0;

}

catch (Exception e) {

System.out.println(e.toString());

}

Output

java.lang.ArithmeticException: / by zero

3. java.lang.Throwable.getMessage() method:

Using this method, we will only get a description of an exception.

Syntax:

public String getMessage()

Java

public class Test {

public static void main(String[] args)

{

try {

int a = 20 / 0;

}

catch (Exception e) {

System.out.println(e.getMessage());

}

This article is contributed by Gaurav Miglani. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

Источник

Java Error Codes

Strictly in compliance with:
https://docs.oracle.com/cd/A97688_16/toplink.903/b10068/errorcod.htm

Descriptor Exceptions (1 — 176)

1 ATTRIBUTE_AND_MAPPING_WITH_INDIRECTION_ MISMATCH

2 ATTRIBUTE_AND_MAPPING_WITHOUT_INDIRECTION_ MISMATCH

6 ATTRIBUTE_NAME_NOT_SPECIFIED

7 ATTRIBUTE_TYPE_NOT_VALID

8 CLASS_INDICATOR_FIELD_NOT_FOUND

9 DIRECT_FIELD_NAME_NOT_SET

10 FIELD_NAME_NOT_SET_IN_MAPPING

11 FOREIGN_KEYS_DEFINED_INCORRECTLY

12 IDENTITY_MAP_NOT_SPECIFIED

13 ILLEGAL_ACCESS_WHILE_GETTING_VALUE_THRU_ INSTANCE_VARIABLE_ACCESSOR

14 ILLEGAL_ACCESS_WHILE_CLONING

15 ILLEGAL_ACCESS_WHILE_CONSTRUCTOR_INSTANTIATION

16 ILLEGAL_ACCESS_WHILE_EVENT_EXECUTION

17 ILLEGAL_ACCESS_WHILE_GETTING_VALUE_THRU_ METHOD_ACCESSOR

18 ILLEGAL_ACCESS_WHILE_INSTANTIATING_METHOD_ BASED_PROXY

19 ILLEGAL_ACCESS_WHILE_INVOKING_ATTRIBUTE_METHOD

20 ILLEGAL_ACCESS_WHILE_INVOKING_FIELD_TO_METHOD

21 ILLEGAL_ACCESS_WHILE_INVOKING_ROW_EXTRACTION_ METHOD

22 ILLEGAL_ACCESS_WHILE_METHOD_INSTANTIATION

23 ILLEGAL_ACCESS_WHILE_OBSOLETE_EVENT_EXECUTION

24 ILLEGAL_ACCESS_WHILE_SETTING_VALUE_THRU_ INSTANCE_VARIABLE_ACCESSOR

25 ILLEGAL_ACCESS_WHILE_SETTING_VALUE_THRU_ METHOD_ACCESSOR

26 ILLEGAL_ARGUMENT_WHILE_GETTING_VALUE_ THRU_INSTANCE_VARIABLE_ACCESSOR

27 ILLEGAL_ARGUMENT_WHILE_GETTING_VALUE_THRU_ METHOD_ACCESSOR

28 ILLEGAL_ARGUMENT_WHILE_INSTANTIATING_METHOD_ BASED_PROXY

29 ILLEGAL_ARGUMENT_WHILE_INVOKING_ATTRIBUTE_ METHOD

30 ILLEGAL_ARGUMENT_WHILE_INVOKING_FIELD_TO_ METHOD

31 ILLEGAL_ARGUMENT_WHILE_OBSOLETE_EVENT_ EXECUTION

32 ILLEGAL_ARGUMENT_WHILE_SETTING_VALUE_THRU_ INSTANCE_VARIABLE_ACCESSOR

33 ILLEGAL_ARGUMENT_WHILE_SETTING_VALUE_THRU _METHOD_ACCESSOR

34 INSTANTIATION_WHILE_CONSTRUCTOR_INSTANTIATION

35 INVALID_DATA_MODIFICATION_EVENT

36 INVALID_DATA_MODIFICATION_EVENT_CODE

37 INVALID_DESCRIPTOR_EVENT_CODE

38 INVALID_IDENTITY_MAP

39 JAVA_CLASS_NOT_SPECIFIED

40 DESCRIPTOR_FOR_INTERFACE_IS_MISSING

41 MAPPING_FOR_SEQUENCE_NUMBER_FIELD

43 MISSING_CLASS_FOR_INDICATOR_FIELD_VALUE

44 MISSING_CLASS_INDICATOR_FIELD

45 MISSING_MAPPING_FOR_FIELD

46 NO_MAPPING_FOR_PRIMARY_KEY

47 MULTIPLE_TABLE_PRIMARY_KEY_NOT_SPECIFIED

48 MULTIPLE_WRITE_MAPPINGS_FOR_FIELD

49 NO_ATTRIBUTE_TRANSFORMATION_METHOD

50 NO_FIELD_NAME_FOR_MAPPING

51 NO_FOREIGN_KEYS_ARE_SPECIFIED

52 NO_REFERENCE_KEY_IS_SPECIFIED

53 NO_RELATION_TABLE

54 NO_SOURCE_RELATION_KEYS_SPECIFIED

55 NO_SUCH_METHOD_ON_FIND_OBSOLETE_METHOD

56 NO_SUCH_METHOD_ON_INITIALIZING_ ATTRIBUTE_METHOD

57 NO_SUCH_METHOD_WHILE_CONSTRUCTOR_ INSTANTIATION

58 NO_SUCH_METHOD_WHILE_CONVERTING_TO_METHOD

59 NO_SUCH_FIELD_WHILE_INITIALIZING_ATTRIBUTES_ IN_INSTANCE_VARIABLE_ACCESSOR

60 NO_SUCH_METHOD_WHILE_INITIALIZING_ ATTRIBUTES_IN_METHOD_ACCESSOR

61 NO_SUCH_METHOD_WHILE_INITIALIZING_ CLASS_EXTRACTION_METHOD

62 NO_SUCH_METHOD_WHILE_INITIALIZING_COPY_POLICY

63 NO_SUCH_METHOD_WHILE_INITIALIZING_ INSTANTIATION_POLICY

64 NO_TARGET_FOREIGN_KEYS_SPECIFIED

65 NO_TARGET_RELATION_KEYS_SPECIFIED

66 NOT_DESERIALIZABLE

67 NOT_SERIALIZABLE

68 NULL_FOR_NON_NULL_AGGREGATE

69 NULL_POINTER_WHILE_GETTING_VALUE_THRU_ INSTANCE_VARIABLE_ACCESSOR

70 NULL_POINTER_WHILE_GETTING_VALUE_THRU_ METHOD_ACCESSOR

71 NULL_POINTER_WHILE_SETTING_VALUE_THRU_ INSTANCE_VARIABLE_ACCESSOR

72 NULL_POINTER_WHILE_SETTING_VALUE_THRU_ METHOD_ACCESSOR

73 PARENT_DESCRIPTOR_NOT_SPECIFIED

74 PRIMARY_KEY_FIELDS_NOT_SPECIFIED

75 REFERENCE_CLASS_NOT_SPECIFIED

77 REFERENCE_DESCRIPTOR_IS_NOT_AGGREGATE

78 REFERENCE_KEY_FIELD_NOT_PROPERLY_SPECIFIED

79 REFERENCE_TABLE_NOT_SPECIFIED

80 RELATION_KEY_FIELD_NOT_PROPERLY_SPECIFIED

81 RETURN_TYPE_IN_GET_ATTRIBUTE_ACCESSOR

82 SECURITY_ON_FIND_METHOD

83 SECURITY_ON_FIND_OBSOLETE_METHOD

84 SECURITY_ON_INITIALIZING_ATTRIBUTE_METHOD

85 SECURITY_WHILE_CONVERTING_TO_METHOD

86 SECURITY_WHILE_INITIALIZING_ATTRIBUTES_IN_ INSTANCE_VARIABLE_ACCESSOR

87 SECURITY_WHILE_INITIALIZING_ATTRIBUTES_IN_ METHOD_ACCESSOR

88 SECURITY_WHILE_INITIALIZING_CLASS_ EXTRACTION_METHOD

89 SECURITY_WHILE_INITIALIZING_COPY_POLICY

90 SECURITY_WHILE_INITIALIZING_INSTANTIATION_POLICY

91 SEQUENCE_NUMBER_PROPERTY_NOT_SPECIFIED

92 SIZE_MISMATCH_OF_FOREIGN_KEYS

93 TABLE_NOT_PRESENT

94 TABLE_NOT_SPECIFIED

96 TARGET_FOREIGN_KEYS_SIZE_MISMATCH

97 TARGET_INVOCATION_WHILE_CLONING

98 TARGET_INVOCATION_WHILE_EVENT_EXECUTION

99 TARGET_INVOCATION_WHILE_GETTING_VALUE_ THRU_METHOD_ACCESSOR

100 TARGET_INVOCATION_WHILE_INSTANTIATING_ METHOD_BASED_PROXY

101 TARGET_INVOCATION_WHILE_INVOKING_ ATTRIBUTE_METHOD

102 TARGET_INVOCATION_WHILE_INVOKING_FIELD_ TO_METHOD

103 TARGET_INVOCATION_WHILE_INVOKING_ROW_ EXTRACTION_METHOD

104 TARGET_INVOCATION_WHILE_METHOD_INSTANTIATION

105 TARGET_INVOCATION_WHILE_OBSOLETE_ EVENT_EXECUTION

106 TARGET_INVOCATION_WHILE_SETTING_VALUE_THRU_ METHOD_ACESSOR

108 VALUE_NOT_FOUND_IN_CLASS_INDICATOR_MAPPING

109 WRITE_LOCK_FIELD_IN_CHILD_DESCRIPTOR

110 DESCRIPTOR_IS_MISSING

111 MULTIPLE_TABLE_PRIMARY_KEY_MUST_BE_ FULLY_QUALIFIED

112 ONLY_ONE_TABLE_CAN_BE_ADDED_WITH_THIS_METHOD

113 NULL_POINTER_WHILE_CONSTRUCTOR_INSTANTIATION

114 NULL_POINTER_WHILE_METHOD_INSTANTIATION

115 NO_ATTRBUTE_VALUE_CONVERSION_TO_FIELD_VALUE_PROVIDED

116 NO_FIELD_VALUE_CONVERSION_TO_ATTRIBUTE_ VALUE_PROVIDED

118 LOCK_MAPPING_CANNOT_BE_READONLY

119 LOCK_MAPPING_MUST_BE_READONLY

120 CHILD_DOES_NOT_DEFINE_ABSTRACT_QUERY_KEY

122 SET_EXISTENCE_CHECKING_NOT_UNDERSTOOD

125 VALUE_HOLDER_INSTANTIATION_MISMATCH

126 NO_SUB_CLASS_MATCH

127 RETURN_AND_MAPPING_WITH_INDIRECTION_MISMATCH

128 RETURN_AND_MAPPING_WITHOUT_INDIRECTION_ MISMATCH

129 PARAMETER_AND_MAPPING_WITH_INDIRECTION_ MISMATCH

130 PARAMETER_AND_MAPPING_WITHOUT_INDIRECTION_ MISMATCH

131 GET_METHOD_RETURN_TYPE_NOT_VALID

133 SET_METHOD_PARAMETER_TYPE_NOT_VALID

135 ILLEGAL_TABLE_NAME_IN_MULTIPLE_TABLE_ FOREIGN_KEY

138 ATTRIBUTE_AND_MAPPING_WITH_TRANSPARENT_ INDIRECTION_MISMATCH

139 RETURN_AND_MAPPING_WITH_TRANSPARENT_ INDIRECTION_MISMATCH

140 PARAMETER_AND_MAPPING_WITH_TRANSPARENT_ INDIRECTION_MISMATCH

141 FIELD_IS_NOT_PRESENT_IN_DATABASE

142 TABLE_IS_NOT_PRESENT_IN_DATABASE

143 MULTIPLE_TABLE_INSERT_ORDER_MISMATCH

144 INVALID_USE_OF_TRANSPARENT_INDIRECTION

145 MISSING_INDIRECT_CONTAINER_CONSTRUCTOR

146 COULD_NOT_INSTANTIATE_INDIRECT_CONTAINER_CLASS

147 INVALID_CONTAINER_POLICY

148 Cause:

149 INVALID_USE_OF_NO_INDIRECTION

150 INDIRECT_CONTAINER_INSTANTIATION_MISMATCH

151 INVALID_MAPPING_OPERATION

152 INVALID_INDIRECTION_POLICY_OPERATION

153 REFERENCE_DESCRIPTOR_IS_NOT_ AGGREGATECOLLECTION

154 INVALID_INDIRECTION_CONTAINER_CLASS

155 MISSING_FOREIGN_KEY_TRANSLATION

156 TRUCTURE_NAME_NOT_SET_IN_MAPPING

157 NORMAL_DESCRIPTORS_DO_NOT_SUPPORT_ NON_RELATIONAL_EXTENSIONS

158 PARENT_CLASS_IS_SELF

159 PROXY_INDIRECTION_NOT_AVAILABLE

160 INVALID_ATTRIBUTE_TYPE_FOR_PROXY_INDIRECTION

161 INVALID_GET_RETURN_TYPE_FOR _PROXY_INDIRECTION

162 INVALID_SET_PARAMETER_TYPE_FOR_PROXY_ INDIRECTION

163 INCORRECT_COLLECTION_POLICY

164 INVALID_AMENDMENT_METHOD

165 ERROR_OCCURRED_IN_AMENDMENT_METHOD

166 VARIABLE_ONE_TO_ONE_MAPPING_IS_NOT_DEFINED

168 TARGET_INVOCATION_WHILE_CONSTRUCTOR_ INSTANTIATION

169 TARGET_INVOCATION_WHILE_CONSTRUCTOR_ INSTANTIATION_OF_FACTORY

170 ILLEGAL_ACCESS_WHILE_CONSTRUCTOR_ INSTANTIATION_OF_FACTORY

171 INSTANTIATION_WHILE_CONSTRUCTOR_ INSTANTIATION_OF_FACTORY

172 NO_SUCH_METHOD_WHILE_CONSTRUCTOR_ INSTANTIATION_OF_FACTORY

173 NULL_POINTER_WHILE_CONSTRUCTOR_ INSTANTIATION_OF_FACTORY

174 ILLEGAL_ACCESS_WHILE_METHOD_ INSTANTIATION_OF_FACTORY

175 TARGET_INVOCATION_WHILE_METHOD_ INSTANTIATION_OF_FACTORY

176 NULL_POINTER_WHILE_METHOD_ INSTANTIATION_OF_FACTORY

Builder Exceptions (1001 — 1042)

1001 No such method

1002 Could not find post load method <methodName> on class <aClass>

1003 Cannot write parameter <object> of class <type>

1004 Could not access method <method>

1005 Invoking <applyResultMethod> raised exception <exception>

1006 Invalid arguments invoking: <applyResultMethod> with <receiver>

1007 Could not access <applyResultMethod> with <receiver>

1008 Parameter mismatch <method>; received <size> parameters

1009 Accessing <methodName> on <className> with <parameters>

1010 Could not find section definition <section> when building section definitions for <target>

1011 Could not convert <object> into an accessible Java class.

1012 File not found

1013 Invalid class/method name format.

1015 Open failed for URL <url>

1016 Could not resolve INIFile location: <sourceString> using search paths <searchPaths>

1017 Invoking <method> on <receiver>

1018 Invoking <method> on <receiver>

1019 Invalid character value; expecting $* format

1020 Unexpected character: {

1021 Unexpected character: }

1022 Expecting object, found token <nextToken>

1023 Unexpected word

1024 setExistenceChecking <token>; not understood

1025 Class <className> not found

1026 Not enough INI elements. Found <count>.

1027 Too many INI elements. Found <count>.

1028 Error writing <writeString>

1029 Illegal access exception

1030 Invocation target exception

1031 Attempting to instantiate <className> with default constructor.

1032 Attempting to instantiate <className> with default constructor.

1033 IO Exception in next token

1034 IOException on close.

1035 Invalid INI(URL) Method: <method>. Should return a string.

1036 Could not cast using <castString>.

1037 A writer or a target file name must be specified

1039 IOException on open.

1040 Post Load Method Not Static

1041 Project Not Found.

1042 Multiple Projects With Name.

Concurrency Exceptions (2001 — 2004)

2001 WAIT_WAS_INTERRUPTED

2002 WAIT_FAILURE_SERVER

2003 WAIT_FAILURE_CLIENT

2004 SIGNAL_ATTEMPTED_BEFORE_WAIT

Conversion Exceptions (3001 — 3007)

3001 COULD_NOT_BE_CONVERTED

3003 INCORRECT_DATE_FORMAT

3004 INCORRECT_TIME_FORMAT

3005 INCORRECT_TIMESTAMP_FORMAT

3006 COULD_NOT_CONVERT_TO_BYTE_ARRAY

3007 COULD_NOT_BE_CONVERTED_TO_CLASS

Database Exceptions (4001 — 4018)

4002 SQL_EXCEPTION

4003 CONFIGURATION_ERROR_CLASS_NOT_FOUND

4005 DATABASE_ACCESSOR_NOT_CONNECTED

4006 ERROR_READING_BLOB_DATA

4007 OULD_NOT_CONVERT_OBJECT_TYPE

4008 LOGOUT_WHILE_TRANSACTION_IN_PROGRESS

4009 SEQUENCE_TABLE_INFORMATION_NOT_COMPLETE

4011 ERROR_PREALLOCATING_SEQUENCE_NUMBERS

4014 CANNOT_REGISTER_SYNCHRONIZATIONLISTENER_ FOR_UNITOFWORK

4015 SYNCHRONIZED_UNITOFWORK_DOES_NOT_ SUPPORT_COMMITANDRESUME

4016 CONFIGURATION_ERROR_NEW_INSTANCE_ INSTANTIATION_EXCEPTION

4017 CONFIGURATION_ERROR_NEW_INSTANCE_ILLEGAL_ ACCESS_EXCEPTION

4018 TRANSACTION_MANAGER_NOT_SET_FOR_JTS_DRIVER

Optimistic Lock Exceptions (5001 — 5007)

5001 NO_VERSION_NUMBER_WHEN_DELETING

5003 OBJECT_CHANGED_SINCE_LAST_READ_WHEN_DELETING

5004 NO_VERSION_NUMBER_WHEN_UPDATING

5006 OBJECT_CHANGED_SINCE_LAST_READ_WHEN_UPDATING

5007 MUST_HAVE_MAPPING_WHEN_IN_OBJECT

5008 NEED_TO_MAP_JAVA_SQL_TIMESTAMP

Query Exceptions (6001 — 6092)

6001 ADDITIONAL_SIZE_QUERY_NOT_SPECIFIED

6002 AGGREGATE_OBJECT_CANNOT_BE_DELETED

6003 ARGUMENT_SIZE_MISMATCH_IN_QUERY_AND_ QUERY_DEFINITION

6004 BACKUP_CLONE_IS_ORIGINAL_FROM_PARENT

6005 BACKUP_CLONE_IS_ORIGINAL_FROM_SELF

6006 BATCH_READING_NOT_SUPPORTED

6007 DESCRIPTOR_IS_MISSING

6008 DESCRIPTOR_IS_MISSING_FOR_NAMED_QUERY

6013 INCORRECT_SIZE_QUERY_FOR_CURSOR_STREAM

6014 INVALID_QUERY

6015 INVALID_QUERY_KEY_IN_EXPRESSION

6016 INVALID_QUERY_ON_SERVER_SESSION

6020 NO_CONCRETE_CLASS_INDICATED

6021 NO_CURSOR_SUPPORT

6023 OBJECT_TO_INSERT_IS_EMPTY

6024 OBJECT_TO_MODIFY_NOT_SPECIFIED

6026 QUERY_NOT_DEFINED

6027 QUERY_SENT_TO_INACTIVE_UNIT_OF_WORK

6028 READ_BEYOND_QUERY

6029 REFERENCE_CLASS_MISSING

6030 REFRESH_NOT_POSSIBLE_WITHOUT_CACHE

6031 SIZE_ONLY_SUPPORTED_ON_EXPRESSION_QUERIES

6032 SQL_STATEMENT_NOT_SET_PROPERLY

6034 INVALID_QUERY_ITEM

6041 SELECTION_OBJECT_CANNOT_BE_NULL

6042 UNNAMED_QUERY_ON_SESSION_BROKER

6043 REPORT_RESULT_WITHOUT_PKS

6044 NULL_PRIMARY_KEY_IN_BUILDING_OBJECT

6045 NO_DESCRIPTOR_FOR_SUBCLASS

6046 CANNOT_DELETE_READ_ONLY_OBJECT

6047 INVALID_OPERATOR

6048 ILLEGAL_USE_OF_GETFIELD

6049 ILLEGAL_USE_OF_GETTABLE

6050 REPORT_QUERY_RESULT_SIZE_MISMATCH

6051 CANNOT_CACHE_PARTIAL_OBJECT

6052 OUTER_JOIN_ONLY_VALID_FOR_ONE_TO_ONE

6054 CANNOT_ADD_TO_CONTAINER

6055 METHOD_INVOCATION_FAILED

6056 CANNOT_CREATE_CLONE

6057 METHOD_NOT_VALID

6058 METHOD_DOES_NOT_EXIST_IN_CONTAINER_CLASS

6059 COULD_NOT_INSTANTIATE_CONTAINER_CLASS

6060 MAP_KEY_NOT_COMPARABLE

6061 CANNOT_ACCESS_METHOD_ON_OBJECT

6062 CALLED_METHOD_THREW_EXCEPTION

6063 INVALID_OPERATION

6064 CANNOT_REMOVE_FROM_CONTAINER

6065 CANNOT_ADD_ELEMENT

6066 BACKUP_CLONE_DELETED

6068 CANNOT_COMPARE_TABLES_IN_EXPRESSION

6069 INVALID_TABLE_FOR_FIELD_IN_EXPRESSION

6070 INVALID_USE_OF_TO_MANY_QUERY_KEY_IN_EXPRESSION

6071 INVALID_USE_OF_ANY_OF_IN_EXPRESSION

6072 CANNOT_QUERY_ACROSS_VARIABLE_ONE_TO_ ONE_MAPPING

6073 ILL_FORMED_EXPRESSION

6074 CANNOT_CONFORM_EXPRESSION

6075 INVALID_OPERATOR_FOR_OBJECT_EXPRESSION

6076 UNSUPPORTED_MAPPING_FOR_OBJECT_COMPARISON

6077 OBJECT_COMPARISON_CANNOT_BE_PARAMETERIZED

6078 INCORRECT_CLASS_FOR_OBJECT_COMPARISON

6079 CANNOT_COMPARE_TARGET_FOREIGN_KEYS_ TO_NULL

6080 INVALID_DATABASE_CALL

6081 INVALID_DATABASE_ACCESSOR

6082 METHOD_DOES_NOT_EXIST_ON_EXPRESSION

6083 IN_CANNOT_BE_PARAMETERIZED

6084 REDIRECTION_CLASS_OR_METHOD_NOT_SET

6085 REDIRECTION_METHOD_NOT_DEFINED_CORRECTLY

6086 REDIRECTION_METHOD_ERROR

6087 EXAMPLE_AND_REFERENCE_OBJECT_CLASS_MISMATCH

6088 NO_ATTRIBUTES_FOR _REPORT_QUERY

6089 NO_EXPRESSION_BUILDER_CLASS_FOUND

6090 CANNOT_SET_REPORT_QUERY_TO_CHECK_ CACHE_ONLY

6091 TYPE_MISMATCH_BETWEEN_ATTRIBUTE_AND_ CONSTANT_ ON_EXPRESSION

6092 MUST_INSTANTIATE_VALUEHOLDERS

Validation Exceptions (7001 — 7097)

7001 LOGIN_BEFORE_ALLOCATING_CLIENT_SESSIONS

7002 POOL_NAME_DOES_NOT_EXIST

7003 MAX_SIZE_LESS_THAN_MIN_SIZE

7004 POOLS_MUST_BE_CONFIGURED_BEFORE_LOGIN

7008 JAVA_TYPE_IS_NOT_A_VALID_DATABASE_TYPE

7009 MISSING_DESCRIPTOR

7010 START_INDEX_OUT_OF_RANGE

7011 STOP_INDEX_OUT_OF_RANGE

7012 FATAL_ERROR_OCCURRED

7013 NO_PROPERTIES_FILE_FOUND

7017 CHILD_DESCRIPTORS_DO_NOT_HAVE_IDENTITY_MAP

7018 FILE_ERROR

7023 INCORRECT_LOGIN_INSTANCE_PROVIDED

7024 INVALID_MERGE_POLICY

7025 ONLY_FIELDS_ARE_VALID_KEYS_FOR_ DATABASE_ROWS

7027 SEQUENCE_SETUP_INCORRECTLY

7028 WRITE_OBJECT_NOT_ALLOWED_IN_UNIT_OF_WORK

7030 CANNOT_SET_READ_POOL_SIZE_AFTER_LOGIN

7031 CANNOT_ADD_DESCRIPTORS_TO_SESSION_BROKER

7032 NO_SESSION_REGISTERED_FOR_CLASS

7033 NO_SESSION_REGISTERED_FOR_NAME

7038 LOG_IO_ERROR

7039 CANNOT_REMOVE_FROM_READ_ONLY_CLASSES_ IN_NESTED_UNIT_OF_WORK

7040 CANNOT_MODIFY_READ_ONLY_CLASSES_SET_ AFTER_USING_UNIT_OF_WORK

7042 LATFORM_CLASS_NOT_FOUND

7043 NO_TABLES_TO_CREATE

7044 LLEGAL_CONTAINER_CLASS

7047 ONTAINER_POLICY_DOES_NOT_USE_KEYS

7048 METHOD_NOT_DECLARED_IN_ITEM_CLASS

7051 MISSING_MAPPING

7052 ILLEGAL_USE_OF_MAP_IN_DIRECTCOLLECTION

7053 CANNOT_RELEASE_NON_CLIENTSESSION

7054 CANNOT_ACQUIRE_CLIENTSESSION_FROM_SESSION

7055 OPTIMISTIC_LOCKING_NOT_SUPPORTED

7056 WRONG_OBJECT_REGISTERED

7058 INVALID_CONNECTOR

7059 INVALID_DATA_SOURCE_NAME

7060 CANNOT_ACQUIRE_DATA_SOURCE

7061 JTS_EXCEPTION_RAISED

7062 FIELD_LEVEL_LOCKING_NOTSUPPORTED_ OUTSIDE_A_UNIT_OF_WORK

7063 EJB_CONTAINER_EXCEPTION_RAISED

7064 EJB_PRIMARY_KEY_REFLECTION_EXCEPTION

7065 EJB_CANNOT_LOAD_REMOTE_CLASS

7066 EJB_MUST_BE_IN_TRANSACTION

7068 EJB_INVALID_PROJECT_CLASS

7069 SESSION_AMENDMENT_EXCEPTION_OCCURED

7070 EJB_TOPLINK_PROPERTIES_NOT_FOUND

7071 CANT_HAVE_UNBOUND_IN_OUTPUT_ARGUMENTS

7073 ORACLE_OBJECT_TYPE_NOT_DEFINED

7074 ORACLE_OBJECT_TYPE_NAME_NOT_DEFINED

7075 ORACLE_VARRAY_MAXIMIM_SIZE_NOT_DEFINED

7076 DESCRIPTOR_MUST_NOT_BE_INITIALIZED

7077 EJB_INVALID_FINDER_ON_HOME

7078 EJB_NO_SUCH_SESSION_SPECIFIED_IN_PROPERTIES

7079 EJB_DESCRIPTOR_NOT_FOUND_IN_SESSION

7080 EJB_FINDER_EXCEPTION

7081 CANNOT_REGISTER_AGGREGATE_OBJECT_IN_ UNIT_OF_ WORK

7082 MULTIPLE_PROJECTS_SPECIFIED_IN_PROPERTIES

7083 O_PROJECT_SPECIFIED_IN_PROPERTIES

7084 INVALID_FILE_TYPE

7085 CANNOT_CREATE_EXTERNAL_TRANSACTION_ CONTROLLER

7087 EJB_SESSION_TYPE_CLASS_NOT_FOUND

7088 CANNOT_CREATE_EXTERNAL_TRANSACTION_ CONTROLLER

7089 SESSION_AMENDMENT_EXCEPTION_OCCURED

7091 SET_LISTENER_CLASSES_EXCEPTION

7092 EXISTING_QUERY_TYPE_CONFLICT

7093 QUERY_ARGUMENT_TYPE_NOT_FOUND

7095 NO_SESSIONS_XML_FOUND

7096 CANNOT_COMMIT_UOW_AGAIN

7097 OPERATION_NOT_SUPPORTED

7099 PROJECT_XML_NOT_FOUND

7101 NO_TOPLINK_EJB_JAR_XML_FOUND

EJBQL Exceptions (8001 — 8009)

8001 recognitionException

8002 generalParsingException

8003 classNotFoundException

8004 aliasResolutionException

8005 resolutionClassNotFoundException

8006 missingDescriptorException

8009 expressionNotSupported

Synchronization Exceptions (8050 — 8070)

8050 DROPPING_REMOTE_CONNECTION

8051 ERROR_DOING_REMOTE_MERGE

8052 ERROR_DOING_LOCAL_MERGE

8053 ERROR_LOOKING_UP_LOCAL_HOST

8054 ERROR_BINDING_CONTROLLER

8055 ERROR_LOOKING_UP_CONTROLLER

8056 ERROR_UNMARSHALLING_MSG

8057 ERROR_GETTING_SYNC_SERVICE

8058 ERROR_NOTIFYING_CLUSTER

8059 ERROR_JOINING_MULTICAST_GROUP

8070 ERROR_RECEIVING_ANNOUNCEMENT

Источник

Best Java code snippets using java.sql.SQLException.getErrorCode (Showing top 20 results out of 3,069)

Refine search







public UncategorizedSQLException(String task, @Nullable String sql, SQLException ex) {
  super(task + "; uncategorized SQLException" + (sql != null ? " for SQL [" + sql + "]" : "") +
      "; SQL state [" + ex.getSQLState() + "]; error code [" + ex.getErrorCode() + "]; " +
      ex.getMessage(), ex);
  this.sql = sql;
}







public JdbcConnectionException(String message, SQLException e) {
  super(message, e);
  this.sqlState = e.getSQLState();
  this.errorCode = e.getErrorCode();
}

private void executeStatement(TransactionContext transactionContext, String createStatement, boolean ignoreStatementExecutionFailure) throws IOException {
  Statement statement = null;
  try {
    LOG.debug("Executing SQL: " + createStatement);
    statement = transactionContext.getConnection().createStatement();
    statement.execute(createStatement);
    commitIfAutoCommitIsDisabled(transactionContext);
  } catch (SQLException e) {
    if (ignoreStatementExecutionFailure) {
      LOG.debug("Could not create JDBC tables; The message table already existed. " + String.format(FAILURE_MESSAGE, createStatement, e.getMessage(), e.getSQLState(), e.getErrorCode()));
    } else {
      LOG.warn("Could not create JDBC tables; they could already exist. " + String.format(FAILURE_MESSAGE, createStatement, e.getMessage(), e.getSQLState(), e.getErrorCode()));
      JDBCPersistenceAdapter.log("Failure details: ", e);
    }
  } finally {
    closeStatement(statement);
  }
}

@Test
public void testInvalidArrayElemRefInUpsert() throws Exception {
  Connection conn = DriverManager.getConnection(getUrl());
  conn.createStatement().execute("CREATE TABLE t (k VARCHAR PRIMARY KEY, a INTEGER[10], B INTEGER[10])");
  try {
    conn.createStatement().execute("UPSERT INTO t(k,a[2]) VALUES('A', 5)");
    fail();
  } catch (SQLException e) {
    assertEquals(SQLExceptionCode.PARSER_ERROR.getErrorCode(), e.getErrorCode());
  }
  conn.close();
}

@Test
public void testEventuallyFails() {
  final AtomicInteger attempts = new AtomicInteger(0);
  Handle handle = dbRule.getJdbi().open();
  assertThatExceptionOfType(SQLException.class)
    .isThrownBy(() -> handle.inTransaction(TransactionIsolationLevel.SERIALIZABLE,
      conn -> {
        attempts.incrementAndGet();
        throw new SQLException("serialization", "40001", attempts.get());
      }))
    .satisfies(e -> assertThat(e.getSQLState()).isEqualTo("40001"))
    .satisfies(e -> assertThat(e.getSuppressed())
      .hasSize(MAX_RETRIES)
      .describedAs("suppressed are ordered reverse chronologically, like a stack")
      .isSortedAccordingTo(Comparator.comparing(ex -> ((SQLException) ex).getErrorCode()).reversed()))
    .describedAs("thrown exception is chronologically last")
    .satisfies(e -> assertThat(e.getErrorCode()).isEqualTo(((SQLException) e.getSuppressed()[0]).getErrorCode() + 1));
  assertThat(attempts.get()).isEqualTo(1 + MAX_RETRIES);
}

@Test
public void testVersionMismatchJdbc() throws Exception {
  try (Connection conn1 = connect(); Connection conn2 = connect()) {
      assertEquals(SqlStateCode.SERIALIZATION_FAILURE, e.getSQLState());
      assertEquals(IgniteQueryErrorCode.TRANSACTION_SERIALIZATION_ERROR, e.getErrorCode());
      assertNotNull(e.getMessage());
      assertTrue(e.getMessage().contains("Cannot serialize transaction due to write conflict"));
      assertEquals(SqlStateCode.TRANSACTION_STATE_EXCEPTION, e.getSQLState());
      assertEquals(IgniteQueryErrorCode.TRANSACTION_COMPLETED, e.getErrorCode());
      assertNotNull(e.getMessage());
      assertTrue(e.getMessage().contains("Transaction is already completed"));
      assertEquals(SqlStateCode.INTERNAL_ERROR, e.getSQLState());
      assertEquals(IgniteQueryErrorCode.UNKNOWN, e.getErrorCode());
      assertNotNull(e.getMessage());

@Test
public void testFailureAndSuccessCallback() throws SQLException {
  AtomicInteger remainingAttempts = new AtomicInteger(MAX_RETRIES);
      .hasSize(expectedExceptions.getAndIncrement())
      .describedAs("ordered chronologically")
      .isSortedAccordingTo(Comparator.comparing(e -> ((SQLException) e).getErrorCode()));
    return null;
  }).when(onFailure).accept(anyList());
      .hasSize(MAX_RETRIES - 1)
      .describedAs("ordered chronologically")
      .isSortedAccordingTo(Comparator.comparing(e -> ((SQLException) e).getErrorCode()));
    return null;
  }).when(onSuccess).accept(anyList());

@Test
public void testVarbinaryArrayNotSupported() throws Exception {
  Connection conn = DriverManager.getConnection(getUrl());
  try {
    conn.createStatement().execute("CREATE TABLE t (k VARCHAR PRIMARY KEY, a VARBINARY[10])");
    fail();
  } catch (SQLException e) {
    assertEquals(SQLExceptionCode.VARBINARY_ARRAY_NOT_SUPPORTED.getErrorCode(), e.getErrorCode());
  }
  conn.close();
}

private void logTranslation(String task, @Nullable String sql, SQLException sqlEx, boolean custom) {
  if (logger.isDebugEnabled()) {
    String intro = custom ? "Custom translation of" : "Translating";
    logger.debug(intro + " SQLException with SQL state '" + sqlEx.getSQLState() +
        "', error code '" + sqlEx.getErrorCode() + "', message [" + sqlEx.getMessage() + "]" +
        (sql != null ? "; SQL was [" + sql + "]": "") + " for task [" + task + "]");
  }
}

@Override
public void doDropTables(TransactionContext c) throws SQLException, IOException {
  Statement s = null;
  try {
    s = c.getConnection().createStatement();
    String[] dropStatments = this.statements.getDropSchemaStatements();
    for (int i = 0; i < dropStatments.length; i++) {
      
      
      try {
        LOG.debug("Executing SQL: " + dropStatments[i]);
        s.execute(dropStatments[i]);
      } catch (SQLException e) {
        LOG.warn("Could not drop JDBC tables; they may not exist." + " Failure was: " + dropStatments[i]
            + " Message: " + e.getMessage() + " SQLState: " + e.getSQLState() + " Vendor code: "
            + e.getErrorCode());
        JDBCPersistenceAdapter.log("Failure details: ", e);
      }
    }
    commitIfAutoCommitIsDisabled(c);
  } finally {
    try {
      s.close();
    } catch (Throwable e) {
    }
  }
}

@Override
public boolean isExceptionFatal(SQLException e) {
  if (e instanceof SQLRecoverableException) {
    return true;
  }
  String sqlState = e.getSQLState();
  if (sqlState != null && sqlState.startsWith("08")) { 
    return true;
  }
  int errorCode = e.getErrorCode();
  switch (errorCode) {
    case -512: 
    case -514: 
    case -516: 
    case -518: 
    case -525: 
          
    case -909: 
    case -918: 
    case -924: 
      return true;
    default:
      break;
  }
  return false;
}

@Test
public void testMutationUsingExecuteQueryShouldFail() throws Exception {
  Properties connectionProperties = new Properties();
  Connection connection = DriverManager.getConnection(getUrl(), connectionProperties);
  PreparedStatement stmt = connection.prepareStatement("DELETE FROM " + ATABLE);
  try {
    stmt.executeQuery();
    fail();
  } catch(SQLException e) {
    assertEquals(SQLExceptionCode.EXECUTE_QUERY_NOT_APPLICABLE.getErrorCode(), e.getErrorCode());
  }
}

@Override
public void preStart() {
  if (createTablesOnStartup) {
    String[] createStatements = getStatements().getCreateLockSchemaStatements();
    Connection connection = null;
    Statement statement = null;
    try {
      connection = getConnection();
      statement = connection.createStatement();
      setQueryTimeout(statement);
      for (int i = 0; i < createStatements.length; i++) {
        LOG.debug("Executing SQL: " + createStatements[i]);
        try {
          statement.execute(createStatements[i]);
        } catch (SQLException e) {
          LOG.info("Could not create lock tables; they could already exist." + " Failure was: "
              + createStatements[i] + " Message: " + e.getMessage() + " SQLState: " + e.getSQLState()
              + " Vendor code: " + e.getErrorCode());
        }
      }
    } catch (SQLException e) {
      LOG.warn("Could not create lock tables; Failure Message: " + e.getMessage() + " SQLState: " + e.getSQLState()
          + " Vendor code: " + e.getErrorCode(), e);
    } finally {
      close(statement);
      close(connection);
    }
  }
}







protected boolean isDuplicateKeyCode(SQLException sqlException, List<Integer> errorCodes) {
  if (errorCodes.contains(sqlException.getErrorCode())) {
    return true;
  } else if (sqlException.getSQLState() != null) {
    try {
      return errorCodes.contains(Integer.parseInt(sqlException.getSQLState()));
    } catch (NumberFormatException e) {
      return false;
    }
  }
  return false;
}

@Test
public void testQueriesUsingExecuteUpdateShouldFail() throws Exception {
  Properties connectionProperties = new Properties();
  Connection connection = DriverManager.getConnection(getUrl(), connectionProperties);
  PreparedStatement stmt = connection.prepareStatement("SELECT * FROM " + ATABLE);
  try {
    stmt.executeUpdate();
    fail();
  } catch(SQLException e) {
    assertEquals(SQLExceptionCode.EXECUTE_UPDATE_NOT_APPLICABLE.getErrorCode(), e.getErrorCode());
  }
}

try {
 conn = getConnection(conf);
 stmt = conn.createStatement();
  stmt.execute("DROP INDEX HL_TXNID_INDEX");
 } catch (SQLException e) {
  if(!("42X65".equals(e.getSQLState()) && 30000 == e.getErrorCode())) {
   LOG.error("Unable to drop index HL_TXNID_INDEX " + e.getMessage() +
    "State=" + e.getSQLState() + " code=" + e.getErrorCode() + " retryCount=" + retryCount);
   success = false;






private void writeException(Throwable e, JsonGenerator gen) throws IOException {
  if (e instanceof VisorExceptionWrapper) {
    VisorExceptionWrapper wrapper = (VisorExceptionWrapper)e;
    gen.writeStringField("className", wrapper.getClassName());
  }
  else
    gen.writeStringField("className", e.getClass().getName());
  if (e.getMessage() != null)
    gen.writeStringField("message", e.getMessage());
  if (e instanceof SQLException) {
    SQLException sqlE = (SQLException)e;
    gen.writeNumberField("errorCode", sqlE.getErrorCode());
    gen.writeStringField("SQLState", sqlE.getSQLState());
  }
}

@Test
public void testArrayConcatSingleArg() throws SQLException {
  Connection conn = DriverManager.getConnection(getUrl());
  try {
    conn.createStatement().execute("CREATE TABLE t (p INTEGER PRIMARY KEY, arr1 INTEGER ARRAY, arr2 INTEGER ARRAY)");
    conn.createStatement().executeQuery("SELECT ARRAY_CAT(arr2) from t");
    fail();
  } catch (SQLException e) {
    assertEquals(SQLExceptionCode.FUNCTION_UNDEFINED.getErrorCode(),e.getErrorCode());
  } finally {
    conn.close();
  }
}

Источник

About |

A beginner’s library for learning about essential Java programming concepts, syntax, APIs, and packages.

Throwing, trying, catching, and cleaning up after Java exceptions

A target floats aimlessly in an ocean of missed darts.

WildPixel

Java exceptions are library types and language features used to represent and deal with program failure. If you’ve wanted to understand how failure is represented in source code, you’ve come to the right place. In addition to an overview of Java exceptions, I’ll get you started with Java’s language features for throwing objects, trying code that may fail, catching thrown objects, and cleaning up your Java code after an exception has been thrown.

In the first half of this tutorial you’ll learn about basic language features and library types that have been around since Java 1.0. In the second half, you’ll discover advanced capabilities introduced in more recent Java versions.

Note that code examples in this tutorial are compatible with JDK 12.

download

Download the source code for example applications in this tutorial. Created by Jeff Friesen for JavaWorld.

What are Java exceptions?

Failure occurs when a Java program’s normal behavior is interrupted by unexpected behavior. This divergence is known as an exception. For example, a program tries to open a file to read its contents, but the file doesn’t exist. Java classifies exceptions into a few types, so let’s consider each one.

Checked exceptions

Java classifies exceptions arising from external factors (such as a missing file) as checked exceptions. The Java compiler checks that such exceptions are either handled (corrected) where they occur or documented to be handled elsewhere.

Runtime (unchecked) exceptions

Suppose a program attempts to divide an integer by integer 0. This impossibility illustrates another kind of exception, namely a runtime exception. Unlike checked exceptions, runtime exceptions typically arise from poorly written source code, and should thus be fixed by the programmer. Because the compiler doesn’t check that runtime exceptions are handled or documented to be handled elsewhere, you can think of a runtime exception as an unchecked exception.

Errors

Some exceptions are very serious because they jeopardize a program’s ability to continue execution. For example, a program tries to allocate memory from the JVM but there isn’t enough free memory to satisfy the request. Another serious situation occurs when a program tries to load a classfile via a Class.forName() method call, but the classfile is corrupt. This kind of exception is known as an error. You should never try to handle errors yourself because the JVM might not be able to recover from it.

Exceptions in source code

An exception may be represented in source code as an error code or as an object. I’ll introduce both and show you why objects are superior.

Error codes versus objects

Programming languages such as C use integer-based error codes to represent failure and reasons for failure—i.e., exceptions. Here are a couple of examples:

if (chdir("C:\temp"))
   printf("Unable to change to temp directory: %dn", errno);
   
FILE *fp = fopen("C:\temp\foo");
if (fp == NULL)
   printf("Unable to open foo: %dn", errno);

C’s chdir() (change directory) function returns an integer: 0 on success or -1 on failure. Similarly, C’s fopen() (file open) function returns a nonnull pointer (integer address) to a FILE structure on success or a null (0) pointer (represented by constant NULL) on failure. In either case, to identify the exception that caused the failure, you must read the global errno variable’s integer-based error code.

Error codes present some problems:

Integers are meaningless; they don’t describe the exceptions they represent. For example, what does 6 mean?
Associating context with an error code is awkward. For example, you might want to output the name of the file that couldn’t be opened, but where are you going to store the file’s name?
Integers are arbitrary, which can lead to confusion when reading source code. For example, specifying if (!chdir("C:\temp")) (! signifies NOT) instead of if (chdir("C:\temp")) to test for failure is clearer. However, 0 was chosen to indicate success, and so if (chdir("C:\temp")) must be specified to test for failure.
Error codes are too easy to ignore, which can lead to buggy code. For example, the programmer could specify chdir("C:\temp"); and ignore the if (fp == NULL) check. Furthermore, the programmer need not examine errno. By not testing for failure, the program behaves erratically when either function returns a failure indicator.

To solve these problems, Java embraced a new approach to exception handling. In Java, we combine objects that describe exceptions with a mechanism based on throwing and catching these objects. Here are some advantages of using objects versus error code to denote exceptions:

An object can be created from a class with a meaningful name. For example, FileNotFoundException (in the java.io package) is more meaningful than 6.
Objects can store context in various fields. For example, you can store a message, the name of the file that could not be opened, the most recent position where a parse operation failed, and/or other items in an object’s fields.
You don’t use if statements to test for failure. Instead, exception objects are thrown to a handler that’s separate from the program code. As a result, the source code is easier to read and less likely to be buggy.

Throwable and its subclasses

Java provides a hierarchy of classes that represent different kinds of exceptions. These classes are rooted in the java.lang package’s Throwable class, along with its Exception, RuntimeException, and Error subclasses.

Throwable is the ultimate superclass where exceptions are concerned. Only objects created from Throwable and its subclasses can be thrown (and subsequently caught). Such objects are known as throwables.

A Throwable object is associated with a detail message that describes an exception. Several constructors, including the pair described below, are provided to create a Throwable object with or without a detail message:

Throwable() creates a Throwable with no detail message. This constructor is appropriate for situations where there is no context. For example, you only want to know that a stack is empty or full.
Throwable(String message) creates a Throwable with message as the detail message. This message can be output to the user and/or logged.

Throwable provides the String getMessage() method to return the detail message. It also provides additional useful methods, which I’ll introduce later.

The Exception class

Throwable has two direct subclasses. One of these subclasses is Exception, which describes an exception arising from an external factor (such as attempting to read from a nonexistent file). Exception declares the same constructors (with identical parameter lists) as Throwable, and each constructor invokes its Throwable counterpart. Exception inherits Throwable‘s methods; it declares no new methods.

Java provides many exception classes that directly subclass Exception. Here are three examples:

CloneNotSupportedException signals an attempt to clone an object whose class doesn’t implement the Cloneable interface. Both types are in the java.lang package.
IOException signals that some kind of I/O failure has occurred. This type is located in the java.io package.
ParseException signals that a failure has occurred while parsing text. This type can be found in the java.text package.

Notice that each Exception subclass name ends with the word Exception. This convention makes it easy to identify the class’s purpose.

You’ll typically subclass Exception (or one of its subclasses) with your own exception classes (whose names should end with Exception). Here are a couple of custom subclass examples:

public class StackFullException extends Exception
{
}

public class EmptyDirectoryException extends Exception
{
   private String directoryName;

   public EmptyDirectoryException(String message, String directoryName)
   {
      super(message);
      this.directoryName = directoryName;
   }

   public String getDirectoryName()
   {
      return directoryName;
   }
}

The first example describes an exception class that doesn’t require a detail message. It’s default noargument constructor invokes Exception(), which invokes Throwable().

The second example describes an exception class whose constructor requires a detail message and the name of the empty directory. The constructor invokes Exception(String message), which invokes Throwable(String message).

Objects instantiated from Exception or one of its subclasses (except for RuntimeException or one of its subclasses) are checked exceptions.

The RuntimeException class

Exception is directly subclassed by RuntimeException, which describes an exception most likely arising from poorly written code. RuntimeException declares the same constructors (with identical parameter lists) as Exception, and each constructor invokes its Exception counterpart. RuntimeException inherits Throwable‘s methods. It declares no new methods.

Java provides many exception classes that directly subclass RuntimeException. The following examples are all members of the java.lang package:

ArithmeticException signals an illegal arithmetic operation, such as attempting to divide an integer by 0.
IllegalArgumentException signals that an illegal or inappropriate argument has been passed to a method.
NullPointerException signals an attempt to invoke a method or access an instance field via the null reference.

Objects instantiated from RuntimeException or one of its subclasses are unchecked exceptions.

The Error class

Throwable‘s other direct subclass is Error, which describes a serious (even abnormal) problem that a reasonable application should not try to handle—such as running out of memory, overflowing the JVM’s stack, or attempting to load a class that cannot be found. Like Exception, Error declares identical constructors to Throwable, inherits Throwable‘s methods, and doesn’t declare any of its own methods.

You can identify Error subclasses from the convention that their class names end with Error. Examples include OutOfMemoryError, LinkageError, and StackOverflowError. All three types belong to the java.lang package.

Throwing exceptions

A C library function notifies calling code of an exception by setting the global errno variable to an error code and returning a failure code. In contrast, a Java method throws an object. Knowing how and when to throw exceptions is an essential aspect of effective Java programming. Throwing an exception involves two basic steps:

Use the throw statement to throw an exception object.
Use the throws clause to inform the compiler.

Later sections will focus on catching exceptions and cleaning up after them, but first let’s learn more about throwables.

The throw statement

Java provides the throw statement to throw an object that describes an exception. Here’s the syntax of the throw statement :

throw throwable;

The object identified by throwable is an instance of Throwable or any of its subclasses. However, you usually only throw objects instantiated from subclasses of Exception or RuntimeException. Here are a couple of examples:

throw new FileNotFoundException("unable to find file " + filename);

throw new IllegalArgumentException("argument passed to count is less than zero");

The throwable is thrown from the current method to the JVM, which checks this method for a suitable handler. If not found, the JVM unwinds the method-call stack, looking for the closest calling method that can handle the exception described by the throwable. If it finds this method, it passes the throwable to the method’s handler, whose code is executed to handle the exception. If no method is found to handle the exception, the JVM terminates with a suitable message.

The throws clause

You need to inform the compiler when you throw a checked exception out of a method. Do this by appending a throws clause to the method’s header. This clause has the following syntax:

throws checkedExceptionClassName (, checkedExceptionClassName)*

A throws clause consists of keyword throws followed by a comma-separated list of the class names of checked exceptions thrown out of the method. Here is an example:

public static void main(String[] args) throws ClassNotFoundException
{
   if (args.length != 1)
   {
      System.err.println("usage: java ... classfile");
      return;
   }
   Class.forName(args[0]);
}

This example attempts to load a classfile identified by a command-line argument. If Class.forName() cannot find the classfile, it throws a java.lang.ClassNotFoundException object, which is a checked exception.

Источник

Исключения

Причиной появления исключений, на мой взгляд, стало очень простое предположение — во время исполнения программы вряд ли можно быть уверенным, что все функции будут делать свою работу без сбоев. Например, если ваш код должен прочитать файл с каким-то именем, а файла такого просто нет ? Или вы хотите по сети обратиться к другой программе, но добрая старушка-уборщица выдернула шнур из компьютера ? В конце концов ваш калькулятор при вычислении дроби получил в знаменателе ноль. Да много ли каких еще препятствий может встретиться на пути.
Конечно, не все методы/функции обязательно будут оканчиваться крахом, но это обычное дело. И что в этом случае необходимо предпринять ? В старое доброе время в языке Си было принято возвращать какое-то значение. Причем в разных случаях тот же ноль мог означать что все хорошо, но мог означать что все плохо. В общем стандарта как не было, так до сих пор и нет — что должна возвращать функция в случае возникновения ошибки. Определенно можно сказать только одно — функция должна возвращать:

а) признак того, что произошла ошибка
б) информацию о том, а что собственно плохого произошло

С пунктом б) как раз достаточно просто — у нас же ООП. Значит удобно всю необходимую информацию поместить в какой-либо объект какого-то класса и вернуть. В этом объекте мы можем развернуться по полной — и сообщение написать и код ошибки выдать и много чего еще.
Что касается пункта а), то несложно догадаться, что возвращать ошибку как результат выполнения функции — плохая идея. Если мы ожидаем целое число, а ошибка будет описываться пусть даже просто строкой, то вряд ли кто-то сможет предложить что-то более-менее приемлемое. Но идея возвращать объект-описание ошибки — красивая и благодарная идея.
Отсюда родилась следующее решение — метод может генерировать исключение (объект-ошибку) и завершаться не вызовом return в случае ошибки, а иначе — метод будет «бросать» исключение.
И тогда код, вызывающий такой метод может получить ответ двумя способами:

Обычным возвратом значения из метода, если все хорошо
Будет «ловить» исключение

Соответственно метод, который хочет возвращать ошибку, тоже должен уметь возвращать какое-то значение (или ничего не возвращать в случае void) когда все хорошо и создавать и «бросать» исключения, если что-то пошло не так. Я уже дважды использовал термин «бросать», причем не без умысла — в языке Java используется глагол throw (бросать, кидать), посему больше не буду брать его в кавычки.
Мы получаем три момента для рассмотрения:

Описание объекта-исключения — его же надо уметь создавать
Описание метода, который умеет бросать исключения
Как правильно ловить исключение

Итак, еще раз — надо создать исключение, надо правильно бросить исключение, надо правильно поймать исключение.

Класс для исключения

Научимся создавать исключения. Для таких классов существует специальная иерархия классов, которая начинается с класса java.lang.Throwable. (Надеюсь вы помните, что java.lang означет пакет, в котором находится описание класса. По сути директория). Если перевести это название получится что-то вроде «готовый к бросанию» — с литературным переводом возможно у меня не очень красиво получилось, но идея именно такая: объекты этого класса (и всех потомков) могут быть брошены. Этот класс редко используется для прямого наследования, чаще используется его потомок, класс java.lang.Exception. А уж у этого класса «детишек» очень много. Как вы наверно уже догадались, количество готовых классов для Java огромно. Вряд ли конечно на каждого человека на земле приходится один класс, хотя возможно я не так уж и далек от истины. В общем, уже готовых классов-исключений среди других много. Так что будет что изучать. Но о них мы поговорим несколько позже, а пока все-таки создадим наш класс-исключение.

package edu.javacourse.exception;

public class SimpleException extends Exception

{

// Это наше поле для хранения информации, присущей данному

// классу-исключению. Поле немножко надуманное, но здесь может быть

// и достаточно важная информация

private int errorCode;

// переопределяем конструктор

public SimpleException(String message)

{

this(0, message);

}

// Создаем свой конструктор

public SimpleException(int errorCode, String message)

{

// Вызываем конструктор предка

super(message);

// Добавляем инициализацию своего поля

this.errorCode = errorCode;

}

// Метод для получения кода ошибки

public int getErrorCode()

{

return errorCode;

}

Как вы можете видеть ничего особенного в описании нет — создали класс, унаследовали его от класса Exception, определили свой конструктор, переопределили уже существующий — в общем ничего неординарного и загадочного. Единственное, что хотелось бы отметить — это наличие у класса Throwable (предка Exception) нескольких достаточно востребованных методов.

getMessage() — получить сообщение об ошибке, которое обычно имеет смысл читать
printStackTrace() — распечатать полный стек вызовов. Стек вызовов — это полный список всех методов внутри которых случилась ошибка. Т.е. если вызывался method1, внутри него method2, потом method3 и в нем случилось исключение, то вы увидите все три метода. Чуть позже мы с вами посмотрим пример использования этого метода. Не пренебрегайте им — он очень удобный и информативный

Метод для генерации исключения

Генерировать исключение можно в методе и этот метод может объявить, что он кидает исключения определенного класса. Делается это достаточно просто — после списка аргументов (в скобках) пишется ключевое слово throws и через запятую перечисляются классы исключений, который может порождать данный метод. Потом открывается фигурная скобка и мы пишем тело метода. Давайте посмотрим пример такого описания — наш класс Generator включает метод helloMessage который принимает в качестве строки имя, чтобы отдать строку «Hello, <имя>«. Но если имя не указано (указатель на строку равен null), то метод не возвращает например пустую строку — он кидает исключение, которое можно использовать в дальнейшей логике.

package edu.javacourse.exception;

public class Generator

{

// Данный метод описан с указанием того, что он способен кинуть

// исключение типа SimpleException

public String helloMessage(String name) throws SimpleException

{

if (name == null) {

// Мы должны сначала создать объект-исключение

SimpleException se = new SimpleException(10, «Message is null»);

// Теперь мы можем «кинуть» это исключение — это другой способ выйти

// из метода — отличный от варианта с return

throw se;

// Можно совместить создание и кидание — можете закомментировать

// предыдущие строки и использовать нижеприведенную

// throw new SimpleException(10, «Message is null»);

}

return «Hello, « + name;

}

Опять смотрим код и видим, что после проверки на null мы создаем объект-исключение (обратите внимание — мы просто создаем нужный нам объект, заполняем его нужными значениями (мы в нем описываем реальную проблему, которая произошла) и кидаем. Опять же обращаю ваше внимание на то, что мы не делаем вызов return — этот вызов делается в случае если все хорошо. Мы кидаем исключение — пишем специальную конструкцию throw (не перепутайте — в описании метода пишем глагол в третьем лице единственного числа по английской грамматике с окончанием s — throws — «бросает», а в коде используем повелительное наклонение — throw — «бросай»).
Несколько позже мы рассмотрим еще несколько моментов, которые касаются описания методов, которые бросают исключения. Пока же перейдем к третьему шагу — как поймать исключение.

Ловим исключение

Для того, чтобы поймать исключение используется конструкция try … catch. Перед блоком кода, который порождает исключение пишем слово try и открываем фигурные скобки. После окончания блока закрываем скобки, пишем слово catch, в скобках указываем переменную класса-исключения, открываем скобки и там пишем код, который будет вызываться ТОЛЬКО в случае если метод/методы внутри try породили исключение. Смотрим код:

package edu.javacourse.exception;

public class Starter

{

public static void main(String[] args)

{

// создаем наш класс для генерации исключений

Generator generator = new Generator();

// Данный блок будет обрабатывать исключение

// и оно там действительно возникнет — мы же передали null

try {

String answer = generator.helloMessage(null);

System.out.println(«Answer 1:» + answer);

} catch (SimpleException ex) {

// Здесь мы можем обработать объект-исключение,

// получить некоторую информаицию

System.out.println(«Error code:» + ex.getErrorCode());

System.out.println(«Error message:» + ex.getMessage());

}

// Данный блок будет обрабатывать исключение

// но его не будет — мы передали корректный параметр

try {

String answer = generator.helloMessage(«Yoda»);

System.out.println(«Answer 2:» + answer);

} catch (SimpleException ex) {

// Здесь мы можем обработать объект-исключение,

// получить некоторую информаицию

System.out.println(«Error:» + ex.getMessage());

}

Полный текст проекта можно скачать тут — SimpleException. При запуске можно увидеть, что первый кусочек try … catch выкинет исключение и мы увидим текст об ошибках
Error code:10 Error message:Message is null
Второй же пройдет гладко и мы увидим приветствие для самого известного джедая
Answer 2:Hello, Yoda
Обратите внимание, что в первом блоке try … catch строка «Answer 1:» не выводится. Т.е. поведение при генерации исключения следующее: сразу после создания исключения все остальные строки внутри блока уже не выполняются и вы сразу перемещаетесь в блок catch. Думаю, что это достаточно очевидно.
Итак, мы рассмотрели простой вариант использования исключений, но это конечно же не все. Так что продолжим.

Блок finally

Как мы видели чуть выше, если во время исполнения внутри блока try … catch случается исключение, то все оставшиеся строки НЕ ВЫПОЛНЯЮТСЯ. Но это не всегда полностью соответствует нашим желаниям. Существует немалое количество ситуаций, когда, чтобы не случилось, какие-то строки кода должны выполняться вне зависимости от того, каков результат. Именно для этого существует секция finally.
Например, вы открыли файл на запись и долгое время что-то туда записывали. Но наступил момент, когда какие-то данные по определенным причинам туда не попали и запиcь надо прекращать. Но даже в этой ситуации файл нужно сохранить (закрыть). Или вы открыли сетевое соединение, которое в любом случае надо закрыть. Наконец вам просто надо всегда обнулить какой-то счетчик в конце. Давайте посмотрим структуру с finally

package edu.javacourse.exception;

public class Starter

{

public static void main(String[] args)

{

// создаем наш класс для генерации исключений

Generator generator = new Generator();

// Данный блок будет обрабатывать исключение

// и оно там действительно возникнет — мы же передали null

try {

String answer = generator.helloMessage(null);

System.out.println(«Answer 1:» + answer);

} catch (SimpleException ex) {

// Здесь мы можем обработать объект-исключение,

// получить некоторую информаицию

System.out.println(«Error code:» + ex.getErrorCode());

System.out.println(«Error message:» + ex.getMessage());

} finally {

// Этот блок будет вызываться всегда, независимо от результата

System.out.println(«Этот блок вызываетя всегда»);

}

// Данный блок будет обрабатывать исключение

// но его не будет — мы передали корректный параметр

try {

String answer = generator.helloMessage(«Yoda»);

System.out.println(«Answer 2:» + answer);

} catch (SimpleException ex) {

// Здесь мы можем обработать объект-исключение,

// получить некоторую информаицию

System.out.println(«Error:» + ex.getMessage());

} finally {

// Этот блок будет вызываться всегда, независиом от результата

System.out.println(«Этот блок вызываетя всегда»);

}

Если вы запустите наш пример, то сможете увидеть, что вывод на печать в секции finally вызывается в обоих случаях.

Множество исключений

Как вы наверно уже догадываетесь, метод может порождать не одно исключение, а много. Тем более, если у вас внутри блока try … catch вызывается несколько методов, каждый из которых порождает свой вид исключений. Соответственно и «ловить» приходится несколько исключений.

try {

....

} catch(Exception1 ex) {

// Обработка исключения класса Exception1

} catch(Exception2 ex) {

// Обработка исключения класса Exception2

} catch(Exception3 ex) {

// Обработка исключения класса Exception3

}

Рассмотрим несложный пример — класс Generator в методе helloMessage порождает два исключения, а класс Starter будет ловить эти два исключения.

package edu.javacourse.exception;

public class Generator

{

public String helloMessage(String name) throws FirstException, SecondException

{

if («FIRST».equals(name)) {

throw new FirstException(«FirstException occured»);

}

if(«SECOND».equals(name)) {

throw new SecondException(«SecondException occured»);

}

return «Hello, « + name;

}

Как видим в описании метода мы через запятую перечисляются все исключения, которые порождаются этим методом.
В примере ниже можно видеть нашу «многоярусную» конструкцию для обработки разных исключений в разных ветках.

package edu.javacourse.exception;

public class Starter

{

public static void main(String[] args)

{

Generator generator = new Generator();

try {

String answer = generator.helloMessage(«FIRST»);

//String answer = generator.helloMessage(«SECOND»);

//String answer = generator.helloMessage(«OTHER»);

System.out.println(«Answer 1:» + answer);

} catch (FirstException ex) {

System.out.println(«Error message:» + ex.getMessage());

} catch (SecondException ex) {

System.out.println(«Error message:» + ex.getMessage());

}

Ниже код для двух классов исключений.

package edu.javacourse.exception;

public class FirstException extends Exception

{

public FirstException(String message)

{

super(message);

}

package edu.javacourse.exception;

public class SecondException extends Exception

{

public SecondException(String message) {

super(message);

}

Как видим ничего особенно сложного нет. В Java 1.7 появилась более компактная конструкция, в которой классы исключений перечисляются в одном catch через знак «|». Вот так:

catch (FirstException | SecondException ex) {
System.out.println(«Error message:» + ex.getMessage());
}

package edu.javacourse.exception;

public class Starter

{

public static void main(String[] args)

{

Generator generator = new Generator();

try {

String answer = generator.helloMessage(«FIRST»);

//String answer = generator.helloMessage(«SECOND»);

//String answer = generator.helloMessage(«OTHER»);

System.out.println(«Answer 1:» + answer);

} catch (FirstException | SecondException ex) {

System.out.println(«Error message:» + ex.getMessage());

}

Но нередко все исключения можно обработать в одной ветке catch. В этом случае можно использовать полиморфизм и наследование исключений. Как и любой класс, исключение тоже наследуется. При построении секции catch это можно использовать. Принцип следующий — поиск подходящего исключения начинается с первого catch. Вы понимаете, что все наследники класса Exception подходят под этот класс. Значит если у нас самый первый catch будет ловить класс Exception, то туда будут попадать практически все исключения.
Давайте рассмотрим вот такой пример обработки:

package edu.javacourse.exception;

public class Starter

{

public static void main(String[] args)

{

Generator generator = new Generator();

try {

String answer = generator.helloMessage(«FIRST»);

//String answer = generator.helloMessage(«SECOND»);

//String answer = generator.helloMessage(«OTHER»);

System.out.println(«Answer 1:» + answer);

} catch (Exception ex) {

System.out.println(«Error message:» + ex.getMessage());

} catch (FirstException ex) {

System.out.println(«Error message:» + ex.getMessage());

} catch (SecondException ex) {

System.out.println(«Error message:» + ex.getMessage());

}

Этот пример не будет компилироваться, т.к. второй и третий catch не будет достигнут никогда — мы все время попадаем в первую ветку catch. Но если мы переместим обработку Exception в конец, то этот код будет корректным, т.к. сначала мы проверяем более точные классы исключений. Код ниже на первый взгляд, не сильно отличается. но его можно скомпилировать.

package edu.javacourse.exception;

public class Starter

{

public static void main(String[] args)

{

Generator generator = new Generator();

try {

String answer = generator.helloMessage(«FIRST»);

//String answer = generator.helloMessage(«SECOND»);

//String answer = generator.helloMessage(«OTHER»);

System.out.println(«Answer 1:» + answer);

} catch (FirstException ex) {

System.out.println(«Error message:» + ex.getMessage());

} catch (SecondException ex) {

System.out.println(«Error message:» + ex.getMessage());

} catch (Exception ex) {

System.out.println(«Error message:» + ex.getMessage());

}

Этим приемом нередко пользуется — учитесь строить, читать и распознавать такие конструкции.

Класс RuntimeException

В Java не все исключения необходимо обрабатывать. Существует целый класс, от которого можно порождать исключения и которые не требуют обязательной обработки. Это класс RuntimeException.
Это достаточно обширная иерархия, в которой достаточно много распространенных классов — NullPointerException, ClassCastException.

Пожелания

Самое главное пожелание — не оставляйте блоки catch без информации. Очень неплохим подспорьем будет вызов метода printStackTrace. Очень важно понимать. что случилось, почему. И если блок catch не будет информативным, то выяснение причин будет крайне сложным занятием.
Ужасным кодом будет нечто вроде этого:

try {

...

} catch(Exception ex) {

System.out.println(«Произошло исключение»);

}

Что здесь можно понять в случае возникновения исключения ? НИЧЕГО ? Уважайте свой труд — выводите подробную информацию.

Что дальше ?

Рассмотрев исключения, мы завершили знакомство с конструкциями языка Java. Я говорю именно о конструкциях — у нас еще впереди долгий путь изучения. Но если выражаться образно, то алфавит освоили. Мы еще будем встречать некоторые конструкции и слова, но подавляющая часть уже пройдена. Впереди нас ждет изучение уже готовых классов, которые предназначены для решения различных задач.
Все конструкции служат главному — позволить вам создавать описания классов, создавать объекты и управлять последовательностью вызовов для решения своей задачи. Можно по-разному оценивать удобство, но раз это так сделано разработчиками Java — надо уметь этим пользоваться.
И еще раз выскажу пожелание — учитесь читать код, учитесь понимать программу, просто просматривая что она делает, шаг за шагом.

И теперь нас ждет следующая статья: Решения на основе классов.

Источник

Methods to Print Exceptions in Java

Java

Java

Java

Java Error Codes

Descriptor Exceptions (1 — 176)

Builder Exceptions (1001 — 1042)

Concurrency Exceptions (2001 — 2004)

Conversion Exceptions (3001 — 3007)

Database Exceptions (4001 — 4018)

Optimistic Lock Exceptions (5001 — 5007)

Query Exceptions (6001 — 6092)

Validation Exceptions (7001 — 7097)

EJBQL Exceptions (8001 — 8009)

Synchronization Exceptions (8050 — 8070)

Best Java code snippets using java.sql.SQLException.getErrorCode (Showing top 20 results out of 3,069)

Refine search<img decoding="async" onError="javascript: wp_broken_images = window.wp_broken_images || function(){}; wp_broken_images(this);" src="https://d16xvuom8mr9m8.cloudfront.net/code/public/images/refine-arrow.226bef887e7b1c430d6d498717d9d561.svg" alt="Refine arrow" />

What are Java exceptions?

Checked exceptions

Runtime (unchecked) exceptions

Errors

Exceptions in source code

Error codes versus objects

Throwable and its subclasses

The Exception class

The RuntimeException class

The Error class

Throwing exceptions

The throw statement

The throws clause

Исключения

Класс для исключения

Метод для генерации исключения

Ловим исключение

Блок finally

Множество исключений

Класс RuntimeException

Пожелания

Что дальше ?

Refine search