AST 使用笔记

   最近公司要求我做一个可以生成代码的工具，需求为像SWT-Desinger那样，多页编辑器，一页显示源代码，另外一页用表格的形式显示类的属性，要求可以修改，这也不是什么和困难的事情，不过以前没做过这样的东西，还得找找资料来研究研究，发现有个叫AST的东西，是Eclipse提供的工具，以前听说过，不过不怎么用，经过一段时间的学习，发现这东西还真不赖，功能挺强大的，像Eclipse的重构功能就是通过这个AST来实现的，AST全名叫抽象语法树，不过功能强是强大，用起来有点麻烦，很容易出错。

今天在用这个AST生成一个Java文件，我是先通过SWT-Designer生成了一个JFace的ApplicationWindow的文件，上面就简单的放一个按钮，单击后弹出一个对话框，然后显示信息，功能是很简单，经过一天的不断尝试，终于通过了编译，直接运行出来了，可以看到我的对话框了，那下面来介绍一下怎么使用这个东西

   ASTParser parser = ASTParser.newParser(AST.JLS3);
    parser.setSource("".toCharArray());

    CompilationUnit unit = (CompilationUnit) parser.createAST(null);
    unit.recordModifications();

    AST ast = unit.getAST();

上面的代码是生成一个空的编译单元，也就是我们的,java 文件了，我们通过ASTParser.newParser(AST.JLS3);来指定遵守的Java规范,如果是JLS2的话是指定Java 1.4的编译规范，那么 JLS3 为遵守Java 5 以上的规范

    PackageDeclaration packageDeclaration = ast.newPackageDeclaration();
    unit.setPackage(packageDeclaration);
    packageDeclaration.setName(ast.newSimpleName("astdemo"));

上面是生成Java文件的包， 结果为 package astdemo;

//类名
    TypeDeclaration classType = ast.newTypeDeclaration();
    classType.setInterface(false);
    List classTypeModifier = classType.modifiers();
    classTypeModifier.add(ast.newModifier(ModifierKeyword.PUBLIC_KEYWORD));
    classType.setName(ast.newSimpleName("MyFirstApp"));
    classType.setSuperclassType(ast.newSimpleType(ast.newSimpleName("ApplicationWindow")));
    unit.types().add(classType);

这里为指定生成文件的类型，可以在这里指定生成类的名称，是生成的是否是接口,还有访问类型，结果是 public class MyFirstApp extends ApplicationWindow {

    //构造方法
    MethodDeclaration methodConstructor = ast.newMethodDeclaration();
    methodConstructor.setConstructor(true);
    List methodConstructorModifier = methodConstructor.modifiers();
    methodConstructorModifier.add(ast.newModifier(ModifierKeyword.PUBLIC_KEYWORD));
    methodConstructor.setName(ast.newSimpleName("MyFirstApp"));
    classType.bodyDeclarations().add(methodConstructor);

上面为生成一个方法，并指定这个方法是构造方法，生成结果是 public MyFirstApp(){

哎，算了，这样太费劲了，下面是程序的代码

package com.vwpolo.jet.example;

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

import org.eclipse.jdt.core.dom.AST;
import org.eclipse.jdt.core.dom.ASTParser;
import org.eclipse.jdt.core.dom.AnonymousClassDeclaration;
import org.eclipse.jdt.core.dom.Block;
import org.eclipse.jdt.core.dom.ClassInstanceCreation;
import org.eclipse.jdt.core.dom.CompilationUnit;
import org.eclipse.jdt.core.dom.ImportDeclaration;
import org.eclipse.jdt.core.dom.InfixExpression;
import org.eclipse.jdt.core.dom.MethodDeclaration;
import org.eclipse.jdt.core.dom.MethodInvocation;
import org.eclipse.jdt.core.dom.PackageDeclaration;
import org.eclipse.jdt.core.dom.PrimitiveType;
import org.eclipse.jdt.core.dom.ReturnStatement;
import org.eclipse.jdt.core.dom.SingleVariableDeclaration;
import org.eclipse.jdt.core.dom.StringLiteral;
import org.eclipse.jdt.core.dom.SuperConstructorInvocation;
import org.eclipse.jdt.core.dom.TypeDeclaration;
import org.eclipse.jdt.core.dom.VariableDeclarationFragment;
import org.eclipse.jdt.core.dom.VariableDeclarationStatement;
import org.eclipse.jdt.core.dom.InfixExpression.Operator;
import org.eclipse.jdt.core.dom.Modifier.ModifierKeyword;

import com.vwpolo.jet.example.JavaASTParserExample9.CompilationUnitImpl;

public class JavaASTParserExample1 {

  private static final String[] IMPORTS = { "org.eclipse.jface.action.*", "org.eclipse.jface.window.*","org.eclipse.swt.events.*",
      "org.eclipse.swt.*","org.eclipse.jface.dialogs.*", "org.eclipse.swt.graphics.*", "org.eclipse.swt.widgets.*" };

  @SuppressWarnings("unchecked")
  public static void main(String[] args) {
    CompilationUnit unit = getCompilationUtil();
    System.out.println(unit.toString());
    
    JavaASTParserExample9.compileAndRun(new CompilationUnitImpl(unit));
  }

  @SuppressWarnings("unchecked")
  private static CompilationUnit getCompilationUtil() {
    ASTParser parser = ASTParser.newParser(AST.JLS3);
    parser.setSource("".toCharArray());

    CompilationUnit unit = (CompilationUnit) parser.createAST(null);
    unit.recordModifications();

    AST ast = unit.getAST();

    PackageDeclaration packageDeclaration = ast.newPackageDeclaration();
    unit.setPackage(packageDeclaration);
    packageDeclaration.setName(ast.newSimpleName("astdemo"));

    for (int i = 0; i < IMPORTS.length; ++i) {
      ImportDeclaration importDeclaration = ast.newImportDeclaration();
      importDeclaration.setName(ast.newName(getSimpleNames(IMPORTS[i])));
      if (IMPORTS[i].indexOf("*") > 0)
        importDeclaration.setOnDemand(true);
      else
        importDeclaration.setOnDemand(false);

      unit.imports().add(importDeclaration);
    }

    //类名
    TypeDeclaration classType = ast.newTypeDeclaration();
    classType.setInterface(false);
    List classTypeModifier = classType.modifiers();
    classTypeModifier.add(ast.newModifier(ModifierKeyword.PUBLIC_KEYWORD));
    classType.setName(ast.newSimpleName("MyFirstApp"));
    classType.setSuperclassType(ast.newSimpleType(ast.newSimpleName("ApplicationWindow")));
    unit.types().add(classType);

    //构造方法
    MethodDeclaration methodConstructor = ast.newMethodDeclaration();
    methodConstructor.setConstructor(true);
    List methodConstructorModifier = methodConstructor.modifiers();
    methodConstructorModifier.add(ast.newModifier(ModifierKeyword.PUBLIC_KEYWORD));
    methodConstructor.setName(ast.newSimpleName("MyFirstApp"));
    classType.bodyDeclarations().add(methodConstructor);

    Block constructorBlock = ast.newBlock();
    methodConstructor.setBody(constructorBlock);

    //super(null);
    SuperConstructorInvocation superConstructorInvocation = ast.newSuperConstructorInvocation();
    constructorBlock.statements().add(superConstructorInvocation);
    superConstructorInvocation.arguments().add(ast.newNullLiteral());

    //createActions();
    MethodInvocation methodInvocation = ast.newMethodInvocation();
    methodInvocation.setName(ast.newSimpleName("createActions"));
    constructorBlock.statements().add(ast.newExpressionStatement(methodInvocation));

    //addToolBar(SWT.FLAT | SWT.WRAP);
    MethodInvocation methodInvocation2 = ast.newMethodInvocation();
    methodInvocation2.setName(ast.newSimpleName("addToolBar"));
    InfixExpression infixExpression = ast.newInfixExpression();
    infixExpression.setOperator(Operator.OR);
    infixExpression.setLeftOperand(ast.newName(getSimpleNames("SWT.FLAT")));
    infixExpression.setRightOperand(ast.newName(getSimpleNames("SWT.WRAP")));
    methodInvocation2.arguments().add(infixExpression);
    constructorBlock.statements().add(ast.newExpressionStatement(methodInvocation2));

    //addMenuBar();
    MethodInvocation methodInvocation3 = ast.newMethodInvocation();
    methodInvocation3.setName(ast.newSimpleName("addMenuBar"));
    constructorBlock.statements().add(ast.newExpressionStatement(methodInvocation3));

    //addStatusLine();
    MethodInvocation methodInvocation4 = ast.newMethodInvocation();
    methodInvocation4.setName(ast.newSimpleName("addStatusLine"));
    constructorBlock.statements().add(ast.newExpressionStatement(methodInvocation4));

    MethodDeclaration methodDeclaration = ast.newMethodDeclaration();
    methodDeclaration.setConstructor(false);
    List methodModifiers = methodDeclaration.modifiers();
    methodModifiers.add(ast.newModifier(ModifierKeyword.PROTECTED_KEYWORD));
    methodDeclaration.setReturnType2(ast.newSimpleType(ast.newSimpleName("Control")));
    methodDeclaration.setName(ast.newSimpleName("createContents"));
    classType.bodyDeclarations().add(methodDeclaration);
    Block methodBlock = ast.newBlock();
    methodDeclaration.setBody(methodBlock);

    // createContents(Composite parent) {
    SingleVariableDeclaration variableDeclaration = ast.newSingleVariableDeclaration();
    variableDeclaration.setType(ast.newSimpleType(ast.newSimpleName("Composite")));
    variableDeclaration.setName(ast.newSimpleName("parent"));
    methodDeclaration.parameters().add(variableDeclaration);

    //    Composite container = new Composite(parent, SWT.NONE);
    VariableDeclarationFragment variableFragment = ast.newVariableDeclarationFragment();
    variableFragment.setName(ast.newSimpleName("container"));
    VariableDeclarationStatement variableStatement = ast.newVariableDeclarationStatement(variableFragment);
    variableStatement.setType(ast.newSimpleType(ast.newSimpleName("Composite")));
    ClassInstanceCreation classCreation = ast.newClassInstanceCreation();
    classCreation.setType(ast.newSimpleType(ast.newSimpleName("Composite")));
    variableFragment.setInitializer(classCreation);
    methodBlock.statements().add(variableStatement);
    classCreation.arguments().add(ast.newSimpleName("parent"));
    classCreation.arguments().add(ast.newName(getSimpleNames("SWT.NONE")));

    //final Button button = new Button(container, SWT.NONE);
    VariableDeclarationFragment variableFragment2 = ast.newVariableDeclarationFragment();
    variableFragment2.setName(ast.newSimpleName("button"));
    VariableDeclarationStatement variableStatement2 = ast.newVariableDeclarationStatement(variableFragment2);
    List variableModifier2 = variableStatement2.modifiers();
    variableModifier2.add(ast.newModifier(ModifierKeyword.FINAL_KEYWORD));
    variableStatement2.setType(ast.newSimpleType(ast.newSimpleName("Button")));
    ClassInstanceCreation classCreation2 = ast.newClassInstanceCreation();
    classCreation2.setType(ast.newSimpleType(ast.newSimpleName("Button")));
    variableFragment2.setInitializer(classCreation2);
    methodBlock.statements().add(variableStatement2);
    classCreation2.arguments().add(ast.newSimpleName("container"));
    classCreation2.arguments().add(ast.newName(getSimpleNames("SWT.NONE")));

    // button.addSelectionListener(new SelectionAdapter() {});

    MethodInvocation methodInvocation5 = ast.newMethodInvocation();
    methodBlock.statements().add(ast.newExpressionStatement(methodInvocation5));
    methodInvocation5.setExpression(ast.newSimpleName("button"));
    methodInvocation5.setName(ast.newSimpleName("addSelectionListener"));

    ClassInstanceCreation ci = ast.newClassInstanceCreation();
    ci.setType(ast.newSimpleType(ast.newSimpleName("SelectionAdapter")));
    methodInvocation5.arguments().add(ci);
    AnonymousClassDeclaration cd = ast.newAnonymousClassDeclaration();
    ci.setAnonymousClassDeclaration(cd);

    //  public void widgetSelected(SelectionEvent e) {

    MethodDeclaration md = ast.newMethodDeclaration();
    md.setConstructor(false);
    List mdModifiers = md.modifiers();
    mdModifiers.add(ast.newModifier(ModifierKeyword.PUBLIC_KEYWORD));
    md.setName(ast.newSimpleName("widgetSelected"));
    cd.bodyDeclarations().add(md);

    SingleVariableDeclaration variableDeclaration2 = ast.newSingleVariableDeclaration();
    variableDeclaration2.setType(ast.newSimpleType(ast.newSimpleName("SelectionEvent")));
    variableDeclaration2.setName(ast.newSimpleName("e"));
    md.parameters().add(variableDeclaration2);
    Block methodBlock2 = ast.newBlock();
    md.setBody(methodBlock2);

    MethodInvocation methodInvocation6 = ast.newMethodInvocation();
    methodInvocation6.setExpression(ast.newSimpleName("MessageDialog"));
    methodInvocation6.setName(ast.newSimpleName("openInformation"));
    MethodInvocation methodInvocation12 = ast.newMethodInvocation();
    methodInvocation12.setName(ast.newSimpleName("getShell"));
    methodInvocation6.arguments().add(methodInvocation12);
    
    StringLiteral stringLiteral1 = ast.newStringLiteral();
    stringLiteral1.setEscapedValue(""信息"");
    StringLiteral stringLiteral2 = ast.newStringLiteral();
    stringLiteral2.setEscapedValue(""你好"");
    methodInvocation6.arguments().add(stringLiteral1);
    methodInvocation6.arguments().add(stringLiteral2);
    methodBlock2.statements().add(ast.newExpressionStatement(methodInvocation6));

    MethodInvocation methodInvocation7 = ast.newMethodInvocation();
    methodInvocation7.setExpression(ast.newSimpleName("button"));
    methodInvocation7.setName(ast.newSimpleName("setText"));
    StringLiteral stringLiteral3 = ast.newStringLiteral();
    stringLiteral3.setEscapedValue(""按 钮"");
    methodInvocation7.arguments().add(stringLiteral3);
    methodBlock.statements().add(ast.newExpressionStatement(methodInvocation7));

    // button.setText("按 钮");
    MethodInvocation methodInvocation8 = ast.newMethodInvocation();
    methodInvocation8.setExpression(ast.newSimpleName("button"));
    methodInvocation8.setName(ast.newSimpleName("setBounds"));
    StringLiteral stringLiteral4 = ast.newStringLiteral();
    stringLiteral4.setEscapedValue(""按 钮"");
    //button.setBounds(69, 28, 44, 23);
    methodInvocation8.arguments().add(ast.newNumberLiteral("69"));
    methodInvocation8.arguments().add(ast.newNumberLiteral("28"));
    methodInvocation8.arguments().add(ast.newNumberLiteral("44"));
    methodInvocation8.arguments().add(ast.newNumberLiteral("23"));
    methodBlock.statements().add(ast.newExpressionStatement(methodInvocation8));

    //return container;
    ReturnStatement returnStatement = ast.newReturnStatement();
    returnStatement.setExpression(ast.newSimpleName("container"));
    methodBlock.statements().add(returnStatement);

    //private void createActions()
    MethodDeclaration methodDeclaration2 = ast.newMethodDeclaration();
    methodDeclaration2.setConstructor(false);
    List methodModifiers2 = methodDeclaration2.modifiers();
    methodModifiers2.add(ast.newModifier(ModifierKeyword.PRIVATE_KEYWORD));
    methodDeclaration2.setReturnType2(ast.newPrimitiveType(PrimitiveType.VOID));
    methodDeclaration2.setName(ast.newSimpleName("createActions"));
    Block methodBlock3 = ast.newBlock();
    methodDeclaration2.setBody(methodBlock3);
    classType.bodyDeclarations().add(methodDeclaration2);

    // protected MenuManager createMenuManager()
    MethodDeclaration methodDeclaration3 = ast.newMethodDeclaration();
    methodDeclaration3.setConstructor(false);
    List methodModifiers3 = methodDeclaration3.modifiers();
    methodModifiers3.add(ast.newModifier(ModifierKeyword.PROTECTED_KEYWORD));
    methodDeclaration3.setReturnType2(ast.newSimpleType(ast.newName("MenuManager")));
    methodDeclaration3.setName(ast.newSimpleName("createMenuManager"));
    Block methodBlock4 = ast.newBlock();
    methodDeclaration3.setBody(methodBlock4);
    classType.bodyDeclarations().add(methodDeclaration3);

    //MenuManager menuManager = new MenuManager("menu");
    VariableDeclarationFragment variableFragment3 = ast.newVariableDeclarationFragment();
    variableFragment3.setName(ast.newSimpleName("menuManager"));
    VariableDeclarationStatement variableStatement3 = ast.newVariableDeclarationStatement(variableFragment3);
    variableStatement3.setType(ast.newSimpleType(ast.newSimpleName("MenuManager")));
    ClassInstanceCreation classCreation3 = ast.newClassInstanceCreation();
    classCreation3.setType(ast.newSimpleType(ast.newSimpleName("MenuManager")));
    StringLiteral stringLiteral5 = ast.newStringLiteral();
    stringLiteral5.setEscapedValue(""menu"");
    classCreation3.arguments().add(stringLiteral5);
    variableFragment3.setInitializer(classCreation3);
    methodBlock4.statements().add(variableStatement3);

    // return menuManager;
    ReturnStatement returnStatement2 = ast.newReturnStatement();
    returnStatement2.setExpression(ast.newSimpleName("menuManager"));
    methodBlock4.statements().add(returnStatement2);

    // protected ToolBarManager createToolBarManager(int style) {
    MethodDeclaration methodDeclaration4 = ast.newMethodDeclaration();
    methodDeclaration4.setConstructor(false);
    List methodModifiers4 = methodDeclaration4.modifiers();
    methodModifiers4.add(ast.newModifier(ModifierKeyword.PROTECTED_KEYWORD));
    methodDeclaration4.setReturnType2(ast.newSimpleType(ast.newName("ToolBarManager")));
    methodDeclaration4.setName(ast.newSimpleName("createToolBarManager"));
    SingleVariableDeclaration variableDeclaration5 = ast.newSingleVariableDeclaration();
    variableDeclaration5.setType(ast.newPrimitiveType(PrimitiveType.INT));
    variableDeclaration5.setName(ast.newSimpleName("style"));
    methodDeclaration4.parameters().add(variableDeclaration5);
    Block methodBlock5 = ast.newBlock();
    methodDeclaration4.setBody(methodBlock5);
    classType.bodyDeclarations().add(methodDeclaration4);

    //MenuManager menuManager = new MenuManager("menu");
    VariableDeclarationFragment variableFragment4 = ast.newVariableDeclarationFragment();
    variableFragment4.setName(ast.newSimpleName("toolBarManager"));
    VariableDeclarationStatement variableStatement4 = ast.newVariableDeclarationStatement(variableFragment4);
    variableStatement4.setType(ast.newSimpleType(ast.newSimpleName("ToolBarManager")));
    ClassInstanceCreation classCreation4 = ast.newClassInstanceCreation();
    classCreation4.setType(ast.newSimpleType(ast.newSimpleName("ToolBarManager")));
    StringLiteral stringLiteral6 = ast.newStringLiteral();
    stringLiteral6.setEscapedValue(""menu"");
    classCreation3.arguments().add(stringLiteral6);
    variableFragment4.setInitializer(classCreation4);
    methodBlock5.statements().add(variableStatement4);

    // toolBarManager
    ReturnStatement returnStatement3 = ast.newReturnStatement();
    returnStatement3.setExpression(ast.newSimpleName("toolBarManager"));
    methodBlock5.statements().add(returnStatement3);

    MethodDeclaration mainMethod = ast.newMethodDeclaration();
    mainMethod.setConstructor(false);
    List mainMethodModifiers = mainMethod.modifiers();
    mainMethodModifiers.add(ast.newModifier(ModifierKeyword.PUBLIC_KEYWORD));
    mainMethodModifiers.add(ast.newModifier(ModifierKeyword.STATIC_KEYWORD));
    mainMethod.setReturnType2(ast.newPrimitiveType(PrimitiveType.VOID));
    mainMethod.setName(ast.newSimpleName("main"));
    Block mainBlock = ast.newBlock();
    mainMethod.setBody(mainBlock);

    SingleVariableDeclaration mainSingleVariable = ast.newSingleVariableDeclaration();
    mainSingleVariable.setType(ast.newArrayType(ast.newSimpleType(ast.newSimpleName("String"))));
    mainSingleVariable.setName(ast.newSimpleName("args"));
    mainMethod.parameters().add(mainSingleVariable);
    classType.bodyDeclarations().add(mainMethod);

    VariableDeclarationFragment variableFragment5 = ast.newVariableDeclarationFragment();
    variableFragment5.setName(ast.newSimpleName("window"));
    VariableDeclarationStatement variableStatement5 = ast.newVariableDeclarationStatement(variableFragment5);
    variableStatement5.setType(ast.newSimpleType(ast.newSimpleName("MyFirstApp")));
    ClassInstanceCreation classCreation5 = ast.newClassInstanceCreation();
    classCreation5.setType(ast.newSimpleType(ast.newSimpleName("MyFirstApp")));
    variableFragment5.setInitializer(classCreation5);
    mainBlock.statements().add(variableStatement5);

    // window.setBlockOnOpen(true);
    MethodInvocation methodInvocation9 = ast.newMethodInvocation();
    methodInvocation9.setExpression(ast.newSimpleName("window"));
    methodInvocation9.setName(ast.newSimpleName("setBlockOnOpen"));
    methodInvocation9.arguments().add(ast.newBooleanLiteral(true));
    mainBlock.statements().add(ast.newExpressionStatement(methodInvocation9));

    // window.setBlockOnOpen(true);
    MethodInvocation methodInvocation10 = ast.newMethodInvocation();
    methodInvocation10.setExpression(ast.newSimpleName("window"));
    methodInvocation10.setName(ast.newSimpleName("open"));
    mainBlock.statements().add(ast.newExpressionStatement(methodInvocation10));

    //Display.getCurrent().dispose();
//    MethodInvocation methodInvocation11 = ast.newMethodInvocation();
//    methodInvocation11.setExpression(ast.newName(getSimpleNames("Display.getCurrent()")));
//    methodInvocation11.setName(ast.newSimpleName("dispose"));
//    mainBlock.statements().add(ast.newExpressionStatement(methodInvocation11));

    return unit;
  }

  @SuppressWarnings("unchecked")
  static private String[] getSimpleNames(String qualifiedName) {
    StringTokenizer st = new StringTokenizer(qualifiedName, ".");
    ArrayList list = new ArrayList();
    while (st.hasMoreTokens()) {
      String name = st.nextToken().trim();
      if (!name.equals("*"))
        list.add(name);
    }
    return (String[]) list.toArray(new String[list.size()]);
  }

}