Now for this application, as I wrote it in a matter of days and released it the day of schedule releases, I had to go with a language I knew very well, and I had to have a reliable, dependable source to host it at. I automatically though of the Google App Engine as it is pretty sweet to play around with and now would be a great time to test it in a live environment. My previous application I had wrote on Google’s free, scalable engine was written in Python. It utilized the amazing Django framework, but I felt like I didn’t really understand the Python language as well as some others. The only other option for selection on the App Engine was Java. This was perfect as I had just completed a summer class on Java and it was extremely fresh in my mind.

Core Java Servlets

Now coming from PHP for web development the idea of Servlets and JSP’s was totally a different way of thinking. With PHP I was used to putting what code I needed to on each page to achieve what needed to be done. With a bit of Python/Django experience, Java’s way was still different, but not as different as PHP to Java. Java’s JSP method reminded me a lot of Django templates, except that JSP’s are a load more powerful. As Django templates (at least from my experience) only allow a few tags, a JSP allows practically any Java code (that would normally go inside a main method) and allows imports and special features unique to JSP’s, like includes. JSP’s includes in fact reminded me some more of Django’s templates with all the splitting up possible of the HTML files.

Now that we briefly know what a JSP is, a servlet is just like a Java class that implements the standard Apache servlet. Within these servlets you have two methods by default doGet(HttpServletRequest req, HttpServletResponse resp) and doPost() with the same arguments. There are a few differences from a standard Java class beyond those previously noted:

resp.getWriter().println(); // to print to the screen you must get the PrintWriter via the resp.getWriter() method
resp.setContentType("text/html"); // must do if you print out any HTML and don't want it to appear as standard text
resp.sendRedirect(String url); // a simple way to send a user to be redirected

There is (obviously) no console input on a web browser, so the standard way to get input via the web is through GET and POST methods. These are handled via the corresponding doGet() and doPost() methods. Now to actually get the value passed, you must know the variable name and use it accordingly.

req.getParameter(String paramName); // where paramName is the ?name=Joe&age=18 name or age

Sometimes you will also find yourself in need of getting an array, from say a multiple choice drop down.

req.getParameterValues(String paramName); // just once and it will return a String[]

Now onto more of the theory behind servlets, and less of the syntax. Now please remember when I say theory, this is just the way I perceive it. In my application if I would have a full blown HTML page, I would always put it in a JSP as it is so simple and better looking. However when there was a simpler page that had a bit more code behind it, I would make that a servlet. An example of a simpler page with more code that I used as a servlet would be my form handlers (any adding or updating interaction with the database), and also I handled the OAuth authentication with servlets.

JSP’s

JSP’s, or Java Server Pages, are a mix between Java code & client-side scripting. It allows you to mix the power of Java and your the models in your MVC framework with the simplicity of a HTML file. You probably see them all over the web, as they are quite effective, especially in larger businesses and universities.
I have not personally gone that far into all the powers of JSP’s but enough to know that I like them. I am not going to try and write a tutorial but just point out a few things I use and a good tutorial or two.
Now one of the simplest, but greatest is the server-side include of static content. This allows you to keep your web pages on the server side leaner and able to easily change base things like headers or footers.

<%@ include file="/include.html" %>

Other useful things to know, if you need to get any parameters or need to mess with the request or response, they are simply called request and response in all JSP’s. So you could use a request.getParameter("id"); for example.
If you need to write anything to the page from within the Java code just throw a out.println(String value); or out.print(String value).

For anything more than what I included check Google for some JSP tutorials or here is a good looking one.

Benefits

I see there being several benefits of using Java as the language behind more complex applications because of it is an object oriented language. It being OO allows code to get so many more times complex. Now, in web development at least, a OO language is only as good as the database that supports it . I happened to be very lucky with Google App Engine as it was powered by a OO database allowing me to store some of my unique data types like “Student”, “Teacher”, “Course”, and “Schedule” in the database and retrieve it like it has been open since it was created. Most of the interface for this was provided in the JDO classes in javax.JDO.
With this and a few classes for getting and selecting certain Students/Teachers/Courses, it was very easy to get exactly the results I want in a few lines of code in a JSP. And I know that in Python and PHP you can have classes and objects, but it’s just not the same as it is in Java. While Java can be pretty strict with it’s types and defining them, it in turn gives a lot of power to create awesome and dynamic applications for the end user.

Finally

As I have been reading in my “Clean Code” book, it is better to take longer and write software better the first time. Better being Javadoc’d and Object-Oriented. If you were to write it the other way, with say PHP or Python and have each script access the relational database, get the results, sort the results into the data you need, and output it correctly, that is so much code duplication. One script could be anywhere from 20% – 50% of the same code over and over, why not just write it great in the beginning in an OO way so the only code duplication you have is one or two lines to load the pre-written-by-you libraries that does all that work in one place, one time.

And sorry Brent I think I like Java Servlets & JSP’s a wee bit more than Python/Django even though I think Django is a great framework and would love if it were written in Java instead, Python just isn’t as big and powerful as Java.

I do not see the “Hello World” that intimidating anymore, for the single reason is that I know what and why all those words are there at the beginning of the file, and the best way for you to get into it is to understand it.

public class HelloWorld {

    public static void main(String[] args) {

        System.out.println("Hello World");

    }

}

The first line is public class HelloWorld. public simply means that from anywhere and by anybody this class can be called. The class simply means that it is a class, as all beginning files in Java will be. The HelloWorld I think should be pretty easy to understand. The second line, public static void main(String[] args)... is a bit more complicated. The public meaning that this method can be called from outside this class. static means that this method can be called without initializing the whole class as an object. void simply means that it returns no value, as methods in the future might, like int or boolean. The next part, main means that this method should be run whenever this program is run, for any Java program to run, there must be a main method. String[] args is probably the strangest part, String is a line of characters, like a word, sentence, anything really. In Java, this [] mean an array, so String[] args means that for it’s parameters it takes an array of Strings. However you won’t deal with this for a while in your Java career. System.out.println... breaks down to System, which is a package (a folder full of classes) and out is a class within the package that deals with output. Finally println is a method (function) which prints the line.

Understanding Strings

Ever wondered why in Java, you see things like int and double and they are lower-cased, but String is capitalized? All class names in Java are capitalized, and so must String be.

String myname = "Jordan";

You are creating a new object (unique version of a class) of the class String. With strings you can do so much more than a primitive type (int, boolean, short, etc.). As myname is an object, it has methods that uniquely work with it.

System.out.print(myname.length()); // prints number of chars in myname

System.out.print(myname.charAt(4)); // prints ‘a' for the 5th char in it

There are many more options, but that will do for examples of how this is an amazing way to store Strings.

More on Classes and Objects

To help you differentiate between classes and objects, I offer the following example.

MathOps.factorial(5); // uses the class MathOps and static method factorial()

MathOps math = new MathOps();

math.factorial(5); // uses the unique object

// another example that shows benefits

ShoppingCart cart1 = new ShoppingCart();

ShoppingCart cart2 = new ShoppingCart();

cart1.add("blanket");

cart1.add("shampoo");

cart2.add("ice cream");

cart1.remove("shampoo");

System.out.println(cart1.list());

System.out.println(cart2.list());

Yes, I have not actually made any of those classes, but those were just for examples, see with the ShoppingCart example, you saw exactly the benefits of the different objects as opposed to storing them in one big class where it would get all mixed up together.

User Input & Reading Files

It is quite strange, but in Java these are EXTREMELY similar so they shall be grouped together. To read user input in Java, one must first look for it.

Scanner s = new Scanner(System.in);

Scanner is a great class. I used to oppose it, but now seeing it’s virsitility, it’s a great class. Anyways what this says is create a new object named “s” that reads System input. To get a line of input is as easy as s.nextLine();

System.out.print("Please enter your name: ");

String name = s.nextLine();

System.out.println("Hello " + name);

Now the reason it was grouped with reading files is because if you want to ready a file, just tell Scanner so.

Scanner s = new Scanner(new File("filename.txt"));

while(s.hasNext()) { // hasNext() returns true as long is there more lines

    System.out.println(s.nextLine());

}

That would print out every line of the file. It is just like reading input, just a different start.

Loops and If’s

If your familiar with PHP this is extremely easy and only requires a paragraph or two.

boolean a  = true;

if(a) {

    // then do this

} else if(!a) {

    // then do this, notice the space between else and if not elseif

} else {

    // else do this

}

if(a) {

    // one line only can use this format

} else {

    // same for loops too

}

for(int i = 0; i < 10; i++) // you can use {} if you want

    System.out.println(i);

while(true) {

    // infinite loop

}

Good Things to Know

Integer.parseInt("123"); // can take a string (like user input) and convert it

Double.parseDouble("2.3"); //ditto

String b = "hey";

b.charAt(0); // gets the a (parameter) character from a string

Conclusion

With just that basic two to three page intro, you should be pretty set. Using just the things desribed here, you can do just about anything text-based. If you want to start working with GUI’s you’ll have to go to google and find a nice tutorial on how to do that. It’s more work, but it is just an extension of this sort of thing.

Glossary

Method (Java) ~ Function (PHP)

Int ~ Medium ranged integers

Double ~ For numbers with a decimal

Boolean ~ True or false

Eclipse gives you that option, to easily and simply get everything you need, and nothing more. In my verrsion of Eclipse I start with Eclipse PDT, which stands for PHP Development Tools. It comes with the Web Tools Platform which includes Server Tools and an Ajax Framework. So now that I have my base setup, I will install some plugins via the handy-dandy and simple update manager in Eclipse. The first plugin is Subclipse which is a nifty Subversion client to go with the built in CVS client. Also to go with PHP I add Python support with PyDev and lastly I have SFTP support incase I need to jump onto a server and change something so I use JCrafts SFTP plugin for that.

Some tools I have read about that sound cool, and interesting, but I have personally never used are Zends Community Server Edition and their PHP Debugger, which both perfectly integrate with the Tools in PDT. And if you need anymore tools just Google it, I bet you someone has made a plugin for it. Thats what great about Eclipse, you build it, your way.

UPDATE

I tried something new today, I hadn’t been liking JCrafts SFTP plugin, it required me to export updates everytime I saved so I would use a built in “Remote Systems Explorer“. That had some errors in my PDT installation so I went and got a standard Java version from Eclipse.org, and installed RSE on the regular version. Now to get my PHP tools back follow the steps here to get the PHP tools on your version. And continue on like normal! This SFTP client is a one that works just like it’s a project instead of having to do a lot of work. Also Remote Systems Explorer does a lot more like Shell and stuff… garsh now it’s starting to sound like Coda.