Integrar JUnit con Spring

Integrar JUnit con Spring es bastante simple. Solo debes crear tu test y anotarlo con @RunWith(SpringJUnit4ClassRunner.class).

JUnit invocará la clase de referencia, en este caso ‘SpringJUnit4ClassRunner’.
SpringJUnit4ClassRunner se encargará de levantar el contexto de Spring, en este ejemplo tengo dos contextos, donde el segundo ’sobreescribe’ al primero.

La configuración del contexto puedes pasarla con otra anotación de Spring @ContextConfiguration

Para inyectar un bean de Spring en el test deben marcarlo con @Autowired.

Spring buscará un bean definido con el mismo nombre del atributo y lo inyectará en tu test. Si queres forzar a Spring para que utilice un bean puedes utilizar @Qualifier

import java.util.ArrayList;
 
import org.apache.log4j.BasicConfigurator;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.junit.AfterClass;
import org.junit.Assert;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
 
/**
 * @author gustavo
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { "/gp/applicationContext.xml", "/gp/applicationContextTesting.xml" })
public class TestWithSpring {
 
    @BeforeClass
    public static void setup() {
        BasicConfigurator.configure();
        Logger.getRootLogger().setLevel(Level.INFO);
        //... configuracion de inicio
    }
 
    @Autowired
    @Qualifier("_testSpringList")
    private ArrayList _testSpringList; // spring inyectara este atributo
 
    @Test
    public void simpleTest() {
        Assert.assertFalse(this._testSpringList.isEmpty());
        for (Object s : this._testSpringList) {
            System.out.println(s.toString());
        }
    }    
 
    @AfterClass
    public static void endClazz() {
        //... 
    }
 
}

En Spring tengo definido _testSpringList de esta manera:

	<bean id="_testSpringList" class="java.util.ArrayList">
		<constructor-arg>
			<list>
				<value>hi!</value>
				<value>bye!</value>
			</list>
		</constructor-arg>
	</bean>

Java: Invocar un metodo y obtener SIEMPRE un Object como retorno

Necesitaba llamar a un método pero obteniendo como retorno siempre un Object. Esto para poder evaluar getMetodo() == null, sin importar si en realidad el método devolvía un primitivo.
Si el método devuelve un primitivo (ej. un int, un boolean, etc), la sentencia getMetodo() == null no compila.
El problema surgía porque las clases eran generadas dinámicamente desde una plantilla xml, y no podía conocer si el valor devuelto sería un Object o un primitivo hasta después de recibir el xml y generar las clases dinámicamente.
Al final la solución era bastante sencilla…
—-

import java.beans.Expression;

public class TestReturnToObject {

    /* Invocar un metodo y obtener SIEMPRE un Objeto como resultado. */

    public static void main(String[] args) throws Exception {
        TestReturnToObject t = new TestReturnToObject();
        t.test();
    }

    public void test() throws Exception {

        BeanTest bean = new BeanTest();
        // Ejecuto el metodo "getValue"
        Expression expr = new Expression(bean, "getValue", new Object[0]);
        expr.execute();

        Object o = expr.getValue(); // Siempre obtengo un Object
        if (o == null) {
            System.out.println("valor nulo");
        } else {
            System.out.println(o.getClass().getName() + " : " + o.toString());
            // java.lang.Integer : 1
        }
    }

    public class BeanTest {

        // Esta es la clase que en realidad se genera dinamicamente
        // El metodo, en esta oportunidad devuelve un primitivo.
        public int getValue() {
            return 1;
        }

        // El mismo metodo puede generarse tambien como un Object
        // segun como venga la plantilla. Algo que no puedo saber de antemano
        //
        // public String getValue() {
        // return new String("hola");
        // }
    }

}

–
¿Te fue útil?

Java Códigos de Barra

¿Cómo usar códigos de barra con Java?
Puedes utilizar esta librería que implementa varios tipos de códigos de barra muy utilizados. Te dejo un ejemplo de uso:

—

import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

import javax.imageio.ImageIO;

import net.sourceforge.jbarcodebean.BarcodeException;
import net.sourceforge.jbarcodebean.JBarcodeBean;
import net.sourceforge.jbarcodebean.model.Interleaved25;

public class TestBarCode {

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

        JBarcodeBean barcode = new JBarcodeBean();

        // nuestro tipo de codigo de barra
        barcode.setCodeType(new Interleaved25());
        //barcode.setCodeType(new Code39());

        // nuestro valor a codificar y algunas configuraciones mas
        barcode.setCode("1234554321987654321123456789");
        barcode.setCheckDigit(true);

        BufferedImage bufferedImage = barcode.draw(new BufferedImage(400, 400, BufferedImage.TYPE_INT_RGB));

        // guardar en disco como png
        File file = new File("codebar.png");
        ImageIO.write(bufferedImage, "png", file);

    }

}

—
Si te sirvió deja algún comentario y sino, también…

Enlace: JBarcodeBean

Mejora la calidad de tu software con testing

Mejorar la calidad de tu software depende también de que hagas buenos test durante su desarrollo.

Es importante tener presente en el ciclo de desarrollo las pruebas y orientarse hacia el testing para evitarse futuros e innecesarios problemas. Los test te ayudarán a encontrar errores, pero ten presente que aunque el test no falle, esto no significa que el software no contenga errores.
Como dijo ‘Dijkstra’ “…El testing prueba la presencia de errores pero no la ausencia de ellos…”

Hay que distinguir dos tipos de errores: los llamados errores de software o bugs y los errores de forma.
Los errores de forma son aquellos en los cuales el software no falla en su código pero si en su funcionalidad, es decir no cumple con lo que se espera de ellos como resultado.

Los frameworks de testing como JUnit, TestNG te ayudarán principalmente con los bugs y otro poco con los errores de funcionalidad, pero estos últimos deben ser subsanados con un buen ciclo de entregas y retroalimentación continuo del software.
Además, estos frameworks te serán de gran utilidad en entornos de aplicación ‘pesados’ donde probar el software significa, por ejemplo, levantar un servidor web.

Otro punto positivo, es que si diseñas buenas suites de pruebas, podrás luego,  ante un cambio por mantenimiento en tu software,  realizar una prueba integral de todos los módulos del mismo verificando que no hayas ‘roto’ alguna otra cosa.
Testear el software es poco divertido (al menos para mí) y apoyarse en un buen framework de testing ayuda a aliviar en parte esa tediosa (pero necesaria) tarea de probar el software. Una vez que tienes hecho el test, lo ejecutas las veces que quieras.

JUnit es un clásico de los test, muy conocido y muy integrado a los principales entornos de desarrollo.
TestNG es otra buena opción para realizar tus pruebas.

Veamos un poco de JUnit con un simple ejemplo:

JUnit

Esta es la consola de JUnit

Anotaciones mas usadas:

@BeforeClass:  se ejecuta una sola vez para todos los test. Util para inicializar variables u otros datos que serán compartidos.
@AfterClass: se ejecuta una sola vez al finalizar los test.
@Before: se ejecuta previo al iniciar cada @Test.
@After: se ejecuta luego de cada @Test
@Test: metodo que será ejecutado como test.

Nuestra clase de test JUnit…
——-

import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;

public class SimpleTestJUnit {

    Calculator calc;

    @Before
    public void setUp() {
        // Before indica que debe ejecutrarse antes de iniciar el test...
        System.out.println("Ejecutando SimpleTest.setUp ...");
        calc = new Calculator();
    }

    @After
    public void after() {
        // After indica que debe ejecutrarse despues del test...
        System.out.println("Ejecutando SimpleTest.after...");
    }

    @Test
    public void testDivision() {
        System.out.println("Ejecutando SimpleTest.testDivision...");
        System.out.println(calc.getDivision(10, 3));
    }

    @Test
    public void testDivisionByZero() {
        // este test se ejecutara con error
        System.out.println("Ejecutando SimpleTest.testDivisionByZero...");
        System.out.println(calc.getDivision(10, 0));
    }

    @Test(expected = ArithmeticException.class)
    public void testDivisionByZeroWithExpectedException() {
        // Este test no dara error. Esperamos la exception ArithmeticException
        System.out.println("Ejecutando SimpleTest.testDivisionByZeroWithExpectedException...");
        System.out.println(calc.getDivision(10, 0));
    }

    @Test
    public void testPrimeNumber() {
        System.out.println("Ejecutando SimpleTest.testPrimeNumber...");
        int i = 10;
        int j = 5;
        System.out.println("Es numero primo: " + calc.isPrimeNumber(i, j));
        Assert.assertTrue(calc.getRest(i, j) == 0);
    }

    @Ignore
    @Test
    public void testIgnore() {
        // NO se ejecutara debido a que tiene la anotacion @Ignore...
        System.out.println("SimpleTest.testIgnore...");
    }

}

———–
Nuestra clase Calculator que usamos para este ejemplo es…
–

public class Calculator {

    public double getDivision(int v1, int v2){
        int i = v1 / v2 ;
        return i;
    }

    public double getRest(int v1, int v2){
        double i = v1 % v2;
        return i;
    }

    public boolean isPrimeNumber(int v1, int v2){
        return getRest(v1, v2) == 0;
    }

}

–
Ahora armaremos un suite para ejecutar varios test’s juntos…
Defines una clase con las dos anotaciones que se muestran, en una de ellas ‘SuiteClasses’ indicarás los test a ejecutar.

import org.junit.runner.RunWith;
import org.junit.runners.Suite;
import org.junit.runners.Suite.SuiteClasses;

@RunWith(Suite.class)
@SuiteClasses( { SimpleTestJUnit.class, SimpleTestJUnit2.class})
public class AllTests {

    public static void main(String[] args) {
        // esta clase ejecutara los test's definidos en @SuiteClasses
    }

}

——

TestNG

Si conoces JUnit te resultará mas que fácil usarlo y si no, verás que es muy parecido a JUnit
Este framework se integra a Eclipse con su plug-in

Esta es la consola de TestNG (muy similar a la de JUnit)

Haz click aqui para ver un test simple con TestNG …

import org.testng.annotations.AfterTest;
import org.testng.annotations.BeforeTest;
import org.testng.annotations.Test;

public class SimpleTestNG {

    @BeforeTest(dependsOnMethods = "setup")
    public void before() {
        // BeforeTest indica que debe ejecutarrse antes de iniciar los test. 
        // Antes se ejecutara 'setup' debido a que esta indicado con 'dependsOnMethods'
        System.out.println("Ejecutando SimpleTest.before (antes debio ejecutarse setup)...");
    }

    @BeforeTest
    public void setup(){
        System.out.println("Ejecutando SimpleTest.setup...");
    }

    @AfterTest
    public void after() {
        // AfterTest indica que debe ejecutrarse despues. 
        System.out.println("Ejecutando SimpleTest.after...");
    }    

    @Test
    public void test() {
        // este es el test a ejecutarse...
        //... tu logica y llamadas a las clases que hace a la logica de negocio...
        System.out.println("Ejecutando SimpleTest.test...");
    }

    @Test(expectedExceptions={RuntimeException.class})
    public void test2() {
        System.out.println("Ejecutando SimpleTest.test2...");
        //Se espera que este test tire una expcetion 'RuntimeException'
        //Si no ocurre la exception el test sera fallido
        //throw new RuntimeException("Error esperado"); // si se comenta fallara el test 
    }

    @Test(enabled = false)
    public void test3() {
        // NO se ejecutara debido a que 'enabled = false'
        System.out.println("Ejecutando SimpleTest.test3...");
    }

}

En TestNG podemos crear también una suite de test’s.
Este xml ejecutará dos test SimpleTestNG, y SimpleTestNG2.
Solo debes ejecutarlo con el menú de TestNG

<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >

<suite name="SuiteSimpleTests"    verbose="1" >
  <test name="GroupTest1"   >
    <classes>
      <class name="test.SimpleTestNG"/>
      <class name="test.SimpleTestNG2"/>
    </classes>
  </test>
</suite>

Como vez, los frameworks son bastante simples de utilizar, es solo cuestión de que te hagas el hábito de trabajar pensando y orientandote al testing. Pronto verás los beneficios que te trae para la calidad de tu software.
Espero te haya servido.

Enlaces: JUnit TestNG

Encontrar librerias Java (jar)

Si tienes dificultades para encontrar alguna librería java, o tal vez necesitas alguna versión en particular de alguna librería que no logras hallar;  date una vuelta por esta página.

Enlace: findJAR

10 buenas razones para buscar algo mejor que Java

He visto este artículo en TheServerSide donde se comentan 10 razones negativas para Java… que supuestamente serían buenos motivos para buscar algo mejor.

En mi modesto criterio, se podrían encontrar muchas mas razones, como en todo aquello que es gran uso. Por ejemplo la gran fragmentación que tiene Java con su inmensa cantidad de frameworks, que muchas veces solo confunden; y tantos otros “aditivos” (léase librerías) para hacer algo que el lenguaje ya debiera traer incorporado.
Aunque, quien piense que es bueno tener muchas opciones para elegir, podría refutar todo esto.

Es cierto que Java trae consigo una carga pesada, que le juega en contra. Esto es, la inmensa cantidad de empresas e instituciones (de todos los tamaños) y desarrolladores que lo usan, que obliga a Java a moverse con cautela. Pienso que hay muchos intereses corporativos y esa es su mayor contra.

No es lo mismo hacer un cambio para uno que para diez, ni que para cientos de miles; el impacto es mayor cuanto mayor es su uso.
Creo que lo importante es el balance entre lo bueno y lo malo. No veo correcto evaluar solo lo negativo para buscar algo mejor. Si buscas algo mejor es porque has sabido hacer un balance entre lo positivo y negativo y encuentras una solución mas favorable al problema que intentas resolver.

Decía Bjarne Stroustrup (creador de C++) “…Sólo hay dos tipos de lenguajes de programación: los lenguajes de los que la gente siempre se queja, y los lenguajes que nadie usa….”

Cliente CVS desde tu código Java

Te explico como crear un cliente CVS desde tu código Java:
Si necesitas conectarte a un CVS directamente desde tu código Java, puedes utilizar la librería Java CVS Client

Te lo dejo este ejemplo para que observes cómo utilizar la librería.

 
import java.io.PrintStream;
 
import org.netbeans.lib.cvsclient.CVSRoot;
import org.netbeans.lib.cvsclient.Client;
import org.netbeans.lib.cvsclient.admin.StandardAdminHandler;
import org.netbeans.lib.cvsclient.command.CommandAbortedException;
import org.netbeans.lib.cvsclient.command.CommandException;
import org.netbeans.lib.cvsclient.command.GlobalOptions;
import org.netbeans.lib.cvsclient.command.checkout.CheckoutCommand;
import org.netbeans.lib.cvsclient.connection.AuthenticationException;
import org.netbeans.lib.cvsclient.connection.PServerConnection;
import org.netbeans.lib.cvsclient.event.CVSAdapter;
import org.netbeans.lib.cvsclient.event.MessageEvent;
 
/**
  * @author peiretti
 */
public class CVSCheckOut {
 
 
	//http://javacvs.netbeans.org/library/
	//http://javacvs.netbeans.org/library/GettingStarted.html
       //http://javacvs.netbeans.org/servlets/ProjectDocumentList
 
	public static void main(String[] args) {
 
		String user = "tuUserName";
		String password = "tuPassword";
		String host = "199.99.99.99";
		String repository = "/var/cvs";
 
		String module = "NombreDelModuloCvs";
		String destinoPath = "c:/destinoCVS";
 
		// comando cvs 
		StringBuffer root = new StringBuffer();
		root.append(":pserver");
		root.append(":" + user);
		if (password != null)
			root.append(":" + password);
		root.append("@" + host);
		root.append(":" + repository);
 
		//:pserver:gustavo:gustavo@199.99.99.99:/var/cvs
		System.out.println(root.toString()); 
 
		// comando checkout
		CheckoutCommand command = new CheckoutCommand();
		command.setModule(module);
 
		// comando para update 
		//UpdateCommand update = new UpdateCommand();
		//
 
		// conexion al server
		PServerConnection conTest = new PServerConnection(CVSRoot.parse(root
				.toString()));
 
		// cvs client
		Client client = new Client(conTest, new StandardAdminHandler());
		client.setLocalPath(destinoPath);
		client.getEventManager().addCVSListener(new CVSAdapter(){
			public void messageSent(MessageEvent e) {
				PrintStream stream = e.isError() ? System.err : System.out;
				stream.println(e.getMessage()); // muestra los mensajes de ejecucion
			}
		});
 
		// opciones globales (usuario, password, host, etc) 
		GlobalOptions globalOptions = new GlobalOptions();
		globalOptions.setCVSRoot(root.toString());
 
		try {
			client.executeCommand(command, globalOptions);
		} catch (CommandAbortedException e) {
			e.printStackTrace();
		} catch (CommandException e) {
			e.printStackTrace();
		} catch (AuthenticationException e) {
			e.printStackTrace();
		}
 
	}
 
}

Html to PDF con Java

¿Cómo convertir html a pdf con Java? Para convertir html a pdf con Java necesitas primero que el html sea un html válido del tipo XHTML
Si tienes tu xhtml listo, entonces podrás usar esta librería Flying Saucer que proporciona una manera simple para la transformación.
Si no tienes un html que sea válido, tendrás que usar alguna herramienta como Tidy para convertir tu html en un xhtml (al final te dejo un ejemplo).

Necesitas en tu proyecto estas librerías:

• core-renderer.jar (Flying Saucer)
• iText (Dependencia necesaria)

Este es un ejemplo sencillo que transforma código html en pdf.
—

//--
 
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
 
import org.xhtmlrenderer.pdf.ITextRenderer;
 
public class HtmlToPdf {
 
	public static void main(String[] args) throws Exception {
 
		File inputFile = new File("holaMundo.xhtml");
		OutputStream os = new FileOutputStream(new File(
				"xhtmlToPdf_holaMundo.pdf"));
 
		ITextRenderer renderer = new ITextRenderer();
		renderer.setDocument(inputFile);
		renderer.layout();
		renderer.createPDF(os);
 
		os.close();
	}
 
}
 
//--

—
Este es nuestro xhtml de entrada “holaMundo.xhtml”

 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
    <head>
        <title>HOLA MUNDO</title>
        <style type="text/css"> b { color: blue;} p { font-size: 18px; } </style>
    </head>
    <body>
        <p>
            <b>HOLA MUNDO... !</b>
        </p>
        <p>
            ...Un sutil pensamiento erroneo puede dar lugar a una indagacion fructifera que revela
            verdades de gran valor......
        </p>
    </body>
</html>

—
Este será nuestro resultado:

Si bajas el source encontraras buena documentación y ejemplos.

Una observación:
Si tu xhtml tiene hojas de estilo (CSS), deberás indicarlas con su URL absoluto para que puedan ser procesadas por la librería.

<link rel="stylesheet" type="text/css" href="http://tusitio.com/css/style.css" />

Te dejo este ejemplo sobre cómo pasar tu html a un xhtml utilizando la libreria Tidy:

//--
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
 
import org.w3c.tidy.Tidy;
 
public class HtmlToXhtml {
 
    public static void main(String[] args) {
 
        // codigo valido para html pero invalido para XHTML
    	// no esta cerrando el tag img
        String html = new String("<img scr='img.gif'>");
        //--
        ByteArrayInputStream b = new ByteArrayInputStream(html.getBytes());
        ByteArrayOutputStream out = new ByteArrayOutputStream();
 
        Tidy tidy = new Tidy();
        tidy.setXHTML(true); // queremos que la salida sea xhtml
        tidy.parse(b, out);
        System.out.println(out.toString());
 
}
}
//--

La salida de Tidy para este ejemplo es la siguiente.
Vemos que Tidy le ha agregado cabeceras, y otros tag; además de cerrar correctamente el tag ‘img’.

 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta name="generator" content="HTML Tidy, see www.w3.org" />
<title></title>
</head>
<body>
<img scr='img.gif' />
</body>
</html>

Espero te sea de utilidad.

Imprimiendo con Java

Este es un ejemplo simple sobre cómo puedes imprimir un archivo desde Java…

import java.io.FileInputStream;
import java.io.FileNotFoundException;
 
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.attribute.standard.Copies;
import javax.print.attribute.standard.MediaSizeName;
 
public class PrintGIF {
 
	public static void main(String args[]) {
 
		// tu archivo a imprimir
		String file = "c:\\image.gif";
 
		// definimos el tipo a imprimir
		DocFlavor docFlavor = DocFlavor.INPUT_STREAM.GIF;
 
		// establecemos algunos atributos de la impresora
		PrintRequestAttributeSet aset = new HashPrintRequestAttributeSet();
		aset.add(MediaSizeName.ISO_A4);
		aset.add(new Copies(1));
 
		// mi impresora por default
		PrintService service = PrintServiceLookup.lookupDefaultPrintService();
 
		Doc docPrint;
		try {
			docPrint = new SimpleDoc(new FileInputStream(file), docFlavor, null);
		} catch (FileNotFoundException e1) {
			e1.printStackTrace();
			return;
		}
 
		// inicio el proceso de impresion...
		DocPrintJob printJob = service.createPrintJob();
		try {
			printJob.print(docPrint, aset);
		} catch (PrintException e) {
			e.printStackTrace();
			return;
		}
	}
}

Quizás te interese también este artículo
Manejando tus impresoras con Java

Manejando tus impresoras con Java

¿Cómo ver todas las impresoras disponibles con java, la impresora que tienes por default y otros atributos de tus impresoras?
Aquí van algunos ejemplos simples…

—

import javax.print.PrintService;
import javax.print.PrintServiceLookup;
import javax.print.attribute.Attribute;
import javax.print.attribute.AttributeSet;
import javax.print.attribute.HashAttributeSet;
import javax.print.attribute.PrintServiceAttributeSet;
import javax.print.attribute.standard.Destination;
import javax.print.attribute.standard.PrinterInfo;
import javax.print.attribute.standard.PrinterIsAcceptingJobs;
import javax.print.attribute.standard.PrinterLocation;
import javax.print.attribute.standard.PrinterMakeAndModel;
import javax.print.attribute.standard.PrinterName;
import javax.print.attribute.standard.PrinterState;
 
/**
 * Ejemplos para ver tus impresoras
 * @author Peiretti
 */
public class PrintExamples {
 
    /**
     * @param args
     */
    public static void main(String[] args) {
 
        printAvailable();
        printDefault();
        printByName("MiImpresora");
    }
 
    public static void printAvailable() {
 
        // busca los servicios de impresion...
        PrintService[] services = PrintServiceLookup.lookupPrintServices(null, null);
 
        // -- ver los atributos de las impresoras...
        for (PrintService printService : services) {
 
            System.out.println(" ---- IMPRESORA: " + printService.getName());
 
            PrintServiceAttributeSet printServiceAttributeSet = printService.getAttributes();
 
            System.out.println("--- atributos");
 
            // todos los atributos de la impresora
            Attribute[] a = printServiceAttributeSet.toArray();
            for (Attribute unAtribute : a) {
                System.out.println("atributo: " + unAtribute.getName());
            }
 
            System.out.println("--- viendo valores especificos de los atributos ");
 
            // valor especifico de un determinado atributo de la impresora
            System.out.println("PrinterLocation: " + printServiceAttributeSet.get(PrinterLocation.class));
            System.out.println("PrinterInfo: " + printServiceAttributeSet.get(PrinterInfo.class));
            System.out.println("PrinterState: " + printServiceAttributeSet.get(PrinterState.class));
            System.out.println("Destination: " + printServiceAttributeSet.get(Destination.class));
            System.out.println("PrinterMakeAndModel: " + printServiceAttributeSet.get(PrinterMakeAndModel.class));
            System.out.println("PrinterIsAcceptingJobs: " + printServiceAttributeSet.get(PrinterIsAcceptingJobs.class));
 
        }
 
    }
 
    public static void printDefault() {
 
        // tu impresora por default
        PrintService service = PrintServiceLookup.lookupDefaultPrintService();
        System.out.println("Tu impresora por default es: " + service.getName());
 
    }
 
    public static void printByName(String printName) {
 
    	PrintService[] services = PrintServiceLookup.lookupPrintServices(null, null);
 
        // buscar por el nombre de la impresora (nombre que le diste en tu S.O.)
        // en "aset" puedes agregar mas atributos de busqueda
        AttributeSet aset = new HashAttributeSet();
        aset.add(new PrinterName(printName, null));
        //aset.add(ColorSupported.SUPPORTED); // si quisieras buscar ademas las que soporten color
 
        services = PrintServiceLookup.lookupPrintServices(null, aset);
        if(services.length == 0){
        	System.out.println("No se encontro impresora con nombre " + printName);
        }
        for (PrintService printService : services) {
        	System.out.println(printService.getName());
		}
    }
}

—