Here’s the code of it.

package com.justthor.reader

import scala.io.Source
import scala.xml._

object SimpleFeedReader {
  def main(args : Array[String]) : Unit = {
    val url = "http://just-thor.com/feed/"
    val data = XML.loadString( Source.fromURL(url).mkString )
    data \ "channel" \ "item" foreach(
      a => println((a \ "title" text) + " == "  + (a \ "link" text))
    )
  }
}

Ok,let’s go thru the code line by line.

At line 09, again we use Source to load content from url,by calling the method fromURL(quite obvious,right?).The mkString will create a String out of the content. Then, we use XML.loadString to parse the String into an XML object.

At line 10, we traverse the XML object with something like XQuery.
The RSS xml format is something like this

<channel>
<link>...</link>
<description>...</description>
<!-- item 1-->
<item>
  <title></title>
  <link></link>
</item>
<!-- item 2-->
<item>
  <title></title>
  <link></link>
</item>
<!-- and the rest goes here -->
</channel>

So when we write

data \ "channel" \ "item"

Here’s the output of the result

File Reading in Java and Scala == http://just-thor.com/2009/10/01/file-reading-in-java-and-scala/
PHP communicate with Java using JSON – Unicode Version == http://just-thor.com/2009/09/28/php-communicate-with-java-using-json-unicode-version/
Scala And JDBC == http://just-thor.com/2009/09/27/scala-and-jdbc/
A mistake or fate? == http://just-thor.com/2009/09/17/a-mistake-or-fate/
Women are weird == http://just-thor.com/2009/09/13/women-are-weird/
20 must visit sites for Java developer == http://just-thor.com/2009/09/12/20-must-visit-sites-for-java-developer/
Why do I practice pair programming? == http://just-thor.com/2009/09/08/why-do-i-practice-pair-programming/
Installing Scala on Windows == http://just-thor.com/2009/09/02/installing-scala-on-window/
Logging for different requested URI in Apache HTTP Server == http://just-thor.com/2009/09/01/logging-for-different-requested-uri-in-apache-http-server/
Say hello to Java and Scala == http://just-thor.com/2009/08/30/say-hello-to-java-and-scala/

And now we have a very simple yet functional RSS parser.

Happy coding,

This is normally how we read files in Java.First we open a reading stream, then read the content and process it,and at last we close the stream.

package com.justthor;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class SampleFileReader {

  /**
   * @param args
   */
  public static void main(String[] args) {
    BufferedReader in; 
    try {
      // Open file
      in = new BufferedReader(new FileReader("test.txt"));
          String str;
       
          // Start reading
          while ((str = in.readLine()) != null) {
        // Print the content
        System.out.println(str);
          }
          
          // Close the stream
          in.close();
      } catch (IOException e) {
        e.printStackTrace();
      }
  }
}

With some third party libraries, such as Apache Common Io, we can simplify the code to something like this.

package com.justthor;

import java.io.File;
import java.io.IOException;
import java.util.List;

import org.apache.commons.io.FileUtils;

public class SampleFileReader {

  /**
   * @param args
   */
  @SuppressWarnings("unchecked")
  public static void main(String[] args) {
    try {
      List<String> contents = FileUtils.readLines(new File("test.txt"));
      for ( String content : contents ) {
        System.out.println(content);
      }
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
  }
}

Well, it does look a bit simple now compare to the previous version. But we only manage to type 1 or 2 lines less than the previous version. This is due to we are force to handle the checked IOException. What if we try to achieve the same thing using Scala?

package com.justthor

import scala.io.Source

object SampleFileReader {
 def main(args : Array[String]) = {
  Source fromFile("test.txt") getLines foreach { println }
 }
}

Its much simple, right? Scala provides an util for IO named Source. This util read the file and get the contents by calling getLines method. This getLines method returns a Iterator[String]. And from there we can process the content by looping the returned iterator. We can use Source util to do more than reading files. I will provide more examples in the next few posts.

Happy coding.

Here’s the code

// Import JDBC package from standard Java SDK
import java.sql.{Connection, DriverManager, ResultSet};

class DataReader {
  // Load the driver
  Class.forName("com.mysql.jdbc.Driver").newInstance;

  val connection = DriverManager getConnection "jdbc:mysql://localhost:3306/mail?user=root&password=&characterEncoding=UTF8"

  def startReadingData(){
    try{

      // Create statement for readonly
      val statement = conn createStatement (ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY)

      val rs = statement executeQuery "select * from mail_queues order by id"

      // Looping resultset
      while (rs next) {
      println (rs getLong "id")
      }

      statement close
    }catch {
      case e => e printStackTrace
    }finally {
      connection close
    }
  }

}

Ok, you maybe wondering,why are so many dots(.) and parentheses missing?In Scala,when you are invoking one function with no or one parameter, you can omit the dot and parentheses. And Scala doesn’t have checked exception, which means you can write the above code without enclosed it with try…catch clause.I included it to make sure the DB connection is properly closed after use.

Happy coding.:)

1.Make sure you have Java installed. Fire up a command line window and type “java -version”, if you have installed Java, you should be able to see the Java version message displayed.

2.Download Scala from http://www.scala-lang.org/downloads . The latest stable version is 2.7.5 as this post is written.

3.Unzip the file and put in, let’s say “c:\dev\scala”.

4.Add a new environment variable named “SCALA_HOME” and the value is “c:\dev\scala”.

5.In your “PATH” environment variable, append the following at the end of the line “%SCALA_HOME%\bin”.

6.Fire up another command line window and type “scala”. You should be able to see the following message.

Welcome to Scala version 2.7.5.final (Java HotSpot(TM) Client VM, Java 1.6.0_14).
Type in expressions to have them evaluated.
Type :help for more information.
scala>

Happy coding.

This is how we do in Java.

public class Hello {
 public static void main(String[] args) {
  System.out.println("Hello world");
 }
}

object Hello {
 def main(args : Array[String]) = println("Hello world")
}

Java style

public class HelloArgument {
 public static void main(String[] args) {
  for (String arg : args) {
   System.out.println("Hello, " + arg);
  }
 }
}

Scala style

object HelloArgument {
 def main(args : Array[String]) = args.foreach(arg => println("Hello, " + arg))
}

Pretty impressive,huh?Comparing Java,we are actually writing less and more readable code in Scala,and the results are the same.

Happy coding.