org.apache.logging.log4j.message.StringFormattedMessage Maven / Gradle / Ivy
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache license, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the license for the specific language governing permissions and
* limitations under the license.
*/
package org.apache.logging.log4j.message;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Arrays;
import java.util.IllegalFormatException;
import java.util.Locale;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.status.StatusLogger;
/**
* Handles messages that consist of a format string conforming to {@link java.util.Formatter}.
*
* Note to implementors
*
* This class implements the unrolled args API even though StringFormattedMessage does not. This leaves the room for
* StringFormattedMessage to unroll itself later.
*
*/
public class StringFormattedMessage implements Message {
private static final Logger LOGGER = StatusLogger.getLogger();
private static final long serialVersionUID = -665975803997290697L;
private static final int HASHVAL = 31;
private String messagePattern;
private transient Object[] argArray;
private String[] stringArgs;
private transient String formattedMessage;
private transient Throwable throwable;
private final Locale locale;
/**
* Constructs a message.
*
* @param locale the locale for this message format
* @param messagePattern the pattern for this message format
* @param arguments The objects to format
* @since 2.6
*/
public StringFormattedMessage(final Locale locale, final String messagePattern, final Object... arguments) {
this.locale = locale;
this.messagePattern = messagePattern;
this.argArray = arguments;
if (arguments != null && arguments.length > 0 && arguments[arguments.length - 1] instanceof Throwable) {
this.throwable = (Throwable) arguments[arguments.length - 1];
}
}
/**
* Constructs a message.
*
* @param messagePattern the pattern for this message format
* @param arguments The objects to format
* @since 2.6
*/
public StringFormattedMessage(final String messagePattern, final Object... arguments) {
this(Locale.getDefault(Locale.Category.FORMAT), messagePattern, arguments);
}
/**
* Returns the formatted message.
* @return the formatted message.
*/
@Override
public String getFormattedMessage() {
if (formattedMessage == null) {
formattedMessage = formatMessage(messagePattern, argArray);
}
return formattedMessage;
}
/**
* Returns the message pattern.
* @return the message pattern.
*/
@Override
public String getFormat() {
return messagePattern;
}
/**
* Returns the message parameters.
* @return the message parameters.
*/
@Override
public Object[] getParameters() {
if (argArray != null) {
return argArray;
}
return stringArgs;
}
protected String formatMessage(final String msgPattern, final Object... args) {
try {
return String.format(locale, msgPattern, args);
} catch (final IllegalFormatException ife) {
LOGGER.error("Unable to format msg: " + msgPattern, ife);
return msgPattern;
}
}
@Override
public boolean equals(final Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
final StringFormattedMessage that = (StringFormattedMessage) o;
if (messagePattern != null ? !messagePattern.equals(that.messagePattern) : that.messagePattern != null) {
return false;
}
return Arrays.equals(stringArgs, that.stringArgs);
}
@Override
public int hashCode() {
int result = messagePattern != null ? messagePattern.hashCode() : 0;
result = HASHVAL * result + (stringArgs != null ? Arrays.hashCode(stringArgs) : 0);
return result;
}
@Override
public String toString() {
return getFormattedMessage();
}
private void writeObject(final ObjectOutputStream out) throws IOException {
out.defaultWriteObject();
getFormattedMessage();
out.writeUTF(formattedMessage);
out.writeUTF(messagePattern);
out.writeInt(argArray.length);
stringArgs = new String[argArray.length];
int i = 0;
for (final Object obj : argArray) {
final String string = String.valueOf(obj);
stringArgs[i] = string;
out.writeUTF(string);
++i;
}
}
private void readObject(final ObjectInputStream in) throws IOException, ClassNotFoundException {
in.defaultReadObject();
formattedMessage = in.readUTF();
messagePattern = in.readUTF();
final int length = in.readInt();
stringArgs = new String[length];
for (int i = 0; i < length; ++i) {
stringArgs[i] = in.readUTF();
}
}
/**
* Return the throwable passed to the Message.
*
* @return the Throwable.
*/
@Override
public Throwable getThrowable() {
return throwable;
}
}