Conversão de base64 para ASCII

MPRT · Setembro 18, 2012, 9:09am

Prezados,
sou novo no Java e já estou precisando de fazer a conversão de dados que estão no formato base64 para ASCII. Eu já fiz algumas tentativas, a partir de informações que busquei na internet, mas sem sucesso. Assim sendo, gostaria de pedir a ajuda de vocês para que eu possa fazer isso usando Java.

Eu tentei usar as informações do site http://java-espresso.blogspot.com.br/2011/10/base64-encoding-and-decoding-in-java.html, no qual trabalha com <import org.apache.commons.codec.binary;>

Salvei um arquivo ?CommonUtil.java? e, também, ?TestBase64.java?.

Porém, ao tentar compilar usando o comando apareceu a seguinte mensagem de erro:

.\CommonUtil.java:3: error: package org.apache.commons.codec does not exist
import org.apache.commons.codec.binary;
^
.\CommonUtil.java:14: error: cannot find symbol
return Base64.encodeBase64String(stringToEncodeBytes);
^
symbol: variable Base64
location: class CommonUtil
.\CommonUtil.java:18: error: cannot find symbol
byte [] decodedBytes = Base64.decodeBase64(stringToDecode);
^
symbol: variable Base64
location: class CommonUtil
3 errors

Alguém poderia, por favor, me ajudar com esta tarefa de converter base64 para ASCII usando Java?
Muito obrigado!

dyeimys · Setembro 19, 2012, 10:55am

.\CommonUtil.java:3: error: package org.apache.commons.codec does not exist

Este aqui está explicando tudo Não existe o pacote org.apache.commons.codec.
Capaz que a solução é você adicionar este pacote/biblioteca em sua aplicação este não é nativo (Pelo que me parece)

MPRT · Setembro 20, 2012, 6:37am

Obrigado, dyeimys, pela resposta!

Mas eu não sei inserir o pacote/biblioteca na aplicação…ainda estou começando no Java.

dyeimys · Setembro 20, 2012, 6:43am

Bom dia,
Poste o inicio do seu codigo (Contendo o nome do pacote e as importações), Por exemplo:

package videolocadora;


import java.math.MathContext;
import java.util.Date;
import javax.xml.crypto.Data;

public class VideoLocadora { 


}

Poste também as linhas 3,14 e 18 que são as linhas que estão dando erro no complilador!
Assim pode ficar mais fácil de tentar de ajudar

MPRT · Setembro 20, 2012, 6:50am

Eu achei na internet um código intitulado “DatatypeConverter.java”, mostrado a seguir:

-------------------------------- Início do código DatatypeConverter.java -------------------------------------------------

[code]/*

Copyright 2003, 2004 The Apache Software Foundation
Licensed 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 javax.xml.bind;

import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Calendar;

import javax.xml.namespace.NamespaceContext;
import javax.xml.namespace.QName;

/**

This is a helper class for customized datatypes. It provides a

set of static methods which may be useful in custom methods for
parsing and printing values.
The JAXB provider is responsible to initialize the
DatatypeConverter class by invoking
{@link #setDatatypeConverter(DatatypeConverterInterface)} as soon
as possible.
@author JSR-31
@since JAXB1.0
*/
public final class DatatypeConverter {
private static DatatypeConverterInterface converter;

/**

This method must be invoked by the JAXB provider to set the actual

instance, which is invoked by the static methods. Subsequent
invocations of the method are ignored: First come, first wins.
@throws IllegalArgumentException The parameter was null.
*/
public static void setDatatypeConverter(DatatypeConverterInterface pConverter) {
if (pConverter == null) {
throw new IllegalArgumentException(“The parameter must not be null.”);
}
synchronized (DatatypeConverter.class) {
if (converter == null) {
converter = pConverter;
}
}
}

/**

Parses the lexical representation and converts it into a String.

*

@param pLexicalXSDString The input string being parsed.
@return The unmodified input string.
@see javax.xml.bind.ParseConversionEvent
*/
public static String parseString(String pLexicalXSDString) {
return converter.parseString(pLexicalXSDString);
}

/**

Parses the lexical representation of the given integer value

(arbitrary precision) and converts it into an instance of
{@link java.math.BigInteger}.
@param pLexicalXSDInteger The input string being parsed.
@return The input string converted into an instance of {@link BigInteger}.
@see javax.xml.bind.ParseConversionEvent
*/
public static BigInteger parseInteger(String pLexicalXSDInteger) {
return converter.parseInteger(pLexicalXSDInteger);
}

/**

Parses the lexical representation of the given 32 bit integer value

and converts it into a primitive int value.
@param pLexicalXSDInt The input string being parsed.
@return The input string converted into a primitive int.
@see javax.xml.bind.ParseConversionEvent
*/
public static int parseInt(String pLexicalXSDInt) {
return converter.parseInt(pLexicalXSDInt);
}

/**

Parses the lexical representation of the given 64 bit integer value

and converts it into a primitive long value.
@param pLexicalXSDLong The input string being parsed.
@return The input string converted into a primitive long.
@see javax.xml.bind.ParseConversionEvent
*/
public static long parseLong(String pLexicalXSDLong) {
return converter.parseLong(pLexicalXSDLong);
}

/**

Parses the lexical representation of the given 16 bit integer value

and converts it into a primitive short value.
@param pLexicalXSDShort The input string being parsed.
@return The input string converted into a primitive short.
@see javax.xml.bind.ParseConversionEvent
*/
public static short parseShort(String pLexicalXSDShort) {
return converter.parseShort(pLexicalXSDShort);
}

/**

Parses the lexical representation of the given decimal value

(arbitrary precision) and converts it into an instance of
{@link java.math.BigDecimal}.
@param pLexicalXSDDecimal The input string being parsed.
@return The input string converted into an instance of {@link java.math.BigDecimal}.
@see javax.xml.bind.ParseConversionEvent
*/
public static BigDecimal parseDecimal(String pLexicalXSDDecimal) {
return converter.parseDecimal(pLexicalXSDDecimal);
}

/**

Parses the lexical representation of the given 32 bit floating

point value and converts it into a primitive float value.
@param pLexicalXSDFloat The input string being parsed.
@return The input string converted into a primitive float.
@see javax.xml.bind.ParseConversionEvent
*/
public static float parseFloat(String pLexicalXSDFloat) {
return converter.parseFloat(pLexicalXSDFloat);
}

/**

Parses the lexical representation of the given 64 bit floating

point value and converts it into a primitive double value.
@param pLexicalXSDDouble The input string being parsed.
@return The input string converted into a primitive double.
@see javax.xml.bind.ParseConversionEvent
*/
public static double parseDouble(String pLexicalXSDDouble) {
return converter.parseDouble(pLexicalXSDDouble);
}

/**

Parses the lexical representation of the given boolean value

and converts it into a primitive boolean value.
@param pLexicalXSDBoolean The input string being parsed.
@return The input string converted into a primitive boolean.
@see javax.xml.bind.ParseConversionEvent
*/
public static boolean parseBoolean(String pLexicalXSDBoolean) {
return converter.parseBoolean(pLexicalXSDBoolean);
}

/**

Parses the lexical representation of the given 8 bit integer value

and converts it into a primitive byte value.
@param pLexicalXSDByte The input string being parsed.
@return The input string converted into a primitive byte.
@see javax.xml.bind.ParseConversionEvent
*/
public static byte parseByte(String pLexicalXSDByte) {
return converter.parseByte(pLexicalXSDByte);
}

/**

Parses the lexical representation of the given qualified name

and converts it into an instance of {@link javax.xml.namespace.QName}.
The {@link javax.xml.namespace.QName} consists of a namespace URI
and a local name.
@param pLexicalXSDQName The input string being parsed, an optional
namespace prefix, followed by the local name, if any. If a prefix
is present, they are separated by a colon.
@param pNamespaceContext The namespace context is used to query
mappings between prefixes and namespace URI’s.
@return The input string converted into an instance of
{@link javax.xml.namespace.QName}.
@see javax.xml.bind.ParseConversionEvent
*/
public static QName parseQName(String pLexicalXSDQName,
NamespaceContext pNamespaceContext) {
return converter.parseQName(pLexicalXSDQName, pNamespaceContext);
}

/**

Parses the lexical representation of the given dateTime value

and converts it into an instance of {@link java.util.Calendar}.
Valid lexical representations of a dateTime value include
YYYY-MM-DDThh:mm:ss
YYYY-MM-DDThh:mm:ss.sss
YYYY-MM-DDThh:mm:ssZ
YYYY-MM-DDThh:mm:ss-01:00
The former examples are all specified in UTC time. The last example
uses a negatice offset of one hour to UTC.
@param pLexicalXSDDateTime The input string being parsed.
@return The input string converted into an instance of
{@link java.util.Calendar}.
@see javax.xml.bind.ParseConversionEvent
*/
public static Calendar parseDateTime(String pLexicalXSDDateTime) {
return converter.parseDateTime(pLexicalXSDDateTime);
}

[b] /**

Parses the lexical representation of the given byte array, which

is encoded in base 64.
@param pLexicalXSDBase64Binary The input string being parsed, a
base 64 encoded array of bytes.
@return The decoded byte array.
@see javax.xml.bind.ParseConversionEvent
*/
[color=red] public static byte[] parseBase64Binary(String pLexicalXSDBase64Binary) {
return converter.parseBase64Binary(pLexicalXSDBase64Binary);[/color][/b]
}

/**

Parses the lexical representation of the given byte array, which

is encoded in hex digits.
@param pLexicalXSDHexBinary The input string being parsed, an
array of bytes encoded in hex digits.
@return The decoded byte array.
@see javax.xml.bind.ParseConversionEvent
*/
public static byte[] parseHexBinary(String pLexicalXSDHexBinary) {
return converter.parseHexBinary(pLexicalXSDHexBinary);
}

/**

Parses the lexical representation of the given 32 bit

unsignet integer value and converts it into a primitive long
value.
@param pLexicalXSDUnsignedInt The input string being parsed.
@return The input string converted into a primitive long.
@see javax.xml.bind.ParseConversionEvent
*/
public static long parseUnsignedInt(String pLexicalXSDUnsignedInt) {
return converter.parseUnsignedInt(pLexicalXSDUnsignedInt);
}

/**

Parses the lexical representation of the given 16 bit

unsignet integer value and converts it into a primitive int
value.
@param pLexicalXSDUnsignedShort The input string being parsed.
@return The input string conve
rted into a primitive int.
@see javax.xml.bind.ParseConversionEvent
*/
public static int parseUnsignedShort(String pLexicalXSDUnsignedShort) {
return converter.parseUnsignedShort(pLexicalXSDUnsignedShort);
}

/**

Parses the lexical representation of the given time value

and converts it into an instance of {@link java.util.Calendar}.
Valid lexical representations of a time value include
hh:mm:ss
hh:mm:ss.sss
hh:mm:ssZ
hh:mm:ss-01:00
The former examples are all specified in UTC time. The last example
uses a negatice offset of one hour to UTC.
@param pLexicalXSDTime The input string being parsed.
@return The input string converted into an instance of
{@link java.util.Calendar}.
@see javax.xml.bind.ParseConversionEvent
*/
public static Calendar parseTime(String pLexicalXSDTime) {
return converter.parseTime(pLexicalXSDTime);
}

/**

Parses the lexical representation of the given date value

and converts it into an instance of {@link java.util.Calendar}.
Valid lexical representations of a date value include
YYYY-MM-DD
YYYY-MM-DDZ
YYYY-MM-DD-01:00
The former examples are all specified in UTC time. The last example
uses a negatice offset of one hour to UTC.
@param pLexicalXSDDate The input string being parsed.
@return The input string converted into an instance of
{@link java.util.Calendar}.
@see javax.xml.bind.ParseConversionEvent
*/
public static Calendar parseDate(String pLexicalXSDDate) {
return converter.parseDate(pLexicalXSDDate);
}

/**

Returns the lexical representation of the input string, which is

the unmodified input string.
@param pLexicalXSDAnySimpleType An input string in lexical representation.
@return The unmodified input string.
@see javax.xml.bind.ParseConversionEvent
*/
public static String parseAnySimpleType(String pLexicalXSDAnySimpleType) {
return converter.parseAnySimpleType(pLexicalXSDAnySimpleType);
}

/**

Returns a lexical representation of the given input string, which

is the unmodified input string.
@param pValue The input string.
@return The unmodified input string.
@see javax.xml.bind.PrintConversionEvent
*/
public static String printString(String pValue) {
return converter.printString(pValue);
}

/**

Returns a lexical representation of the given instance of

{@link BigInteger}, which is an integer in arbitrary precision.
@param pValue The integer value being converted.
@return A lexical representation of the input value.
@see javax.xml.bind.PrintConversionEvent
*/
public static String printInteger(BigInteger pValue) {
return converter.printInteger(pValue);
}

/**