亚洲AV成人无码天堂,亚洲AV无码国产丝袜在线观看,日韩精品成人亚洲专区

Fri, 25 Apr 2008 08:07:00 GMT

�q�接各种数据库方式速查�?br />
下面�|�列了各�U�数据库使用JDBC�q�接的方式，可以作�ؓ一个手册��用�?

1、Oracle8/8i/9i数据库（thin模式�Q?

Class.forName("oracle.jdbc.driver.OracleDriver").newInstance();
String url="jdbc:oracle:thin:@localhost:1521:orcl"; //orcl为数据库的SID
String user="test";
String password="test";
Connection conn= DriverManager.getConnection(url,user,password);

2、DB2数据�?

Class.forName("com.ibm.db2.jdbc.app.DB2Driver ").newInstance();
String url="jdbc:db2://localhost:5000/sample"; //sample��Z��的数据库�?nbsp;
String user="admin";
String password="";
Connection conn= DriverManager.getConnection(url,user,password);

3、Sql Server7.0/2000数据�?

Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver").newInstance();
String url="jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=mydb";
//mydb为数据库
String user="sa";
String password="";
Connection conn= DriverManager.getConnection(url,user,password);

4、Sybase数据�?

Class.forName("com.sybase.jdbc.SybDriver").newInstance();
String url =" jdbc:sybase:Tds:localhost:5007/myDB";//myDB��Z��的数据库�?nbsp;
Properties sysProps = System.getProperties();
SysProps.put("user","userid");
SysProps.put("password","user_password");
Connection conn= DriverManager.getConnection(url, SysProps);

5、Informix数据�?

Class.forName("com.informix.jdbc.IfxDriver").newInstance();
String url = "jdbc:informix-sqli://123.45.67.89:1533/myDB:INFORMIXSERVER=myserver;
user=testuser;password=testpassword"; //myDB为数据库�?nbsp;
Connection conn= DriverManager.getConnection(url);

6、MySQL数据�?

Class.forName("org.gjt.mm.mysql.Driver").newInstance();
String url ="jdbc:mysql://localhost/myDB?user=soft&password=soft1234&useUnicode=true&characterEncoding=8859_1"
//myDB为数据库�?nbsp;
Connection conn= DriverManager.getConnection(url);

7、PostgreSQL数据�?

Class.forName("org.postgresql.Driver").newInstance();
String url ="jdbc:postgresql://localhost/myDB" //myDB为数据库�?nbsp;
String user="myuser";
String password="mypassword";
Connection conn= DriverManager.getConnection(url,user,password);

8、access数据库直�q�用ODBC�?br />

Class.forName("sun.jdbc.odbc.JdbcOdbcDriver") ;
String url="jdbc:odbc:Driver={MicroSoft Access Driver (*.mdb)};DBQ="+application.getRealPath("/Data/ReportDemo.mdb");
Connection conn = DriverManager.getConnection(url,"","");
Statement stmtNew=conn.createStatement() ;

《�{�?/span>

月芽�?/a> 2008-04-25 16:07 发表评论

Sun, 04 Nov 2007 14:03:00 GMT

资料攉��于互联网�Q�如有不妥，请告之）、个人心得�?/span>

1.默认的��Q点类型是双精度（double�Q�，要想要一个float必须在��Q�Ҏ��后面加F或者f。如�Q�float pi = 3.14;是错误的

2.��点型�{化�ؓ整型�Ӟ��不进行四舍五入，直接截断��数点后面的�?Java的类型检查很严格�Q�从低精度�{换到高精度是无须昑ּ�转换的，double d = 123;。但是反�q�来�Q�进行窄化�{换，由高�_�ֺ�向低�_�ֺ��Q�或者一�U�类型到另一�U�类型，则必��M��用强制类型�{化�?br />
3.在数�l�声明中包含数组长度永远是不合法的！如：int[5] arr; 。因为，声明的时候�ƈ没有实例化�Q何对象，只有在实例化数组对象�Ӟ��JVM才分配空��_��q�时才与长度有关�?br />
4.对象�c�d��的数�l�虽然被默认初始化了�Q�但是�ƈ没有调用其构造函数。也��是��_��Car[] myCar = new Car[10];只创��Z��一个myCar数组对象�Q��ƈ没有创徏Car对象的�Q何实例！�q�与单纯的new一个对象不同！单个的new对象�Ӟ��׃��调用相应的构造函数�?br />
5.数组有length属性，字符串有length�Q�）�Ҏ��

6.String中的每个字符都是一�?6位的Unicode字符�Q�用Unicode很容易表达丰富的国际化字�W�集�Q�比如很好的中文支持。char中可以保存一个中文汉字，应�ؓchar也是一�?6位的Unicode字符度�ؓ0�?br />
8.String对象是不变的�Q�可以变化的是String对象的引用�?br />
9.String的不变性的机制昄��会在String帔R��内有大量的冗余。如�Q?1" + "2" + "3" +......+ "n" 产生了n+(n+1)个String对象�Q�因此Java��Z��更有效地使用内存�Q�JVM留出一块特�D�的内存区域�Q�被�U�Cؓ“String帔R��?#8221;。对 String多么照顾啊！当编译器遇见String帔R��的时候，它检查该池内是否已经存在相同的String帔R��。如果找刎ͼ��把新常量的引用指向现有�?String�Q�不创徏��M��新的String帔R��对象�?br />
10.java中的对象是在堆中被创建的�Q�new�Q�，但常量类的String有点特别�Q�像“haha”�q�样的字�W�串�Ҏ��W?条是存放在String帔R��池的�Q�而String s=new String("haha");��实在堆中被创徏的�?br />
11.throw和throws关键字。throw用在�Ҏ��体中抛出异常�Q�后面是一个具体的异常对象。throws用在�Ҏ��参数列表括号的后面，用来声明此方法会抛出的异常种�c�，后面跟着一个异常类�?br />
12.要把相应的System.out和System.err信息输入到文件中。代码：

        try   {
            System.out.println("没上");
            System.setOut(new   PrintStream(new   FileOutputStream(new   File( "c:/test.txt "))));
            System.out.println( "haha ");
            System.out.println("error");
        }   catch   (Exception   e)   {
            e.printStackTrace();
        }

err的吧setOut改�ؓsetErr��可以了�?br />

月芽�?/a> 2007-11-04 22:03 发表评论

Thu, 11 Oct 2007 07:50:00 GMT

一、在web.xml中配�|�Spring容器的启�?nbsp;�Q�通用的方法）

<context-param>
 <param-name>contextConfigLocationparam-name>
 <param-value>/WEB-INF/classes/applicationContext.xmlparam-value>
 //如有多个spring配置文�g用逗号隔开
context-param>

<listener>
 <listener-class>org.springframework.web.context.ContextLoaderListenerlistener-class>
listener>

二、struts1的启动方�?br />

<plug-in className="org.springframework.web.struts.ContextLoaderPlugIn">
<set-property property="contextConfigLocation" value="/WEB-INF/applicationContext.xml,
/WEB-INF/action-servlet.xml" />
plug-in>

<�?gt;

月芽�?/a> 2007-10-11 15:50 发表评论

Thu, 11 Oct 2007 02:19:00 GMT

ActionServlet �c�d��应的�c�d��?/span>org.apche.struts.action.ActionServlet�Q�它�?/span>struts框架的核心控制器�l��g�Q�所有用��L��h��都先�?/span>ActionServlet来处理，然后再由ActionServlet把请求�{发给其他�l��g�?/span>
Struts只允�怸�个应用中配置一�?/span> ActionServlet�Q�但是可以将ActionServlet扩展�?/span>
Servlet容器在启动时�Q�或者用户首�ơ请�?/span>ActionServlet时加�?/span>ActionServlet�c�，在上�q�情况下�Q?/span>Servlet容器都会�?/span>ActionServlet被加载后立即执行它的init()�Ҏ��?/span>Init()�q�程如下�Q?/span>
　　1.调用initInternal()�Ҏ��Q�初始化struts框架内在的消息资源，如与�pȝ��日志相关的通知、警告和错误信息�?/span>
　　2.调用initOther()�Q�从web.xml文�g中加�?/span>ActionServlet的初始化参数�Q�如config 参数
　　3.调用initServlet(),�?/span>web.xml文�g中加�?/span>ActionServlet�?/span>URL映射信息。此外还会注�?/span>web.xml�?/span>
struts配置文�g所使用�?/span>DTD文�g�Q�这�?/span>DTD文�g用来验证web.xml�?/span>struts配置文�g的语�?/span>
　　4.调用initModuleConfig()�Q�加载�ƈ解析默认子应用模块的struts配置文�g�Q�创�?/span>ModuleConfig对象�Q�把它存�?/span>ServletContext�?/span>
        5.调用intiModuleMessageResources()�Q�加载�ƈ初始化默认子应用模块的消息资源，创徏
MessageResources对象�Q�把它存�?/span>ServletContext�?/span>
        6.调用initModuleDataSources()�Ҏ��Q�加载�ƈ初始化默认子应用模块的数据源。如果没有在struts配置文�g中没有定�?/span>元素�Q�就忽略�q�一��程
         7.调用initModulePlugins(),加蝲�q�初始化默认子应用模块的所有插�?/span>
         8.当默认子应用模块被成功初始化后，如果应用�q�包括其他子应用模块�Q�将重复��程4-7�Q�分别对其他子应用模块进行初始化。扩�?/span>ActionServlet�c�，定义如下的类�Q?/span>

package sample;

public class ExtendedActionServlet extends ActionServlet {
        public void init() throws ServletException {
               super.init();
               //do some operations
               ……………
        }
}

扩展完类后，�q�应该在web.xml文�g中如下配�|�：

<servlet>
 <servlet-name>sampleservlet-name>
<servlet-class>sample.ExtendedActionServletservlet-class>
servlet>
<servlet-mapping>
 <servlet-name>sampleservlet-name>
 <url-pattern>/action/*

//上面�?action/*表示负责处理所有以/action为前�~�的URL,后面�?表示转义

<�?/span>>

月芽�?/a> 2007-10-11 10:19 发表评论

Wed, 10 Oct 2007 08:46:00 GMT

当一个复杂的对象被构造时,它的构造函数按下面的顺序被调用(that the order of constructor calls for a complex object is as follows)

1.其基�c?base-class)的构造函数被调用,�q�个步骤以递归的方式重�?所以最底层(the root of hierarchy)的构造函数首先被执行,然后是它上一层派生类(the next-derived class)...直到最��层的派生类(the most-derived class).

The base-class constructor is called. This step is repeated recursively such that the root of the hierarchy is constructed first, followed by the next-derived class, etc., until the most-derived class is reached.)

2.如果有包含关�p?composition),那么它的成员对象按照声明的顺序被构�?

Member initializers are called in the order of declaration.

3.�z��c�L��造函数的内容(body)被执�?

The body of the derived-class constructor is called.

一个实�?

class Cake{
   Cake(){System.out.println("Cake()");}
}

class Meal {
  Meal() { System.out.println("Meal()"); }
}

class Bread {
  Bread() { System.out.println("Bread()"); }
}

class Cheese {
  Cheese() { System.out.println("Cheese()"); }
}

class Lettuce {
  Lettuce() { System.out.println("Lettuce()"); }
}

class Lunch extends Meal {
  Lunch() { System.out.println("Lunch()"); }
}

class PortableLunch extends Lunch {
   //if make derived-class object as the menber of the base-class will lead a infinite
   //loop and program will stop because of the memory consumed

   //private Sandwich s=new Sandwich();
  private Cake a=new Cake();
  PortableLunch() { System.out.println("PortableLunch()");}
}

public class Sandwich extends PortableLunch
{
  private Bread b = new Bread();
  private Cheese c = new Cheese();
  private Lettuce l = new Lettuce();

  public Sandwich() {
    System.out.println("Sandwich()");
  }

  public static void main(String[] args)  {
    new Sandwich();
  }
}

输出:

Meal()
Lunch()
Cake()
PortableLunch()
Bread()
Cheese()
Lettuce()
Sandwich()

main()函数中要构造一个Sandwich的对�?调用(�q�不是执�?它基�c�PortableLunch的构造函�?PortableLunch又�? 归的调用,然后是Meal,Meal是��承的最底层的基�c?不算Object)所以它的构造函数首先被执行,然后按次序返回到Lunch, PortableLunch,但在PortableLunch的构造函数被执行之前,它的成员对象Cake a先按照声明的��序被构�?然后执行PortableLunch(),接着是Sandwich的成员对�?最后是Sandwich().

�?被注释掉的代�?��base-class的对象作为derive-class的成员对�?�q�样会递归无法�l�束,最后程序因堆栈耗尽而结�?Exception in thread main java.lang.StackOverflowError).

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1134115(�?

月芽�?/a> 2007-10-10 16:46 发表评论

Subversion(SVN)版本控制安装使用指南

Mon, 17 Sep 2007 07:49:00 GMT

摘要: Subversion是近期在开源社��Z��非常��行的一�Ƅ��本控制��Y�Ӟ��它是CVS的替代��物�? 它的主要特征有： · CVS大部分的功能�?· 支持“目录”�U�别的版本管理，�q�且解决了CVS中迟�q�未能解决的文�g重命名和�U�d��{�问题。甚臛_��文�g或文件夹�?.. 阅读全文

月芽�?/a> 2007-09-17 15:49 发表评论

Wed, 12 Sep 2007 15:58:00 GMT

Introduction

This Tutorial will explain you, what struts is, how it builds itself up and why it is advantage to use it for your web application. First, I will provide you some informations about Java Servlets, Java Server Pages and Java Beans, because they are parts of struts.

Java Servlets

Servlets represents java programs that runs on a web server. They allow the developer to produce dynamic web sites with java.

A Servlet has the following tasks

It reads and processed data, which a user typed in a HTML form on a web page.
If necessary other informations will be processed. For Example what browser or system will be used.
It generate results with the existing data. It calls the business logic directly in the servlet or another class, which contain the logic or executes a database query.
The results will be formated. If the browser. If the Browser expects an answer in the HTML format, then the results must be formatted in accordance with the standard. It is possible to return different formats of data with a servlet. (gif, jpeg, doc, etc.).
Suitable answer parameters are set. Befor the servlet return the data to the browser, it sends some parameter. The parameter contains the format, that will returned by the servlet, what time the browser use to cache the site and some more.
Return the document, in the format that it sends befor, to the browser.

Java Server Pages (JSP)

JavaServer Pages (JSP) are text documents, which are similar to HTML Files. But you find also java code in the JSP File. JavaServer Pages allow you to mix regulare, static HTML with dynamic generated contents of servlets. The java code is inserted in the HTML document on a JSP File, differently to a servlet, where the HTML code is embedded in the java code.

Java Beans

Java Beans are nothing else as classes, which keep a fixed naming convention, defined by Sun, for their event processing and methods. The attributes (variables) of the java beans are private. The access to these attributes is managed by access methods. The java specification specify these access methodes (getter and setter methods). If a java bean contains a attribute name, you can set or get the value of the attributes with the methode setName() or getName().

Business logic

The business logic is the core of the application. The processes are implemented in the business logic to manage the data. For Example: when someone borrows a book in a library, that is a process in the business logic. The process change the state of the data (is the book borrowsed or not) or reads the state and then provide this information for a dialog.

This short outline should be sufficient, in order to understand the structure of struts.

Why is struts helpful?

Sepration of dialogs and business logic (functionality)

Some peoples develop web applications with Perl or PHP and implement their SQL Querys and the business logics directly in the HTML document.

The source code looks like the following example:

<html><head><title>Important titletitle>head>
<body>
<someScript>
dbConnection = openDBConnection(someDB)
resultSet = dbConnection.executeQuery('select bookName from books')
loop over resultSet{
print (resultSet.field('bookName') + '
')
}
someScript>
body>html>

You can develop in this way, when you use java servlets or JSP. It is convenient in small projects. But imagine you have 70 dialogs, many database querys in this dialogs and you want to define a field status, setting if a book is deleted or not.

Good luck

In order to alter functions and database querys easily, we should seperate these from the dialogs.

Advantage of separation

Changes on the functionality, without working in the dialogs.
Better overview, functionality not mixed with the dialogs.
Easy maintain a application
Different dialogs, but the same functionality

Central control

In order to control the interaction between the dialogs and business processes, you need a central control unit. This control unit manage all importants courses of the application, when which business process and which dialog will be used.

You have some disadvantages, if you implement the order of the processes directly to the business logic.

You can not reuse a part of the processes. In the following picture the process "Give Money" will bring you to the process "Select sort of icecream" every time.
If you want to change the order of the processes or add more options, you have to change it directly in the business logic.

Advantages of the central control

It is easy to change the order of the business processes.
Better overview, which dialogs will be used on which business processes.
A central place to control the interaction between business processes and dialogs.

Translation into the technical language

The name of this model is Model-View-Controller (MVC)

Model (business logic / business processes ? Java Beans)

View (dialogs ? JavaServer Pages)

Controller (central control unit - Java Servlets)

You will find more about the MVC later in this tutorial.

More helpfully capabilities

Internationalisation

If you do not want to translate a dialog, you put the dialog texts directly into the JSP File.

<html:form action="someAction">
 Please give your name and the book title 
 Name:
<html:text property="name"/> 
 Title:
<html:text property="title"/> 
<html:submit/>
html:form>

Struts support resources files. In this files you can define a key for a text.

bookDialog.formIntro=Please give your name and the title of the book.
bookDialog.inputName=Name:
bookDialog.bookTitle=Title:

This key can be used to diplay the text in the JSP file.

<html:form action="someAction">
<bean:message key="bookDialog.formIntro"/> 
<bean:message key="bookDialog.inputName"/>
<html:text property="name"/> 
<bean:message key="bookDialog.bookTitle"/>
<html:text property="title"/> 
<html:submit/>
html:form>

Struts call the locale specific resource file by using the browser settings. You may overwrite this setting. It is quite easy to build an internationalized application with struts.

Error handling

Struts saves error messages in the business logic and can display this in the dialogs. You can show all errors or bind an error to a field (ex. Emailaddress incorrect) and show the error beside of it.

The error messages will be added to the resource files, so the errors can be internationalised too.

Validation of input fields

Whether an input field of a form contains a valid date, an email, a number or something else, in each application you have to check it. Struts supports a complete solution to validate form fields. You only have to define which form field will be checked and which error message will be displayed.

Components of struts

JavaServer Pages (JSP) take over the role of dialogs in struts,

Java Beans take over the business logic and business processes and

Java Servlets take over the central control unit

Thats why we talk about three great parts of struts.

Model (business logic / business processes ? Java Beans)

View (dialogs ? JavaServer Pages)

Controller (central control unit - Java Servlets)

The model represent the actual state of the application. Two kinds of java beans are used. There are java beans which contains the data of a form or data to display (ex. The books of a library) and java beans which includes the functionality of the application or call the business logic (when a user borrows a book).

The view component is responsible for the presentation of the data. The java server pages contain HTML, XML and Java Script, like a normal HTML site. Futhermore you can use java code. Struts provide tag libraries, a summary of functions, which can be use to prepare the data for displaying.

The last component is the controller. The controller manage the request of the web browser, which a user called by an address (URL). But also forward to an action which are execute and which dialogs will be used to display the informations.

The picture below illustrates the interaction between these components.

If the user sends a query with a browser, the controller(servlet) gets and processes this query. It decides which action will be called or to which view component it must be forward.

After the controller calls an action, the action can read data from a database and provide this data to the model component, java beans. The action (business logic) returns the "next step" to the controller. The controller checks what kind is the next step. (JSP View, next action, ...) and forwards to it.

The view component (JSP) reads the updated data from the model component and prepare this for the presentation. Then it sends the answer as HTML site back to the browser. The user sees the result of his query.

Struts configuration

Struts will be configured with various configuration files. The following files are very important.

web.xml

struts-config.xml

Struts-Tag-Bibliotheken

Properties-Dateien

The illustration will show you, on which places struts use the configuration files.

web.xml

With the web.xml you configure the web server for the struts application. In this file you can set where the web server find the struts-config.xml and some other global properties.

struts-config.xml

The controller calls the business logic or a view with a name. The allocation of the names to the action classes or JSP Files(Views) will be set in the struts-config.xml. The advantage is that you can change the definition of the Workflows (Action Mapping), without using the long class names everytime. If you change a class name, you only have to change the name in the struts-config.xml. You don´t update any other part of your application.

Struts-Tag-Libraries

The Struts-Tag-Libraries, a summary of functions, extends the functionality of JavaServer pages. They support the internationalisation (multi-language) of your web application, and the easy creation of form elements.

Properties files

This files will be used to keep the internationalized textes of your web application. You can create a seperated properties file for each language, which contain all textes of the application.

转自�Q�http://www.laliluna.de

月芽�?/a> 2007-09-12 23:58 发表评论

Wed, 12 Sep 2007 09:58:00 GMT

Hibernate的对象有3�U�状�?分别�?瞬时�?Transient)、持久�?Persistent)、脱��?Detached).处于持久态的对象也称为PO(PersistenceObject),瞬时对象和脱��对象也�U�CؓVO(ValueObject).

瞬时�?/strong>
由new命��o开辟内存空间的java对象,

eg.Person person=new Person("xiaoxiao","�?/span>");

如果没有变量对该对象�q�行引用,它将被java虚拟机回�?

瞬时对象在内存孤立存�?它是携带信息的蝲�?不和数据库的数据有�Q何关联关�p?在Hibernate�?可通过session的save()或saveOrUpdate()�Ҏ��瞬时对象与数据库相兌��,�q�将数据对应的插入数据库�?此时该瞬时对象�{变成持久化对�?

持久�?/strong>
处于该状态的对象在数据库中具有对应的记录,�q�拥有一个持久化标识.如果是用hibernate的delete()�Ҏ��,对应的持久对象就变成瞬时对象,因数据库中的对应数据已被删除,该对象不再与数据库的记录兌��.

当一个session执行close()或clear()、evict()之后,持久对象变成��q��对象,此时持久对象会变成脱��对�?此时该对象虽然具有数据库识别�?但它已不在HIbernate持久层的��理之下.

持久对象��h��如下特点:

1.和session实例兌��;

2.在数据库中有与之兌��的记�?

��q��?br /> 当与某持久对象关联的session被关闭后,该持久对象�{变�ؓ��q��对象.当脱��对象被重新兌��到session上时,�q�再�ơ�{变成持久对象.

��q��对象拥有数据库的识别�?可通过update()、saveOrUpdate()�{�方�?转变成持久对�?

��q��对象��h��如下特点:

1.本质上与瞬时对象相同,在没有�Q何变量引用它�?JVM会在适当的时候将它回�?

2.比瞬时对象多了一个数据库记录标识�?

《�{�?/p>

月芽�?/a> 2007-09-12 17:58 发表评论

Wed, 12 Sep 2007 08:22:00 GMT

This is a pattern for Data Access Objects with JDK 5.0, from the CaveatEmptor example application. It is also explained in the book Java Persistence with Hibernate. Two links you might find useful: Sessions and transactions and Open Session in View.

This time I based the DAO example on interfaces. Tools like Hibernate already provide database portability, so persistence layer portability shouldn't be a driving motivation for interfaces. However, DAO interfaces make sense in more complex applications, when several persistence services are encapsulate in one persistence layer. I'd say that you should use Hibernate (or Java Persistence APIs) directly in most cases, the best reason to use an additional DAO layer is higher abstraction (e.g. methods like getMaximumBid() instead of session.createQuery(...) repeated a dozen times).

The DAO interfaces

I use one interface per persistent entity, with a super interface for common CRUDfunctionality:

public interface GenericDAO<T, ID extends Serializable> {

 T findById(ID id, boolean lock);

 List<T> findAll();

 List<T> findByExample(T exampleInstance);

 T makePersistent(T entity);

 void makeTransient(T entity);
}

You can already see that this is going to be a pattern for a state-oriented data access API, with methods such as makePersistent() and makeTransient(). Furthermore, to implement a DAO you have to provide a type and an identifier argument. As for most ORM solutions, identifier types have to be serializable.
The DAO interface for a particular entity extends the generic interface and provides the type arguments:

public interface ItemDAO extends GenericDAO<Item, Long> {

 public static final String QUERY_MAXBID = "ItemDAO.QUERY_MAXBID";
 public static final String QUERY_MINBID = "ItemDAO.QUERY_MINBID";

 Bid getMaxBid(Long itemId);
 Bid getMinBid(Long itemId);

}

We basically separate generic CRUD operations and actual business-related data access operations from each other. (Ignore the named query constants for now, they are convenient if you use annotations.) However, even if only CRUD operations are needed for a particular entity, you should still write an interface for it, even it it is going to be empty. It is important to use a concrete DAO in your controller code, otherwise you will face some refactoring once you have to introduce specific data access operations for this entity.

An implementation with Hibernate

An implementation of the interfaces could be done with any state-management capable persistence service. First, the generic CRUD implementation with Hibernate:

public abstract class GenericHibernateDAO<T, ID extends Serializable>
 implements GenericDAO<T, ID> {

 private Class<T> persistentClass;
 private Session session;

 public GenericHibernateDAO() {
 this.persistentClass = (Class<T>) ((ParameterizedType) getClass()
 .getGenericSuperclass()).getActualTypeArguments()[0];
 }

 @SuppressWarnings("unchecked")
 public void setSession(Session s) {
 this.session = s;
 }

 protected Session getSession() {
 if (session == null)
 throw new IllegalStateException("Session has not been set on DAO before usage");
 return session;
 }

 public Class<T> getPersistentClass() {
 return persistentClass;
 }

 @SuppressWarnings("unchecked")
 public T findById(ID id, boolean lock) {
 T entity;
 if (lock)
 entity = (T) getSession().load(getPersistentClass(), id, LockMode.UPGRADE);
 else
 entity = (T) getSession().load(getPersistentClass(), id);

 return entity;
 }

 @SuppressWarnings("unchecked")
 public List<T> findAll() {
 return findByCriteria();
 }

 @SuppressWarnings("unchecked")
 public List<T> findByExample(T exampleInstance, String[] excludeProperty) {
 Criteria crit = getSession().createCriteria(getPersistentClass());
 Example example = Example.create(exampleInstance);
 for (String exclude : excludeProperty) {
 example.excludeProperty(exclude);
 }
 crit.add(example);
 return crit.list();
 }

 @SuppressWarnings("unchecked")
 public T makePersistent(T entity) {
 getSession().saveOrUpdate(entity);
 return entity;
 }

 public void makeTransient(T entity) {
 getSession().delete(entity);
 }

 public void flush() {
 getSession().flush();
 }

 public void clear() {
 getSession().clear();
 }

 /**
 * Use this inside subclasses as a convenience method.
 */
 @SuppressWarnings("unchecked")
 protected List<T> findByCriteria(Criterion criterion) {
 Criteria crit = getSession().createCriteria(getPersistentClass());
 for (Criterion c : criterion) {
 crit.add(c);
 }
 return crit.list();
 }

}

There are some interesting things in this implementation. First, it clearly needs a Session to work, provided with setter injection. You could also use constructor injection. How you set the Session and what scope this Session has is of no concern to the actual DAO implementation. A DAO should not control transactions or the Session scope.

We need to suppress a few compile-time warnings about unchecked casts, because Hibernate's interfaces are JDK 1.4 only. What follows are the implementations of the generic CRUD operations, quite straightforward. The last method is quite nice, using another JDK 5.0 feature, varargs. It helps us to build Criteria queries in concrete entity DAOs. This is an example of a concrete DAO that extends the generic DAO implementation for Hibernate:

public class ItemDAOHibernate
 extends GenericHibernateDAO<Item, Long>
 implements ItemDAO {

 public Bid getMaxBid(Long itemId) {
 Query q = getSession().getNamedQuery(ItemDAO.QUERY_MAXBID);
 q.setParameter("itemid", itemId);
 return (Bid) q.uniqueResult();
 }

 public Bid getMinBid(Long itemId) {
 Query q = getSession().getNamedQuery(ItemDAO.QUERY_MINBID);
 q.setParameter("itemid", itemId);
 return (Bid) q.uniqueResult();
 }

}
Another example which uses the findByCriteria() method of the superclass with variable arguments:
public class CategoryDAOHibernate
 extends GenericHibernateDAO<Category, Long>
 implements CategoryDAO {

 public Collection<Category> findAll(boolean onlyRootCategories) {
 if (onlyRootCategories)
 return findByCriteria( Expression.isNull("parent") );
 else
 return findAll();
 }
}

Preparing DAOs with factories

We could bring it all together in a DAO factory, which not only sets the Session when a DAO is constructed but also contains nested classes to implement CRUD-only DAOs with no business-related operations:

public class HibernateDAOFactory extends DAOFactory {

 public ItemDAO getItemDAO() {
 return (ItemDAO)instantiateDAO(ItemDAOHibernate.class);
 }

 public CategoryDAO getCategoryDAO() {
 return (CategoryDAO)instantiateDAO(CategoryDAOHibernate.class);
 }

 public CommentDAO getCommentDAO() {
 return (CommentDAO)instantiateDAO(CommentDAOHibernate.class);
 }

 public ShipmentDAO getShipmentDAO() {
 return (ShipmentDAO)instantiateDAO(ShipmentDAOHibernate.class);
 }

 private GenericHibernateDAO instantiateDAO(Class daoClass) {
 try {
 GenericHibernateDAO dao = (GenericHibernateDAO)daoClass.newInstance();
 dao.setSession(getCurrentSession());
 return dao;
 } catch (Exception ex) {
 throw new RuntimeException("Can not instantiate DAO: " + daoClass, ex);
 }
 }

 // You could override this if you don't want HibernateUtil for lookup
 protected Session getCurrentSession() {
 return HibernateUtil.getSessionFactory().getCurrentSession();
 }

 // Inline concrete DAO implementations with no business-related data access methods.
 // If we use public static nested classes, we can centralize all of them in one source file.

 public static class CommentDAOHibernate
 extends GenericHibernateDAO<Comment, Long>
 implements CommentDAO {}

 public static class ShipmentDAOHibernate
 extends GenericHibernateDAO<Shipment, Long>
 implements ShipmentDAO {}

}
This concrete factory for Hibernate DAOs extends the abstract factory, which is the interface we'll use in application code:
public abstract class DAOFactory {

 /**
 * Creates a standalone DAOFactory that returns unmanaged DAO
 * beans for use in any environment Hibernate has been configured
 * for. Uses HibernateUtil/SessionFactory and Hibernate context
 * propagation (CurrentSessionContext), thread-bound or transaction-bound,
 * and transaction scoped.
 */
 public static final Class HIBERNATE = org.hibernate.ce.auction.dao.hibernate.HibernateDAOFactory.class;

 /**
 * Factory method for instantiation of concrete factories.
 */
 public static DAOFactory instance(Class factory) {
 try {
 return (DAOFactory)factory.newInstance();
 } catch (Exception ex) {
 throw new RuntimeException("Couldn't create DAOFactory: " + factory);
 }
 }

 // Add your DAO interfaces here
 public abstract ItemDAO getItemDAO();
 public abstract CategoryDAO getCategoryDAO();
 public abstract CommentDAO getCommentDAO();
 public abstract ShipmentDAO getShipmentDAO();

}

Note that this factory example is suitable for persistence layers which are primarily implemented with a single persistence service, such as Hibernate or EJB 3.0 persistence. If you have to mix persistence APIs, for example, Hibernate and plain JDBC, the pattern changes slightly. Keep in mind that you can also call session.connection() inside a Hibernate-specific DAO, or use one of the many bulk operation/SQL support options in Hibernate 3.1 to avoid plain JDBC.

Finally, this is how data access now looks like in controller/command handler code (pick whatever transaction demarcation strategy you like, the DAO code doesn't change):

// EJB3 CMT: @TransactionAttribute(TransactionAttributeType.REQUIRED)
public void execute() {

 // JTA: UserTransaction utx = jndiContext.lookup("UserTransaction");
 // JTA: utx.begin();

 // Plain JDBC: HibernateUtil.getCurrentSession().beginTransaction();

 DAOFactory factory = DAOFactory.instance(DAOFactory.HIBERNATE);
 ItemDAO itemDAO = factory.getItemDAO();
 UserDAO userDAO = factory.getUserDAO();

 Bid currentMaxBid = itemDAO.getMaxBid(itemId);
 Bid currentMinBid = itemDAO.getMinBid(itemId);

 Item item = itemDAO.findById(itemId, true);

 newBid = item.placeBid(userDAO.findById(userId, false),
 bidAmount,
 currentMaxBid,
 currentMinBid);

 // JTA: utx.commit(); // Don't forget exception handling

 // Plain JDBC: HibernateUtil.getCurrentSession().getTransaction().commit(); // Don't forget exception handling

}
The database transaction, either JTA or direct JDBC, is started and committed in an interceptor that runs for every execute(), following the Open Session in View pattern. You can use AOP for this or any kind of interceptor that can be wrapped around a method call, see Session handling with AOP.
��Q�http://www.hibernate.org

月芽�?/a> 2007-09-12 16:22 发表评论