Imprimer avec Java

Imprimer avec JavaFX

Cette solution est conseillée pour une application avec une interface graphique JavaFX.

import javafx.application.Application;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.print.PrinterJob;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.control.Label;
import javafx.scene.control.TextArea;
import javafx.scene.layout.VBox;
import javafx.stage.Stage;

public class JavaFXPrint extends Application {

 public static void main(String[] args) {
  launch(args);
 }

 @Override
 public void start(Stage stage) {

  Label jobStatus = new Label("Status de l'impression : ");

  TextArea textArea = new TextArea();

  Button printButton = new Button("Imprimer");

  // Creation d'un handler pour le bouton
  printButton.setOnAction(new EventHandler < ActionEvent > () {
   public void handle(ActionEvent event) {

    // Creation du printer job
    PrinterJob job = PrinterJob.createPrinterJob();

    // Montre la boite de dialogue
    boolean proceed = job.showPrintDialog(stage);

    // Si l'utilisateur clique sur imprimer dans la boite de dialogue
    if (proceed) {

     job.jobStatusProperty().addListener((observable, oldValue, newValue) -> {

      if (newValue == PrinterJob.JobStatus.PRINTING)
       jobStatus.setText("Status de l'impression : Impression en cours...");

      if (newValue == PrinterJob.JobStatus.DONE)
       jobStatus.setText("Status de l'impression : Texte imprimé avec succès !");

      if (newValue == PrinterJob.JobStatus.ERROR)
       jobStatus.setText("Status de l'impression : Erreur lors de l'impression");

     });

     // Imprime la zone texte
     boolean printed = job.printPage(textArea);

     if (printed) {
      job.endJob();
     }
    }

   }
  });

  /* Mise en page */
  VBox root = new VBox();

  root.getChildren().addAll(textArea, printButton, jobStatus);

  Scene scene = new Scene(root);
  stage.setScene(scene);
  /* Fin mise en page */

  stage.show();
 }

}

Impression basique

Cette solution est recommandée pour une application en ligne de commande.

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;

import javax.print.Doc;
import javax.print.DocFlavor;
import javax.print.DocPrintJob;
import javax.print.PrintException;
import javax.print.PrintService;
import javax.print.PrintServiceLookup;
import javax.print.SimpleDoc;
import javax.print.attribute.HashPrintRequestAttributeSet;
import javax.print.attribute.PrintRequestAttributeSet;
import javax.print.event.PrintJobEvent;
import javax.print.event.PrintJobListener;

public class BasicPrint {

 public static void main(String[] args) throws PrintException, IOException {

  // On donne la type MIME d'impression
  DocFlavor flavor = DocFlavor.INPUT_STREAM.AUTOSENSE;

  // On peut prendre tous les services disponibles
  //PrintService[] services = PrintServiceLookup.lookupPrintServices(flavor, null);

  PrintService service = PrintServiceLookup.lookupDefaultPrintService();

  PrintRequestAttributeSet pref = new HashPrintRequestAttributeSet();
  // On peut ouvrir la boite de dialogue avec aucune préférences
  //PrintService service = ServiceUI.printDialog(null, 200, 200, services, null, flavor, pref);

  if (service == null) {
   System.out.println("Impression annulée");
   System.exit(0);
  }

  // La chaine à imprimer
  InputStream is = new ByteArrayInputStream("Super texte".getBytes());

  /* On crée un document et l'impression */
  Doc doc = new SimpleDoc(is, flavor, null);
  DocPrintJob job = service.createPrintJob();

  // On ajoute un Job Listener pour savoir si le texte à été imprimé
  PrintJobWatcher printJobWatcher = new PrintJobWatcher();
  job.addPrintJobListener(printJobWatcher);

  // impression
  job.print(doc, pref);

  /*
   * processus bloquant... on attend que l'impression se termine
   */
  printJobWatcher.waitForDone();

  is.close();

 }
}

class PrintJobWatcher implements PrintJobListener {

 boolean done = false;

 // processus bloquant
 public synchronized void waitForDone() {
  try {
   // on attend tant que l'impression n'est pas terminée
   while (!done)
    wait();
  } catch (InterruptedException e) {}
 }

 @Override
 public void printDataTransferCompleted(PrintJobEvent arg0) {
  System.out.println("Donnée transférée");
 }

 @Override
 public void printJobCanceled(PrintJobEvent arg0) {
  System.out.println("Impression annulée");
  notifyDone();
 }

 @Override
 public void printJobRequiresAttention(PrintJobEvent arg0) {
  System.out.println("Erreur... (Pas de papier)");
 }

 @Override
 public void printJobCompleted(PrintJobEvent evt) {
  System.out.println("Texte imprimé avec succès");
  notifyDone();
 }

 @Override
 public void printJobNoMoreEvents(PrintJobEvent arg0) {
  System.out.println("Texte imprimé avec succès (sans vérification)");
  notifyDone();

 }

 @Override
 public void printJobFailed(PrintJobEvent evt) {
  System.out.println("Erreur lors de l'impression");
  notifyDone();
 }

 void notifyDone() {
  synchronized(this) {
   done = true;
   System.out.println("Impression terminée !");
   this.notify();
  }
 }


}

Imprimer avec Java Swing

Cette méthode est recommandée pour une application avec une interface graphique Swing.

import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.print.PrinterException;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JTextArea;

public class SwingPrint {

 public static void main(String[] args) {

  JFrame mainFrame = new JFrame();

  mainFrame.setLayout(new GridBagLayout());

  /* Mise en page */
  GridBagConstraints gbc = new GridBagConstraints();

  // un seul élément par ligne
  gbc.gridx = 0;

  // aligne les éléments à gauche
  gbc.anchor = GridBagConstraints.WEST;
  /* Fin Mise en page */

  JTextArea textArea = new JTextArea(10, 50);

  JButton printButton = new JButton("Imprimer");

  printButton.addActionListener(new ActionListener() {

   @Override
   public void actionPerformed(ActionEvent arg0) {
    try {
     // impression
     textArea.print();
    } catch (PrinterException e) {
     System.out.println("Erreur lors de l'impression");
    }
   }

  });
  mainFrame.add(textArea, gbc);
  mainFrame.add(printButton, gbc);
  mainFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  mainFrame.pack();
  mainFrame.setVisible(true);

 }

}

Imprimer en ligne de commande (méthode non conseillée)

Cette solution n'est pas recommandée puisqu'elle dépend du système d'exploitation. Il vaut mieux utiliser la méthode basique.

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

public class RuntimePrint {

 public static void main(String[] args) throws IOException {

  // enregistrement fichier à imprimer
  File file = new File("fichier.txt");
  if (file.createNewFile()) {

   BufferedWriter writer = new BufferedWriter(new FileWriter(file));
   writer.write("Texte à imprimer");
   writer.close();

   String os = System.getProperty("os.name").toLowerCase();

   if (os.contains("windows")) {
    // exécute une commande avec ProcessBuilder pour imprimer sous windows : commande print ou notepad /p
   } else if (os.contains("linux") || os.contains("mac")) {
    // exécute une commande avec ProcessBuilder pour imprimer sous linux et mac : commande lpr
   }

  } else {
   System.out.println("fichier.txt existe déjà !");
  }

 }

}