TUTORIAL NHIBERNATE

O Processo de Desenvolvimento

Brevemente o NHibernate terá ferramentas para ajudar na geração do schema da

tabela, gerando e atualizando assim os arquivos de mapeamentos. Entretanto,
estamos assumindo que não temos estas ferramentas e sendo assim, teremos que
criar o arquivo de mapeamento (XML) entre a Classe .NET e a Tabela da Base de
Dados manualmente. Abaixo os passos para o desenvolvimento:

• 1. Criar a Tabela na Base de Dados.

• 2. Criar a Classe .NET.
• 3. Criar o Arquivo de Mapeamento.
• 4. Criar o Arquivo de Configuração do NHibernate.
• 5. Usar a API do NHibernate.

Passo 1: Escrevendo o SQL

O exemplo é algo bem simples. Considere que estamos desenvolvendo um

subsistema básico de gerenciamento de usuários para um Web Site qualquer. O
tabela chamará usuários (users) e estaremos assumindo que a Base de Dados a ser
utilizada chama-se NHibernate:

1 USE NHibernate
2 GO
3
4 CREATE TABLE users (
5 LogonID nvarchar(20) NOT NULL default '0',
6 Name nvarchar(40) default NULL,
7 Password nvarchar(20) default NULL,
8 EmailAddress nvarchar(40) default NULL,
9 LastLogon datetime default NULL,
10 PRIMARY KEY (LogonID)
11 GO
12 )

Passo 2: Criando a Classe .NET

Necessitamos criar uma classe com as propriedades que desejamos persistir na

Base de Dados. NHibernate utiliza Reflection para resgatar e atribuir os valores as
propriedades dos objetos que queremos persistir. Veja abaixo uma classe simples
que pode ser persistida utilizando NHibernate:

1 using System;
2
3 namespace CS
4 {
5 public class User
6 {
7 private string id;
8 private string userName;
9 private string password;
10 private string emailAddress;
11 private DateTime lastLogon;
12
13 public User(){}
14
15 private string Id
16 {
17 get { return id; }
 18 set { id = value; }
19 }
20
21 private string UserName
22 {
23 get { return userName; }
24 set { userName = value; }
25 }
26
27 private string Password
28 {
29 get { return password; }
30 set { password = value; }
31 }
32
33 private string EmailAddress
34 {
35 get { return emailAddress; }
36 set { emailAddress = value; }
37 }
38
39 private DateTime LastLogon
40 {
41 get { return lastLogon; }
42 set { lastLogon = value; }
43 }
44 }
45 }

No exemplo acima, as propriedades e o construtor é definido como públicos, mas

isso não é uma exigência para o NHibernate, podendo utilizar propriedades
definidas como public, protected, internal ou mesmo private para persistir os
dados.

Passo 3: Escrevendo o Arquivo de Mapeamento

Com a tabela criada na Base de Dados e a nossa Classe .NET também escrita, ainda
necessitamos uma maneira de dizer ao NHibernate quais as propriedades da Classe
.NET que receberá as informações das colunas da tabela da Base de Dados. Isto é
realizado através de um arquivo de mapeamento, escrito em formato XML, tendo
cada classe seu respectivo arquivo XML de mapeamento.

Para que o sistema funcione corretamente, você deve nomear o arquivo de

mapeamento com o mesmo nome da classe, ficando da seguinte forma:
"Objeto.hbm.xml", e no nosso caso: "User.hbm.xml". Além disso, é necessário
colocá-lo no mesmo diretório da classe, pois com isso o NHibernate fará as coisas
com mais facilidade. Abaixo um exemplo do arquivo de mapeamento:

1 <?xml version="1.0" encoding="utf-8" ?>

2 <hibernate-mapping xmlns="urn:nhibernate-mapping-2.0">
3 <class name="CS.User, CS" table="users">
4 <id name="Id" column="LogonId" type="String" length="20">
5 <generator class="assigned" />
6 </id>
7 <property name="UserName" column= "Name" type="String" length="40"/>
8 <property name="Password" type="String" length="20"/>
9 <property name="EmailAddress" type="String" length="40"/>
10 <property name="LastLogon" type="DateTime"/>
11 </class>
12 </hibernate-mapping>

Analisando o código acima, o que mais nos chama a atenção são as tags class e
table, onde definimos o nome da Classe e o nome da Tabela da Base de Dados de
onde será recuperado e/ou inserido os dados. No caso de nosso exemplo, estamos
mapeando os dados da tabela "users" para a classe "User".
Logo mais abaixo temos as propriedades que compõem nosso objeto. Internamento
o NHibernate varre este arquivo recuperando os atributos "name", que
correspondem as propriedades da nossa Classe User. É recuperado também o
atributo "column", que se refere a coluna correspondente na Base de Dados,
lembrando que este atributo é opcional, e quando ocultado o NHibernate assume
que o nome da coluna na Base de Dados é o mesmo da Propriedade.

A tag Id é a responsável por ser a chave identificadora do objeto/registro, onde

mapeamos a propriedade (name) para a coluna da Base de Dados (column). No
nosso exemplo, geramos as nossas próprias chaves, não necessitando que a Base
de Dados gere automaticamente, mas isso é perfeitamente possível. Para saber um
pouco mais sobre chaves, poderá consultar a documentação do NHibernate.

Observação: Se você estiver utilizando Visual Studio .NET, certifique-se que ao

compilar o projeto a propriedade Build Action dos arquivos XML de mapeamento -
que no nosso caso chama-se "User.hbm.xml" - está definido como "Embedded
Resource", para que o arquivo XML faça parte do Assembly como Resource. Isso
facilita porque não há a necessidade de distribuir os arquivos XML de mapeamento
juntos com a aplicação, mas claro, a desvantagem é que se mudar o arquivo de
mapeamento, a aplicação deverá ser recompilada.

Passo 4: Criando o Arquivo de de Configuração para a Base de Dados

Ainda falta dizermos ao NHibernate onde ele deverá ir buscar e persistir os dados.
A maneira mais fácil e simples é criando uma seção de configuração dentro do
arquivo de configuração da aplicação (Web.Config ou App.Config). Isto é
equivalente a usar as propriedades de configuração do NHibernate. Abaixo veremos
como criar a seção de configuração dentro do arquivo App.Config:

1 <?xml version="1.0" encoding="utf-8" ?>

2 <configuration>
3 <configSections>
4 <section
5 name="nhibernate"
6 type="System.Configuration.NameValueSectionHandler, System,
7 Version=1.0.3300.0,Culture=neutral, PublicKeyToken=b77a5c561934e089" />
8 </configSections>
9
10 <nhibernate>
11 <add
12 key="hibernate.connection.provider"
13 value="NHibernate.Connection.DriverConnectionProvider"
14 />
15 <add
16 key="hibernate.dialect"
17 value="NHibernate.Dialect.MsSql2000Dialect"
18 />
19 <add
20 key="hibernate.connection.driver_class"
21 value="NHibernate.Driver.SqlClientDriver"
22 />
23 <add
24 key="hibernate.connection.connection_string"
25 value="CONNECTION_STRING"
26 />
27 </nhibernate>
28 </configuration>
No código acima, definimos o SqlClient como Provider para acesso à Base de Dados
SQL Server 2000. A ConnectionString foi ocultada apenas para não confundir o
leitor, tendo que ser definida com os dados de acesso do servidor de Banco de
Dados que estará servindo a aplicação.

Veja não existe nenhuma informação sobre a configuração do log4net. NHibernate

usa log4net para registrar o que está acontecendo internamente. Em uma aplicação
em produção é recomendável configurarar o log4net e ajustar NHibernate ao nível
apropriado do registro para seu cenário.

Passo 5: Utilizando o NHibernate

Até agora fizemos o trabalho árduo. Se tudo ocorreu como esperamos, até o
momento temos:

• Arquivo User.cs - Classe .NET do nosso objeto.

• Arquivo User.hbm.xml - Arquivo XML de mapeamento.
• app.Config - Arquivo de Configuração da aplicação.
• SQL Server - A Tabela "users" criada.

Abaixo os passos que devemos seguir para utilizar o NHibernate para recuperar e
inserir os dados na Base de Dados:

• 1. - Criar o Objeto de Configuração.

• 2. - Informar ao Objeto de Configuração os tipos de Objeto que deseja
persistir.
• 3. - Criar uma sessão com a Base de Dados.
• 4. - Carregar, Salvar e Consultar seus objetos.
• 5. - Fechar ou Flush() na sessão com a Base de Dados.

Abaixo veremos como utilizar o NHibernate:

Inicialmente devemos criar o objeto de configuração do NHibernate que é

responsável e tem o conhecimento sobre todos os mapeamentos que existem entre
os objetos do nosso sistema e a Base de Dados.

1 Configuration cfg = new Configuration();

2 cfg.AddAssembly("CS");

O objeto de Configuração recupera através do Assembly todos os arquivos que

terminam com ".hbm.xml" qual o utilizará para efetuar as manipulações. Existem
outras formas de definir e carregar os arquivos de mapeamentos, mas esta é a
forma mais simples.

O objeto de ISession representa uma conexão com a sua Base de Dados e o

ITransaction representa uma transação controlada também pelo NHibernate.

1 ISessionFactory factory = cfg.BuildSessionFactory();

2 ISession session = factory.OpenSession();
3 ITransaction transaction = session.BeginTransaction();

Depois das configurações realizadas, nos resta definitivamente inserir, carregar e

consultar a Base de Dados através do NHibernate:

1 User newUser = new User();

2 newUser.Id = "joe_cool";
3 newUser.UserName = "Joseph Cool";
4 newUser.Password = "abc123";
 5 newUser.EmailAddress = "joe@cool.com";
6 newUser.LastLogon = DateTime.Now;
7
8 session.Save(newUser);
9
10 transaction.Commit();
11 session.Close();

Como podemos ver no código acima, um novo objeto do tipo User é criado,
definimos as suas propriedades e depois o passamos para o método Save(...) do
NHibernate, que baseando-se no arquivo XML de mapeamento correspondente, faz
a persistência do objeto de forma "mágica" na nossa Base de Dados.

Para recuperar um objeto da Base de Dados, utilize o método Load, passando o ID

do usuário para carregarmos o objeto e assim manipulá-lo. Exemplo:

1 session = factory.OpenSession();
2
3 User joeCool = (User)session.Load(typeof(User), "joe_cool");
4
5 joeCool.EmailAddress = "tt@tt.com";
6 session.Flush();

Depois de recuperado o Usuario com o Id "joe_cool" da Base de Dados, alteramos o

E-Mail do mesmo para "tt@tt.com" e invocamos o método Flush() da Session para
persistir/devolver os dados atualizados na Base de Dados.

Podemos também recuperar uma lista de objetos da nossa Base de Dados através
do NHibernate. Utilizamos a Interface IList para isto, qual encontra-se dentro do
Namespace System.Collections. Um exemplo simples seria algo como:

1 session = factory.OpenSession();
2
3 IList userList = session.CreateCriteria(typeof(User)).List();
4
5 foreach(User user in userList)
6 Console.WriteLine(user.Id + " último login em " + user.LastLogon);