Image via Wikipedia

I know there are many Spring MVC/JPA2 tutorials and projects out there, and in the previous years I have forgotten how many new projects I have started projects using Spring MVC and JPA2, so I added two template projects to Google Code, mainly for myself.

Spring MVC Quick Startup: This project is a simple template project for Spring 3 MVC.

Spring MVC-JPA2 Quick Startup: This project is a simple template project for Spring 3 MVC, JPA2(I favor JPA2 over Hibernate) and also the basic Spring Security.

These projects are really quick startup template projects, I changed some of my projects in 10 min. So there might be some issues but at least it should be enough for the initial setup.

Please feel free to use.

The Winners:

1. Goddess Alert
2. Shuffle Wear
3. SNTMNT

The other projects that pitched:

• Legal Toolkit
• tipNtrip
• Party with a Local
• UnslothMe
• THE RACING APP
• GoCaramba (Sustainability Award)
• Diet Community
• Fuzzle.fm
• Six Legends
• Twuppets
• BLINKER
• Suggest.it
• Joink
• Cedars University
• Askbox
• Prep Board
• TweepFeed.com
• Delicify
• Project Paygle
• RankVote
• Didoo

Congratulations to the winners and all the startups! Thanks to the organizers of Amsterdam Startup Weekend it was an amazing and inspiring weekend!

Here is Mike Lee’s post How to Win: Lessons from Startup Weekend Amsterdam.

Here are the maven dependencies for JAXB at pom.xml:

	<dependencies>
		<dependency>
			<groupId>javax.xml.bind</groupId>
			<artifactId>jaxb-api</artifactId>
		</dependency>
		<dependency>
			<groupId>com.sun.xml.bind</groupId>
			<artifactId>jaxb-impl</artifactId>
		</dependency>
	</dependencies>

and here is the JAXB xjc plugin settings at pom.xml, of course you can change the output directory configuration, I wanted to generate the code at build to target/generated-sources folder:

	<build>
		<plugins>
			<!-- JAXB xjc plugin that invokes the xjc compiler to compile XML schema into Java classes.-->
			<plugin>
				<groupId>org.codehaus.mojo</groupId>
				<artifactId>jaxb2-maven-plugin</artifactId>
				<executions>
					<execution>
						<goals>
							<goal>xjc</goal>
						</goals>
					</execution>
				</executions>
				<configuration>
					<!-- The schema directory or xsd files. -->
					<schemaDirectory>${basedir}/src/main/resources/xsd</schemaDirectory>
					<!-- The package in which the source files will be generated. -->
					<packageName>com.mypackage</packageName>
					<!-- The working directory to create the generated java source files. -->
					<outputDirectory>${build.directory}/generated-sources/jaxb</outputDirectory>
				</configuration>
			</plugin>
		</plugins>

As a side note for code generation: code generation convention is using “target/generated-sources/” folder, it is added as source folder by default.

After adding your XSD file at “resources/xsd” you can generate your code with mvn jaxb2:xjc or mvn clean install commands.

The maven dependency is:

        <dependency>
            <groupId>net.htmlparser.jericho</groupId>
            <artifactId>jericho-html</artifactId>
            <version>3.1</version>
        </dependency>

Here is a simple code using Source to construct the source data, which can be a String, Reader, InputStream, URLConnection or URL.

    public String read(InputStream is) throws IOException {
        Source source = new Source(is);
        return source.getTextExtractor().toString();
    }

and you can merge the HTML using StreamedSource which is preferred for performance with the memory. Now let’s insert a title at the head segment:

    public String merge(InputStream is) {
        Writer writer = new StringWriter();
        try {
            StreamedSource source = new StreamedSource(is);
            for (Segment s : source) {
                if (s instanceof StartTag) {
                    writer.write(s.toString());
                    if (((StartTag) s).getName().equals(HTMLElementName.HEAD)) {
                        writer.write("<title>TEST</title>");
                    }
                } else {
                    writer.write(s.toString());
                }
            }
            writer.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return writer.toString();
    }

As you can see Jericho is really easy to use!

import org.springframework.mail.javamail.ConfigurableMimeFileTypeMap;

import javax.activation.FileTypeMap;
import java.io.IOException;

public class ResourceContentTypeResolver {

    private FileTypeMap fileTypeMap;

    public ResourceContentTypeResolver() {
        fileTypeMap = new ConfigurableMimeFileTypeMap();
    }

    public String getContentType(String fileName) throws IOException {
        if (fileName == null) {
            return null;
        }
        return fileTypeMap.getContentType(fileName.toLowerCase());
    }

}

There is also a great article about Getting the Mime Type from a File.

Hi again after 1 year
I updated my blog’s theme, which is not very girly now I also removed some old posts, especially about JSF, because actually it has been a long time since I used JSF, and they were really very old…

Image via Wikipedia

We needed different log files for a common web project, this gateway project simply loads web services dynamically and generates the wsdd files at runtime, but the problem was huge size of the common log file used by all services. So we needed different log files for different services.

Here is the step by step solution to separate&customize the log files:

• The first step is adding a filter to web.xml file so we can set the service names:

  <filter>
  <filter-name>WSLoggerFilter</filter-name>
  <filter-class>com.logger.WSLoggerFilter</filter-class>
  <description></description>
  </filter>
  
  <filter-mapping>
  <filter-name>WSLoggerFilter</filter-name>
  <url-pattern>/*</url-pattern>
  </filter-mapping>
  

• Here is the simple filter - WSLoggerFilter.java:

  public final class WSLoggerFilter implements Filter {
  private static final String SERVICE_NAME = "serviceName";
  
  public void doFilter(ServletRequest request, ServletResponse response,
  FilterChain chain) throws IOException, ServletException {
  String[] url = ((HttpServletRequest)request).getRequestURI().split("/");
  MDC.put(SERVICE_NAME, url != null ? url[url.length - 1] : "");
  // Forward the request to the next resource in the chain
  chain.doFilter(request, response);
  MDC.remove(SERVICE_NAME);
  }  .....
  

• The next step is adding a custom adapter that uses the MDC "serviceName" parameter to separate the log files, we just alter the name of the default logging file by adding the serviceName parameter we set at the filter. We add the custom adapter to the log4j.properties file:

  # custom file appender
  log4j.appender.F=com.logger.WSLoggerAppender
  log4j.appender.F.mdcName=serviceName

• Next step is implementing the custom appender. I used DailyRollingFileAppender to change the name of the logging file, simply by adding service name. Simply do not forget to override close method to close all the appenders we used. The custom adapter file WSLoggerAppender.java:

  public class WSLoggerAppender extends DailyRollingFileAppender {
  private String mdcName;
  
  private Map<string, dailyrollingfileappender=""> map = new HashMap<string, dailyrollingfileappender="">();
  
  @Override
  public synchronized void doAppend(LoggingEvent event) {
  Object key = MDC.get(getMdcName());
  if (key == null) {
  super.doAppend(event);
  return;
  }
  String serviceName = key.toString();
  if (serviceName != null &amp;&amp; serviceName.length() > 0 &amp;&amp; !map.containsKey(serviceName)) {
  try {
  DailyRollingFileAppender dailyRollingFileAppender = new DailyRollingFileAppender(layout, fileName + "." + serviceName, getDatePattern());
  map.put(serviceName, dailyRollingFileAppender);
  } catch (IOException e) {
  }
  }
  DailyRollingFileAppender ap = (DailyRollingFileAppender) map.get(serviceName);
  if (ap != null)
  ap.doAppend(event);
  else
  super.append(event);
  }
  
  @Override
  public void close() {
  for (Iterator iter = map.values().iterator(); iter.hasNext();) {
  DailyRollingFileAppender appender = (DailyRollingFileAppender) iter.next();
  appender.close();
  }
  super.close();
  }
  
  public void setMdcName(String mdcName) {
  this.mdcName = mdcName;
  }
  
  public String getMdcName() {
  return mdcName;
  }
  }

That was all!

Well startup steps with IntelliJ IDEA:

• Download the Grails
• Set the GRAILS_HOME and add it to path environment variable
• Download the Grails IntelliJ plugin JetGroovy (If you use IntelliJ IDEA 8 you should skip this step, since JetGroovy plugin is bundled in this version otherwise IDE would crash)
  
• Just unzip the JetGroovy to plugins folder
• Change the installation directory for Grails from Settings/Groovy&Grails
• Update the JetGroovy plugin from Settings/Plugins (There were some mysterious errors at IntelliJ like crashing at Backspace key )

My first HelloGrails application had the below error, after playing with the Grails version and trying an older version: grails-1.0.4, I realized that the Groovy was also necessary for JetGroovy plugin. I had already installed groovy but GROOVY_HOME environment setting was missing, but still I could not get the point: Why can’t I use Grails without Groovy @IntelliJ?

java.lang.ClassNotFoundException: org.codehaus.groovy.grails.cli.GrailsScriptRunner
at org.codehaus.groovy.tools.RootLoader.findClass(RootLoader.java:156)
at java.lang.ClassLoader.loadClass(ClassLoader.java:306)
at org.codehaus.groovy.tools.RootLoader.loadClass(RootLoader.java:128)
at java.lang.ClassLoader.loadClass(ClassLoader.java:251)
at org.codehaus.groovy.tools.GroovyStarter.rootLoader(GroovyStarter.java:98)
at org.codehaus.groovy.tools.GroovyStarter.main(GroovyStarter.java:130)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
at java.lang.reflect.Method.invoke(Method.java:597)
at com.intellij.rt.execution.application.AppMain.main(AppMain.java:90)
Process finished with exit code 1


Anyway, you can add two more steps for Grails startup for IntelliJ IDEA users:

• Download the Groovy
• Set the GROOVY_HOME and add it to path environment variable

My startup configuration:
grails-1.0.4
groovy-1.5.7
jdk1.6.0_07
IntelliJ IDEA 7.0.4

The books we ordered have just arrived: great gifts for the new year

• The Mythical Man-Month: Essays on Software Engineering

I will start with classic book of software engineering – The Mythical Man-Month: Essays on Software Engineering first which was first published in 1975 by Fred Brooks. This anniversary edition includes four new chapters and I really wonder about the evolution of software engineering and the human factor in the past 33 years. I can’t wait especially for the legendary The Mythical-Man Month and No Silver Bullet essays.

• Peopleware: Productive Projects and Teams

Peopleware is another oldies/goldies project management book, first published in 1987, described as “Anti-Dilbert Manifesto”

• Agile Project Management With Scrum

Agile Project Management book from Ken Schwaber, one of the originators of the Scrum process. Agile development process explained with lots of examples, success and failure projects.

I wish you a Happy New Year!

First change your perspective to Resource and check your .project file if natures tag also contains facet nature:

    <natures>
        <nature>org.eclipse.jdt.core.javanature</nature>
        <nature>org.eclipse.wst.common.project.facet.core.nature</nature>
    </natures>

And second update your project facets by Project Properties/Project Facets/Add Remove Project Facets:

So you can use and add this new web project to Tomcat server.

Note: We still use older Eclipse version 3.2.2 because of some custom plugin problems