Java tutorial
/* * $Id$ Created on Apr 19, 2006 * * Copyright (C) 2006 Idega Software hf. All Rights Reserved. * * This software is the proprietary information of Idega hf. Use is subject to * license terms. */ package com.idega.eclipse.ejbwizards; import java.util.ArrayList; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Set; import java.util.StringTokenizer; import org.eclipse.core.resources.IResource; import org.eclipse.core.runtime.CoreException; import org.eclipse.core.runtime.IProgressMonitor; import org.eclipse.jdt.core.Flags; import org.eclipse.jdt.core.ICompilationUnit; import org.eclipse.jdt.core.IImportDeclaration; import org.eclipse.jdt.core.IJavaElement; import org.eclipse.jdt.core.IMethod; import org.eclipse.jdt.core.IType; import org.eclipse.jdt.core.JavaCore; import org.eclipse.jdt.core.JavaModelException; import org.eclipse.jdt.core.Signature; import org.eclipse.jdt.core.dom.AST; import org.eclipse.jdt.core.dom.ASTParser; import org.eclipse.jdt.core.dom.CompilationUnit; import org.eclipse.jdt.core.dom.ImportDeclaration; import org.eclipse.jdt.core.dom.Javadoc; import org.eclipse.jdt.core.dom.MethodDeclaration; import org.eclipse.jdt.core.dom.Modifier; import org.eclipse.jdt.core.dom.PackageDeclaration; import org.eclipse.jdt.core.dom.ParameterizedType; import org.eclipse.jdt.core.dom.PrimitiveType; import org.eclipse.jdt.core.dom.SingleVariableDeclaration; import org.eclipse.jdt.core.dom.TagElement; import org.eclipse.jdt.core.dom.TextElement; import org.eclipse.jdt.core.dom.Type; import org.eclipse.jdt.core.dom.TypeDeclaration; import org.eclipse.jdt.ui.CodeGeneration; import org.eclipse.jface.dialogs.MessageDialog; import org.eclipse.jface.text.BadLocationException; import org.eclipse.jface.text.Document; import org.eclipse.swt.widgets.Shell; import org.eclipse.text.edits.MalformedTreeException; import org.eclipse.text.edits.TextEdit; public abstract class BeanCreator { private IType type; private Map importMap; private Set interfaceImports; private Set homeInterfaceImports; private Set homeImplImports; protected boolean isLegacyEntity = false; protected boolean isSessionBean = false; protected boolean isJDK1_5 = false; protected BeanCreator(IResource resource) { this(resource, false); } protected BeanCreator(IResource resource, boolean isLegacyOrSessionBean) { this.isLegacyEntity = isLegacyOrSessionBean; this.isSessionBean = isLegacyOrSessionBean; String resourceName = resource.getName(); IJavaElement javaElement = JavaCore.create(resource); if (javaElement instanceof ICompilationUnit) { String typeName = resourceName.substring(0, resourceName.indexOf(".java")); ICompilationUnit compilationUnit = (ICompilationUnit) javaElement; fillImportMap(compilationUnit); this.type = compilationUnit.getType(typeName); } Map map = javaElement.getJavaProject().getOptions(false); if (map != null) { String value = (String) map.get("org.eclipse.jdt.core.compiler.compliance"); if (value != null) { float version = Float.parseFloat(value); if (version > 1.4) { this.isJDK1_5 = true; } } } try { generateCode(); } catch (JavaModelException jme) { jme.printStackTrace(System.err); } } protected void displayInformation(String title, String text) { Shell shell = new Shell(); MessageDialog.openInformation(shell, title, text); } protected void addInterfaceImport(String importName) { if (this.interfaceImports == null) { this.interfaceImports = new HashSet(); } this.interfaceImports.add(importName); } protected Set getInterfaceImports() { if (this.interfaceImports == null) { this.interfaceImports = new HashSet(); } return this.interfaceImports; } protected void addHomeInterfaceImport(String importName) { if (this.homeInterfaceImports == null) { this.homeInterfaceImports = new HashSet(); } this.homeInterfaceImports.add(importName); } protected Set getHomeInterfaceImports() { if (this.homeInterfaceImports == null) { this.homeInterfaceImports = new HashSet(); } return this.homeInterfaceImports; } protected void addHomeImplImport(String importName) { if (this.homeImplImports == null) { this.homeImplImports = new HashSet(); } this.homeImplImports.add(importName); } protected Set getHomeImplImports() { if (this.homeImplImports == null) { this.homeImplImports = new HashSet(); } return this.homeImplImports; } protected String getTypeComment(ICompilationUnit iUnit, String typeName) { try { String lineDelimiter = System.getProperty("line.separator", "\n"); //$NON-NLS-1$ //$NON-NLS-2$ String comment = CodeGeneration.getTypeComment(iUnit, typeName, lineDelimiter); if (comment != null) { return comment; } } catch (CoreException e) { e.printStackTrace(); } return null; } protected String getFileComment(ICompilationUnit iUnit) { try { String lineDelimiter = System.getProperty("line.separator", "\n"); //$NON-NLS-1$ //$NON-NLS-2$ String comment = CodeGeneration.getFileComment(iUnit, lineDelimiter); if (comment != null) { return comment; } } catch (CoreException e) { e.printStackTrace(); } return null; } protected abstract void generateCode() throws JavaModelException; protected IType getType() { return this.type; } protected String getImportSignature(String importName) { if (importName.indexOf("[") != -1) { importName = importName.substring(0, importName.indexOf("[")); } if (importName.indexOf("<") != -1) { importName = importName.substring(0, importName.indexOf("<")); } return (String) this.importMap.get(importName); } protected void addInterfaceToBean(IProgressMonitor monitor, ICompilationUnit iUnit, String interfaceName) throws JavaModelException, MalformedTreeException, BadLocationException { String source = iUnit.getBuffer().getContents(); Document document = new Document(source); ASTParser parser = ASTParser.newParser(AST.JLS3); parser.setSource(iUnit); CompilationUnit unit = (CompilationUnit) parser.createAST(monitor); unit.recordModifications(); AST ast = unit.getAST(); Type interfaceType = ast.newSimpleType(ast.newSimpleName(interfaceName)); TypeDeclaration typeDeclaration = (TypeDeclaration) unit.types().get(0); if (typeDeclaration.superInterfaceTypes().contains(interfaceType)) { typeDeclaration.superInterfaceTypes().add(interfaceType); } TextEdit edits = unit.rewrite(document, iUnit.getJavaProject().getOptions(true)); // computation of the new source code edits.apply(document); String newSource = document.get(); // update of the compilation unit iUnit.getBuffer().setContents(newSource); iUnit.reconcile(ICompilationUnit.NO_AST, false, null, null); iUnit.commitWorkingCopy(true, null); iUnit.discardWorkingCopy(); } private void fillImportMap(ICompilationUnit iUnit) { if (this.importMap == null) { this.importMap = new HashMap(); } try { IImportDeclaration[] imports = iUnit.getImports(); for (int i = 0; i < imports.length; i++) { IImportDeclaration declaration = imports[i]; String importName = declaration.getElementName(); this.importMap.put(importName.substring(importName.lastIndexOf(".") + 1), importName); } } catch (JavaModelException jme) { jme.printStackTrace(); } } public List filterMethods(IMethod[] methods, MethodFilter[] validFilterNames, MethodFilter[] nonValidFilterNames) throws JavaModelException { ArrayList list = new ArrayList(); for (int i = 0; i < methods.length; i++) { IMethod method = methods[i]; if (Flags.isPublic(method.getFlags()) && !Flags.isStatic(method.getFlags())) { String methodName = method.getElementName(); boolean valid = false; if (validFilterNames != null || nonValidFilterNames != null) { if (nonValidFilterNames != null) { valid = true; for (int j = 0; j < nonValidFilterNames.length; j++) { MethodFilter filter = nonValidFilterNames[j]; if (filter.filter(methodName)) { valid &= false; } } } if (validFilterNames != null) { for (int j = 0; j < validFilterNames.length; j++) { boolean filters = validFilterNames[j].filter(methodName); if (filters) { valid |= true; } } } } else { valid = true; } if (valid) { list.add(method); } } } return list; } protected String getReturnType(String returnType) { returnType = Signature.getSignatureSimpleName(returnType); if (returnType.equals("void")) { returnType = null; } return returnType; } protected Type getType(AST ast, String type) { Type returnType = null; if (type != null) { boolean isArray = false; boolean isGenericType = false; if (type.indexOf("[") != -1) { isArray = true; } if (type.indexOf("<") != -1) { isGenericType = true; } try { if (isArray) { returnType = ast.newArrayType( ast.newSimpleType(ast.newSimpleName(type.substring(0, type.indexOf("["))))); } else if (isGenericType) { returnType = ast.newParameterizedType( ast.newSimpleType(ast.newSimpleName(type.substring(0, type.indexOf("<"))))); StringTokenizer tokens = new StringTokenizer( type.substring(type.indexOf("<") + 1, type.indexOf(">")), ","); while (tokens.hasMoreTokens()) { ((ParameterizedType) returnType).typeArguments() .add(getType(ast, tokens.nextToken().trim())); } } else { returnType = ast.newSimpleType(ast.newSimpleName(type)); } } catch (IllegalArgumentException iae) { if (isArray) { returnType = ast.newArrayType( ast.newPrimitiveType(PrimitiveType.toCode(type.substring(0, type.indexOf("["))))); } else { returnType = ast.newPrimitiveType(PrimitiveType.toCode(type)); } } } else { returnType = ast.newPrimitiveType(PrimitiveType.VOID); } return returnType; } protected PackageDeclaration getPackageDeclaration(AST ast, String packageName) { PackageDeclaration packageDeclaration = ast.newPackageDeclaration(); packageDeclaration.setName(ast.newName(packageName)); return packageDeclaration; } protected TypeDeclaration getTypeDeclaration(AST ast, String name, boolean isInterface, String superClass, String[] interfaces, Set imports) { TypeDeclaration classType = ast.newTypeDeclaration(); classType.setInterface(isInterface); classType.modifiers().addAll(ast.newModifiers(Modifier.PUBLIC)); classType.setName(ast.newSimpleName(name)); if (isInterface) { classType.superInterfaceTypes().add(ast.newSimpleType(ast.newSimpleName(superClass))); } else { classType.setSuperclassType(ast.newSimpleType(ast.newSimpleName(superClass))); } if (interfaces != null) { for (int i = 0; i < interfaces.length; i++) { if (!Signature.getSignatureSimpleName(interfaces[i]).equals(name)) { classType.superInterfaceTypes().add( ast.newSimpleType(ast.newSimpleName(Signature.getSignatureSimpleName(interfaces[i])))); imports.add(getImportSignature(Signature.toString(interfaces[i]))); } } } return classType; } protected Javadoc getJavadoc(AST ast, IMethod method) { Javadoc jc = ast.newJavadoc(); TagElement tag = ast.newTagElement(); tag.setTagName(TagElement.TAG_SEE); TextElement te = ast.newTextElement(); te.setText(getType().getFullyQualifiedName() + "#" + method.getElementName()); tag.fragments().add(te); jc.tags().add(tag); return jc; } protected MethodDeclaration getMethodDeclaration(AST ast, IMethod method, Set imports) throws JavaModelException { String returnType = getReturnType(method.getReturnType()); String methodName = method.getElementName(); return getMethodDeclaration(ast, method, methodName, returnType, imports, true); } protected MethodDeclaration getMethodDeclaration(AST ast, IMethod method, String methodName, String returnType, Set imports, boolean addJavadoc) throws JavaModelException { String[] exceptions = method.getExceptionTypes(); String[] parameterTypes = method.getParameterTypes(); String[] parameterNames = method.getParameterNames(); MethodDeclaration methodConstructor = ast.newMethodDeclaration(); methodConstructor.setConstructor(false); methodConstructor.modifiers().addAll(ast.newModifiers(Modifier.PUBLIC)); methodConstructor.setReturnType2(getType(ast, returnType)); methodConstructor.setName(ast.newSimpleName(methodName)); if (returnType != null) { imports.add(getImportSignature(returnType)); } for (int i = 0; i < exceptions.length; i++) { methodConstructor.thrownExceptions() .add(ast.newSimpleName(Signature.getSignatureSimpleName(exceptions[i]))); imports.add(getImportSignature(Signature.toString(exceptions[i]))); } for (int i = 0; i < parameterTypes.length; i++) { String parameterType = getReturnType(parameterTypes[i]); SingleVariableDeclaration variableDeclaration = ast.newSingleVariableDeclaration(); variableDeclaration.modifiers().addAll(ast.newModifiers(Modifier.NONE)); variableDeclaration.setType(getType(ast, parameterType)); variableDeclaration.setName(ast.newSimpleName(parameterNames[i])); methodConstructor.parameters().add(variableDeclaration); imports.add(getImportSignature(Signature.toString(parameterTypes[i]))); } if (addJavadoc) { methodConstructor.setJavadoc(getJavadoc(ast, method)); } return methodConstructor; } protected void writeImports(AST ast, CompilationUnit unit, Set imports) { Iterator iter = imports.iterator(); while (iter.hasNext()) { String importName = (String) iter.next(); if (importName != null) { ImportDeclaration importDeclaration = ast.newImportDeclaration(); importDeclaration.setName(ast.newName(importName)); importDeclaration.setOnDemand(false); unit.imports().add(importDeclaration); } } } protected void commitChanges(ICompilationUnit iUnit, CompilationUnit unit, Document document) throws MalformedTreeException, BadLocationException, JavaModelException { TextEdit edits = unit.rewrite(document, iUnit.getJavaProject().getOptions(true)); edits.apply(document); String newSource = document.get(); iUnit.getBuffer().setContents(newSource); iUnit.reconcile(ICompilationUnit.NO_AST, false, null, null); iUnit.commitWorkingCopy(true, null); iUnit.discardWorkingCopy(); } }