jsf hibernate and Spring Enterprise Web Application

http://www.javaworld.com/javaworld/jw-07-2004/jw-0719-jsf.html?page=1

Build a real-world Web application with JavaServer Faces, the Spring Framework, and Hibernate

By Derek Yang Shen, JavaWorld.com, 07/19/04

Son derece güzel ve faydalı bir makale. Temel Tasarım Prensiplerine dikkat edilerek oluşturulmuş bir web enterprise şablon uygulaması içeriryor.

JPA Ve Hibernate

JPA ve Hibernate

Aslında JPA ve Hibernate farklı şeylerdir. JPA bir Persistence API dir. Implementasyon içermez.Hibernate ise bir persistence layer implementasyonudur. JPA dan önce direk hibernate kullanıyorduk ve hibernate kütüphanelerine bağımlıydık. JPA bir JEE standardıdır ve ek bir library eklememize gerek kalmaz. Uygulamamızdan JPA ya referanslar yazarız. Doğrudan Hibernate kütüphanelerine referans yazmayız. Sonuçta uygulamamız bir implementasyon kütüphanesine bağımlı olmaz. JPA+Hibernate şeklinde yazdığımız bir uygulamayı çok rahatlıkla JPA+EclipseLink yada bir başka implemantasyon setine çevirebiliriz. Kodlarımızda bir bağımlılık olmadığından refactor yapmamız gerekmez. Bu konuda bazı makale ve Tutoriallar:

http://www.theserverside.com/tutorial/Hibernate-35-Without-Hibernate-Ridding-Your-Code-of-the-Hiberante-API-Calls

http://netbeans.org/kb/docs/web/hibernate-jpa.html

JSF 2.0 Tutorial with Netbeans

Çok Faydalı bir JSF 2.0 eğitimi.

http://netbeans.org/kb/docs/web/jsf20-crud.html#createDB

Core Design Patterns: Abstract Factory Pattern

Abstract Factory Pattern: Bu paternin yaptığı iş bir çok değişik factory objesini encapsule etmekdir. Creation ile ilgili bir patterndir. Kullanımı şöyledir. Client uygulama abstract factory classından somut bir obje yaratır. Ve bu objenin genel methodlarını kullanır. Client uygulama alt seviyede yaratılan objenin hangi obje olduğunu bilmez. Bu pattern bir obje kümesinin implementasyon ayrıntıları ile genel kullanımını birbirinden ayırır.

Örnek Kod:

Button.java
package factory;
abstract class Button
{
public abstract void paint();
}

OSXButton.java
package factory;
class OSXButton extends Button
{
public void paint()
{
System.out.println("I'm an OSXButton: ");
}
}

WinButton.java
package factory;
class WinButton extends Button
{
public void paint()
{
System.out.println("I'm a WinButton: ");
}
}

GUIFactory.java
package factory;
abstract class GUIFactory
{
public static GUIFactory getFactory()
{
//int sys = readFromConfigFile("OS_TYPE");
int sys=1;
if (sys == 0)
{
return new WinFactory();
}
else
{
return new OSXFactory();
}
}

public abstract Button createButton();
}

OSXFactory.java
package factory;
class OSXFactory extends GUIFactory
{
public Button createButton()
{
return new OSXButton();
}
}

WinFactory.java
package factory;
class WinFactory extends GUIFactory
{
public Button createButton()
{
return new WinButton();
}
}

Application.java
package factory;
public class Application
{
public static void main(String[] args)
{
//GUIFactory içindeki int sys=1 satırı int sys=0 yapılırsa winButton üretilir.
GUIFactory factory = GUIFactory.getFactory();
Button button = factory.createButton();
button.paint();
}
// Output is either:
// "I'm a WinButton:"
// or:
// "I'm an OSXButton:"
}

UML Of Abstract Factory Pattern

Core Design Patterns: Decorator Pattern

Decorator Pattern: run time da var olan obje yada objelere yeni davranış şekilleri eklemek için kullanılır. Bu pattern bir tür subclass işlemidir ancak extend işlemi compile time da değil runtime da yapılmaktadır. Bu da ekstra flexibility kazandırır.

Decorator pattern bir decorator objesinin diğer bir objeyi wrap etmesi şeklinde yapılır. Ve bu genelde decorator objesinin constructorına diğer objenin parametre olarak girmesi ile sağlanır.

Örnek Kod:

DecoratedWindowTest.java
package decoratorPattern;

public class DecoratedWindowTest {
public static void main(String[] args) {
// create a decorated Window with horizontal and vertical scrollbars
Window decoratedWindow = new HorizontalScrollBarDecorator (
new VerticalScrollBarDecorator(new SimpleWindow()));

// print the Window's description
System.out.println(decoratedWindow.getDescription());
}
}

HorizontalScrollBarDecorator.java
package decoratorPattern;
// the second concrete decorator which adds horizontal scrollbar functionality
class HorizontalScrollBarDecorator extends WindowDecorator {
public HorizontalScrollBarDecorator(Window decoratedWindow) {
super(decoratedWindow);
}

public void draw() {
drawHorizontalScrollBar();
decoratedWindow.draw();
}

private void drawHorizontalScrollBar() {
// draw the horizontal scrollbar
}

public String getDescription() {
return decoratedWindow.getDescription()
+ ", including horizontal scrollbars";
}
}

SimpleWindow.java
package decoratorPattern;

// implementation of a simple Window without any scrollbars
class SimpleWindow implements Window {
public void draw() {
// draw window
}

public String getDescription() {
return "simple window";
}
}

VerticalScrollBarDecorator.java
package decoratorPattern;

// the first concrete decorator which adds vertical scrollbar functionality
class VerticalScrollBarDecorator extends WindowDecorator {
public VerticalScrollBarDecorator(Window decoratedWindow) {
super(decoratedWindow);
}

public void draw() {
drawVerticalScrollBar();
decoratedWindow.draw();
}

private void drawVerticalScrollBar() {
// draw the vertical scrollbar
}

public String getDescription() {
return decoratedWindow.getDescription()
+ ", including vertical scrollbars";
}
}

Window.java
package decoratorPattern;

// the Window interface
interface Window {
public void draw(); // draws the Window
public String getDescription(); // returns a description of the Window
}


WindowDecorator.java
package decoratorPattern;

// abstract decorator class - note that it implements Window
abstract class WindowDecorator implements Window {
protected Window decoratedWindow; // the Window being decorated

public WindowDecorator(Window decoratedWindow) {
this.decoratedWindow = decoratedWindow;
}
}

UML Of Decorator Pattern

Core Design Patterns: Command Pattern

Command Pattern: Actionları objeye encapsule etme yönteminin adıdır. Her bir action bir object olarak düşünülür. Bu sayede yeniden kullanabilme, loglayabilme, undo v.s. bir çok vantaj sağlamaktadır.

Örnek Kod:
/*
The Design Patterns Java Companion

Copyright (C) 1998, by James W. Cooper

IBM Thomas J. Watson Research Center

*/

package CommandPattern;

import java.awt.Button;
import java.awt.Color;
import java.awt.FileDialog;
import java.awt.Frame;
import java.awt.Menu;
import java.awt.MenuBar;
import java.awt.MenuItem;
import java.awt.Panel;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class ActionCommand extends Frame {
Menu mnuFile;

MenuItem mnuOpen, mnuExit;

Button btnRed;

Panel p;

Frame fr;

//-----------------------------------------
public ActionCommand() {
super("Frame without commands");
fr = this; //sae cop of this frame
MenuBar mbar = new MenuBar();
setMenuBar(mbar);

mnuFile = new Menu("File", true);
mbar.add(mnuFile);

mnuOpen = new MenuItem("Open...");
mnuFile.add(mnuOpen);
mnuExit = new MenuItem("Exit");
mnuFile.add(mnuExit);

mnuOpen.addActionListener(new fileOpen());
mnuExit.addActionListener(new fileExit());

btnRed = new Button("Red");
p = new Panel();
add(p);
p.add(btnRed);

btnRed.addActionListener(new btnRed());
setBounds(100, 100, 200, 100);
setVisible(true);
}

//-----------------------------------------
private void exitClicked() {
System.exit(0);
}

//-----------------------------------------
static public void main(String argv[]) {
new ActionCommand();
}

//=====----====--inner classes---=====----
class fileOpen implements ActionListener {
public void actionPerformed(ActionEvent e) {
FileDialog fDlg = new FileDialog(fr, "Open a file", FileDialog.LOAD);
fDlg.show();
}
}

//-------------------------------------
class btnRed implements ActionListener {
public void actionPerformed(ActionEvent e) {
p.setBackground(Color.red);
}
}

//-------------------------------------
class fileExit implements ActionListener {
public void actionPerformed(ActionEvent e) {
System.exit(0);
}
}
}
//=====================================

Core Design Patterns:Facade Pattern

Facade Pattern bir nesne merkezli tasarım paternidir.Facade in kelime anlamı maske , önyüz anlamındadır. Bir facade nesnesi büyük, karmaşık bir kod bloğuna yada bir sınıf kütüphanesine basit bir arayüzdür. Yani karmaşık kütüphanelerin client tarafından kolay kullanımı sağlar.


FacadeSınıfı
package facadePattern;
import java.text.*;
import java.util.*;
/** "Façade" */
class UserfriendlyDate
{
Calendar cal = Calendar.getInstance();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

public UserfriendlyDate (String isodate_ymd) throws ParseException {
Date date = sdf.parse(isodate_ymd);
cal.setTime(date);
}

public void addDays (int days) {
cal.add (Calendar. DAY_OF_MONTH, days);
}

public String toString() {
return sdf.format(cal.getTime());
}
}


Client Code:
package facadePattern;
import java.text.ParseException;
class FacadePattern
{
public static void main(String[] args) throws ParseException
{
UserfriendlyDate d = new UserfriendlyDate("1980-08-20");
System.out.println ("Date: " + d);
d.addDays(20);
System.out.println ("20 days after: " + d);
}
}

UML of Façade Pattern