Código Fonte do JavaDoc

Entusiasta Java Membro desde: 10/07/2008 07:32:45 Mensagens: 20 Offline

Senhores,

Estou com a seguinte necessidade.
Preciso do código fonte do JavaDoc. Ou melhor, preciso customizar algumas coisas na documentação de meu projeto quando o JavaDoc for gerado.

Ja tentei baixar o código fonte do java so que não achei nada do JavaDoc.

Alquem tem um luz?

Moderador Membro desde: 29/07/2004 16:10:13 Mensagens: 17543 Offline

http://download.java.net/jdk6/source/

Moderador Membro desde: 29/07/2004 16:10:13 Mensagens: 17543 Offline

As classes estão em j2se\src\share\classes\com\sun\tools\javadoc

thiagonego wrote:...preciso customizar algumas coisas na documentação de meu projeto quando o JavaDoc for gerado.

Como assim? O que exatamente você quer fazer?

Entusiasta Java Membro desde: 10/07/2008 07:32:45 Mensagens: 20 Offline

Preciso durante que o JavaDoc gere a documentação algumas verificações sejam feitas e entre outras coisas adicionar algumas informações no banco.
Dai quero modificar a código para que isso seja possivel.

Muito obg pela ajuda.

Moderador Membro desde: 29/07/2004 16:10:13 Mensagens: 17543 Offline

http://java.sun.com/javase/6/docs/technotes/guides/javadoc/doclet/overview.html

Você quer o código fonte do executável javadoc? Não sei se ele está disponível (sem contar que ele é escrito em linguagem nativa).

Moderador Membro desde: 29/07/2004 16:10:13 Mensagens: 17543 Offline

O javadoc não é "escrito em linguagem nativa".

Na verdade, o javadoc.exe é apenas um "wrapping" para "java -classpath tools.jar com.sun.tools.javadoc.Main" ou coisa parecida.

Se quiser, experimente chamar o javadoc dessa maneira (adicionando os parâmetros, é claro).

thingol wrote:O javadoc não é "escrito em linguagem nativa".

Na verdade, o javadoc.exe é apenas um "wrapping" para "java -classpath tools.jar com.sun.tools.javadoc.Main" ou coisa parecida.

Se quiser, experimente chamar o javadoc dessa maneira (adicionando os parâmetros, é claro).

]
Ops... erro técnico. Realmente, o que é escrito em linguagem nativa é só o wrapping mesmo.

Entusiasta Java Membro desde: 10/07/2008 07:32:45 Mensagens: 20 Offline

Gente muito obrigado pela a ajuda.
Fazia um tempão que esta procurando isso.

Agora vou analisar todo aquele código pra poder fazer alguma coisa...

Assim que conseguir algo escrevo aqui.

OBG

...tanto que com algum decompilador (como JD-GUI) dá pra ver o código fonte de todo o javadoc.

Entusiasta Java Membro desde: 10/07/2008 07:32:45 Mensagens: 20 Offline

Senhors,

Muito obrigado por tudo.

Até agora consegui resolver o que queria com esse post. Porém surgiu novas dúvidas que falarei depois que explicar como foi resolvido.

Para que possamos customizar um Java Doc como eu estava querendo existe um forma muito boa que é utilizando o Java Doclets.

Aqui tem um exemplo de como acrescentar gráficos na documentação utilizando esse Doclets:
http://code.google.com/p/apiviz/

Vale apenas dar uma olhada.

Então vou colcar aqui um exemplo de um doclet

package br.com.seiz.generatorApi.doclets;

import java.util.ArrayList;
import java.util.List;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import br.com.seiz.generatorApi.bean.Project;
import br.com.seiz.generatorApi.dao.GenericDaoJpa;

import com.sun.javadoc.AnnotationDesc;
import com.sun.javadoc.ClassDoc;
import com.sun.javadoc.ConstructorDoc;
import com.sun.javadoc.FieldDoc;
import com.sun.javadoc.MemberDoc;
import com.sun.javadoc.ParamTag;
import com.sun.javadoc.RootDoc;
import com.sun.javadoc.Tag;

public class Generator{
	
	public static boolean start(RootDoc root) {
        
        ClassDoc[] classes = root.classes();

/*
         * Iterando as classes
         */
        for (ClassDoc cd : classes) {
        	
    		//Throws
    		//Assign
        	String assing = cd.modifiers() + " " + cd.simpleTypeName();
        	
        	//Super Classe
        	//TODO Fazer aqui um metodo para mondar a arvore de super classes
        	if (cd.superclass() != null){
        		cd.superclass().simpleTypeName();        	
        	}
        	
        	/**
        	 * SubClasses
        	 */
        	List<String> subClasses = new ArrayList<String>();
        	ClassDoc[] classes2 = root.classes();
        	for (ClassDoc classDoc : classes2) {
				if (classDoc.subclassOf(cd) && !cd.equals(classDoc)){
					subClasses.add(classDoc.simpleTypeName());
				}
			}
        	
        	/**
        	 * Iterando as TAG´s
        	 */
        	Tag[] tags = cd.tags();
        	for (Tag tag : tags) {
				tag.name();
			}
        	
        	//Nome do Pacote
        	cd.containingPackage().name();
        	
        	//Comentário
        	cd.commentText();
        	
        	/**
        	 * Iterando os parametros
        	 */
        	ParamTag[] paramTagClasse = cd.typeParamTags();
        	for (ParamTag paramTag : paramTagClasse) {
			}
        	
        	/*
        	 * Iterando os Fields
        	 */
        	FieldDoc[] fieldsDocClass = cd.fields();
        	for (FieldDoc fieldDoc : fieldsDocClass) {
			}
        	
        	/*
        	 * Iterando as anotações da classe
        	 */
        	AnnotationDesc[] annotationDescsClasse = cd.annotations();
        	for (AnnotationDesc annotationDesc : annotationDescsClasse) {
			}
        	
        	/**
        	 * Iterando os Construtores da classe
        	 */
        	ConstructorDoc[] construtores = cd.constructors();
        	for (ConstructorDoc construtor : construtores) {
			}
        	
        	/**
        	 * Iterando os Métodos
        	 */
        	for(MemberDoc md : cd.methods()) {
            	md.commentText();
            	md.getRawCommentText();
            	if(isDeprecated(md.annotations()))
            		System.out.println("Deprecated: " + md.qualifiedName());
        	}
        	
        	
		}
        
        return true;
	}

private static Boolean isDeprecated(AnnotationDesc[] annotations) {
		for (AnnotationDesc annotationDesc : annotations) {
			if ("java.lang.Deprecated".equalsIgnoreCase(annotationDesc.annotationType().qualifiedName().toString()))
				return true;
		}
		return false;
	}
}

Com essa classe vc vai conseguir todas as informações da documentação se seu projeto.
Estava eu querendo fazer um parse com Ruby do HTML gerado pelo Javadoc so que da muito mais trabalho que isso.

Pronto. Agora vamos algo atual problema.

Preciso customizar um documentação utilizando um Doclet. Ou melhor, preciso pegar todas as informações de meu projeto como:
Classes, métodos, se publicos, se protected, argumentos, comentários, tag de comentários, Erros, Exceções, Interfaces e etc.

Ou seja todas aquelas informações que estão da documentação e PERSISTIR em um banco de dados. Para que possamos fazer um certo estudo aqui com todos os nossos projetos.

Por tanto vou mostrar minha estrutura.

Criei um projeto que vai persistir no banco e que possuirá a classe de Doclet com a seguinte arquitetura vamos chamalo de "GERADOR".
Spring, JPA + Hibernate e JSF.
Gerei um jar desse projeto utilizando o plugin "FAT Jar" que coloca dentro de JAR principal todas as classes das lib que contem o projeto ( Spring, JPA e etc).

Portanto chegarei em cada um de nossos sistemas e vou mandar gerar a documentação utilizando um Doclet que vou desenvolver.
No método inicial desse Doclet " start() " vou iniciar o contexto do spring e começar a persistir as informações que desejo.

Tudo da certo até o momento que vou iniciar o contexto do Spring.

A exceção é a seguinte:
http://pastie.org/775523

Não sei se ficou claro pra vc´s.
Qualquer dúvida me pergunta aqui ok.

Será que os gurus aqui poderá me ajudar?!

Valew

Javadoc é um doclet?

AS

Entusiasta Java Membro desde: 10/07/2008 07:32:45 Mensagens: 20 Offline

Não. O JavaDoc utiliza de um Doclet Standart para gerar os HTMLs.
Por tanto gerarei um Doclect proprio para persistir meus dados.
Entendeu?

GUJ Hacker Membro desde: 26/09/2009 09:18:56 Mensagens: 5750 Offline

Para evitar tais problemas, e para ficar mais fácil de debugar, eu preferiria ter um Doclet que gerasse um XML (ou coisa parecida) e que eu pudesse conferir para ver se os dados que preciso estão corretos, e um programa usando o framework Spring que lesse esse XML.

Não sei se o javadoc pode chamar seu doclet de forma que o Spring possa ser corretamente inicializado. Pode ser que haja alguma sutileza que você só pudesse descobrir depois de muito tempo - acho que é mais fácil separar as coisas.

Notícias, artigos e o maior fórum brasileiro sobre Java