Imprimir desde código Java

Impresión desde Java mediante ejemplos

Más información en:


PrinterJob (http://www.javacommerce.com/articles/printing.html)

Printing in JDK 1.4 Part 1 (http://www-106.ibm.com/developerworks/library/j-mer0322/)

Printing in JDK 1.4 Part 2 (http://www-106.ibm.com/developerworks/library/j-mer0424.html)

PrintService (http://java.sun.com/j2se/1.4/docs/api/javax/print/PrintService.html)

Objeto PrinterJob

Para usar el objeto PrinterJob deberemos tener un objeto Printable que será el que contendrá lo que queremos imprimir.
Este objeto debe contener la función print donde indicaremos la información que nos interesa imprimir.
Esta información será dibujada sobre un objeto Graphics (que luego pasaremos a Graphics2D) o Graphics2D (la impresión en Java, al menos versones anteriores es un trabajo gráfico, de ahí su lentitud).
Después crearemos el objeto PrinterJob,
mediante setPrintable(objeto_a_imprimir) haremos que se dibuje la página a mandar a la impresora.
Llamaremos o no, a la ventana de configuración de impresión, y por último imprimiremos.

Impresión mediante un objeto PrinterJob(JDK1.2+) para imprimir gráficos.

//Impresión en Java2 mediante PrinterJob
import java.awt.*;
import java.awt.print.*;
import java.awt.geom.*;

//La clase debe de implementar la impresión implements Printable
class ObjetoAImprimir implements Printable
{
public int print (Graphics g, PageFormat f, int pageIndex)
{
//Creamos un objeto 2D para dibujar en el
Graphics2D g2 = (Graphics2D) g;
//Este código imprime 2 páginas una con un cuadrado o marco
//y una segunda con un circulo en la esquina superior izquierda

//Creamos el rectángulo
//getImagebleX() coge la parte de la hoja donde podemos
//imprimir quitando los bordes. Si no hiciesemos
//esto así y tuviesemos bordes definidos en la impresión
//lo que dibujasemos fuera de los bordes no lo
//imprimiría aunque cupiese en la hoja físicamente.
Rectangle2D rect = new Rectangle2D.Double(f.getImageableX(),
f.getImageableY(),
f.getImageableWidth(),
f.getImageableHeight());

//Creamos la circunferencia
Ellipse2D circle = new Ellipse2D.Double(100,100,100,100);

//pageIndex indica el número de la página que se imprime
//cuando es 0 primera página a imprimir, es un rectángulo
//cuando es 1 segunda página a imprimir, es una circunferencia
//En otro caso se devulve que no hay más páginas a imprimir
switch (pageIndex)
{
case 0 : //Página 1: Dibujamos sobre g y luego lo pasamos a g2
g.setColor(Color.black);
g.fillRect(110,120,30,5);
g.setColor(Color.pink);
g.drawLine(0,0,200,200);
g2 = (Graphics2D) g;
return PAGE_EXISTS; //La página 1 existe y se imprimirá
case 1 : //Página 2: Circunferencia y rectángulo
g2.setColor(Color.red);
g2.draw(circle);
g2.draw(rect);
return PAGE_EXISTS;  //La página 2 existe y se imprimirá
default: return NO_SUCH_PAGE;        //No se imprimirán más páginas
}
}
}

//clase pública que se ejecuta donde debe de estar el main que llama a la
//otra clase.
public class Imprime
{
public static void main (String[] args)
{
// Creamos un objeto de impresión.
PrinterJob job = PrinterJob.getPrinterJob();

// Hacemos imprimible el objeto ObjetoAImprimir
job.setPrintable(new ObjetoAImprimir());
//Pondrá algo tipo Información job: sun.awt.windows.WPrinterJob@4a5ab2
System.out.println("Información job: " + job.toString());

//Abre el cuadro de diálogo de la impresora, si queremos que imprima
//directamente sin cuadro de diálogo quitamos el if...
if (job.printDialog())
{
//Imprime, llama a la función print del objeto a imprimir
//en nuestro caso el Objeto ObjetoAImprimir
try { job.print(); }
catch (PrinterException e) { System.out.println("Error de impresión: " + e); }
}
}
}

Objeto FileOutputStream

Este objeto es usado habitualmente para crear ficheros.
Como el Stream lo podemos redireccionar, en este caso lo enviamos a la impresora, ya sea indicando la ubicación en red, como el puerto en el que está, y a partir de aquí sólo hay que mandar el fujo de datos para que lo reciba la impresora.
Se debe tener en cuenta que en este caso deberemos saber de antemano la ubicación de la impresora y que no será un código portable a otra estación de trabajo ya que puede no tener acceso a la impresora indicada.

Impresión mediante un objeto FileOutputStream para imprimir texto.

//Impresión en Java2 mediante FileOutputStream
import java.awt.print.*;
import java.util.*;
import java.io.*;

//La clase debe de implementar la impresión implements Printable

//clase pública que se ejecuta donde debe de estar el main que
// llama a laotra clase.
public class ImprimeTexto
{
public static void main (String[] args)
{

try {

//Esto saldría en la consola de java o en la consola de sistema operatico
System.out.println("Probando, probando la impresión.");

//enviar a imprimir en pantalla.
//FileDescriptor fd = FileDescriptor.out;
//FileOutputStream os = new FileOutputStream(fd);

//enviar a imprimir a la impresora en red, debemos conocer el nombre de la
//impresora.
//Desde windows se puede poner ...new FileOutputStream("//Au-4022/hp1100");

//Formato UNIX
//FileOutputStream os = new FileOutputStream("\\\\Au-4022\\hp1100");

//Si tuviesemos la impresora en el puerto paralelo
//FileOutputStream os = new FileOutputStream("LPT1:");
//Si tuviesemos la impresora en el puerto serie
//FileOutputStream os = new FileOutputStream("COM1:");

//Enviar a un archivo de texto.
FileOutputStream os = new FileOutputStream("nombre_archivo.txt");
PrintStream ps = new PrintStream(os);
ps.println("prueba de impresión realizada");
ps.close();

}
catch(Exception e){
System.out.println("Error: "+e.getMessage());
}
}
}

Objeto PrintService.

Es un objeto de la versión 1.4 del JDK.
Si se soporta este objeto, es la mejor opción ya que es la más depurada.

Un servicio de impresión puede ser cualquier impresora instalada en la máquina tanto local como en red.
Tras crear el objeto de servicio de impresión y asignar una en concreto, crearemos un objeto documento Doc.
que contendrá lo que vamos a imprimir.
Este documento puede contener texto, gráficos, etc... simplemente mediante el objeto DocFlavor indicaremos al objeto PrintService que tipo de datos contiene el documento.
aunque deberemos comprobar que el servicio de impresión accepte ese tipo de datos (el DocFlavor).
Una vez creado el documento, definido el tipo de datos y rellenados estos datos, se mandará a imprimir.

Impresión mediante un objeto PrintService(JDK1.4+) para imprimir texto.

//Cogemos el servicio de impresión por defecto (impresora por defecto)
PrintService service = PrintServiceLookup.lookupDefaultPrintService();
//Le decimos el tipo de datos que vamos a enviar a la impresora
//Tipo: bytes Subtipo: autodetectado
DocFlavor flavor = DocFlavor.BYTE_ARRAY.AUTOSENSE;
//Creamos un trabajo de impresión
DocPrintJob pj = service.createPrintJob();
//Nuestro trabajo de impresión envía una cadena de texto
String ss=new String("Aquí lo que vamos a imprimir.");
byte[] bytes;
//Transformamos el texto a bytes que es lo que soporta la impresora
bytes=ss.getBytes();
//Creamos un documento (Como si fuese una hoja de Word para imprimir)
Doc doc=new SimpleDoc(bytes,flavor,null);

//Obligado coger la excepción PrintException
try {
//Mandamos a impremir el documento
pj.print(doc, null);
}
catch (PrintException e) {
System.out.println("Error al imprimir: "+e.getMessage());
}

Impresión mediante un objeto PrintService(JDK1.4+) para imprimir un objeto printable como con PrinterJob.

Usaremos la clase ObjetoAImprimir como en el ejemplo con PrinterObject.


ObjetoAImprimir puede ser cualquier objeto que implemente Printable (Applets, Panels,Objetos propios,?)

PrintService service = PrintServiceLookup.lookupDefaultPrintService();
//Indicamos que lo que vamos a imprimir es un objeto imprimible
DocFlavor flavor = DocFlavor.SERVICE_FORMATTED.PRINTABLE;
DocPrintJob pj = service.createPrintJob();
//Creamos el documento a imprimir que contendrá el objeto
Doc doc=new SimpleDoc(new ObjetoAImprimir(),flavor,null);

try {
pj.print(doc, null);
}
catch (PrintException e) {
System.out.println("Error al imprimir: "+e.getMessage());
}

Información del objeto PrintService.

//Coger impresora por defecto
PrintService service = PrintServiceLookup.lookupDefaultPrintService();
System.out.println("Nombre impresora por defecto: "+service.getName());

//Coger todas las impresoras instaladas (tanto en local como en red)
PrintService[] services = PrintServiceLookup.lookupPrintServices(null, null);
//Tendremos un array con todas las impresoras instaladas
//con length podemos saber el nº de impresoras
System.out.println("Número de impresoras configuradas en el sistema: "
+ services.length);

if (services.length > 0) {
//Recorre el array de impresoras (o servicios de impresión)
for(int i=0;iSystem.out.println("Impresora "+(i+1)+":"+services[i].getName());
}
}

//BYTE_ARRAY indica el tipo y AUTOSENSE el subtipo
DocFlavor flavor = DocFlavor.BYTE_ARRAY.AUTOSENSE;
//Comprobar si el tipo está soportado por la impresión
System.out.println("Flavor soportado?:"
+ service.isDocFlavorSupported(flavor));  //true o false
System.out.println("Flavor mime type:"+flavor.getMimeType());
//Listar los tipos soportados
DocFlavor[] flavs=service.getSupportedDocFlavors();
for(int c=0;cSystem.out.println("Tipo soportado: " +
flavs[c].getMimeType() +"  " + flavs[c].toString());
}

//Listar todos los servicios que soportan un tipo de impresión,
//en este caso impresión en color
aset = new HashAttributeSet(); //Creamos grupo de atributos
aset.add(ColorSupported.SUPPORTED); //Añadimos atributo
PrintService[] services = PrintServiceLookup.lookupPrintServices(null, aset);
System.out.println("Número de impresoras en color: "+services.length);
//Si hay alguna impresora que cumple la condición
if (services.length > 0) {
for(int i=0;iSystem.out.println("Impresora en color " + (i+1) + ":"
+ services[i].getName()); //Muestra el nombre
}
}

FaNK. Para cualquier duda o tirón de orejas, e-mail a: barf_ak_ARROBA_yahoo.es