Erro na declaração dos "imports"

Bom dia a todos, sou novato em programação Java, porém, nas linguagens que utilizo tenho dificuldade para assinar um xml no padrão nfe, então, descobri um código Java que faz isso, só que a pessoa que deixou este código não colocou os imports necessários, utilizei a tecla control, shift e "o" do eclipse, mas não obtive sucesso segue abaixo o código.

import java.io.ByteArrayOutputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.security.KeyStore;

import java.security.PrivateKey;

import java.security.cert.X509Certificate;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Enumeration;

import java.util.List;

import javax.xml.crypto.dsig.CanonicalizationMethod;

import javax.xml.crypto.dsig.DigestMethod;

import javax.xml.crypto.dsig.Reference;

import javax.xml.crypto.dsig.SignatureMethod;

import javax.xml.crypto.dsig.SignedInfo;

import javax.xml.crypto.dsig.Transform;

import javax.xml.crypto.dsig.XMLSignature;

import javax.xml.crypto.dsig.XMLSignatureFactory;

import javax.xml.crypto.dsig.dom.DOMSignContext;

import javax.xml.crypto.dsig.keyinfo.KeyInfo;

import javax.xml.crypto.dsig.keyinfo.KeyInfoFactory;

import javax.xml.crypto.dsig.keyinfo.X509Data;

import javax.xml.crypto.dsig.spec.C14NMethodParameterSpec;

import javax.xml.crypto.dsig.spec.TransformParameterSpec;

import javax.xml.parsers.DocumentBuilder;

import javax.xml.parsers.DocumentBuilderFactory;

import javax.xml.transform.Transformer;

import javax.xml.transform.TransformerFactory;

import javax.xml.transform.dom.DOMSource;

import javax.xml.transform.stream.StreamResult;

import org.w3c.dom.Document;

import org.w3c.dom.Element;

import org.w3c.dom.NodeList;

import com.sun.xml.internal.bind.Util;

public class AssinaXML {

public static void main(String[] args) {

System.out.println(signature(“D:\temp\nfe.xml”, “d:\temp\xxx.xml”,“infNFe”));

}

public static String signature(String xmlFileName, String xmlResponseName, 
                               String idNode) {
    try {

        DocumentBuilderFactory factory = 
            DocumentBuilderFactory.newInstance();
        factory.setNamespaceAware(true);
        DocumentBuilder builder = factory.newDocumentBuilder();
        Document doc = builder.parse(new File(xmlFileName));

        // Create a DOM XMLSignatureFactory that will be used to   
        // generate the enveloped signature.   
        XMLSignatureFactory fac = 
            XMLSignatureFactory.getInstance("DOM", new org.jcp.xml.dsig.internal.dom.XMLDSigRI());

        // Create a Reference to the enveloped document (in this case,   
        // you are signing the whole document, so a URI of "" signifies   
        // that, and also specify the SHA1 digest algorithm and   
        // the ENVELOPED Transform.   
        ArrayList transformList = new ArrayList();
        TransformParameterSpec tps = null;
        Transform envelopedTransform = 
            fac.newTransform(Transform.ENVELOPED, tps);
        Transform c14NTransform = 
            fac.newTransform("http://www.w3.org/TR/2001/REC-xml-c14n-20010315", 
                             tps);

        transformList.add(envelopedTransform);
        transformList.add(c14NTransform);

        // Load the KeyStore and get the signing key and certificate.   
        char[] pin = 
            Util.undoHexCodified(APPSet.getProperty("pin")).toCharArray();

KeyStore ks = KeyStore.getInstance("PKCS12");
        FileInputStream fis = 
            new FileInputStream(new File(APPSet.getProperty("certificado")));

ks.load(fis, pin);
        KeyStore.PrivateKeyEntry pkEntry = null;
        Enumeration aliasesEnum = ks.aliases();
        PrivateKey privateKey = null;
        while (aliasesEnum.hasMoreElements()) {
            String alias = (String)aliasesEnum.nextElement();
            System.out.println(alias);
            if (ks.isKeyEntry(alias)) {
                pkEntry = 
                        (KeyStore.PrivateKeyEntry)ks.getEntry(alias, new KeyStore.PasswordProtection(pin));
                privateKey = pkEntry.getPrivateKey();
                break;
            }
        }

        X509Certificate cert = (X509Certificate)pkEntry.getCertificate();

        // Create the KeyInfo containing the X509Data.   
        KeyInfoFactory kif = fac.getKeyInfoFactory();
        List x509Content = new ArrayList();
        x509Content.add(cert);
        X509Data xd = kif.newX509Data(x509Content);
        KeyInfo ki = kif.newKeyInfo(Collections.singletonList(xd));

        assinarXML(fac, transformList, privateKey, ki, doc, idNode);

        // Output the resulting document.   
        ByteArrayOutputStream os = new ByteArrayOutputStream();
        TransformerFactory tf = TransformerFactory.newInstance();
        Transformer trans = tf.newTransformer();
        trans.transform(new DOMSource(doc), new StreamResult(os));

        File fout = new File(xmlResponseName);
        FileOutputStream out = new FileOutputStream(fout);
        try {
            out.write(os.toByteArray());
        } catch (Exception e) {
        }
        //return os.toString();   
        return "ok";
    } catch (Exception e) {
        e.printStackTrace();
        return e.toString();
    }
}


private static void assinarXML(XMLSignatureFactory fac, 
                               ArrayList transformList, 
                               PrivateKey privateKey, KeyInfo ki, 
                               Document doc, 
                               String idNode) throws Exception {

    // Obtem elemento do documento a ser assinado, será criado uma REFERENCE para o mesmo
    NodeList elements = doc.getElementsByTagName(idNode);
    Element el = (Element)elements.item(0);
    String id = el.getAttribute("Id");

    // Create a DOM XMLSignatureFactory that will be used to generate the enveloped signature.
    Reference ref = 
        fac.newReference("#" + id, fac.newDigestMethod(DigestMethod.SHA1, 
                                                       null), 
                         transformList, null, null);

    // Create the SignedInfo.
    SignedInfo si = 
        fac.newSignedInfo(fac.newCanonicalizationMethod(CanonicalizationMethod.INCLUSIVE, 
                                                        (C14NMethodParameterSpec)null), 
                          fac.newSignatureMethod(SignatureMethod.RSA_SHA1, 
                                                 null), 
                          Collections.singletonList(ref));

    XMLSignature signature = fac.newXMLSignature(si, ki);
    DOMSignContext dsc = 
        new DOMSignContext(privateKey, doc.getDocumentElement());
    signature.sign(dsc);
}