Converter arquivos do Excel para o Google Sheets em Java

Este artigo mostra como converter o MS Excel XLS ou XLSX para o Planilhas Google programaticamente em Java.

Converter Excel XLS ou XLSX para Google Sheets em Java

Google Sheets é um aplicativo on-line popular que permite criar e manipular documentos de planilha. Além disso, permite compartilhar as planilhas com várias pessoas em tempo real. Portanto, muitas vezes você precisa exportar dados de pastas de trabalho Excel para uma planilha no Planilhas Google de forma programática. Neste artigo, daremos um passo a passo completo de como exportar dados do Excel para uma planilha do Google Sheets em Java.

Pré-requisitos - Converter arquivo do Excel para planilhas do Google
- Projeto Google Cloud
- Conversão de APIs Java para Excel em Planilhas Google
Etapas para exportar o Excel XLSX para o Planilhas Google
Código fonte completo

Pré-requisitos - Converter arquivo do Excel para planilhas do Google em Java

Projeto Google Cloud

Google Cloud é uma plataforma de computação em nuvem, que fornece vários tipos de serviços que podemos utilizar em nossos aplicativos. Para usar a Google Sheets API, teremos que criar um projeto no console do Google Cloud e habilitar a Google Sheets API. Você pode ler o guia passo a passo sobre como criar um projeto do Google Cloud e ativar a Sheets API.

Conversão de APIs Java para Excel em Planilhas Google

Para exportar dados de arquivos XLS/XLSX do Excel para o Planilhas Google, precisaremos das seguintes APIs.

Aspose.Cells for Java - To read the data from Excel files.
APIs de cliente do Google para Java - Para criar e atualizar planilhas no Planilhas Google.

Para instalar essas APIs, você pode usar as seguintes configurações em seu arquivo pom.xml.

<repositories>
	<repository>
		<id>AsposeJavaAPI</id>
		<name>Aspose Java API</name>
		<url>http://repository.aspose.com/repo/</url>
	</repository>
</repositories>
<dependencies>
	<dependency>
		<groupId>com.google.api-client</groupId>
		<artifactId>google-api-client-gson</artifactId>
		<version>1.33.0</version>
	</dependency>
	<dependency>
		<groupId>com.google.oauth-client</groupId>
		<artifactId>google-oauth-client-jetty</artifactId>
		<version>1.32.1</version>
	</dependency>
	<dependency>
		<groupId>com.google.apis</groupId>
		<artifactId>google-api-services-sheets</artifactId>
		<version>v4-rev20210629-1.32.1</version>
	</dependency>
	<dependency>
		<groupId>com.aspose</groupId>
		<artifactId>aspose-cells</artifactId>
		<version>22.2</version>
	</dependency>
</dependencies>

Exportar dados do Excel para o Planilhas Google em Java

A seguir estão as etapas para ler um arquivo do Excel e exportar seus dados para o Planilhas Google em um aplicativo de console Java.

Crie um novo aplicativo Java (desktop).
Instale Aspose.Cells para Java e APIs de cliente do Google no projeto, conforme mencionado na seção anterior.
Copie o arquivo JSON (aquele que baixamos após criar as credenciais no Google Cloud) e cole-o no diretório do projeto.
Especifique os escopos do aplicativo que definem as permissões de acesso às planilhas. Além disso, crie variáveis para o caminho do diretório do token e a fábrica JSON.

/**
 * Instância global dos escopos necessários. Se modificar esses escopos, exclua
 * seus tokens/pasta salvos anteriormente.
 */
private static final String APPLICATION_NAME = "Google Sheets API Java Quickstart";
private static final JsonFactory JSON_FACTORY = GsonFactory.getDefaultInstance();
private static final String TOKENS_DIRECTORY_PATH = "tokens";
private static final List<String> SCOPES = Collections.singletonList(SheetsScopes.SPREADSHEETS);

Crie um método getCredentials que autorize o usuário usando o arquivo de credenciais.

private static Credential getCredentials(final NetHttpTransport HTTP_TRANSPORT) throws IOException {
	// Carregar segredos do cliente
	InputStream in = new FileInputStream(new File("credentials.json"));
	GoogleClientSecrets clientSecrets = GoogleClientSecrets.load(JSON_FACTORY, new InputStreamReader(in));

	// Crie fluxo e acione a solicitação de autorização do usuário
	GoogleAuthorizationCodeFlow flow = new GoogleAuthorizationCodeFlow.Builder(HTTP_TRANSPORT, JSON_FACTORY,
			clientSecrets, SCOPES)
					.setDataStoreFactory(new FileDataStoreFactory(new java.io.File(TOKENS_DIRECTORY_PATH)))
					.setAccessType("offline").build();
	LocalServerReceiver receiver = new LocalServerReceiver.Builder().setPort(8888).build();
	return new AuthorizationCodeInstalledApp(flow, receiver).authorize("user");
}

Crie o método createSpreadsheet para criar uma nova planilha no Planilhas Google e defina o nome da planilha padrão. Este método retorna um objeto Spreadsheet.

private static Spreadsheet createSpreadsheet(Sheets _service, String spreadsheetName, String _defaultSheetName)
		throws IOException {
	// Criar uma nova planilha
	Spreadsheet spreadsheet = new Spreadsheet()
			.setProperties(new SpreadsheetProperties().setTitle(spreadsheetName));

	// Criar uma nova planilha
	Sheet sheet = new Sheet();
	sheet.setProperties(new SheetProperties());
	sheet.getProperties().setTitle(_defaultSheetName);

	// Adicionar folha à lista
	List<Sheet> sheetList = new ArrayList<Sheet>();
	sheetList.add(sheet);
	spreadsheet.setSheets(sheetList);

	// Executar solicitação
	spreadsheet = _service.spreadsheets().create(spreadsheet).setFields("spreadsheetId").execute();
	System.out.println("Spreadsheet ID: " + spreadsheet.getSpreadsheetId());

	return spreadsheet;
}

Crie um método addSheet para adicionar uma nova planilha na planilha do Google.

private static void addSheet(Sheets _service, String _spreadSheetID, String _sheetName) {
	try {
		// Adicionar nova planilha
		AddSheetRequest addSheetRequest = new AddSheetRequest();
		addSheetRequest.setProperties(new SheetProperties());
		addSheetRequest.getProperties().setTitle(_sheetName);

		// Criar solicitação de atualização
		BatchUpdateSpreadsheetRequest batchUpdateSpreadsheetRequest = new BatchUpdateSpreadsheetRequest();
		Request req = new Request();
		req.setAddSheet(addSheetRequest);
		batchUpdateSpreadsheetRequest.setRequests(new ArrayList<Request>());
		batchUpdateSpreadsheetRequest.getRequests().add(req);

		// Executar solicitação
		_service.spreadsheets().batchUpdate(_spreadSheetID, batchUpdateSpreadsheetRequest).execute();
	} catch (Exception e) {
		System.out.println("Error in creating sheet: " + e.getMessage());
	}
}

Agora, crie o método exportExcelToGoogle e, nesse método, inicialize o serviço Sheets.

// Crie um novo serviço de cliente de API autorizado.
final NetHttpTransport HTTP_TRANSPORT = GoogleNetHttpTransport.newTrustedTransport();

Sheets service = new Sheets.Builder(HTTP_TRANSPORT, JSON_FACTORY, getCredentials(HTTP_TRANSPORT))
		.setApplicationName(APPLICATION_NAME).build();

Em seguida, carregue o arquivo Excel XLS/XLSX usando Aspose.Cells para Java. Além disso, obtenha o nome da primeira planilha na pasta de trabalho.

// Carregar uma pasta de trabalho do Excel
Workbook wb = new Workbook(_excelFileName);

// Obter nome da primeira planilha
String defaultWorksheetName = wb.getWorksheets().get(0).getName().trim();

// Obter todas as planilhas
WorksheetCollection collection = wb.getWorksheets();

Chame o método createSpreadsheet para criar uma nova planilha no Google Sheets.

// Criar uma nova planilha do Google com planilha padrão
Spreadsheet spreadsheet = createSpreadsheet(service, wb.getFileName(), defaultWorksheetName);

Leia os dados de cada planilha e salve-os em uma lista.

String range;

// Percorrer planilhas
for (int worksheetIndex = 0; worksheetIndex < collection.getCount(); worksheetIndex++) {
	// Obter referência da planilha
	Worksheet ws = collection.get(worksheetIndex);

	if (worksheetIndex == 0) {
		// A primeira planilha é criada por padrão, portanto, apenas defina o intervalo
		range = defaultWorksheetName + "!A:Y";
	} else {
		// Adicionar uma nova planilha
		addSheet(service, spreadsheet.getSpreadsheetId(), ws.getName().trim());
		range = ws.getName().trim() + "!A:Y";
	}

	// Obter número de linhas e colunas
	int rows = ws.getCells().getMaxDataRow();
	int cols = ws.getCells().getMaxDataColumn();

	List<List<Object>> worksheetData = new ArrayList<List<Object>>();

	// Percorrer as linhas
	for (int i = 0; i <= rows; i++) {
		List<Object> rowData = new ArrayList<Object>();

		// Percorrer cada coluna na linha selecionada
		for (int j = 0; j <= cols; j++) {
			if (ws.getCells().get(i, j).getValue() == null)
				rowData.add("");
			else
				rowData.add(ws.getCells().get(i, j).getValue());
		}

		// Adicionar aos dados da planilha
		worksheetData.add(rowData);
	}
  
  // TO-DO: Executar solicitação para postar dados no Planilhas Google 
}

Para cada planilha no arquivo Excel, crie uma solicitação para gravar dados na planilha no Planilhas Google.

// Definir intervalo
ValueRange body = new ValueRange();
body.setRange(range);

// Definir valores
body.setValues(worksheetData);

// Exportar valores para o Planilhas Google
UpdateValuesResponse result = service.spreadsheets().values()
		.update(spreadsheet.getSpreadsheetId(), range, body).setValueInputOption("USER_ENTERED")
		.execute();

// Saída de impressão
System.out.printf("%d cells updated.", result.getUpdatedCells());

O método completo para ler e exportar dados de um arquivo do Excel para uma planilha no Google Sheets é fornecido abaixo.

private static void exportExcelToGoogle(String _excelFileName) {
	try {
		// Crie um novo serviço de cliente de API autorizado.
		final NetHttpTransport HTTP_TRANSPORT = GoogleNetHttpTransport.newTrustedTransport();
		
		Sheets service = new Sheets.Builder(HTTP_TRANSPORT, JSON_FACTORY, getCredentials(HTTP_TRANSPORT))
				.setApplicationName(APPLICATION_NAME).build();
		
		// Carregar uma pasta de trabalho do Excel
		Workbook wb = new Workbook(_excelFileName);
		
		// Obter nome da primeira planilha
		String defaultWorksheetName = wb.getWorksheets().get(0).getName().trim();
		
		// Obter todas as planilhas
		WorksheetCollection collection = wb.getWorksheets();

		// Criar uma nova planilha do Google com planilha padrão
		Spreadsheet spreadsheet = createSpreadsheet(service, wb.getFileName(), defaultWorksheetName);

		System.out.println("Spreadsheet URL: " + spreadsheet.getSpreadsheetUrl());
		System.out.println("ID: " + spreadsheet.getSpreadsheetId());

		String range;

		// Percorrer planilhas
		for (int worksheetIndex = 0; worksheetIndex < collection.getCount(); worksheetIndex++) {
			// Obter referência da planilha
			Worksheet ws = collection.get(worksheetIndex);

			if (worksheetIndex == 0) {
				// A primeira planilha é criada por padrão, portanto, apenas defina o intervalo
				range = defaultWorksheetName + "!A:Y";
			} else {
				// Adicionar uma nova planilha
				addSheet(service, spreadsheet.getSpreadsheetId(), ws.getName().trim());
				range = ws.getName().trim() + "!A:Y";
			}

			// Obter número de linhas e colunas
			int rows = ws.getCells().getMaxDataRow();
			int cols = ws.getCells().getMaxDataColumn();

			List<List<Object>> worksheetData = new ArrayList<List<Object>>();

			// Percorrer as linhas
			for (int i = 0; i <= rows; i++) {
				List<Object> rowData = new ArrayList<Object>();

				// Percorrer cada coluna na linha selecionada
				for (int j = 0; j <= cols; j++) {
					if (ws.getCells().get(i, j).getValue() == null)
						rowData.add("");
					else
						rowData.add(ws.getCells().get(i, j).getValue());
				}

				// Adicionar aos dados da planilha
				worksheetData.add(rowData);
			}

			// Definir intervalo
			ValueRange body = new ValueRange();
			body.setRange(range);

			// Definir valores
			body.setValues(worksheetData);

			// Exportar valores para o Planilhas Google
			UpdateValuesResponse result = service.spreadsheets().values()
					.update(spreadsheet.getSpreadsheetId(), range, body).setValueInputOption("USER_ENTERED")
					.execute();
			
			// Saída de impressão
			System.out.printf("%d cells updated.", result.getUpdatedCells());

		}

		// Abra a planilha do Google no navegador
		Desktop desk = Desktop.getDesktop();
		desk.browse(new URI("https://docs.google.com/spreadsheets/d/" + spreadsheet.getSpreadsheetId()));
	} catch (Exception e) {
		System.out.println(e.getMessage());
	}
}

Código fonte completo

Veja a seguir o código-fonte completo para converter um arquivo XLSX do Excel para o Planilhas Google em Java.

package excel_to_google_sheets;

import com.aspose.cells.Workbook;
import com.aspose.cells.Worksheet;
import com.aspose.cells.WorksheetCollection;
import com.google.api.client.auth.oauth2.Credential;
import com.google.api.client.extensions.java6.auth.oauth2.AuthorizationCodeInstalledApp;
import com.google.api.client.extensions.jetty.auth.oauth2.LocalServerReceiver;
import com.google.api.client.googleapis.auth.oauth2.GoogleAuthorizationCodeFlow;
import com.google.api.client.googleapis.auth.oauth2.GoogleClientSecrets;
import com.google.api.client.googleapis.javanet.GoogleNetHttpTransport;
import com.google.api.client.http.javanet.NetHttpTransport;
import com.google.api.client.json.JsonFactory;
import com.google.api.client.json.gson.GsonFactory;
import com.google.api.client.util.store.FileDataStoreFactory;
import com.google.api.services.sheets.v4.Sheets;
import com.google.api.services.sheets.v4.SheetsScopes;
import com.google.api.services.sheets.v4.model.AddSheetRequest;
import com.google.api.services.sheets.v4.model.BatchUpdateSpreadsheetRequest;
import com.google.api.services.sheets.v4.model.Request;
import com.google.api.services.sheets.v4.model.Sheet;
import com.google.api.services.sheets.v4.model.SheetProperties;
import com.google.api.services.sheets.v4.model.Spreadsheet;
import com.google.api.services.sheets.v4.model.SpreadsheetProperties;
import com.google.api.services.sheets.v4.model.UpdateValuesResponse;
import com.google.api.services.sheets.v4.model.ValueRange;
import java.awt.Desktop;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URI;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class ExportExcelToGoogle {

	/**
	 * Instância global dos escopos necessários. Se modificar esses escopos, exclua
	 * seus tokens/pasta salvos anteriormente.
	 */
	private static final String APPLICATION_NAME = "Google Sheets API Java Quickstart";
	private static final JsonFactory JSON_FACTORY = GsonFactory.getDefaultInstance();
	private static final String TOKENS_DIRECTORY_PATH = "tokens";
	private static final List<String> SCOPES = Collections.singletonList(SheetsScopes.SPREADSHEETS);

	public static void main(String[] args) throws Exception {		
		// Exportar dados do Excel para o Planilhas Google
		exportExcelToGoogle("workbook.xlsx");
	}

	private static void exportExcelToGoogle(String _excelFileName) {
		try {
			// Crie um novo serviço de cliente de API autorizado.
			final NetHttpTransport HTTP_TRANSPORT = GoogleNetHttpTransport.newTrustedTransport();
			
			Sheets service = new Sheets.Builder(HTTP_TRANSPORT, JSON_FACTORY, getCredentials(HTTP_TRANSPORT))
					.setApplicationName(APPLICATION_NAME).build();
			
			// Carregar uma pasta de trabalho do Excel
			Workbook wb = new Workbook(_excelFileName);
			
			// Obter nome da primeira planilha
			String defaultWorksheetName = wb.getWorksheets().get(0).getName().trim();
			
			// Obter todas as planilhas
			WorksheetCollection collection = wb.getWorksheets();
	
			// Criar uma nova planilha do Google com planilha padrão
			Spreadsheet spreadsheet = createSpreadsheet(service, wb.getFileName(), defaultWorksheetName);
	
			String range;
	
			// Percorrer planilhas
			for (int worksheetIndex = 0; worksheetIndex < collection.getCount(); worksheetIndex++) {
				// Obter referência da planilha
				Worksheet ws = collection.get(worksheetIndex);
	
				if (worksheetIndex == 0) {
					// A primeira planilha é criada por padrão, portanto, apenas defina o intervalo
					range = defaultWorksheetName + "!A:Y";
				} else {
					// Adicionar uma nova planilha
					addSheet(service, spreadsheet.getSpreadsheetId(), ws.getName().trim());
					range = ws.getName().trim() + "!A:Y";
				}
	
				// Obter número de linhas e colunas
				int rows = ws.getCells().getMaxDataRow();
				int cols = ws.getCells().getMaxDataColumn();
	
				List<List<Object>> worksheetData = new ArrayList<List<Object>>();
	
				// Percorrer as linhas
				for (int i = 0; i <= rows; i++) {
					List<Object> rowData = new ArrayList<Object>();
	
					// Percorrer cada coluna na linha selecionada
					for (int j = 0; j <= cols; j++) {
						if (ws.getCells().get(i, j).getValue() == null)
							rowData.add("");
						else
							rowData.add(ws.getCells().get(i, j).getValue());
					}
	
					// Adicionar aos dados da planilha
					worksheetData.add(rowData);
				}
	
				// Definir intervalo
				ValueRange body = new ValueRange();
				body.setRange(range);
	
				// Definir valores
				body.setValues(worksheetData);
	
				// Exportar valores para o Planilhas Google
				UpdateValuesResponse result = service.spreadsheets().values()
						.update(spreadsheet.getSpreadsheetId(), range, body).setValueInputOption("USER_ENTERED")
						.execute();
				
				// Saída de impressão
				System.out.printf("%d cells updated.", result.getUpdatedCells());
	
			}
	
			// Abra a planilha do Google no navegador
			Desktop desk = Desktop.getDesktop();
			desk.browse(new URI("https://docs.google.com/spreadsheets/d/" + spreadsheet.getSpreadsheetId()));
		} catch (Exception e) {
			System.out.println(e.getMessage());
		}
	}

	private static Spreadsheet createSpreadsheet(Sheets _service, String spreadsheetName, String _defaultSheetName)
			throws IOException {
		// Criar uma nova planilha
		Spreadsheet spreadsheet = new Spreadsheet()
				.setProperties(new SpreadsheetProperties().setTitle(spreadsheetName));
	
		// Criar uma nova planilha
		Sheet sheet = new Sheet();
		sheet.setProperties(new SheetProperties());
		sheet.getProperties().setTitle(_defaultSheetName);
	
		// Adicionar folha à lista
		List<Sheet> sheetList = new ArrayList<Sheet>();
		sheetList.add(sheet);
		spreadsheet.setSheets(sheetList);
	
		// Executar solicitação
		spreadsheet = _service.spreadsheets().create(spreadsheet).setFields("spreadsheetId").execute();
		System.out.println("Spreadsheet ID: " + spreadsheet.getSpreadsheetId());
	
		return spreadsheet;
	}

	private static void addSheet(Sheets _service, String _spreadSheetID, String _sheetName) {
		try {
			// Adicionar nova planilha
			AddSheetRequest addSheetRequest = new AddSheetRequest();
			addSheetRequest.setProperties(new SheetProperties());
			addSheetRequest.getProperties().setTitle(_sheetName);
	
			// Criar solicitação de atualização
			BatchUpdateSpreadsheetRequest batchUpdateSpreadsheetRequest = new BatchUpdateSpreadsheetRequest();
			Request req = new Request();
			req.setAddSheet(addSheetRequest);
			batchUpdateSpreadsheetRequest.setRequests(new ArrayList<Request>());
			batchUpdateSpreadsheetRequest.getRequests().add(req);
	
			// Executar solicitação
			_service.spreadsheets().batchUpdate(_spreadSheetID, batchUpdateSpreadsheetRequest).execute();
		} catch (Exception e) {
			System.out.println("Error in creating sheet: " + e.getMessage());
		}
	}

	private static Credential getCredentials(final NetHttpTransport HTTP_TRANSPORT) throws IOException {
		// Carregar segredos do cliente
		InputStream in = new FileInputStream(new File("credentials.json"));
		GoogleClientSecrets clientSecrets = GoogleClientSecrets.load(JSON_FACTORY, new InputStreamReader(in));
	
		// Crie fluxo e acione a solicitação de autorização do usuário
		GoogleAuthorizationCodeFlow flow = new GoogleAuthorizationCodeFlow.Builder(HTTP_TRANSPORT, JSON_FACTORY,
				clientSecrets, SCOPES)
						.setDataStoreFactory(new FileDataStoreFactory(new java.io.File(TOKENS_DIRECTORY_PATH)))
						.setAccessType("offline").build();
		LocalServerReceiver receiver = new LocalServerReceiver.Builder().setPort(8888).build();
		return new AuthorizationCodeInstalledApp(flow, receiver).authorize("user");
	}
}

Demo - Converta arquivos do Excel para o Google Sheets em Java

Obtenha uma licença gratuita do Aspose.Cells

Você pode obter uma licença temporária gratuita e usar o Aspose.Cells para Java sem limitações de avaliação.

Conclusão

Neste artigo, você aprendeu como converter arquivos Excel XLS ou XLSX em Planilhas Google programaticamente em Java. Fornecemos as diretrizes completas sobre como criar um projeto do Google Cloud, ativar a API do Planilhas Google, ler arquivos do Excel e exportar dados de arquivos do Excel para o Planilhas Google. Você também pode visitar a documentação para ler mais sobre Aspose.Cells for Java. Caso você tenha alguma dúvida ou pergunta, informe-nos através do nosso fórum.

Veja também

Crie arquivos do Excel usando Java sem o MS Office

Pré-requisitos - Converter arquivo do Excel para planilhas do Google em Java#

Projeto Google Cloud#

Conversão de APIs Java para Excel em Planilhas Google#

Exportar dados do Excel para o Planilhas Google em Java#

Código fonte completo#

Demo - Converta arquivos do Excel para o Google Sheets em Java#

Obtenha uma licença gratuita do Aspose.Cells#

Conclusão#

Veja também#